]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/hwmon/lm95241.c
parport: Use the PCI IRQ if offered
[linux-2.6.git] / drivers / hwmon / lm95241.c
1 /*
2  * lm95241.c - Part of lm_sensors, Linux kernel modules for hardware
3  *             monitoring
4  * Copyright (C) 2008 Davide Rizzo <elpa-rizzo@gmail.com>
5  *
6  * Based on the max1619 driver. The LM95241 is a sensor chip made by National
7  *   Semiconductors.
8  * It reports up to three temperatures (its own plus up to
9  * two external ones). Complete datasheet can be
10  * obtained from National's website at:
11  *   http://www.national.com/ds.cgi/LM/LM95241.pdf
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26  */
27
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/jiffies.h>
32 #include <linux/i2c.h>
33 #include <linux/hwmon.h>
34 #include <linux/hwmon-sysfs.h>
35 #include <linux/err.h>
36 #include <linux/mutex.h>
37 #include <linux/sysfs.h>
38
39 static const unsigned short normal_i2c[] = {
40         0x19, 0x2a, 0x2b, I2C_CLIENT_END};
41
42 /* Insmod parameters */
43 I2C_CLIENT_INSMOD_1(lm95241);
44
45 /* LM95241 registers */
46 #define LM95241_REG_R_MAN_ID            0xFE
47 #define LM95241_REG_R_CHIP_ID           0xFF
48 #define LM95241_REG_R_STATUS            0x02
49 #define LM95241_REG_RW_CONFIG           0x03
50 #define LM95241_REG_RW_REM_FILTER       0x06
51 #define LM95241_REG_RW_TRUTHERM         0x07
52 #define LM95241_REG_W_ONE_SHOT          0x0F
53 #define LM95241_REG_R_LOCAL_TEMPH       0x10
54 #define LM95241_REG_R_REMOTE1_TEMPH     0x11
55 #define LM95241_REG_R_REMOTE2_TEMPH     0x12
56 #define LM95241_REG_R_LOCAL_TEMPL       0x20
57 #define LM95241_REG_R_REMOTE1_TEMPL     0x21
58 #define LM95241_REG_R_REMOTE2_TEMPL     0x22
59 #define LM95241_REG_RW_REMOTE_MODEL     0x30
60
61 /* LM95241 specific bitfields */
62 #define CFG_STOP 0x40
63 #define CFG_CR0076 0x00
64 #define CFG_CR0182 0x10
65 #define CFG_CR1000 0x20
66 #define CFG_CR2700 0x30
67 #define R1MS_SHIFT 0
68 #define R2MS_SHIFT 2
69 #define R1MS_MASK (0x01 << (R1MS_SHIFT))
70 #define R2MS_MASK (0x01 << (R2MS_SHIFT))
71 #define R1DF_SHIFT 1
72 #define R2DF_SHIFT 2
73 #define R1DF_MASK (0x01 << (R1DF_SHIFT))
74 #define R2DF_MASK (0x01 << (R2DF_SHIFT))
75 #define R1FE_MASK 0x01
76 #define R2FE_MASK 0x05
77 #define TT1_SHIFT 0
78 #define TT2_SHIFT 4
79 #define TT_OFF 0
80 #define TT_ON 1
81 #define TT_MASK 7
82 #define MANUFACTURER_ID 0x01
83 #define DEFAULT_REVISION 0xA4
84
85 /* Conversions and various macros */
86 #define TEMP_FROM_REG(val_h, val_l) (((val_h) & 0x80 ? (val_h) - 0x100 : \
87     (val_h)) * 1000 + (val_l) * 1000 / 256)
88
89 /* Functions declaration */
90 static int lm95241_attach_adapter(struct i2c_adapter *adapter);
91 static int lm95241_detect(struct i2c_adapter *adapter, int address,
92                           int kind);
93 static void lm95241_init_client(struct i2c_client *client);
94 static int lm95241_detach_client(struct i2c_client *client);
95 static struct lm95241_data *lm95241_update_device(struct device *dev);
96
97 /* Driver data (common to all clients) */
98 static struct i2c_driver lm95241_driver = {
99         .driver = {
100                 .name   = "lm95241",
101         },
102         .attach_adapter = lm95241_attach_adapter,
103         .detach_client  = lm95241_detach_client,
104 };
105
106 /* Client data (each client gets its own) */
107 struct lm95241_data {
108         struct i2c_client client;
109         struct device *hwmon_dev;
110         struct mutex update_lock;
111         unsigned long last_updated, rate; /* in jiffies */
112         char valid; /* zero until following fields are valid */
113         /* registers values */
114         u8 local_h, local_l; /* local */
115         u8 remote1_h, remote1_l; /* remote1 */
116         u8 remote2_h, remote2_l; /* remote2 */
117         u8 config, model, trutherm;
118 };
119
120 /* Sysfs stuff */
121 #define show_temp(value) \
122 static ssize_t show_##value(struct device *dev, \
123     struct device_attribute *attr, char *buf) \
124 { \
125         struct lm95241_data *data = lm95241_update_device(dev); \
126         snprintf(buf, PAGE_SIZE - 1, "%d\n", \
127                 TEMP_FROM_REG(data->value##_h, data->value##_l)); \
128         return strlen(buf); \
129 }
130 show_temp(local);
131 show_temp(remote1);
132 show_temp(remote2);
133
134 static ssize_t show_rate(struct device *dev, struct device_attribute *attr,
135                          char *buf)
136 {
137         struct lm95241_data *data = lm95241_update_device(dev);
138
139         snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->rate / HZ);
140         return strlen(buf);
141 }
142
143 static ssize_t set_rate(struct device *dev, struct device_attribute *attr,
144                         const char *buf, size_t count)
145 {
146         struct i2c_client *client = to_i2c_client(dev);
147         struct lm95241_data *data = i2c_get_clientdata(client);
148
149         strict_strtol(buf, 10, &data->rate);
150         data->rate = data->rate * HZ / 1000;
151
152         return count;
153 }
154
155 #define show_type(flag) \
156 static ssize_t show_type##flag(struct device *dev, \
157                                    struct device_attribute *attr, char *buf) \
158 { \
159         struct i2c_client *client = to_i2c_client(dev); \
160         struct lm95241_data *data = i2c_get_clientdata(client); \
161 \
162         snprintf(buf, PAGE_SIZE - 1, \
163                 data->model & R##flag##MS_MASK ? "1\n" : "2\n"); \
164         return strlen(buf); \
165 }
166 show_type(1);
167 show_type(2);
168
169 #define show_min(flag) \
170 static ssize_t show_min##flag(struct device *dev, \
171     struct device_attribute *attr, char *buf) \
172 { \
173         struct i2c_client *client = to_i2c_client(dev); \
174         struct lm95241_data *data = i2c_get_clientdata(client); \
175 \
176         snprintf(buf, PAGE_SIZE - 1, \
177                 data->config & R##flag##DF_MASK ?       \
178                 "-127000\n" : "0\n"); \
179         return strlen(buf); \
180 }
181 show_min(1);
182 show_min(2);
183
184 #define show_max(flag) \
185 static ssize_t show_max##flag(struct device *dev, \
186     struct device_attribute *attr, char *buf) \
187 { \
188         struct i2c_client *client = to_i2c_client(dev); \
189         struct lm95241_data *data = i2c_get_clientdata(client); \
190 \
191         snprintf(buf, PAGE_SIZE - 1, \
192                 data->config & R##flag##DF_MASK ? \
193                 "127000\n" : "255000\n"); \
194         return strlen(buf); \
195 }
196 show_max(1);
197 show_max(2);
198
199 #define set_type(flag) \
200 static ssize_t set_type##flag(struct device *dev, \
201                                   struct device_attribute *attr, \
202                                   const char *buf, size_t count) \
203 { \
204         struct i2c_client *client = to_i2c_client(dev); \
205         struct lm95241_data *data = i2c_get_clientdata(client); \
206 \
207         long val; \
208         strict_strtol(buf, 10, &val); \
209 \
210         if ((val == 1) || (val == 2)) { \
211 \
212                 mutex_lock(&data->update_lock); \
213 \
214                 data->trutherm &= ~(TT_MASK << TT##flag##_SHIFT); \
215                 if (val == 1) { \
216                         data->model |= R##flag##MS_MASK; \
217                         data->trutherm |= (TT_ON << TT##flag##_SHIFT); \
218                 } \
219                 else { \
220                         data->model &= ~R##flag##MS_MASK; \
221                         data->trutherm |= (TT_OFF << TT##flag##_SHIFT); \
222                 } \
223 \
224                 data->valid = 0; \
225 \
226                 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, \
227                                           data->model); \
228                 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, \
229                                           data->trutherm); \
230 \
231                 mutex_unlock(&data->update_lock); \
232 \
233         } \
234         return count; \
235 }
236 set_type(1);
237 set_type(2);
238
239 #define set_min(flag) \
240 static ssize_t set_min##flag(struct device *dev, \
241         struct device_attribute *devattr, const char *buf, size_t count) \
242 { \
243         struct i2c_client *client = to_i2c_client(dev); \
244         struct lm95241_data *data = i2c_get_clientdata(client); \
245 \
246         long val; \
247         strict_strtol(buf, 10, &val); \
248 \
249         mutex_lock(&data->update_lock); \
250 \
251         if (val < 0) \
252                 data->config |= R##flag##DF_MASK; \
253         else \
254                 data->config &= ~R##flag##DF_MASK; \
255 \
256         data->valid = 0; \
257 \
258         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, \
259                 data->config); \
260 \
261         mutex_unlock(&data->update_lock); \
262 \
263         return count; \
264 }
265 set_min(1);
266 set_min(2);
267
268 #define set_max(flag) \
269 static ssize_t set_max##flag(struct device *dev, \
270         struct device_attribute *devattr, const char *buf, size_t count) \
271 { \
272         struct i2c_client *client = to_i2c_client(dev); \
273         struct lm95241_data *data = i2c_get_clientdata(client); \
274 \
275         long val; \
276         strict_strtol(buf, 10, &val); \
277 \
278         mutex_lock(&data->update_lock); \
279 \
280         if (val <= 127000) \
281                 data->config |= R##flag##DF_MASK; \
282         else \
283                 data->config &= ~R##flag##DF_MASK; \
284 \
285         data->valid = 0; \
286 \
287         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, \
288                 data->config); \
289 \
290         mutex_unlock(&data->update_lock); \
291 \
292         return count; \
293 }
294 set_max(1);
295 set_max(2);
296
297 static DEVICE_ATTR(temp1_input, S_IRUGO, show_local, NULL);
298 static DEVICE_ATTR(temp2_input, S_IRUGO, show_remote1, NULL);
299 static DEVICE_ATTR(temp3_input, S_IRUGO, show_remote2, NULL);
300 static DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type1, set_type1);
301 static DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type2, set_type2);
302 static DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min1, set_min1);
303 static DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min2, set_min2);
304 static DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max1, set_max1);
305 static DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max2, set_max2);
306 static DEVICE_ATTR(rate, S_IWUSR | S_IRUGO, show_rate, set_rate);
307
308 static struct attribute *lm95241_attributes[] = {
309         &dev_attr_temp1_input.attr,
310         &dev_attr_temp2_input.attr,
311         &dev_attr_temp3_input.attr,
312         &dev_attr_temp2_type.attr,
313         &dev_attr_temp3_type.attr,
314         &dev_attr_temp2_min.attr,
315         &dev_attr_temp3_min.attr,
316         &dev_attr_temp2_max.attr,
317         &dev_attr_temp3_max.attr,
318         &dev_attr_rate.attr,
319         NULL
320 };
321
322 static const struct attribute_group lm95241_group = {
323         .attrs = lm95241_attributes,
324 };
325
326 /* Init/exit code */
327 static int lm95241_attach_adapter(struct i2c_adapter *adapter)
328 {
329         if (!(adapter->class & I2C_CLASS_HWMON))
330                 return 0;
331         return i2c_probe(adapter, &addr_data, lm95241_detect);
332 }
333
334 /*
335  * The following function does more than just detection. If detection
336  * succeeds, it also registers the new chip.
337  */
338 static int lm95241_detect(struct i2c_adapter *adapter, int address, int kind)
339 {
340         struct i2c_client *new_client;
341         struct lm95241_data *data;
342         int err = 0;
343         const char *name = "";
344
345         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
346                 goto exit;
347
348         data = kzalloc(sizeof(struct lm95241_data), GFP_KERNEL);
349         if (!data) {
350                 err = -ENOMEM;
351                 goto exit;
352         }
353
354         /* The common I2C client data is placed right before the
355            LM95241-specific data. */
356         new_client = &data->client;
357         i2c_set_clientdata(new_client, data);
358         new_client->addr = address;
359         new_client->adapter = adapter;
360         new_client->driver = &lm95241_driver;
361         new_client->flags = 0;
362
363         /*
364          * Now we do the remaining detection. A negative kind means that
365          * the driver was loaded with no force parameter (default), so we
366          * must both detect and identify the chip. A zero kind means that
367          * the driver was loaded with the force parameter, the detection
368          * step shall be skipped. A positive kind means that the driver
369          * was loaded with the force parameter and a given kind of chip is
370          * requested, so both the detection and the identification steps
371          * are skipped.
372          */
373         if (kind < 0) { /* detection */
374                 if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
375                      != MANUFACTURER_ID)
376                 || (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
377                     < DEFAULT_REVISION)) {
378                         dev_dbg(&adapter->dev,
379                                 "LM95241 detection failed at 0x%02x.\n",
380                                 address);
381                         goto exit_free;
382                 }
383         }
384
385         if (kind <= 0) { /* identification */
386                 if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
387                      == MANUFACTURER_ID)
388                 && (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
389                     >= DEFAULT_REVISION)) {
390
391                         kind = lm95241;
392
393                         if (kind <= 0) { /* identification failed */
394                                 dev_info(&adapter->dev, "Unsupported chip\n");
395                                 goto exit_free;
396                         }
397                 }
398         }
399
400         if (kind == lm95241)
401                 name = "lm95241";
402
403         /* We can fill in the remaining client fields */
404         strlcpy(new_client->name, name, I2C_NAME_SIZE);
405         data->valid = 0;
406         mutex_init(&data->update_lock);
407
408         /* Tell the I2C layer a new client has arrived */
409         err = i2c_attach_client(new_client);
410         if (err)
411                 goto exit_free;
412
413         /* Initialize the LM95241 chip */
414         lm95241_init_client(new_client);
415
416         /* Register sysfs hooks */
417         err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group);
418         if (err)
419                 goto exit_detach;
420
421         data->hwmon_dev = hwmon_device_register(&new_client->dev);
422         if (IS_ERR(data->hwmon_dev)) {
423                 err = PTR_ERR(data->hwmon_dev);
424                 goto exit_remove_files;
425         }
426
427         return 0;
428
429 exit_remove_files:
430         sysfs_remove_group(&new_client->dev.kobj, &lm95241_group);
431 exit_detach:
432         i2c_detach_client(new_client);
433 exit_free:
434         kfree(data);
435 exit:
436         return err;
437 }
438
439 static void lm95241_init_client(struct i2c_client *client)
440 {
441         struct lm95241_data *data = i2c_get_clientdata(client);
442
443         data->rate = HZ;    /* 1 sec default */
444         data->valid = 0;
445         data->config = CFG_CR0076;
446         data->model = 0;
447         data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
448
449         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
450                                   data->config);
451         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
452                                   R1FE_MASK | R2FE_MASK);
453         i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
454                                   data->trutherm);
455         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
456                                   data->model);
457 }
458
459 static int lm95241_detach_client(struct i2c_client *client)
460 {
461         struct lm95241_data *data = i2c_get_clientdata(client);
462         int err;
463
464         hwmon_device_unregister(data->hwmon_dev);
465         sysfs_remove_group(&client->dev.kobj, &lm95241_group);
466
467         err = i2c_detach_client(client);
468         if (err)
469                 return err;
470
471         kfree(data);
472         return 0;
473 }
474
475 static struct lm95241_data *lm95241_update_device(struct device *dev)
476 {
477         struct i2c_client *client = to_i2c_client(dev);
478         struct lm95241_data *data = i2c_get_clientdata(client);
479
480         mutex_lock(&data->update_lock);
481
482         if (time_after(jiffies, data->last_updated + data->rate) ||
483             !data->valid) {
484                 dev_dbg(&client->dev, "Updating lm95241 data.\n");
485                 data->local_h =
486                         i2c_smbus_read_byte_data(client,
487                                                  LM95241_REG_R_LOCAL_TEMPH);
488                 data->local_l =
489                         i2c_smbus_read_byte_data(client,
490                                                  LM95241_REG_R_LOCAL_TEMPL);
491                 data->remote1_h =
492                         i2c_smbus_read_byte_data(client,
493                                                  LM95241_REG_R_REMOTE1_TEMPH);
494                 data->remote1_l =
495                         i2c_smbus_read_byte_data(client,
496                                                  LM95241_REG_R_REMOTE1_TEMPL);
497                 data->remote2_h =
498                         i2c_smbus_read_byte_data(client,
499                                                  LM95241_REG_R_REMOTE2_TEMPH);
500                 data->remote2_l =
501                         i2c_smbus_read_byte_data(client,
502                                                  LM95241_REG_R_REMOTE2_TEMPL);
503                 data->last_updated = jiffies;
504                 data->valid = 1;
505         }
506
507         mutex_unlock(&data->update_lock);
508
509         return data;
510 }
511
512 static int __init sensors_lm95241_init(void)
513 {
514         return i2c_add_driver(&lm95241_driver);
515 }
516
517 static void __exit sensors_lm95241_exit(void)
518 {
519         i2c_del_driver(&lm95241_driver);
520 }
521
522 MODULE_AUTHOR("Davide Rizzo <elpa-rizzo@gmail.com>");
523 MODULE_DESCRIPTION("LM95241 sensor driver");
524 MODULE_LICENSE("GPL");
525
526 module_init(sensors_lm95241_init);
527 module_exit(sensors_lm95241_exit);