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