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