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