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