2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
4 * Copyright (C) 2003-2009 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.
11 * This driver also supports the LM89 and LM99, two other sensor chips
12 * made by National Semiconductor. Both have an increased remote
13 * temperature measurement accuracy (1 degree), and the LM99
14 * additionally shifts remote temperatures (measured and limits) by 16
15 * degrees, which allows for higher temperatures measurement.
16 * Note that there is no way to differentiate between both chips.
17 * When device is auto-detected, the driver will assume an LM99.
19 * This driver also supports the LM86, another sensor chip made by
20 * National Semiconductor. It is exactly similar to the LM90 except it
21 * has a higher accuracy.
23 * This driver also supports the ADM1032, a sensor chip made by Analog
24 * Devices. That chip is similar to the LM90, with a few differences
25 * that are not handled by this driver. Among others, it has a higher
26 * accuracy than the LM90, much like the LM86 does.
28 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
29 * chips made by Maxim. These chips are similar to the LM86.
30 * Note that there is no easy way to differentiate between the three
31 * variants. The extra address and features of the MAX6659 are not
32 * supported by this driver. These chips lack the remote temperature
35 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
36 * MAX6692 chips made by Maxim. These are again similar to the LM86,
37 * but they use unsigned temperature values and can report temperatures
38 * from 0 to 145 degrees.
40 * This driver also supports the MAX6680 and MAX6681, two other sensor
41 * chips made by Maxim. These are quite similar to the other Maxim
42 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
43 * be treated identically.
45 * This driver also supports the ADT7461 chip from Analog Devices.
46 * It's supported in both compatibility and extended mode. It is mostly
47 * compatible with LM90 except for a data format difference for the
48 * temperature value registers.
50 * Since the LM90 was the first chipset supported by this driver, most
51 * comments will refer to this chipset, but are actually general and
52 * concern all supported chipsets, unless mentioned otherwise.
54 * This program is free software; you can redistribute it and/or modify
55 * it under the terms of the GNU General Public License as published by
56 * the Free Software Foundation; either version 2 of the License, or
57 * (at your option) any later version.
59 * This program is distributed in the hope that it will be useful,
60 * but WITHOUT ANY WARRANTY; without even the implied warranty of
61 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
62 * GNU General Public License for more details.
64 * You should have received a copy of the GNU General Public License
65 * along with this program; if not, write to the Free Software
66 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
69 #include <linux/module.h>
70 #include <linux/init.h>
71 #include <linux/slab.h>
72 #include <linux/jiffies.h>
73 #include <linux/i2c.h>
74 #include <linux/hwmon-sysfs.h>
75 #include <linux/hwmon.h>
76 #include <linux/err.h>
77 #include <linux/mutex.h>
78 #include <linux/sysfs.h>
82 * Address is fully defined internally and cannot be changed except for
83 * MAX6659, MAX6680 and MAX6681.
84 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6649, MAX6657
85 * and MAX6658 have address 0x4c.
86 * ADM1032-2, ADT7461-2, LM89-1, LM99-1 and MAX6646 have address 0x4d.
87 * MAX6647 has address 0x4e.
88 * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
89 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
93 static const unsigned short normal_i2c[] = {
94 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
100 I2C_CLIENT_INSMOD_8(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680,
107 #define LM90_REG_R_MAN_ID 0xFE
108 #define LM90_REG_R_CHIP_ID 0xFF
109 #define LM90_REG_R_CONFIG1 0x03
110 #define LM90_REG_W_CONFIG1 0x09
111 #define LM90_REG_R_CONFIG2 0xBF
112 #define LM90_REG_W_CONFIG2 0xBF
113 #define LM90_REG_R_CONVRATE 0x04
114 #define LM90_REG_W_CONVRATE 0x0A
115 #define LM90_REG_R_STATUS 0x02
116 #define LM90_REG_R_LOCAL_TEMP 0x00
117 #define LM90_REG_R_LOCAL_HIGH 0x05
118 #define LM90_REG_W_LOCAL_HIGH 0x0B
119 #define LM90_REG_R_LOCAL_LOW 0x06
120 #define LM90_REG_W_LOCAL_LOW 0x0C
121 #define LM90_REG_R_LOCAL_CRIT 0x20
122 #define LM90_REG_W_LOCAL_CRIT 0x20
123 #define LM90_REG_R_REMOTE_TEMPH 0x01
124 #define LM90_REG_R_REMOTE_TEMPL 0x10
125 #define LM90_REG_R_REMOTE_OFFSH 0x11
126 #define LM90_REG_W_REMOTE_OFFSH 0x11
127 #define LM90_REG_R_REMOTE_OFFSL 0x12
128 #define LM90_REG_W_REMOTE_OFFSL 0x12
129 #define LM90_REG_R_REMOTE_HIGHH 0x07
130 #define LM90_REG_W_REMOTE_HIGHH 0x0D
131 #define LM90_REG_R_REMOTE_HIGHL 0x13
132 #define LM90_REG_W_REMOTE_HIGHL 0x13
133 #define LM90_REG_R_REMOTE_LOWH 0x08
134 #define LM90_REG_W_REMOTE_LOWH 0x0E
135 #define LM90_REG_R_REMOTE_LOWL 0x14
136 #define LM90_REG_W_REMOTE_LOWL 0x14
137 #define LM90_REG_R_REMOTE_CRIT 0x19
138 #define LM90_REG_W_REMOTE_CRIT 0x19
139 #define LM90_REG_R_TCRIT_HYST 0x21
140 #define LM90_REG_W_TCRIT_HYST 0x21
142 /* MAX6646/6647/6649/6657/6658/6659 registers */
144 #define MAX6657_REG_R_LOCAL_TEMPL 0x11
149 #define LM90_FLAG_ADT7461_EXT 0x01 /* ADT7461 extended mode */
152 * Functions declaration
155 static int lm90_detect(struct i2c_client *client, struct i2c_board_info *info);
156 static int lm90_probe(struct i2c_client *client,
157 const struct i2c_device_id *id);
158 static void lm90_init_client(struct i2c_client *client);
159 static int lm90_remove(struct i2c_client *client);
160 static struct lm90_data *lm90_update_device(struct device *dev);
163 * Driver data (common to all clients)
166 static const struct i2c_device_id lm90_id[] = {
167 { "adm1032", adm1032 },
168 { "adt7461", adt7461 },
173 { "max6646", max6646 },
174 { "max6647", max6646 },
175 { "max6649", max6646 },
176 { "max6657", max6657 },
177 { "max6658", max6657 },
178 { "max6659", max6657 },
179 { "max6680", max6680 },
180 { "max6681", max6680 },
183 MODULE_DEVICE_TABLE(i2c, lm90_id);
185 static struct i2c_driver lm90_driver = {
186 .class = I2C_CLASS_HWMON,
191 .remove = lm90_remove,
193 .detect = lm90_detect,
194 .address_data = &addr_data,
198 * Client data (each client gets its own)
202 struct device *hwmon_dev;
203 struct mutex update_lock;
204 char valid; /* zero until following fields are valid */
205 unsigned long last_updated; /* in jiffies */
209 /* registers values */
210 s8 temp8[4]; /* 0: local low limit
212 2: local critical limit
213 3: remote critical limit */
214 s16 temp11[5]; /* 0: remote input
217 3: remote offset (except max6646 and max6657)
220 u8 alarms; /* bitvector */
225 * For local temperatures and limits, critical limits and the hysteresis
226 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
227 * For remote temperatures and limits, it uses signed 11-bit values with
228 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some
229 * Maxim chips use unsigned values.
232 static inline int temp_from_s8(s8 val)
237 static inline int temp_from_u8(u8 val)
242 static inline int temp_from_s16(s16 val)
244 return val / 32 * 125;
247 static inline int temp_from_u16(u16 val)
249 return val / 32 * 125;
252 static s8 temp_to_s8(long val)
259 return (val - 500) / 1000;
260 return (val + 500) / 1000;
263 static u8 temp_to_u8(long val)
269 return (val + 500) / 1000;
272 static s16 temp_to_s16(long val)
279 return (val - 62) / 125 * 32;
280 return (val + 62) / 125 * 32;
283 static u8 hyst_to_reg(long val)
289 return (val + 500) / 1000;
293 * ADT7461 in compatibility mode is almost identical to LM90 except that
294 * attempts to write values that are outside the range 0 < temp < 127 are
295 * treated as the boundary value.
297 * ADT7461 in "extended mode" operation uses unsigned integers offset by
298 * 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC.
300 static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
302 if (data->flags & LM90_FLAG_ADT7461_EXT)
303 return (val - 64) * 1000;
305 return temp_from_s8(val);
308 static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
310 if (data->flags & LM90_FLAG_ADT7461_EXT)
311 return (val - 0x4000) / 64 * 250;
313 return temp_from_s16(val);
316 static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
318 if (data->flags & LM90_FLAG_ADT7461_EXT) {
323 return (val + 500 + 64000) / 1000;
329 return (val + 500) / 1000;
333 static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
335 if (data->flags & LM90_FLAG_ADT7461_EXT) {
340 return (val + 64000 + 125) / 250 * 64;
346 return (val + 125) / 250 * 64;
354 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
357 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
358 struct lm90_data *data = lm90_update_device(dev);
361 if (data->kind == adt7461)
362 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
363 else if (data->kind == max6646)
364 temp = temp_from_u8(data->temp8[attr->index]);
366 temp = temp_from_s8(data->temp8[attr->index]);
368 /* +16 degrees offset for temp2 for the LM99 */
369 if (data->kind == lm99 && attr->index == 3)
372 return sprintf(buf, "%d\n", temp);
375 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
376 const char *buf, size_t count)
378 static const u8 reg[4] = {
379 LM90_REG_W_LOCAL_LOW,
380 LM90_REG_W_LOCAL_HIGH,
381 LM90_REG_W_LOCAL_CRIT,
382 LM90_REG_W_REMOTE_CRIT,
385 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
386 struct i2c_client *client = to_i2c_client(dev);
387 struct lm90_data *data = i2c_get_clientdata(client);
388 long val = simple_strtol(buf, NULL, 10);
389 int nr = attr->index;
391 /* +16 degrees offset for temp2 for the LM99 */
392 if (data->kind == lm99 && attr->index == 3)
395 mutex_lock(&data->update_lock);
396 if (data->kind == adt7461)
397 data->temp8[nr] = temp_to_u8_adt7461(data, val);
398 else if (data->kind == max6646)
399 data->temp8[nr] = temp_to_u8(val);
401 data->temp8[nr] = temp_to_s8(val);
402 i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
403 mutex_unlock(&data->update_lock);
407 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
410 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
411 struct lm90_data *data = lm90_update_device(dev);
414 if (data->kind == adt7461)
415 temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
416 else if (data->kind == max6646)
417 temp = temp_from_u16(data->temp11[attr->index]);
419 temp = temp_from_s16(data->temp11[attr->index]);
421 /* +16 degrees offset for temp2 for the LM99 */
422 if (data->kind == lm99 && attr->index <= 2)
425 return sprintf(buf, "%d\n", temp);
428 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
429 const char *buf, size_t count)
431 static const u8 reg[6] = {
432 LM90_REG_W_REMOTE_LOWH,
433 LM90_REG_W_REMOTE_LOWL,
434 LM90_REG_W_REMOTE_HIGHH,
435 LM90_REG_W_REMOTE_HIGHL,
436 LM90_REG_W_REMOTE_OFFSH,
437 LM90_REG_W_REMOTE_OFFSL,
440 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
441 struct i2c_client *client = to_i2c_client(dev);
442 struct lm90_data *data = i2c_get_clientdata(client);
443 long val = simple_strtol(buf, NULL, 10);
444 int nr = attr->index;
446 /* +16 degrees offset for temp2 for the LM99 */
447 if (data->kind == lm99 && attr->index <= 2)
450 mutex_lock(&data->update_lock);
451 if (data->kind == adt7461)
452 data->temp11[nr] = temp_to_u16_adt7461(data, val);
453 else if (data->kind == max6657 || data->kind == max6680)
454 data->temp11[nr] = temp_to_s8(val) << 8;
455 else if (data->kind == max6646)
456 data->temp11[nr] = temp_to_u8(val) << 8;
458 data->temp11[nr] = temp_to_s16(val);
460 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
461 data->temp11[nr] >> 8);
462 if (data->kind != max6657 && data->kind != max6680
463 && data->kind != max6646)
464 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
465 data->temp11[nr] & 0xff);
466 mutex_unlock(&data->update_lock);
470 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
473 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
474 struct lm90_data *data = lm90_update_device(dev);
477 if (data->kind == adt7461)
478 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
479 else if (data->kind == max6646)
480 temp = temp_from_u8(data->temp8[attr->index]);
482 temp = temp_from_s8(data->temp8[attr->index]);
484 /* +16 degrees offset for temp2 for the LM99 */
485 if (data->kind == lm99 && attr->index == 3)
488 return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
491 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
492 const char *buf, size_t count)
494 struct i2c_client *client = to_i2c_client(dev);
495 struct lm90_data *data = i2c_get_clientdata(client);
496 long val = simple_strtol(buf, NULL, 10);
499 mutex_lock(&data->update_lock);
500 if (data->kind == adt7461)
501 temp = temp_from_u8_adt7461(data, data->temp8[2]);
502 else if (data->kind == max6646)
503 temp = temp_from_u8(data->temp8[2]);
505 temp = temp_from_s8(data->temp8[2]);
507 data->temp_hyst = hyst_to_reg(temp - val);
508 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
510 mutex_unlock(&data->update_lock);
514 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
517 struct lm90_data *data = lm90_update_device(dev);
518 return sprintf(buf, "%d\n", data->alarms);
521 static ssize_t show_alarm(struct device *dev, struct device_attribute
524 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
525 struct lm90_data *data = lm90_update_device(dev);
526 int bitnr = attr->index;
528 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
531 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
532 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
533 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
535 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
537 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
539 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
541 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
543 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
545 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
547 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
548 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
551 /* Individual alarm files */
552 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
553 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
554 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
555 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
556 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
557 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
558 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
559 /* Raw alarm file for compatibility */
560 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
562 static struct attribute *lm90_attributes[] = {
563 &sensor_dev_attr_temp1_input.dev_attr.attr,
564 &sensor_dev_attr_temp2_input.dev_attr.attr,
565 &sensor_dev_attr_temp1_min.dev_attr.attr,
566 &sensor_dev_attr_temp2_min.dev_attr.attr,
567 &sensor_dev_attr_temp1_max.dev_attr.attr,
568 &sensor_dev_attr_temp2_max.dev_attr.attr,
569 &sensor_dev_attr_temp1_crit.dev_attr.attr,
570 &sensor_dev_attr_temp2_crit.dev_attr.attr,
571 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
572 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
574 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
575 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
576 &sensor_dev_attr_temp2_fault.dev_attr.attr,
577 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
578 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
579 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
580 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
581 &dev_attr_alarms.attr,
585 static const struct attribute_group lm90_group = {
586 .attrs = lm90_attributes,
589 /* pec used for ADM1032 only */
590 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
593 struct i2c_client *client = to_i2c_client(dev);
594 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
597 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
598 const char *buf, size_t count)
600 struct i2c_client *client = to_i2c_client(dev);
601 long val = simple_strtol(buf, NULL, 10);
605 client->flags &= ~I2C_CLIENT_PEC;
608 client->flags |= I2C_CLIENT_PEC;
617 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
623 /* The ADM1032 supports PEC but not on write byte transactions, so we need
624 to explicitly ask for a transaction without PEC. */
625 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
627 return i2c_smbus_xfer(client->adapter, client->addr,
628 client->flags & ~I2C_CLIENT_PEC,
629 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
632 /* It is assumed that client->update_lock is held (unless we are in
633 detection or initialization steps). This matters when PEC is enabled,
634 because we don't want the address pointer to change between the write
635 byte and the read byte transactions. */
636 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
640 if (client->flags & I2C_CLIENT_PEC) {
641 err = adm1032_write_byte(client, reg);
643 err = i2c_smbus_read_byte(client);
645 err = i2c_smbus_read_byte_data(client, reg);
648 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
657 /* Return 0 if detection is successful, -ENODEV otherwise */
658 static int lm90_detect(struct i2c_client *new_client,
659 struct i2c_board_info *info)
661 struct i2c_adapter *adapter = new_client->adapter;
662 int address = new_client->addr;
663 const char *name = NULL;
664 int man_id, chip_id, reg_config1, reg_convrate;
666 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
669 /* detection and identification */
670 if ((man_id = i2c_smbus_read_byte_data(new_client,
671 LM90_REG_R_MAN_ID)) < 0
672 || (chip_id = i2c_smbus_read_byte_data(new_client,
673 LM90_REG_R_CHIP_ID)) < 0
674 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
675 LM90_REG_R_CONFIG1)) < 0
676 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
677 LM90_REG_R_CONVRATE)) < 0)
680 if ((address == 0x4C || address == 0x4D)
681 && man_id == 0x01) { /* National Semiconductor */
684 reg_config2 = i2c_smbus_read_byte_data(new_client,
689 if ((reg_config1 & 0x2A) == 0x00
690 && (reg_config2 & 0xF8) == 0x00
691 && reg_convrate <= 0x09) {
693 && (chip_id & 0xF0) == 0x20) { /* LM90 */
696 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
698 dev_info(&adapter->dev,
699 "Assuming LM99 chip at 0x%02x\n",
701 dev_info(&adapter->dev,
702 "If it is an LM89, instantiate it "
703 "with the new_device sysfs "
707 && (chip_id & 0xF0) == 0x10) { /* LM86 */
712 if ((address == 0x4C || address == 0x4D)
713 && man_id == 0x41) { /* Analog Devices */
714 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
715 && (reg_config1 & 0x3F) == 0x00
716 && reg_convrate <= 0x0A) {
718 /* The ADM1032 supports PEC, but only if combined
719 transactions are not used. */
720 if (i2c_check_functionality(adapter,
721 I2C_FUNC_SMBUS_BYTE))
722 info->flags |= I2C_CLIENT_PEC;
724 if (chip_id == 0x51 /* ADT7461 */
725 && (reg_config1 & 0x1B) == 0x00
726 && reg_convrate <= 0x0A) {
730 if (man_id == 0x4D) { /* Maxim */
732 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
733 * register. Reading from that address will return the last
734 * read value, which in our case is those of the man_id
735 * register. Likewise, the config1 register seems to lack a
736 * low nibble, so the value will be those of the previous
737 * read, so in our case those of the man_id register.
739 if (chip_id == man_id
740 && (address == 0x4C || address == 0x4D)
741 && (reg_config1 & 0x1F) == (man_id & 0x0F)
742 && reg_convrate <= 0x09) {
746 * The chip_id register of the MAX6680 and MAX6681 holds the
747 * revision of the chip. The lowest bit of the config1 register
748 * is unused and should return zero when read, so should the
749 * second to last bit of config1 (software reset).
752 && (reg_config1 & 0x03) == 0x00
753 && reg_convrate <= 0x07) {
757 * The chip_id register of the MAX6646/6647/6649 holds the
758 * revision of the chip. The lowest 6 bits of the config1
759 * register are unused and should return zero when read.
762 && (reg_config1 & 0x3f) == 0x00
763 && reg_convrate <= 0x07) {
768 if (!name) { /* identification failed */
769 dev_dbg(&adapter->dev,
770 "Unsupported chip at 0x%02x (man_id=0x%02X, "
771 "chip_id=0x%02X)\n", address, man_id, chip_id);
775 strlcpy(info->type, name, I2C_NAME_SIZE);
780 static int lm90_probe(struct i2c_client *new_client,
781 const struct i2c_device_id *id)
783 struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
784 struct lm90_data *data;
787 data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
792 i2c_set_clientdata(new_client, data);
793 mutex_init(&data->update_lock);
795 /* Set the device type */
796 data->kind = id->driver_data;
797 if (data->kind == adm1032) {
798 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
799 new_client->flags &= ~I2C_CLIENT_PEC;
802 /* Initialize the LM90 chip */
803 lm90_init_client(new_client);
805 /* Register sysfs hooks */
806 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
808 if (new_client->flags & I2C_CLIENT_PEC) {
809 if ((err = device_create_file(&new_client->dev,
811 goto exit_remove_files;
813 if (data->kind != max6657 && data->kind != max6646) {
814 if ((err = device_create_file(&new_client->dev,
815 &sensor_dev_attr_temp2_offset.dev_attr)))
816 goto exit_remove_files;
819 data->hwmon_dev = hwmon_device_register(&new_client->dev);
820 if (IS_ERR(data->hwmon_dev)) {
821 err = PTR_ERR(data->hwmon_dev);
822 goto exit_remove_files;
828 sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
829 device_remove_file(&new_client->dev, &dev_attr_pec);
836 static void lm90_init_client(struct i2c_client *client)
838 u8 config, config_orig;
839 struct lm90_data *data = i2c_get_clientdata(client);
842 * Start the conversions.
844 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
846 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
847 dev_warn(&client->dev, "Initialization failed!\n");
850 config_orig = config;
852 /* Check Temperature Range Select */
853 if (data->kind == adt7461) {
855 data->flags |= LM90_FLAG_ADT7461_EXT;
859 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
860 * 0.125 degree resolution) and range (0x08, extend range
861 * to -64 degree) mode for the remote temperature sensor.
863 if (data->kind == max6680) {
867 config &= 0xBF; /* run */
868 if (config != config_orig) /* Only write if changed */
869 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
872 static int lm90_remove(struct i2c_client *client)
874 struct lm90_data *data = i2c_get_clientdata(client);
876 hwmon_device_unregister(data->hwmon_dev);
877 sysfs_remove_group(&client->dev.kobj, &lm90_group);
878 device_remove_file(&client->dev, &dev_attr_pec);
879 if (data->kind != max6657 && data->kind != max6646)
880 device_remove_file(&client->dev,
881 &sensor_dev_attr_temp2_offset.dev_attr);
887 static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
893 * There is a trick here. We have to read two registers to have the
894 * sensor temperature, but we have to beware a conversion could occur
895 * inbetween the readings. The datasheet says we should either use
896 * the one-shot conversion register, which we don't want to do
897 * (disables hardware monitoring) or monitor the busy bit, which is
898 * impossible (we can't read the values and monitor that bit at the
899 * exact same time). So the solution used here is to read the high
900 * byte once, then the low byte, then the high byte again. If the new
901 * high byte matches the old one, then we have a valid reading. Else
902 * we have to read the low byte again, and now we believe we have a
905 if ((err = lm90_read_reg(client, regh, &oldh))
906 || (err = lm90_read_reg(client, regl, &l))
907 || (err = lm90_read_reg(client, regh, &newh)))
910 err = lm90_read_reg(client, regl, &l);
914 *value = (newh << 8) | l;
919 static struct lm90_data *lm90_update_device(struct device *dev)
921 struct i2c_client *client = to_i2c_client(dev);
922 struct lm90_data *data = i2c_get_clientdata(client);
924 mutex_lock(&data->update_lock);
926 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
929 dev_dbg(&client->dev, "Updating lm90 data.\n");
930 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
931 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
932 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
933 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
934 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
936 if (data->kind == max6657 || data->kind == max6646) {
937 lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
938 MAX6657_REG_R_LOCAL_TEMPL,
941 if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
943 data->temp11[4] = h << 8;
945 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
946 LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
948 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
949 data->temp11[1] = h << 8;
950 if (data->kind != max6657 && data->kind != max6680
951 && data->kind != max6646
952 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
954 data->temp11[1] |= l;
956 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
957 data->temp11[2] = h << 8;
958 if (data->kind != max6657 && data->kind != max6680
959 && data->kind != max6646
960 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
962 data->temp11[2] |= l;
965 if (data->kind != max6657 && data->kind != max6646) {
966 if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
968 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
970 data->temp11[3] = (h << 8) | l;
972 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
974 data->last_updated = jiffies;
978 mutex_unlock(&data->update_lock);
983 static int __init sensors_lm90_init(void)
985 return i2c_add_driver(&lm90_driver);
988 static void __exit sensors_lm90_exit(void)
990 i2c_del_driver(&lm90_driver);
993 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
994 MODULE_DESCRIPTION("LM90/ADM1032 driver");
995 MODULE_LICENSE("GPL");
997 module_init(sensors_lm90_init);
998 module_exit(sensors_lm90_exit);