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