2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
4 * Copyright (C) 2003-2008 Jean Delvare <khali@linux-fr.org>
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
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.
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
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
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. These chips lack the remote temperature
47 * This driver also supports the MAX6680 and MAX6681, two other sensor
48 * chips made by Maxim. These are quite similar to the other Maxim
49 * chips. Complete datasheet can be obtained at:
50 * http://www.maxim-ic.com/quick_view2.cfm/qv_pk/3370
51 * The MAX6680 and MAX6681 only differ in the pinout so they can be
52 * treated identically.
54 * This driver also supports the ADT7461 chip from Analog Devices but
55 * only in its "compatability mode". If an ADT7461 chip is found but
56 * is configured in non-compatible mode (where its temperature
57 * register values are decoded differently) it is ignored by this
58 * driver. Complete datasheet can be obtained from Analog's website
60 * http://www.analog.com/en/prod/0,2877,ADT7461,00.html
62 * Since the LM90 was the first chipset supported by this driver, most
63 * comments will refer to this chipset, but are actually general and
64 * concern all supported chipsets, unless mentioned otherwise.
66 * This program is free software; you can redistribute it and/or modify
67 * it under the terms of the GNU General Public License as published by
68 * the Free Software Foundation; either version 2 of the License, or
69 * (at your option) any later version.
71 * This program is distributed in the hope that it will be useful,
72 * but WITHOUT ANY WARRANTY; without even the implied warranty of
73 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
74 * GNU General Public License for more details.
76 * You should have received a copy of the GNU General Public License
77 * along with this program; if not, write to the Free Software
78 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
81 #include <linux/module.h>
82 #include <linux/init.h>
83 #include <linux/slab.h>
84 #include <linux/jiffies.h>
85 #include <linux/i2c.h>
86 #include <linux/hwmon-sysfs.h>
87 #include <linux/hwmon.h>
88 #include <linux/err.h>
89 #include <linux/mutex.h>
90 #include <linux/sysfs.h>
94 * Address is fully defined internally and cannot be changed except for
95 * MAX6659, MAX6680 and MAX6681.
96 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
98 * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
99 * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
100 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
101 * 0x4c, 0x4d or 0x4e.
104 static const unsigned short normal_i2c[] = {
105 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
111 I2C_CLIENT_INSMOD_7(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680);
117 #define LM90_REG_R_MAN_ID 0xFE
118 #define LM90_REG_R_CHIP_ID 0xFF
119 #define LM90_REG_R_CONFIG1 0x03
120 #define LM90_REG_W_CONFIG1 0x09
121 #define LM90_REG_R_CONFIG2 0xBF
122 #define LM90_REG_W_CONFIG2 0xBF
123 #define LM90_REG_R_CONVRATE 0x04
124 #define LM90_REG_W_CONVRATE 0x0A
125 #define LM90_REG_R_STATUS 0x02
126 #define LM90_REG_R_LOCAL_TEMP 0x00
127 #define LM90_REG_R_LOCAL_HIGH 0x05
128 #define LM90_REG_W_LOCAL_HIGH 0x0B
129 #define LM90_REG_R_LOCAL_LOW 0x06
130 #define LM90_REG_W_LOCAL_LOW 0x0C
131 #define LM90_REG_R_LOCAL_CRIT 0x20
132 #define LM90_REG_W_LOCAL_CRIT 0x20
133 #define LM90_REG_R_REMOTE_TEMPH 0x01
134 #define LM90_REG_R_REMOTE_TEMPL 0x10
135 #define LM90_REG_R_REMOTE_OFFSH 0x11
136 #define LM90_REG_W_REMOTE_OFFSH 0x11
137 #define LM90_REG_R_REMOTE_OFFSL 0x12
138 #define LM90_REG_W_REMOTE_OFFSL 0x12
139 #define LM90_REG_R_REMOTE_HIGHH 0x07
140 #define LM90_REG_W_REMOTE_HIGHH 0x0D
141 #define LM90_REG_R_REMOTE_HIGHL 0x13
142 #define LM90_REG_W_REMOTE_HIGHL 0x13
143 #define LM90_REG_R_REMOTE_LOWH 0x08
144 #define LM90_REG_W_REMOTE_LOWH 0x0E
145 #define LM90_REG_R_REMOTE_LOWL 0x14
146 #define LM90_REG_W_REMOTE_LOWL 0x14
147 #define LM90_REG_R_REMOTE_CRIT 0x19
148 #define LM90_REG_W_REMOTE_CRIT 0x19
149 #define LM90_REG_R_TCRIT_HYST 0x21
150 #define LM90_REG_W_TCRIT_HYST 0x21
152 /* MAX6657-specific registers */
154 #define MAX6657_REG_R_LOCAL_TEMPL 0x11
157 * Conversions and various macros
158 * For local temperatures and limits, critical limits and the hysteresis
159 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
160 * For remote temperatures and limits, it uses signed 11-bit values with
161 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
164 #define TEMP1_FROM_REG(val) ((val) * 1000)
165 #define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \
166 (val) >= 127000 ? 127 : \
167 (val) < 0 ? ((val) - 500) / 1000 : \
168 ((val) + 500) / 1000)
169 #define TEMP2_FROM_REG(val) ((val) / 32 * 125)
170 #define TEMP2_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
171 (val) >= 127875 ? 0x7FE0 : \
172 (val) < 0 ? ((val) - 62) / 125 * 32 : \
173 ((val) + 62) / 125 * 32)
174 #define HYST_TO_REG(val) ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
175 ((val) + 500) / 1000)
178 * ADT7461 is almost identical to LM90 except that attempts to write
179 * values that are outside the range 0 < temp < 127 are treated as
180 * the boundary value.
183 #define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
184 (val) >= 127000 ? 127 : \
185 ((val) + 500) / 1000)
186 #define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
187 (val) >= 127750 ? 0x7FC0 : \
188 ((val) + 125) / 250 * 64)
191 * Functions declaration
194 static int lm90_detect(struct i2c_client *client, int kind,
195 struct i2c_board_info *info);
196 static int lm90_probe(struct i2c_client *client,
197 const struct i2c_device_id *id);
198 static void lm90_init_client(struct i2c_client *client);
199 static int lm90_remove(struct i2c_client *client);
200 static struct lm90_data *lm90_update_device(struct device *dev);
203 * Driver data (common to all clients)
206 static const struct i2c_device_id lm90_id[] = {
207 { "adm1032", adm1032 },
208 { "adt7461", adt7461 },
212 { "lm99", lm99 }, /* Missing temperature offset */
213 { "max6657", max6657 },
214 { "max6658", max6657 },
215 { "max6659", max6657 },
216 { "max6680", max6680 },
217 { "max6681", max6680 },
220 MODULE_DEVICE_TABLE(i2c, lm90_id);
222 static struct i2c_driver lm90_driver = {
223 .class = I2C_CLASS_HWMON,
228 .remove = lm90_remove,
230 .detect = lm90_detect,
231 .address_data = &addr_data,
235 * Client data (each client gets its own)
239 struct device *hwmon_dev;
240 struct mutex update_lock;
241 char valid; /* zero until following fields are valid */
242 unsigned long last_updated; /* in jiffies */
245 /* registers values */
246 s8 temp8[4]; /* 0: local low limit
248 2: local critical limit
249 3: remote critical limit */
250 s16 temp11[5]; /* 0: remote input
253 3: remote offset (except max6657)
256 u8 alarms; /* bitvector */
263 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
266 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
267 struct lm90_data *data = lm90_update_device(dev);
268 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
271 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
272 const char *buf, size_t count)
274 static const u8 reg[4] = {
275 LM90_REG_W_LOCAL_LOW,
276 LM90_REG_W_LOCAL_HIGH,
277 LM90_REG_W_LOCAL_CRIT,
278 LM90_REG_W_REMOTE_CRIT,
281 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
282 struct i2c_client *client = to_i2c_client(dev);
283 struct lm90_data *data = i2c_get_clientdata(client);
284 long val = simple_strtol(buf, NULL, 10);
285 int nr = attr->index;
287 mutex_lock(&data->update_lock);
288 if (data->kind == adt7461)
289 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
291 data->temp8[nr] = TEMP1_TO_REG(val);
292 i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
293 mutex_unlock(&data->update_lock);
297 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
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", TEMP2_FROM_REG(data->temp11[attr->index]));
305 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
306 const char *buf, size_t count)
308 static const u8 reg[6] = {
309 LM90_REG_W_REMOTE_LOWH,
310 LM90_REG_W_REMOTE_LOWL,
311 LM90_REG_W_REMOTE_HIGHH,
312 LM90_REG_W_REMOTE_HIGHL,
313 LM90_REG_W_REMOTE_OFFSH,
314 LM90_REG_W_REMOTE_OFFSL,
317 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
318 struct i2c_client *client = to_i2c_client(dev);
319 struct lm90_data *data = i2c_get_clientdata(client);
320 long val = simple_strtol(buf, NULL, 10);
321 int nr = attr->index;
323 mutex_lock(&data->update_lock);
324 if (data->kind == adt7461)
325 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
327 data->temp11[nr] = TEMP2_TO_REG(val);
328 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
329 data->temp11[nr] >> 8);
330 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
331 data->temp11[nr] & 0xff);
332 mutex_unlock(&data->update_lock);
336 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
339 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
340 struct lm90_data *data = lm90_update_device(dev);
341 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
342 - TEMP1_FROM_REG(data->temp_hyst));
345 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
346 const char *buf, size_t count)
348 struct i2c_client *client = to_i2c_client(dev);
349 struct lm90_data *data = i2c_get_clientdata(client);
350 long val = simple_strtol(buf, NULL, 10);
353 mutex_lock(&data->update_lock);
354 hyst = TEMP1_FROM_REG(data->temp8[2]) - val;
355 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
357 mutex_unlock(&data->update_lock);
361 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
364 struct lm90_data *data = lm90_update_device(dev);
365 return sprintf(buf, "%d\n", data->alarms);
368 static ssize_t show_alarm(struct device *dev, struct device_attribute
371 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
372 struct lm90_data *data = lm90_update_device(dev);
373 int bitnr = attr->index;
375 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
378 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
379 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
380 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
382 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
384 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
386 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
388 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
390 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
392 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
394 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
395 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
398 /* Individual alarm files */
399 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
400 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
401 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
402 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
403 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
404 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
405 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
406 /* Raw alarm file for compatibility */
407 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
409 static struct attribute *lm90_attributes[] = {
410 &sensor_dev_attr_temp1_input.dev_attr.attr,
411 &sensor_dev_attr_temp2_input.dev_attr.attr,
412 &sensor_dev_attr_temp1_min.dev_attr.attr,
413 &sensor_dev_attr_temp2_min.dev_attr.attr,
414 &sensor_dev_attr_temp1_max.dev_attr.attr,
415 &sensor_dev_attr_temp2_max.dev_attr.attr,
416 &sensor_dev_attr_temp1_crit.dev_attr.attr,
417 &sensor_dev_attr_temp2_crit.dev_attr.attr,
418 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
419 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
421 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
422 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
423 &sensor_dev_attr_temp2_fault.dev_attr.attr,
424 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
425 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
426 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
427 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
428 &dev_attr_alarms.attr,
432 static const struct attribute_group lm90_group = {
433 .attrs = lm90_attributes,
436 /* pec used for ADM1032 only */
437 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
440 struct i2c_client *client = to_i2c_client(dev);
441 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
444 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
445 const char *buf, size_t count)
447 struct i2c_client *client = to_i2c_client(dev);
448 long val = simple_strtol(buf, NULL, 10);
452 client->flags &= ~I2C_CLIENT_PEC;
455 client->flags |= I2C_CLIENT_PEC;
464 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
470 /* The ADM1032 supports PEC but not on write byte transactions, so we need
471 to explicitly ask for a transaction without PEC. */
472 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
474 return i2c_smbus_xfer(client->adapter, client->addr,
475 client->flags & ~I2C_CLIENT_PEC,
476 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
479 /* It is assumed that client->update_lock is held (unless we are in
480 detection or initialization steps). This matters when PEC is enabled,
481 because we don't want the address pointer to change between the write
482 byte and the read byte transactions. */
483 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
487 if (client->flags & I2C_CLIENT_PEC) {
488 err = adm1032_write_byte(client, reg);
490 err = i2c_smbus_read_byte(client);
492 err = i2c_smbus_read_byte_data(client, reg);
495 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
504 /* Return 0 if detection is successful, -ENODEV otherwise */
505 static int lm90_detect(struct i2c_client *new_client, int kind,
506 struct i2c_board_info *info)
508 struct i2c_adapter *adapter = new_client->adapter;
509 int address = new_client->addr;
510 const char *name = "";
512 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
516 * Now we do the remaining detection. A negative kind means that
517 * the driver was loaded with no force parameter (default), so we
518 * must both detect and identify the chip. A zero kind means that
519 * the driver was loaded with the force parameter, the detection
520 * step shall be skipped. A positive kind means that the driver
521 * was loaded with the force parameter and a given kind of chip is
522 * requested, so both the detection and the identification steps
526 /* Default to an LM90 if forced */
530 if (kind < 0) { /* detection and identification */
531 int man_id, chip_id, reg_config1, reg_convrate;
533 if ((man_id = i2c_smbus_read_byte_data(new_client,
534 LM90_REG_R_MAN_ID)) < 0
535 || (chip_id = i2c_smbus_read_byte_data(new_client,
536 LM90_REG_R_CHIP_ID)) < 0
537 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
538 LM90_REG_R_CONFIG1)) < 0
539 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
540 LM90_REG_R_CONVRATE)) < 0)
543 if ((address == 0x4C || address == 0x4D)
544 && man_id == 0x01) { /* National Semiconductor */
547 if ((reg_config2 = i2c_smbus_read_byte_data(new_client,
548 LM90_REG_R_CONFIG2)) < 0)
551 if ((reg_config1 & 0x2A) == 0x00
552 && (reg_config2 & 0xF8) == 0x00
553 && reg_convrate <= 0x09) {
555 && (chip_id & 0xF0) == 0x20) { /* LM90 */
558 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
562 && (chip_id & 0xF0) == 0x10) { /* LM86 */
567 if ((address == 0x4C || address == 0x4D)
568 && man_id == 0x41) { /* Analog Devices */
569 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
570 && (reg_config1 & 0x3F) == 0x00
571 && reg_convrate <= 0x0A) {
574 if (chip_id == 0x51 /* ADT7461 */
575 && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
576 && reg_convrate <= 0x0A) {
580 if (man_id == 0x4D) { /* Maxim */
582 * The MAX6657, MAX6658 and MAX6659 do NOT have a
583 * chip_id register. Reading from that address will
584 * return the last read value, which in our case is
585 * those of the man_id register. Likewise, the config1
586 * register seems to lack a low nibble, so the value
587 * will be those of the previous read, so in our case
588 * those of the man_id register.
590 if (chip_id == man_id
591 && (address == 0x4C || address == 0x4D)
592 && (reg_config1 & 0x1F) == (man_id & 0x0F)
593 && reg_convrate <= 0x09) {
596 /* The chip_id register of the MAX6680 and MAX6681
597 * holds the revision of the chip.
598 * the lowest bit of the config1 register is unused
599 * and should return zero when read, so should the
600 * second to last bit of config1 (software reset)
603 && (reg_config1 & 0x03) == 0x00
604 && reg_convrate <= 0x07) {
609 if (kind <= 0) { /* identification failed */
610 dev_info(&adapter->dev,
611 "Unsupported chip (man_id=0x%02X, "
612 "chip_id=0x%02X).\n", man_id, chip_id);
617 /* Fill the i2c board info */
620 } else if (kind == adm1032) {
622 /* The ADM1032 supports PEC, but only if combined
623 transactions are not used. */
624 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
625 info->flags |= I2C_CLIENT_PEC;
626 } else if (kind == lm99) {
628 } else if (kind == lm86) {
630 } else if (kind == max6657) {
632 } else if (kind == max6680) {
634 } else if (kind == adt7461) {
637 strlcpy(info->type, name, I2C_NAME_SIZE);
642 static int lm90_probe(struct i2c_client *new_client,
643 const struct i2c_device_id *id)
645 struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
646 struct lm90_data *data;
649 data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
654 i2c_set_clientdata(new_client, data);
655 mutex_init(&data->update_lock);
657 /* Set the device type */
658 data->kind = id->driver_data;
659 if (data->kind == adm1032) {
660 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
661 new_client->flags &= ~I2C_CLIENT_PEC;
664 /* Initialize the LM90 chip */
665 lm90_init_client(new_client);
667 /* Register sysfs hooks */
668 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
670 if (new_client->flags & I2C_CLIENT_PEC) {
671 if ((err = device_create_file(&new_client->dev,
673 goto exit_remove_files;
675 if (data->kind != max6657) {
676 if ((err = device_create_file(&new_client->dev,
677 &sensor_dev_attr_temp2_offset.dev_attr)))
678 goto exit_remove_files;
681 data->hwmon_dev = hwmon_device_register(&new_client->dev);
682 if (IS_ERR(data->hwmon_dev)) {
683 err = PTR_ERR(data->hwmon_dev);
684 goto exit_remove_files;
690 sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
691 device_remove_file(&new_client->dev, &dev_attr_pec);
698 static void lm90_init_client(struct i2c_client *client)
700 u8 config, config_orig;
701 struct lm90_data *data = i2c_get_clientdata(client);
704 * Start the conversions.
706 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
708 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
709 dev_warn(&client->dev, "Initialization failed!\n");
712 config_orig = config;
715 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
716 * 0.125 degree resolution) and range (0x08, extend range
717 * to -64 degree) mode for the remote temperature sensor.
719 if (data->kind == max6680) {
723 config &= 0xBF; /* run */
724 if (config != config_orig) /* Only write if changed */
725 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
728 static int lm90_remove(struct i2c_client *client)
730 struct lm90_data *data = i2c_get_clientdata(client);
732 hwmon_device_unregister(data->hwmon_dev);
733 sysfs_remove_group(&client->dev.kobj, &lm90_group);
734 device_remove_file(&client->dev, &dev_attr_pec);
735 if (data->kind != max6657)
736 device_remove_file(&client->dev,
737 &sensor_dev_attr_temp2_offset.dev_attr);
743 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
749 * There is a trick here. We have to read two registers to have the
750 * sensor temperature, but we have to beware a conversion could occur
751 * inbetween the readings. The datasheet says we should either use
752 * the one-shot conversion register, which we don't want to do
753 * (disables hardware monitoring) or monitor the busy bit, which is
754 * impossible (we can't read the values and monitor that bit at the
755 * exact same time). So the solution used here is to read the high
756 * byte once, then the low byte, then the high byte again. If the new
757 * high byte matches the old one, then we have a valid reading. Else
758 * we have to read the low byte again, and now we believe we have a
761 if ((err = lm90_read_reg(client, regh, &oldh))
762 || (err = lm90_read_reg(client, regl, &l))
763 || (err = lm90_read_reg(client, regh, &newh)))
766 err = lm90_read_reg(client, regl, &l);
770 *value = (newh << 8) | l;
775 static struct lm90_data *lm90_update_device(struct device *dev)
777 struct i2c_client *client = to_i2c_client(dev);
778 struct lm90_data *data = i2c_get_clientdata(client);
780 mutex_lock(&data->update_lock);
782 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
785 dev_dbg(&client->dev, "Updating lm90 data.\n");
786 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
787 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
788 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
789 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
790 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
792 if (data->kind == max6657) {
793 lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
794 MAX6657_REG_R_LOCAL_TEMPL,
797 if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
799 data->temp11[4] = h << 8;
801 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
802 LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
804 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0
805 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
806 data->temp11[1] = (h << 8) | l;
807 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0
808 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
809 data->temp11[2] = (h << 8) | l;
810 if (data->kind != max6657) {
811 if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
813 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
815 data->temp11[3] = (h << 8) | l;
817 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
819 data->last_updated = jiffies;
823 mutex_unlock(&data->update_lock);
828 static int __init sensors_lm90_init(void)
830 return i2c_add_driver(&lm90_driver);
833 static void __exit sensors_lm90_exit(void)
835 i2c_del_driver(&lm90_driver);
838 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
839 MODULE_DESCRIPTION("LM90/ADM1032 driver");
840 MODULE_LICENSE("GPL");
842 module_init(sensors_lm90_init);
843 module_exit(sensors_lm90_exit);