Merge branch 'topic/hda' into for-linus
[linux-2.6] / drivers / hwmon / lm70.c
1 /*
2  * lm70.c
3  *
4  * The LM70 is a temperature sensor chip from National Semiconductor (NS).
5  * Copyright (C) 2006 Kaiwan N Billimoria <kaiwan@designergraphix.com>
6  *
7  * The LM70 communicates with a host processor via an SPI/Microwire Bus
8  * interface. The complete datasheet is available at National's website
9  * here:
10  * http://www.national.com/pf/LM/LM70.html
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  */
26
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/device.h>
31 #include <linux/err.h>
32 #include <linux/sysfs.h>
33 #include <linux/hwmon.h>
34 #include <linux/mutex.h>
35 #include <linux/spi/spi.h>
36
37
38 #define DRVNAME         "lm70"
39
40 #define LM70_CHIP_LM70          0       /* original NS LM70 */
41 #define LM70_CHIP_TMP121        1       /* TI TMP121/TMP123 */
42
43 struct lm70 {
44         struct device *hwmon_dev;
45         struct mutex lock;
46         unsigned int chip;
47 };
48
49 /* sysfs hook function */
50 static ssize_t lm70_sense_temp(struct device *dev,
51                 struct device_attribute *attr, char *buf)
52 {
53         struct spi_device *spi = to_spi_device(dev);
54         int status, val = 0;
55         u8 rxbuf[2];
56         s16 raw=0;
57         struct lm70 *p_lm70 = dev_get_drvdata(&spi->dev);
58
59         if (mutex_lock_interruptible(&p_lm70->lock))
60                 return -ERESTARTSYS;
61
62         /*
63          * spi_read() requires a DMA-safe buffer; so we use
64          * spi_write_then_read(), transmitting 0 bytes.
65          */
66         status = spi_write_then_read(spi, NULL, 0, &rxbuf[0], 2);
67         if (status < 0) {
68                 printk(KERN_WARNING
69                 "spi_write_then_read failed with status %d\n", status);
70                 goto out;
71         }
72         raw = (rxbuf[0] << 8) + rxbuf[1];
73         dev_dbg(dev, "rxbuf[0] : 0x%02x rxbuf[1] : 0x%02x raw=0x%04x\n",
74                 rxbuf[0], rxbuf[1], raw);
75
76         /*
77          * LM70:
78          * The "raw" temperature read into rxbuf[] is a 16-bit signed 2's
79          * complement value. Only the MSB 11 bits (1 sign + 10 temperature
80          * bits) are meaningful; the LSB 5 bits are to be discarded.
81          * See the datasheet.
82          *
83          * Further, each bit represents 0.25 degrees Celsius; so, multiply
84          * by 0.25. Also multiply by 1000 to represent in millidegrees
85          * Celsius.
86          * So it's equivalent to multiplying by 0.25 * 1000 = 250.
87          *
88          * TMP121/TMP123:
89          * 13 bits of 2's complement data, discard LSB 3 bits,
90          * resolution 0.0625 degrees celsius.
91          */
92         switch (p_lm70->chip) {
93         case LM70_CHIP_LM70:
94                 val = ((int)raw / 32) * 250;
95                 break;
96
97         case LM70_CHIP_TMP121:
98                 val = ((int)raw / 8) * 625 / 10;
99                 break;
100         }
101
102         status = sprintf(buf, "%d\n", val); /* millidegrees Celsius */
103 out:
104         mutex_unlock(&p_lm70->lock);
105         return status;
106 }
107
108 static DEVICE_ATTR(temp1_input, S_IRUGO, lm70_sense_temp, NULL);
109
110 static ssize_t lm70_show_name(struct device *dev, struct device_attribute
111                               *devattr, char *buf)
112 {
113         struct lm70 *p_lm70 = dev_get_drvdata(dev);
114         int ret;
115
116         switch (p_lm70->chip) {
117         case LM70_CHIP_LM70:
118                 ret = sprintf(buf, "lm70\n");
119                 break;
120         case LM70_CHIP_TMP121:
121                 ret = sprintf(buf, "tmp121\n");
122                 break;
123         default:
124                 ret = -EINVAL;
125         }
126         return ret;
127 }
128
129 static DEVICE_ATTR(name, S_IRUGO, lm70_show_name, NULL);
130
131 /*----------------------------------------------------------------------*/
132
133 static int __devinit common_probe(struct spi_device *spi, int chip)
134 {
135         struct lm70 *p_lm70;
136         int status;
137
138         /* NOTE:  we assume 8-bit words, and convert to 16 bits manually */
139
140         p_lm70 = kzalloc(sizeof *p_lm70, GFP_KERNEL);
141         if (!p_lm70)
142                 return -ENOMEM;
143
144         mutex_init(&p_lm70->lock);
145         p_lm70->chip = chip;
146
147         /* sysfs hook */
148         p_lm70->hwmon_dev = hwmon_device_register(&spi->dev);
149         if (IS_ERR(p_lm70->hwmon_dev)) {
150                 dev_dbg(&spi->dev, "hwmon_device_register failed.\n");
151                 status = PTR_ERR(p_lm70->hwmon_dev);
152                 goto out_dev_reg_failed;
153         }
154         dev_set_drvdata(&spi->dev, p_lm70);
155
156         if ((status = device_create_file(&spi->dev, &dev_attr_temp1_input))
157          || (status = device_create_file(&spi->dev, &dev_attr_name))) {
158                 dev_dbg(&spi->dev, "device_create_file failure.\n");
159                 goto out_dev_create_file_failed;
160         }
161
162         return 0;
163
164 out_dev_create_file_failed:
165         device_remove_file(&spi->dev, &dev_attr_temp1_input);
166         hwmon_device_unregister(p_lm70->hwmon_dev);
167 out_dev_reg_failed:
168         dev_set_drvdata(&spi->dev, NULL);
169         kfree(p_lm70);
170         return status;
171 }
172
173 static int __devinit lm70_probe(struct spi_device *spi)
174 {
175         /* signaling is SPI_MODE_0 on a 3-wire link (shared SI/SO) */
176         if ((spi->mode & (SPI_CPOL | SPI_CPHA)) || !(spi->mode & SPI_3WIRE))
177                 return -EINVAL;
178
179         return common_probe(spi, LM70_CHIP_LM70);
180 }
181
182 static int __devinit tmp121_probe(struct spi_device *spi)
183 {
184         /* signaling is SPI_MODE_0 with only MISO connected */
185         if (spi->mode & (SPI_CPOL | SPI_CPHA))
186                 return -EINVAL;
187
188         return common_probe(spi, LM70_CHIP_TMP121);
189 }
190
191 static int __devexit lm70_remove(struct spi_device *spi)
192 {
193         struct lm70 *p_lm70 = dev_get_drvdata(&spi->dev);
194
195         device_remove_file(&spi->dev, &dev_attr_temp1_input);
196         device_remove_file(&spi->dev, &dev_attr_name);
197         hwmon_device_unregister(p_lm70->hwmon_dev);
198         dev_set_drvdata(&spi->dev, NULL);
199         kfree(p_lm70);
200
201         return 0;
202 }
203
204 static struct spi_driver tmp121_driver = {
205         .driver = {
206                 .name   = "tmp121",
207                 .owner  = THIS_MODULE,
208         },
209         .probe  = tmp121_probe,
210         .remove = __devexit_p(lm70_remove),
211 };
212
213 static struct spi_driver lm70_driver = {
214         .driver = {
215                 .name   = "lm70",
216                 .owner  = THIS_MODULE,
217         },
218         .probe  = lm70_probe,
219         .remove = __devexit_p(lm70_remove),
220 };
221
222 static int __init init_lm70(void)
223 {
224         int ret = spi_register_driver(&lm70_driver);
225         if (ret)
226                 return ret;
227
228         ret = spi_register_driver(&tmp121_driver);
229         if (ret)
230                 spi_unregister_driver(&lm70_driver);
231
232         return ret;
233 }
234
235 static void __exit cleanup_lm70(void)
236 {
237         spi_unregister_driver(&lm70_driver);
238         spi_unregister_driver(&tmp121_driver);
239 }
240
241 module_init(init_lm70);
242 module_exit(cleanup_lm70);
243
244 MODULE_AUTHOR("Kaiwan N Billimoria");
245 MODULE_DESCRIPTION("NS LM70 / TI TMP121/TMP123 Linux driver");
246 MODULE_LICENSE("GPL");