hwmon: (lm90) Don't spam the kernel log
[linux-2.6] / drivers / hwmon / lm90.c
1 /*
2  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
3  *          monitoring
4  * Copyright (C) 2003-2008  Jean Delvare <khali@linux-fr.org>
5  *
6  * Based on the lm83 driver. The LM90 is a sensor chip made by National
7  * Semiconductor. It reports up to two temperatures (its own plus up to
8  * one external one) with a 0.125 deg resolution (1 deg for local
9  * temperature) and a 3-4 deg accuracy.
10  *
11  * This driver also supports the LM89 and LM99, two other sensor chips
12  * made by National Semiconductor. Both have an increased remote
13  * temperature measurement accuracy (1 degree), and the LM99
14  * additionally shifts remote temperatures (measured and limits) by 16
15  * degrees, which allows for higher temperatures measurement. The
16  * driver doesn't handle it since it can be done easily in user-space.
17  * Note that there is no way to differentiate between both chips.
18  *
19  * This driver also supports the LM86, another sensor chip made by
20  * National Semiconductor. It is exactly similar to the LM90 except it
21  * has a higher accuracy.
22  *
23  * This driver also supports the ADM1032, a sensor chip made by Analog
24  * Devices. That chip is similar to the LM90, with a few differences
25  * that are not handled by this driver. Among others, it has a higher
26  * accuracy than the LM90, much like the LM86 does.
27  *
28  * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
29  * chips made by Maxim. These chips are similar to the LM86.
30  * Note that there is no easy way to differentiate between the three
31  * variants. The extra address and features of the MAX6659 are not
32  * supported by this driver. These chips lack the remote temperature
33  * offset feature.
34  *
35  * This driver also supports the MAX6646, MAX6647 and MAX6649 chips
36  * made by Maxim.  These are again similar to the LM86, but they use
37  * unsigned temperature values and can report temperatures from 0 to
38  * 145 degrees.
39  *
40  * This driver also supports the MAX6680 and MAX6681, two other sensor
41  * chips made by Maxim. These are quite similar to the other Maxim
42  * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
43  * be treated identically.
44  *
45  * This driver also supports the ADT7461 chip from Analog Devices.
46  * It's supported in both compatibility and extended mode. It is mostly
47  * compatible with LM90 except for a data format difference for the
48  * temperature value registers.
49  *
50  * Since the LM90 was the first chipset supported by this driver, most
51  * comments will refer to this chipset, but are actually general and
52  * concern all supported chipsets, unless mentioned otherwise.
53  *
54  * This program is free software; you can redistribute it and/or modify
55  * it under the terms of the GNU General Public License as published by
56  * the Free Software Foundation; either version 2 of the License, or
57  * (at your option) any later version.
58  *
59  * This program is distributed in the hope that it will be useful,
60  * but WITHOUT ANY WARRANTY; without even the implied warranty of
61  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
62  * GNU General Public License for more details.
63  *
64  * You should have received a copy of the GNU General Public License
65  * along with this program; if not, write to the Free Software
66  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
67  */
68
69 #include <linux/module.h>
70 #include <linux/init.h>
71 #include <linux/slab.h>
72 #include <linux/jiffies.h>
73 #include <linux/i2c.h>
74 #include <linux/hwmon-sysfs.h>
75 #include <linux/hwmon.h>
76 #include <linux/err.h>
77 #include <linux/mutex.h>
78 #include <linux/sysfs.h>
79
80 /*
81  * Addresses to scan
82  * Address is fully defined internally and cannot be changed except for
83  * MAX6659, MAX6680 and MAX6681.
84  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6649, MAX6657
85  * and MAX6658 have address 0x4c.
86  * ADM1032-2, ADT7461-2, LM89-1, LM99-1 and MAX6646 have address 0x4d.
87  * MAX6647 has address 0x4e.
88  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
89  * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
90  * 0x4c, 0x4d or 0x4e.
91  */
92
93 static const unsigned short normal_i2c[] = {
94         0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
95
96 /*
97  * Insmod parameters
98  */
99
100 I2C_CLIENT_INSMOD_8(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680,
101                     max6646);
102
103 /*
104  * The LM90 registers
105  */
106
107 #define LM90_REG_R_MAN_ID               0xFE
108 #define LM90_REG_R_CHIP_ID              0xFF
109 #define LM90_REG_R_CONFIG1              0x03
110 #define LM90_REG_W_CONFIG1              0x09
111 #define LM90_REG_R_CONFIG2              0xBF
112 #define LM90_REG_W_CONFIG2              0xBF
113 #define LM90_REG_R_CONVRATE             0x04
114 #define LM90_REG_W_CONVRATE             0x0A
115 #define LM90_REG_R_STATUS               0x02
116 #define LM90_REG_R_LOCAL_TEMP           0x00
117 #define LM90_REG_R_LOCAL_HIGH           0x05
118 #define LM90_REG_W_LOCAL_HIGH           0x0B
119 #define LM90_REG_R_LOCAL_LOW            0x06
120 #define LM90_REG_W_LOCAL_LOW            0x0C
121 #define LM90_REG_R_LOCAL_CRIT           0x20
122 #define LM90_REG_W_LOCAL_CRIT           0x20
123 #define LM90_REG_R_REMOTE_TEMPH         0x01
124 #define LM90_REG_R_REMOTE_TEMPL         0x10
125 #define LM90_REG_R_REMOTE_OFFSH         0x11
126 #define LM90_REG_W_REMOTE_OFFSH         0x11
127 #define LM90_REG_R_REMOTE_OFFSL         0x12
128 #define LM90_REG_W_REMOTE_OFFSL         0x12
129 #define LM90_REG_R_REMOTE_HIGHH         0x07
130 #define LM90_REG_W_REMOTE_HIGHH         0x0D
131 #define LM90_REG_R_REMOTE_HIGHL         0x13
132 #define LM90_REG_W_REMOTE_HIGHL         0x13
133 #define LM90_REG_R_REMOTE_LOWH          0x08
134 #define LM90_REG_W_REMOTE_LOWH          0x0E
135 #define LM90_REG_R_REMOTE_LOWL          0x14
136 #define LM90_REG_W_REMOTE_LOWL          0x14
137 #define LM90_REG_R_REMOTE_CRIT          0x19
138 #define LM90_REG_W_REMOTE_CRIT          0x19
139 #define LM90_REG_R_TCRIT_HYST           0x21
140 #define LM90_REG_W_TCRIT_HYST           0x21
141
142 /* MAX6646/6647/6649/6657/6658/6659 registers */
143
144 #define MAX6657_REG_R_LOCAL_TEMPL       0x11
145
146 /*
147  * Device flags
148  */
149 #define LM90_FLAG_ADT7461_EXT           0x01    /* ADT7461 extended mode */
150
151 /*
152  * Functions declaration
153  */
154
155 static int lm90_detect(struct i2c_client *client, int kind,
156                        struct i2c_board_info *info);
157 static int lm90_probe(struct i2c_client *client,
158                       const struct i2c_device_id *id);
159 static void lm90_init_client(struct i2c_client *client);
160 static int lm90_remove(struct i2c_client *client);
161 static struct lm90_data *lm90_update_device(struct device *dev);
162
163 /*
164  * Driver data (common to all clients)
165  */
166
167 static const struct i2c_device_id lm90_id[] = {
168         { "adm1032", adm1032 },
169         { "adt7461", adt7461 },
170         { "lm90", lm90 },
171         { "lm86", lm86 },
172         { "lm89", lm99 },
173         { "lm99", lm99 },       /* Missing temperature offset */
174         { "max6646", max6646 },
175         { "max6647", max6646 },
176         { "max6649", max6646 },
177         { "max6657", max6657 },
178         { "max6658", max6657 },
179         { "max6659", max6657 },
180         { "max6680", max6680 },
181         { "max6681", max6680 },
182         { }
183 };
184 MODULE_DEVICE_TABLE(i2c, lm90_id);
185
186 static struct i2c_driver lm90_driver = {
187         .class          = I2C_CLASS_HWMON,
188         .driver = {
189                 .name   = "lm90",
190         },
191         .probe          = lm90_probe,
192         .remove         = lm90_remove,
193         .id_table       = lm90_id,
194         .detect         = lm90_detect,
195         .address_data   = &addr_data,
196 };
197
198 /*
199  * Client data (each client gets its own)
200  */
201
202 struct lm90_data {
203         struct device *hwmon_dev;
204         struct mutex update_lock;
205         char valid; /* zero until following fields are valid */
206         unsigned long last_updated; /* in jiffies */
207         int kind;
208         int flags;
209
210         /* registers values */
211         s8 temp8[4];    /* 0: local low limit
212                            1: local high limit
213                            2: local critical limit
214                            3: remote critical limit */
215         s16 temp11[5];  /* 0: remote input
216                            1: remote low limit
217                            2: remote high limit
218                            3: remote offset (except max6646 and max6657)
219                            4: local input */
220         u8 temp_hyst;
221         u8 alarms; /* bitvector */
222 };
223
224 /*
225  * Conversions
226  * For local temperatures and limits, critical limits and the hysteresis
227  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
228  * For remote temperatures and limits, it uses signed 11-bit values with
229  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
230  * Maxim chips use unsigned values.
231  */
232
233 static inline int temp_from_s8(s8 val)
234 {
235         return val * 1000;
236 }
237
238 static inline int temp_from_u8(u8 val)
239 {
240         return val * 1000;
241 }
242
243 static inline int temp_from_s16(s16 val)
244 {
245         return val / 32 * 125;
246 }
247
248 static inline int temp_from_u16(u16 val)
249 {
250         return val / 32 * 125;
251 }
252
253 static s8 temp_to_s8(long val)
254 {
255         if (val <= -128000)
256                 return -128;
257         if (val >= 127000)
258                 return 127;
259         if (val < 0)
260                 return (val - 500) / 1000;
261         return (val + 500) / 1000;
262 }
263
264 static u8 temp_to_u8(long val)
265 {
266         if (val <= 0)
267                 return 0;
268         if (val >= 255000)
269                 return 255;
270         return (val + 500) / 1000;
271 }
272
273 static s16 temp_to_s16(long val)
274 {
275         if (val <= -128000)
276                 return 0x8000;
277         if (val >= 127875)
278                 return 0x7FE0;
279         if (val < 0)
280                 return (val - 62) / 125 * 32;
281         return (val + 62) / 125 * 32;
282 }
283
284 static u8 hyst_to_reg(long val)
285 {
286         if (val <= 0)
287                 return 0;
288         if (val >= 30500)
289                 return 31;
290         return (val + 500) / 1000;
291 }
292
293 /*
294  * ADT7461 in compatibility mode is almost identical to LM90 except that
295  * attempts to write values that are outside the range 0 < temp < 127 are
296  * treated as the boundary value.
297  *
298  * ADT7461 in "extended mode" operation uses unsigned integers offset by
299  * 64 (e.g., 0 -> -64 degC).  The range is restricted to -64..191 degC.
300  */
301 static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
302 {
303         if (data->flags & LM90_FLAG_ADT7461_EXT)
304                 return (val - 64) * 1000;
305         else
306                 return temp_from_s8(val);
307 }
308
309 static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
310 {
311         if (data->flags & LM90_FLAG_ADT7461_EXT)
312                 return (val - 0x4000) / 64 * 250;
313         else
314                 return temp_from_s16(val);
315 }
316
317 static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
318 {
319         if (data->flags & LM90_FLAG_ADT7461_EXT) {
320                 if (val <= -64000)
321                         return 0;
322                 if (val >= 191000)
323                         return 0xFF;
324                 return (val + 500 + 64000) / 1000;
325         } else {
326                 if (val <= 0)
327                         return 0;
328                 if (val >= 127000)
329                         return 127;
330                 return (val + 500) / 1000;
331         }
332 }
333
334 static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
335 {
336         if (data->flags & LM90_FLAG_ADT7461_EXT) {
337                 if (val <= -64000)
338                         return 0;
339                 if (val >= 191750)
340                         return 0xFFC0;
341                 return (val + 64000 + 125) / 250 * 64;
342         } else {
343                 if (val <= 0)
344                         return 0;
345                 if (val >= 127750)
346                         return 0x7FC0;
347                 return (val + 125) / 250 * 64;
348         }
349 }
350
351 /*
352  * Sysfs stuff
353  */
354
355 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
356                           char *buf)
357 {
358         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
359         struct lm90_data *data = lm90_update_device(dev);
360         int temp;
361
362         if (data->kind == adt7461)
363                 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
364         else if (data->kind == max6646)
365                 temp = temp_from_u8(data->temp8[attr->index]);
366         else
367                 temp = temp_from_s8(data->temp8[attr->index]);
368
369         return sprintf(buf, "%d\n", temp);
370 }
371
372 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
373                          const char *buf, size_t count)
374 {
375         static const u8 reg[4] = {
376                 LM90_REG_W_LOCAL_LOW,
377                 LM90_REG_W_LOCAL_HIGH,
378                 LM90_REG_W_LOCAL_CRIT,
379                 LM90_REG_W_REMOTE_CRIT,
380         };
381
382         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
383         struct i2c_client *client = to_i2c_client(dev);
384         struct lm90_data *data = i2c_get_clientdata(client);
385         long val = simple_strtol(buf, NULL, 10);
386         int nr = attr->index;
387
388         mutex_lock(&data->update_lock);
389         if (data->kind == adt7461)
390                 data->temp8[nr] = temp_to_u8_adt7461(data, val);
391         else if (data->kind == max6646)
392                 data->temp8[nr] = temp_to_u8(val);
393         else
394                 data->temp8[nr] = temp_to_s8(val);
395         i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
396         mutex_unlock(&data->update_lock);
397         return count;
398 }
399
400 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
401                            char *buf)
402 {
403         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
404         struct lm90_data *data = lm90_update_device(dev);
405         int temp;
406
407         if (data->kind == adt7461)
408                 temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
409         else if (data->kind == max6646)
410                 temp = temp_from_u16(data->temp11[attr->index]);
411         else
412                 temp = temp_from_s16(data->temp11[attr->index]);
413
414         return sprintf(buf, "%d\n", temp);
415 }
416
417 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
418                           const char *buf, size_t count)
419 {
420         static const u8 reg[6] = {
421                 LM90_REG_W_REMOTE_LOWH,
422                 LM90_REG_W_REMOTE_LOWL,
423                 LM90_REG_W_REMOTE_HIGHH,
424                 LM90_REG_W_REMOTE_HIGHL,
425                 LM90_REG_W_REMOTE_OFFSH,
426                 LM90_REG_W_REMOTE_OFFSL,
427         };
428
429         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
430         struct i2c_client *client = to_i2c_client(dev);
431         struct lm90_data *data = i2c_get_clientdata(client);
432         long val = simple_strtol(buf, NULL, 10);
433         int nr = attr->index;
434
435         mutex_lock(&data->update_lock);
436         if (data->kind == adt7461)
437                 data->temp11[nr] = temp_to_u16_adt7461(data, val);
438         else if (data->kind == max6657 || data->kind == max6680)
439                 data->temp11[nr] = temp_to_s8(val) << 8;
440         else if (data->kind == max6646)
441                 data->temp11[nr] = temp_to_u8(val) << 8;
442         else
443                 data->temp11[nr] = temp_to_s16(val);
444
445         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
446                                   data->temp11[nr] >> 8);
447         if (data->kind != max6657 && data->kind != max6680
448             && data->kind != max6646)
449                 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
450                                           data->temp11[nr] & 0xff);
451         mutex_unlock(&data->update_lock);
452         return count;
453 }
454
455 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
456                              char *buf)
457 {
458         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
459         struct lm90_data *data = lm90_update_device(dev);
460         int temp;
461
462         if (data->kind == adt7461)
463                 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
464         else
465                 temp = temp_from_s8(data->temp8[attr->index]);
466
467         return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
468 }
469
470 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
471                             const char *buf, size_t count)
472 {
473         struct i2c_client *client = to_i2c_client(dev);
474         struct lm90_data *data = i2c_get_clientdata(client);
475         long val = simple_strtol(buf, NULL, 10);
476         long hyst;
477
478         mutex_lock(&data->update_lock);
479         hyst = temp_from_s8(data->temp8[2]) - val;
480         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
481                                   hyst_to_reg(hyst));
482         mutex_unlock(&data->update_lock);
483         return count;
484 }
485
486 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
487                            char *buf)
488 {
489         struct lm90_data *data = lm90_update_device(dev);
490         return sprintf(buf, "%d\n", data->alarms);
491 }
492
493 static ssize_t show_alarm(struct device *dev, struct device_attribute
494                           *devattr, char *buf)
495 {
496         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
497         struct lm90_data *data = lm90_update_device(dev);
498         int bitnr = attr->index;
499
500         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
501 }
502
503 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
504 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
505 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
506         set_temp8, 0);
507 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
508         set_temp11, 1);
509 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
510         set_temp8, 1);
511 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
512         set_temp11, 2);
513 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
514         set_temp8, 2);
515 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
516         set_temp8, 3);
517 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
518         set_temphyst, 2);
519 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
520 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
521         set_temp11, 3);
522
523 /* Individual alarm files */
524 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
525 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
526 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
527 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
528 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
529 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
530 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
531 /* Raw alarm file for compatibility */
532 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
533
534 static struct attribute *lm90_attributes[] = {
535         &sensor_dev_attr_temp1_input.dev_attr.attr,
536         &sensor_dev_attr_temp2_input.dev_attr.attr,
537         &sensor_dev_attr_temp1_min.dev_attr.attr,
538         &sensor_dev_attr_temp2_min.dev_attr.attr,
539         &sensor_dev_attr_temp1_max.dev_attr.attr,
540         &sensor_dev_attr_temp2_max.dev_attr.attr,
541         &sensor_dev_attr_temp1_crit.dev_attr.attr,
542         &sensor_dev_attr_temp2_crit.dev_attr.attr,
543         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
544         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
545
546         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
547         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
548         &sensor_dev_attr_temp2_fault.dev_attr.attr,
549         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
550         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
551         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
552         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
553         &dev_attr_alarms.attr,
554         NULL
555 };
556
557 static const struct attribute_group lm90_group = {
558         .attrs = lm90_attributes,
559 };
560
561 /* pec used for ADM1032 only */
562 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
563                         char *buf)
564 {
565         struct i2c_client *client = to_i2c_client(dev);
566         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
567 }
568
569 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
570                        const char *buf, size_t count)
571 {
572         struct i2c_client *client = to_i2c_client(dev);
573         long val = simple_strtol(buf, NULL, 10);
574
575         switch (val) {
576         case 0:
577                 client->flags &= ~I2C_CLIENT_PEC;
578                 break;
579         case 1:
580                 client->flags |= I2C_CLIENT_PEC;
581                 break;
582         default:
583                 return -EINVAL;
584         }
585
586         return count;
587 }
588
589 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
590
591 /*
592  * Real code
593  */
594
595 /* The ADM1032 supports PEC but not on write byte transactions, so we need
596    to explicitly ask for a transaction without PEC. */
597 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
598 {
599         return i2c_smbus_xfer(client->adapter, client->addr,
600                               client->flags & ~I2C_CLIENT_PEC,
601                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
602 }
603
604 /* It is assumed that client->update_lock is held (unless we are in
605    detection or initialization steps). This matters when PEC is enabled,
606    because we don't want the address pointer to change between the write
607    byte and the read byte transactions. */
608 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
609 {
610         int err;
611
612         if (client->flags & I2C_CLIENT_PEC) {
613                 err = adm1032_write_byte(client, reg);
614                 if (err >= 0)
615                         err = i2c_smbus_read_byte(client);
616         } else
617                 err = i2c_smbus_read_byte_data(client, reg);
618
619         if (err < 0) {
620                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
621                          reg, err);
622                 return err;
623         }
624         *value = err;
625
626         return 0;
627 }
628
629 /* Return 0 if detection is successful, -ENODEV otherwise */
630 static int lm90_detect(struct i2c_client *new_client, int kind,
631                        struct i2c_board_info *info)
632 {
633         struct i2c_adapter *adapter = new_client->adapter;
634         int address = new_client->addr;
635         const char *name = "";
636
637         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
638                 return -ENODEV;
639
640         /*
641          * Now we do the remaining detection. A negative kind means that
642          * the driver was loaded with no force parameter (default), so we
643          * must both detect and identify the chip. A zero kind means that
644          * the driver was loaded with the force parameter, the detection
645          * step shall be skipped. A positive kind means that the driver
646          * was loaded with the force parameter and a given kind of chip is
647          * requested, so both the detection and the identification steps
648          * are skipped.
649          */
650
651         /* Default to an LM90 if forced */
652         if (kind == 0)
653                 kind = lm90;
654
655         if (kind < 0) { /* detection and identification */
656                 int man_id, chip_id, reg_config1, reg_convrate;
657
658                 if ((man_id = i2c_smbus_read_byte_data(new_client,
659                                                 LM90_REG_R_MAN_ID)) < 0
660                  || (chip_id = i2c_smbus_read_byte_data(new_client,
661                                                 LM90_REG_R_CHIP_ID)) < 0
662                  || (reg_config1 = i2c_smbus_read_byte_data(new_client,
663                                                 LM90_REG_R_CONFIG1)) < 0
664                  || (reg_convrate = i2c_smbus_read_byte_data(new_client,
665                                                 LM90_REG_R_CONVRATE)) < 0)
666                         return -ENODEV;
667                 
668                 if ((address == 0x4C || address == 0x4D)
669                  && man_id == 0x01) { /* National Semiconductor */
670                         int reg_config2;
671
672                         if ((reg_config2 = i2c_smbus_read_byte_data(new_client,
673                                                 LM90_REG_R_CONFIG2)) < 0)
674                                 return -ENODEV;
675
676                         if ((reg_config1 & 0x2A) == 0x00
677                          && (reg_config2 & 0xF8) == 0x00
678                          && reg_convrate <= 0x09) {
679                                 if (address == 0x4C
680                                  && (chip_id & 0xF0) == 0x20) { /* LM90 */
681                                         kind = lm90;
682                                 } else
683                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
684                                         kind = lm99;
685                                 } else
686                                 if (address == 0x4C
687                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
688                                         kind = lm86;
689                                 }
690                         }
691                 } else
692                 if ((address == 0x4C || address == 0x4D)
693                  && man_id == 0x41) { /* Analog Devices */
694                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
695                          && (reg_config1 & 0x3F) == 0x00
696                          && reg_convrate <= 0x0A) {
697                                 kind = adm1032;
698                         } else
699                         if (chip_id == 0x51 /* ADT7461 */
700                          && (reg_config1 & 0x1B) == 0x00
701                          && reg_convrate <= 0x0A) {
702                                 kind = adt7461;
703                         }
704                 } else
705                 if (man_id == 0x4D) { /* Maxim */
706                         /*
707                          * The MAX6657, MAX6658 and MAX6659 do NOT have a
708                          * chip_id register. Reading from that address will
709                          * return the last read value, which in our case is
710                          * those of the man_id register. Likewise, the config1
711                          * register seems to lack a low nibble, so the value
712                          * will be those of the previous read, so in our case
713                          * those of the man_id register.
714                          */
715                         if (chip_id == man_id
716                          && (address == 0x4C || address == 0x4D)
717                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
718                          && reg_convrate <= 0x09) {
719                                 kind = max6657;
720                         } else
721                         /* The chip_id register of the MAX6680 and MAX6681
722                          * holds the revision of the chip.
723                          * the lowest bit of the config1 register is unused
724                          * and should return zero when read, so should the
725                          * second to last bit of config1 (software reset)
726                          */
727                         if (chip_id == 0x01
728                          && (reg_config1 & 0x03) == 0x00
729                          && reg_convrate <= 0x07) {
730                                 kind = max6680;
731                         } else
732                         /* The chip_id register of the MAX6646/6647/6649
733                          * holds the revision of the chip.
734                          * The lowest 6 bits of the config1 register are
735                          * unused and should return zero when read.
736                          */
737                         if (chip_id == 0x59
738                          && (reg_config1 & 0x3f) == 0x00
739                          && reg_convrate <= 0x07) {
740                                 kind = max6646;
741                         }
742                 }
743
744                 if (kind <= 0) { /* identification failed */
745                         dev_dbg(&adapter->dev,
746                                 "Unsupported chip at 0x%02x (man_id=0x%02X, "
747                                 "chip_id=0x%02X)\n", address, man_id, chip_id);
748                         return -ENODEV;
749                 }
750         }
751
752         /* Fill the i2c board info */
753         if (kind == lm90) {
754                 name = "lm90";
755         } else if (kind == adm1032) {
756                 name = "adm1032";
757                 /* The ADM1032 supports PEC, but only if combined
758                    transactions are not used. */
759                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
760                         info->flags |= I2C_CLIENT_PEC;
761         } else if (kind == lm99) {
762                 name = "lm99";
763         } else if (kind == lm86) {
764                 name = "lm86";
765         } else if (kind == max6657) {
766                 name = "max6657";
767         } else if (kind == max6680) {
768                 name = "max6680";
769         } else if (kind == adt7461) {
770                 name = "adt7461";
771         } else if (kind == max6646) {
772                 name = "max6646";
773         }
774         strlcpy(info->type, name, I2C_NAME_SIZE);
775
776         return 0;
777 }
778
779 static int lm90_probe(struct i2c_client *new_client,
780                       const struct i2c_device_id *id)
781 {
782         struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
783         struct lm90_data *data;
784         int err;
785
786         data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
787         if (!data) {
788                 err = -ENOMEM;
789                 goto exit;
790         }
791         i2c_set_clientdata(new_client, data);
792         mutex_init(&data->update_lock);
793
794         /* Set the device type */
795         data->kind = id->driver_data;
796         if (data->kind == adm1032) {
797                 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
798                         new_client->flags &= ~I2C_CLIENT_PEC;
799         }
800
801         /* Initialize the LM90 chip */
802         lm90_init_client(new_client);
803
804         /* Register sysfs hooks */
805         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
806                 goto exit_free;
807         if (new_client->flags & I2C_CLIENT_PEC) {
808                 if ((err = device_create_file(&new_client->dev,
809                                               &dev_attr_pec)))
810                         goto exit_remove_files;
811         }
812         if (data->kind != max6657 && data->kind != max6646) {
813                 if ((err = device_create_file(&new_client->dev,
814                                 &sensor_dev_attr_temp2_offset.dev_attr)))
815                         goto exit_remove_files;
816         }
817
818         data->hwmon_dev = hwmon_device_register(&new_client->dev);
819         if (IS_ERR(data->hwmon_dev)) {
820                 err = PTR_ERR(data->hwmon_dev);
821                 goto exit_remove_files;
822         }
823
824         return 0;
825
826 exit_remove_files:
827         sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
828         device_remove_file(&new_client->dev, &dev_attr_pec);
829 exit_free:
830         kfree(data);
831 exit:
832         return err;
833 }
834
835 static void lm90_init_client(struct i2c_client *client)
836 {
837         u8 config, config_orig;
838         struct lm90_data *data = i2c_get_clientdata(client);
839
840         /*
841          * Start the conversions.
842          */
843         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
844                                   5); /* 2 Hz */
845         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
846                 dev_warn(&client->dev, "Initialization failed!\n");
847                 return;
848         }
849         config_orig = config;
850
851         /* Check Temperature Range Select */
852         if (data->kind == adt7461) {
853                 if (config & 0x04)
854                         data->flags |= LM90_FLAG_ADT7461_EXT;
855         }
856
857         /*
858          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
859          * 0.125 degree resolution) and range (0x08, extend range
860          * to -64 degree) mode for the remote temperature sensor.
861          */
862         if (data->kind == max6680) {
863                 config |= 0x18;
864         }
865
866         config &= 0xBF; /* run */
867         if (config != config_orig) /* Only write if changed */
868                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
869 }
870
871 static int lm90_remove(struct i2c_client *client)
872 {
873         struct lm90_data *data = i2c_get_clientdata(client);
874
875         hwmon_device_unregister(data->hwmon_dev);
876         sysfs_remove_group(&client->dev.kobj, &lm90_group);
877         device_remove_file(&client->dev, &dev_attr_pec);
878         if (data->kind != max6657 && data->kind != max6646)
879                 device_remove_file(&client->dev,
880                                    &sensor_dev_attr_temp2_offset.dev_attr);
881
882         kfree(data);
883         return 0;
884 }
885
886 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
887 {
888         int err;
889         u8 oldh, newh, l;
890
891         /*
892          * There is a trick here. We have to read two registers to have the
893          * sensor temperature, but we have to beware a conversion could occur
894          * inbetween the readings. The datasheet says we should either use
895          * the one-shot conversion register, which we don't want to do
896          * (disables hardware monitoring) or monitor the busy bit, which is
897          * impossible (we can't read the values and monitor that bit at the
898          * exact same time). So the solution used here is to read the high
899          * byte once, then the low byte, then the high byte again. If the new
900          * high byte matches the old one, then we have a valid reading. Else
901          * we have to read the low byte again, and now we believe we have a
902          * correct reading.
903          */
904         if ((err = lm90_read_reg(client, regh, &oldh))
905          || (err = lm90_read_reg(client, regl, &l))
906          || (err = lm90_read_reg(client, regh, &newh)))
907                 return err;
908         if (oldh != newh) {
909                 err = lm90_read_reg(client, regl, &l);
910                 if (err)
911                         return err;
912         }
913         *value = (newh << 8) | l;
914
915         return 0;
916 }
917
918 static struct lm90_data *lm90_update_device(struct device *dev)
919 {
920         struct i2c_client *client = to_i2c_client(dev);
921         struct lm90_data *data = i2c_get_clientdata(client);
922
923         mutex_lock(&data->update_lock);
924
925         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
926                 u8 h, l;
927
928                 dev_dbg(&client->dev, "Updating lm90 data.\n");
929                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
930                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
931                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
932                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
933                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
934
935                 if (data->kind == max6657 || data->kind == max6646) {
936                         lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
937                                     MAX6657_REG_R_LOCAL_TEMPL,
938                                     &data->temp11[4]);
939                 } else {
940                         if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
941                                           &h) == 0)
942                                 data->temp11[4] = h << 8;
943                 }
944                 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
945                             LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
946
947                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
948                         data->temp11[1] = h << 8;
949                         if (data->kind != max6657 && data->kind != max6680
950                          && data->kind != max6646
951                          && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
952                                           &l) == 0)
953                                 data->temp11[1] |= l;
954                 }
955                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
956                         data->temp11[2] = h << 8;
957                         if (data->kind != max6657 && data->kind != max6680
958                          && data->kind != max6646
959                          && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
960                                           &l) == 0)
961                                 data->temp11[2] |= l;
962                 }
963
964                 if (data->kind != max6657 && data->kind != max6646) {
965                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
966                                           &h) == 0
967                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
968                                           &l) == 0)
969                                 data->temp11[3] = (h << 8) | l;
970                 }
971                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
972
973                 data->last_updated = jiffies;
974                 data->valid = 1;
975         }
976
977         mutex_unlock(&data->update_lock);
978
979         return data;
980 }
981
982 static int __init sensors_lm90_init(void)
983 {
984         return i2c_add_driver(&lm90_driver);
985 }
986
987 static void __exit sensors_lm90_exit(void)
988 {
989         i2c_del_driver(&lm90_driver);
990 }
991
992 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
993 MODULE_DESCRIPTION("LM90/ADM1032 driver");
994 MODULE_LICENSE("GPL");
995
996 module_init(sensors_lm90_init);
997 module_exit(sensors_lm90_exit);