USB: makes usb_endpoint_* functions inline.
[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-2006  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. Complete datasheet can be
10  * obtained from National's website at:
11  *   http://www.national.com/pf/LM/LM90.html
12  *
13  * This driver also supports the LM89 and LM99, two other sensor chips
14  * made by National Semiconductor. Both have an increased remote
15  * temperature measurement accuracy (1 degree), and the LM99
16  * additionally shifts remote temperatures (measured and limits) by 16
17  * degrees, which allows for higher temperatures measurement. The
18  * driver doesn't handle it since it can be done easily in user-space.
19  * Complete datasheets can be obtained from National's website at:
20  *   http://www.national.com/pf/LM/LM89.html
21  *   http://www.national.com/pf/LM/LM99.html
22  * Note that there is no way to differentiate between both chips.
23  *
24  * This driver also supports the LM86, another sensor chip made by
25  * National Semiconductor. It is exactly similar to the LM90 except it
26  * has a higher accuracy.
27  * Complete datasheet can be obtained from National's website at:
28  *   http://www.national.com/pf/LM/LM86.html
29  *
30  * This driver also supports the ADM1032, a sensor chip made by Analog
31  * Devices. That chip is similar to the LM90, with a few differences
32  * that are not handled by this driver. Complete datasheet can be
33  * obtained from Analog's website at:
34  *   http://www.analog.com/en/prod/0,2877,ADM1032,00.html
35  * Among others, it has a higher accuracy than the LM90, much like the
36  * LM86 does.
37  *
38  * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
39  * chips made by Maxim. These chips are similar to the LM86. Complete
40  * datasheet can be obtained at Maxim's website at:
41  *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2578
42  * Note that there is no easy way to differentiate between the three
43  * variants. The extra address and features of the MAX6659 are not
44  * supported by this driver.
45  *
46  * This driver also supports the ADT7461 chip from Analog Devices but
47  * only in its "compatability mode". If an ADT7461 chip is found but
48  * is configured in non-compatible mode (where its temperature
49  * register values are decoded differently) it is ignored by this
50  * driver. Complete datasheet can be obtained from Analog's website
51  * at:
52  *   http://www.analog.com/en/prod/0,2877,ADT7461,00.html
53  *
54  * Since the LM90 was the first chipset supported by this driver, most
55  * comments will refer to this chipset, but are actually general and
56  * concern all supported chipsets, unless mentioned otherwise.
57  *
58  * This program is free software; you can redistribute it and/or modify
59  * it under the terms of the GNU General Public License as published by
60  * the Free Software Foundation; either version 2 of the License, or
61  * (at your option) any later version.
62  *
63  * This program is distributed in the hope that it will be useful,
64  * but WITHOUT ANY WARRANTY; without even the implied warranty of
65  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
66  * GNU General Public License for more details.
67  *
68  * You should have received a copy of the GNU General Public License
69  * along with this program; if not, write to the Free Software
70  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
71  */
72
73 #include <linux/module.h>
74 #include <linux/init.h>
75 #include <linux/slab.h>
76 #include <linux/jiffies.h>
77 #include <linux/i2c.h>
78 #include <linux/hwmon-sysfs.h>
79 #include <linux/hwmon.h>
80 #include <linux/err.h>
81 #include <linux/mutex.h>
82 #include <linux/sysfs.h>
83
84 /*
85  * Addresses to scan
86  * Address is fully defined internally and cannot be changed except for
87  * MAX6659.
88  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
89  * have address 0x4c.
90  * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
91  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
92  */
93
94 static unsigned short normal_i2c[] = { 0x4c, 0x4d, I2C_CLIENT_END };
95
96 /*
97  * Insmod parameters
98  */
99
100 I2C_CLIENT_INSMOD_6(lm90, adm1032, lm99, lm86, max6657, adt7461);
101
102 /*
103  * The LM90 registers
104  */
105
106 #define LM90_REG_R_MAN_ID               0xFE
107 #define LM90_REG_R_CHIP_ID              0xFF
108 #define LM90_REG_R_CONFIG1              0x03
109 #define LM90_REG_W_CONFIG1              0x09
110 #define LM90_REG_R_CONFIG2              0xBF
111 #define LM90_REG_W_CONFIG2              0xBF
112 #define LM90_REG_R_CONVRATE             0x04
113 #define LM90_REG_W_CONVRATE             0x0A
114 #define LM90_REG_R_STATUS               0x02
115 #define LM90_REG_R_LOCAL_TEMP           0x00
116 #define LM90_REG_R_LOCAL_HIGH           0x05
117 #define LM90_REG_W_LOCAL_HIGH           0x0B
118 #define LM90_REG_R_LOCAL_LOW            0x06
119 #define LM90_REG_W_LOCAL_LOW            0x0C
120 #define LM90_REG_R_LOCAL_CRIT           0x20
121 #define LM90_REG_W_LOCAL_CRIT           0x20
122 #define LM90_REG_R_REMOTE_TEMPH         0x01
123 #define LM90_REG_R_REMOTE_TEMPL         0x10
124 #define LM90_REG_R_REMOTE_OFFSH         0x11
125 #define LM90_REG_W_REMOTE_OFFSH         0x11
126 #define LM90_REG_R_REMOTE_OFFSL         0x12
127 #define LM90_REG_W_REMOTE_OFFSL         0x12
128 #define LM90_REG_R_REMOTE_HIGHH         0x07
129 #define LM90_REG_W_REMOTE_HIGHH         0x0D
130 #define LM90_REG_R_REMOTE_HIGHL         0x13
131 #define LM90_REG_W_REMOTE_HIGHL         0x13
132 #define LM90_REG_R_REMOTE_LOWH          0x08
133 #define LM90_REG_W_REMOTE_LOWH          0x0E
134 #define LM90_REG_R_REMOTE_LOWL          0x14
135 #define LM90_REG_W_REMOTE_LOWL          0x14
136 #define LM90_REG_R_REMOTE_CRIT          0x19
137 #define LM90_REG_W_REMOTE_CRIT          0x19
138 #define LM90_REG_R_TCRIT_HYST           0x21
139 #define LM90_REG_W_TCRIT_HYST           0x21
140
141 /*
142  * Conversions and various macros
143  * For local temperatures and limits, critical limits and the hysteresis
144  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
145  * For remote temperatures and limits, it uses signed 11-bit values with
146  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
147  */
148
149 #define TEMP1_FROM_REG(val)     ((val) * 1000)
150 #define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
151                                  (val) >= 127000 ? 127 : \
152                                  (val) < 0 ? ((val) - 500) / 1000 : \
153                                  ((val) + 500) / 1000)
154 #define TEMP2_FROM_REG(val)     ((val) / 32 * 125)
155 #define TEMP2_TO_REG(val)       ((val) <= -128000 ? 0x8000 : \
156                                  (val) >= 127875 ? 0x7FE0 : \
157                                  (val) < 0 ? ((val) - 62) / 125 * 32 : \
158                                  ((val) + 62) / 125 * 32)
159 #define HYST_TO_REG(val)        ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
160                                  ((val) + 500) / 1000)
161
162 /* 
163  * ADT7461 is almost identical to LM90 except that attempts to write
164  * values that are outside the range 0 < temp < 127 are treated as
165  * the boundary value. 
166  */
167
168 #define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
169                                  (val) >= 127000 ? 127 : \
170                                  ((val) + 500) / 1000)
171 #define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
172                                  (val) >= 127750 ? 0x7FC0 : \
173                                  ((val) + 125) / 250 * 64)
174
175 /*
176  * Functions declaration
177  */
178
179 static int lm90_attach_adapter(struct i2c_adapter *adapter);
180 static int lm90_detect(struct i2c_adapter *adapter, int address,
181         int kind);
182 static void lm90_init_client(struct i2c_client *client);
183 static int lm90_detach_client(struct i2c_client *client);
184 static struct lm90_data *lm90_update_device(struct device *dev);
185
186 /*
187  * Driver data (common to all clients)
188  */
189
190 static struct i2c_driver lm90_driver = {
191         .driver = {
192                 .name   = "lm90",
193         },
194         .id             = I2C_DRIVERID_LM90,
195         .attach_adapter = lm90_attach_adapter,
196         .detach_client  = lm90_detach_client,
197 };
198
199 /*
200  * Client data (each client gets its own)
201  */
202
203 struct lm90_data {
204         struct i2c_client client;
205         struct class_device *class_dev;
206         struct mutex update_lock;
207         char valid; /* zero until following fields are valid */
208         unsigned long last_updated; /* in jiffies */
209         int kind;
210
211         /* registers values */
212         s8 temp8[5];    /* 0: local input
213                            1: local low limit
214                            2: local high limit
215                            3: local critical limit
216                            4: remote critical limit */
217         s16 temp11[3];  /* 0: remote input
218                            1: remote low limit
219                            2: remote high limit */
220         u8 temp_hyst;
221         u8 alarms; /* bitvector */
222 };
223
224 /*
225  * Sysfs stuff
226  */
227
228 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
229                           char *buf)
230 {
231         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
232         struct lm90_data *data = lm90_update_device(dev);
233         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
234 }
235
236 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
237                          const char *buf, size_t count)
238 {
239         static const u8 reg[4] = {
240                 LM90_REG_W_LOCAL_LOW,
241                 LM90_REG_W_LOCAL_HIGH,
242                 LM90_REG_W_LOCAL_CRIT,
243                 LM90_REG_W_REMOTE_CRIT,
244         };
245
246         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
247         struct i2c_client *client = to_i2c_client(dev);
248         struct lm90_data *data = i2c_get_clientdata(client);
249         long val = simple_strtol(buf, NULL, 10);
250         int nr = attr->index;
251
252         mutex_lock(&data->update_lock);
253         if (data->kind == adt7461)
254                 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
255         else
256                 data->temp8[nr] = TEMP1_TO_REG(val);
257         i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
258         mutex_unlock(&data->update_lock);
259         return count;
260 }
261
262 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
263                            char *buf)
264 {
265         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
266         struct lm90_data *data = lm90_update_device(dev);
267         return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
268 }
269
270 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
271                           const char *buf, size_t count)
272 {
273         static const u8 reg[4] = {
274                 LM90_REG_W_REMOTE_LOWH,
275                 LM90_REG_W_REMOTE_LOWL,
276                 LM90_REG_W_REMOTE_HIGHH,
277                 LM90_REG_W_REMOTE_HIGHL,
278         };
279
280         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
281         struct i2c_client *client = to_i2c_client(dev);
282         struct lm90_data *data = i2c_get_clientdata(client);
283         long val = simple_strtol(buf, NULL, 10);
284         int nr = attr->index;
285
286         mutex_lock(&data->update_lock);
287         if (data->kind == adt7461)
288                 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
289         else
290                 data->temp11[nr] = TEMP2_TO_REG(val);
291         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
292                                   data->temp11[nr] >> 8);
293         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
294                                   data->temp11[nr] & 0xff);
295         mutex_unlock(&data->update_lock);
296         return count;
297 }
298
299 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
300                              char *buf)
301 {
302         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
303         struct lm90_data *data = lm90_update_device(dev);
304         return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
305                        - TEMP1_FROM_REG(data->temp_hyst));
306 }
307
308 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
309                             const char *buf, size_t count)
310 {
311         struct i2c_client *client = to_i2c_client(dev);
312         struct lm90_data *data = i2c_get_clientdata(client);
313         long val = simple_strtol(buf, NULL, 10);
314         long hyst;
315
316         mutex_lock(&data->update_lock);
317         hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
318         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
319                                   HYST_TO_REG(hyst));
320         mutex_unlock(&data->update_lock);
321         return count;
322 }
323
324 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
325                            char *buf)
326 {
327         struct lm90_data *data = lm90_update_device(dev);
328         return sprintf(buf, "%d\n", data->alarms);
329 }
330
331 static ssize_t show_alarm(struct device *dev, struct device_attribute
332                           *devattr, char *buf)
333 {
334         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
335         struct lm90_data *data = lm90_update_device(dev);
336         int bitnr = attr->index;
337
338         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
339 }
340
341 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
342 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
343 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
344         set_temp8, 1);
345 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
346         set_temp11, 1);
347 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
348         set_temp8, 2);
349 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
350         set_temp11, 2);
351 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
352         set_temp8, 3);
353 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
354         set_temp8, 4);
355 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
356         set_temphyst, 3);
357 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
358
359 /* Individual alarm files */
360 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
361 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
362 static SENSOR_DEVICE_ATTR(temp2_input_fault, S_IRUGO, show_alarm, NULL, 2);
363 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
364 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
365 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
366 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
367 /* Raw alarm file for compatibility */
368 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
369
370 static struct attribute *lm90_attributes[] = {
371         &sensor_dev_attr_temp1_input.dev_attr.attr,
372         &sensor_dev_attr_temp2_input.dev_attr.attr,
373         &sensor_dev_attr_temp1_min.dev_attr.attr,
374         &sensor_dev_attr_temp2_min.dev_attr.attr,
375         &sensor_dev_attr_temp1_max.dev_attr.attr,
376         &sensor_dev_attr_temp2_max.dev_attr.attr,
377         &sensor_dev_attr_temp1_crit.dev_attr.attr,
378         &sensor_dev_attr_temp2_crit.dev_attr.attr,
379         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
380         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
381
382         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
383         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
384         &sensor_dev_attr_temp2_input_fault.dev_attr.attr,
385         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
386         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
387         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
388         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
389         &dev_attr_alarms.attr,
390         NULL
391 };
392
393 static const struct attribute_group lm90_group = {
394         .attrs = lm90_attributes,
395 };
396
397 /* pec used for ADM1032 only */
398 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
399                         char *buf)
400 {
401         struct i2c_client *client = to_i2c_client(dev);
402         return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
403 }
404
405 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
406                        const char *buf, size_t count)
407 {
408         struct i2c_client *client = to_i2c_client(dev);
409         long val = simple_strtol(buf, NULL, 10);
410
411         switch (val) {
412         case 0:
413                 client->flags &= ~I2C_CLIENT_PEC;
414                 break;
415         case 1:
416                 client->flags |= I2C_CLIENT_PEC;
417                 break;
418         default:
419                 return -EINVAL;
420         }
421
422         return count;
423 }
424
425 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
426
427 /*
428  * Real code
429  */
430
431 /* The ADM1032 supports PEC but not on write byte transactions, so we need
432    to explicitely ask for a transaction without PEC. */
433 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
434 {
435         return i2c_smbus_xfer(client->adapter, client->addr,
436                               client->flags & ~I2C_CLIENT_PEC,
437                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
438 }
439
440 /* It is assumed that client->update_lock is held (unless we are in
441    detection or initialization steps). This matters when PEC is enabled,
442    because we don't want the address pointer to change between the write
443    byte and the read byte transactions. */
444 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
445 {
446         int err;
447
448         if (client->flags & I2C_CLIENT_PEC) {
449                 err = adm1032_write_byte(client, reg);
450                 if (err >= 0)
451                         err = i2c_smbus_read_byte(client);
452         } else
453                 err = i2c_smbus_read_byte_data(client, reg);
454
455         if (err < 0) {
456                 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
457                          reg, err);
458                 return err;
459         }
460         *value = err;
461
462         return 0;
463 }
464
465 static int lm90_attach_adapter(struct i2c_adapter *adapter)
466 {
467         if (!(adapter->class & I2C_CLASS_HWMON))
468                 return 0;
469         return i2c_probe(adapter, &addr_data, lm90_detect);
470 }
471
472 /*
473  * The following function does more than just detection. If detection
474  * succeeds, it also registers the new chip.
475  */
476 static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
477 {
478         struct i2c_client *new_client;
479         struct lm90_data *data;
480         int err = 0;
481         const char *name = "";
482
483         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
484                 goto exit;
485
486         if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
487                 err = -ENOMEM;
488                 goto exit;
489         }
490
491         /* The common I2C client data is placed right before the
492            LM90-specific data. */
493         new_client = &data->client;
494         i2c_set_clientdata(new_client, data);
495         new_client->addr = address;
496         new_client->adapter = adapter;
497         new_client->driver = &lm90_driver;
498         new_client->flags = 0;
499
500         /*
501          * Now we do the remaining detection. A negative kind means that
502          * the driver was loaded with no force parameter (default), so we
503          * must both detect and identify the chip. A zero kind means that
504          * the driver was loaded with the force parameter, the detection
505          * step shall be skipped. A positive kind means that the driver
506          * was loaded with the force parameter and a given kind of chip is
507          * requested, so both the detection and the identification steps
508          * are skipped.
509          */
510
511         /* Default to an LM90 if forced */
512         if (kind == 0)
513                 kind = lm90;
514
515         if (kind < 0) { /* detection and identification */
516                 u8 man_id, chip_id, reg_config1, reg_convrate;
517
518                 if (lm90_read_reg(new_client, LM90_REG_R_MAN_ID,
519                                   &man_id) < 0
520                  || lm90_read_reg(new_client, LM90_REG_R_CHIP_ID,
521                                   &chip_id) < 0
522                  || lm90_read_reg(new_client, LM90_REG_R_CONFIG1,
523                                   &reg_config1) < 0
524                  || lm90_read_reg(new_client, LM90_REG_R_CONVRATE,
525                                   &reg_convrate) < 0)
526                         goto exit_free;
527                 
528                 if (man_id == 0x01) { /* National Semiconductor */
529                         u8 reg_config2;
530
531                         if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
532                                           &reg_config2) < 0)
533                                 goto exit_free;
534
535                         if ((reg_config1 & 0x2A) == 0x00
536                          && (reg_config2 & 0xF8) == 0x00
537                          && reg_convrate <= 0x09) {
538                                 if (address == 0x4C
539                                  && (chip_id & 0xF0) == 0x20) { /* LM90 */
540                                         kind = lm90;
541                                 } else
542                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
543                                         kind = lm99;
544                                 } else
545                                 if (address == 0x4C
546                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
547                                         kind = lm86;
548                                 }
549                         }
550                 } else
551                 if (man_id == 0x41) { /* Analog Devices */
552                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
553                          && (reg_config1 & 0x3F) == 0x00
554                          && reg_convrate <= 0x0A) {
555                                 kind = adm1032;
556                         } else
557                         if (chip_id == 0x51 /* ADT7461 */
558                          && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
559                          && reg_convrate <= 0x0A) {
560                                 kind = adt7461;
561                         }
562                 } else
563                 if (man_id == 0x4D) { /* Maxim */
564                         /*
565                          * The Maxim variants do NOT have a chip_id register.
566                          * Reading from that address will return the last read
567                          * value, which in our case is those of the man_id
568                          * register. Likewise, the config1 register seems to
569                          * lack a low nibble, so the value will be those of the
570                          * previous read, so in our case those of the man_id
571                          * register.
572                          */
573                         if (chip_id == man_id
574                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
575                          && reg_convrate <= 0x09) {
576                                 kind = max6657;
577                         }
578                 }
579
580                 if (kind <= 0) { /* identification failed */
581                         dev_info(&adapter->dev,
582                             "Unsupported chip (man_id=0x%02X, "
583                             "chip_id=0x%02X).\n", man_id, chip_id);
584                         goto exit_free;
585                 }
586         }
587
588         if (kind == lm90) {
589                 name = "lm90";
590         } else if (kind == adm1032) {
591                 name = "adm1032";
592                 /* The ADM1032 supports PEC, but only if combined
593                    transactions are not used. */
594                 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
595                         new_client->flags |= I2C_CLIENT_PEC;
596         } else if (kind == lm99) {
597                 name = "lm99";
598         } else if (kind == lm86) {
599                 name = "lm86";
600         } else if (kind == max6657) {
601                 name = "max6657";
602         } else if (kind == adt7461) {
603                 name = "adt7461";
604         }
605
606         /* We can fill in the remaining client fields */
607         strlcpy(new_client->name, name, I2C_NAME_SIZE);
608         data->valid = 0;
609         data->kind = kind;
610         mutex_init(&data->update_lock);
611
612         /* Tell the I2C layer a new client has arrived */
613         if ((err = i2c_attach_client(new_client)))
614                 goto exit_free;
615
616         /* Initialize the LM90 chip */
617         lm90_init_client(new_client);
618
619         /* Register sysfs hooks */
620         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
621                 goto exit_detach;
622         if (new_client->flags & I2C_CLIENT_PEC) {
623                 if ((err = device_create_file(&new_client->dev,
624                                               &dev_attr_pec)))
625                         goto exit_remove_files;
626         }
627
628         data->class_dev = hwmon_device_register(&new_client->dev);
629         if (IS_ERR(data->class_dev)) {
630                 err = PTR_ERR(data->class_dev);
631                 goto exit_remove_files;
632         }
633
634         return 0;
635
636 exit_remove_files:
637         sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
638         device_remove_file(&new_client->dev, &dev_attr_pec);
639 exit_detach:
640         i2c_detach_client(new_client);
641 exit_free:
642         kfree(data);
643 exit:
644         return err;
645 }
646
647 static void lm90_init_client(struct i2c_client *client)
648 {
649         u8 config;
650
651         /*
652          * Start the conversions.
653          */
654         i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
655                                   5); /* 2 Hz */
656         if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
657                 dev_warn(&client->dev, "Initialization failed!\n");
658                 return;
659         }
660         if (config & 0x40)
661                 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
662                                           config & 0xBF); /* run */
663 }
664
665 static int lm90_detach_client(struct i2c_client *client)
666 {
667         struct lm90_data *data = i2c_get_clientdata(client);
668         int err;
669
670         hwmon_device_unregister(data->class_dev);
671         sysfs_remove_group(&client->dev.kobj, &lm90_group);
672         device_remove_file(&client->dev, &dev_attr_pec);
673
674         if ((err = i2c_detach_client(client)))
675                 return err;
676
677         kfree(data);
678         return 0;
679 }
680
681 static struct lm90_data *lm90_update_device(struct device *dev)
682 {
683         struct i2c_client *client = to_i2c_client(dev);
684         struct lm90_data *data = i2c_get_clientdata(client);
685
686         mutex_lock(&data->update_lock);
687
688         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
689                 u8 oldh, newh, l;
690
691                 dev_dbg(&client->dev, "Updating lm90 data.\n");
692                 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
693                 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
694                 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
695                 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
696                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
697                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
698
699                 /*
700                  * There is a trick here. We have to read two registers to
701                  * have the remote sensor temperature, but we have to beware
702                  * a conversion could occur inbetween the readings. The
703                  * datasheet says we should either use the one-shot
704                  * conversion register, which we don't want to do (disables
705                  * hardware monitoring) or monitor the busy bit, which is
706                  * impossible (we can't read the values and monitor that bit
707                  * at the exact same time). So the solution used here is to
708                  * read the high byte once, then the low byte, then the high
709                  * byte again. If the new high byte matches the old one,
710                  * then we have a valid reading. Else we have to read the low
711                  * byte again, and now we believe we have a correct reading.
712                  */
713                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
714                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
715                  && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
716                  && (newh == oldh
717                   || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
718                         data->temp11[0] = (newh << 8) | l;
719
720                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
721                  && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
722                         data->temp11[1] = (newh << 8) | l;
723                 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
724                  && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
725                         data->temp11[2] = (newh << 8) | l;
726                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
727
728                 data->last_updated = jiffies;
729                 data->valid = 1;
730         }
731
732         mutex_unlock(&data->update_lock);
733
734         return data;
735 }
736
737 static int __init sensors_lm90_init(void)
738 {
739         return i2c_add_driver(&lm90_driver);
740 }
741
742 static void __exit sensors_lm90_exit(void)
743 {
744         i2c_del_driver(&lm90_driver);
745 }
746
747 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
748 MODULE_DESCRIPTION("LM90/ADM1032 driver");
749 MODULE_LICENSE("GPL");
750
751 module_init(sensors_lm90_init);
752 module_exit(sensors_lm90_exit);