2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
4 * Copyright (C) 2003-2010 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
};
96 enum chips
{ lm90
, adm1032
, lm99
, lm86
, max6657
, adt7461
, max6680
, max6646
,
103 #define LM90_REG_R_MAN_ID 0xFE
104 #define LM90_REG_R_CHIP_ID 0xFF
105 #define LM90_REG_R_CONFIG1 0x03
106 #define LM90_REG_W_CONFIG1 0x09
107 #define LM90_REG_R_CONFIG2 0xBF
108 #define LM90_REG_W_CONFIG2 0xBF
109 #define LM90_REG_R_CONVRATE 0x04
110 #define LM90_REG_W_CONVRATE 0x0A
111 #define LM90_REG_R_STATUS 0x02
112 #define LM90_REG_R_LOCAL_TEMP 0x00
113 #define LM90_REG_R_LOCAL_HIGH 0x05
114 #define LM90_REG_W_LOCAL_HIGH 0x0B
115 #define LM90_REG_R_LOCAL_LOW 0x06
116 #define LM90_REG_W_LOCAL_LOW 0x0C
117 #define LM90_REG_R_LOCAL_CRIT 0x20
118 #define LM90_REG_W_LOCAL_CRIT 0x20
119 #define LM90_REG_R_REMOTE_TEMPH 0x01
120 #define LM90_REG_R_REMOTE_TEMPL 0x10
121 #define LM90_REG_R_REMOTE_OFFSH 0x11
122 #define LM90_REG_W_REMOTE_OFFSH 0x11
123 #define LM90_REG_R_REMOTE_OFFSL 0x12
124 #define LM90_REG_W_REMOTE_OFFSL 0x12
125 #define LM90_REG_R_REMOTE_HIGHH 0x07
126 #define LM90_REG_W_REMOTE_HIGHH 0x0D
127 #define LM90_REG_R_REMOTE_HIGHL 0x13
128 #define LM90_REG_W_REMOTE_HIGHL 0x13
129 #define LM90_REG_R_REMOTE_LOWH 0x08
130 #define LM90_REG_W_REMOTE_LOWH 0x0E
131 #define LM90_REG_R_REMOTE_LOWL 0x14
132 #define LM90_REG_W_REMOTE_LOWL 0x14
133 #define LM90_REG_R_REMOTE_CRIT 0x19
134 #define LM90_REG_W_REMOTE_CRIT 0x19
135 #define LM90_REG_R_TCRIT_HYST 0x21
136 #define LM90_REG_W_TCRIT_HYST 0x21
138 /* MAX6646/6647/6649/6657/6658/6659 registers */
140 #define MAX6657_REG_R_LOCAL_TEMPL 0x11
145 #define LM90_FLAG_ADT7461_EXT (1 << 0) /* ADT7461 extended mode */
146 /* Device features */
147 #define LM90_HAVE_OFFSET (1 << 1) /* temperature offset register */
148 #define LM90_HAVE_LOCAL_EXT (1 << 2) /* extended local temperature */
149 #define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit */
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 void lm90_alert(struct i2c_client
*client
, unsigned int flag
);
160 static int lm90_remove(struct i2c_client
*client
);
161 static struct lm90_data
*lm90_update_device(struct device
*dev
);
164 * Driver data (common to all clients)
167 static const struct i2c_device_id lm90_id
[] = {
168 { "adm1032", adm1032
},
169 { "adt7461", adt7461
},
174 { "max6646", max6646
},
175 { "max6647", max6646
},
176 { "max6649", max6646
},
177 { "max6657", max6657
},
178 { "max6658", max6657
},
179 { "max6659", max6657
},
180 { "max6680", max6680
},
181 { "max6681", max6680
},
182 { "w83l771", w83l771
},
185 MODULE_DEVICE_TABLE(i2c
, lm90_id
);
187 static struct i2c_driver lm90_driver
= {
188 .class = I2C_CLASS_HWMON
,
193 .remove
= lm90_remove
,
196 .detect
= lm90_detect
,
197 .address_list
= normal_i2c
,
201 * Client data (each client gets its own)
205 struct device
*hwmon_dev
;
206 struct mutex update_lock
;
207 char valid
; /* zero until following fields are valid */
208 unsigned long last_updated
; /* in jiffies */
212 u8 config_orig
; /* Original configuration register value */
213 u8 alert_alarms
; /* Which alarm bits trigger ALERT# */
215 /* registers values */
216 s8 temp8
[4]; /* 0: local low limit
218 2: local critical limit
219 3: remote critical limit */
220 s16 temp11
[5]; /* 0: remote input
223 3: remote offset (except max6646 and max6657)
226 u8 alarms
; /* bitvector */
231 * For local temperatures and limits, critical limits and the hysteresis
232 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
233 * For remote temperatures and limits, it uses signed 11-bit values with
234 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some
235 * Maxim chips use unsigned values.
238 static inline int temp_from_s8(s8 val
)
243 static inline int temp_from_u8(u8 val
)
248 static inline int temp_from_s16(s16 val
)
250 return val
/ 32 * 125;
253 static inline int temp_from_u16(u16 val
)
255 return val
/ 32 * 125;
258 static s8
temp_to_s8(long val
)
265 return (val
- 500) / 1000;
266 return (val
+ 500) / 1000;
269 static u8
temp_to_u8(long val
)
275 return (val
+ 500) / 1000;
278 static s16
temp_to_s16(long val
)
285 return (val
- 62) / 125 * 32;
286 return (val
+ 62) / 125 * 32;
289 static u8
hyst_to_reg(long val
)
295 return (val
+ 500) / 1000;
299 * ADT7461 in compatibility mode is almost identical to LM90 except that
300 * attempts to write values that are outside the range 0 < temp < 127 are
301 * treated as the boundary value.
303 * ADT7461 in "extended mode" operation uses unsigned integers offset by
304 * 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC.
306 static inline int temp_from_u8_adt7461(struct lm90_data
*data
, u8 val
)
308 if (data
->flags
& LM90_FLAG_ADT7461_EXT
)
309 return (val
- 64) * 1000;
311 return temp_from_s8(val
);
314 static inline int temp_from_u16_adt7461(struct lm90_data
*data
, u16 val
)
316 if (data
->flags
& LM90_FLAG_ADT7461_EXT
)
317 return (val
- 0x4000) / 64 * 250;
319 return temp_from_s16(val
);
322 static u8
temp_to_u8_adt7461(struct lm90_data
*data
, long val
)
324 if (data
->flags
& LM90_FLAG_ADT7461_EXT
) {
329 return (val
+ 500 + 64000) / 1000;
335 return (val
+ 500) / 1000;
339 static u16
temp_to_u16_adt7461(struct lm90_data
*data
, long val
)
341 if (data
->flags
& LM90_FLAG_ADT7461_EXT
) {
346 return (val
+ 64000 + 125) / 250 * 64;
352 return (val
+ 125) / 250 * 64;
360 static ssize_t
show_temp8(struct device
*dev
, struct device_attribute
*devattr
,
363 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
364 struct lm90_data
*data
= lm90_update_device(dev
);
367 if (data
->kind
== adt7461
)
368 temp
= temp_from_u8_adt7461(data
, data
->temp8
[attr
->index
]);
369 else if (data
->kind
== max6646
)
370 temp
= temp_from_u8(data
->temp8
[attr
->index
]);
372 temp
= temp_from_s8(data
->temp8
[attr
->index
]);
374 /* +16 degrees offset for temp2 for the LM99 */
375 if (data
->kind
== lm99
&& attr
->index
== 3)
378 return sprintf(buf
, "%d\n", temp
);
381 static ssize_t
set_temp8(struct device
*dev
, struct device_attribute
*devattr
,
382 const char *buf
, size_t count
)
384 static const u8 reg
[4] = {
385 LM90_REG_W_LOCAL_LOW
,
386 LM90_REG_W_LOCAL_HIGH
,
387 LM90_REG_W_LOCAL_CRIT
,
388 LM90_REG_W_REMOTE_CRIT
,
391 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
392 struct i2c_client
*client
= to_i2c_client(dev
);
393 struct lm90_data
*data
= i2c_get_clientdata(client
);
394 int nr
= attr
->index
;
398 err
= strict_strtol(buf
, 10, &val
);
402 /* +16 degrees offset for temp2 for the LM99 */
403 if (data
->kind
== lm99
&& attr
->index
== 3)
406 mutex_lock(&data
->update_lock
);
407 if (data
->kind
== adt7461
)
408 data
->temp8
[nr
] = temp_to_u8_adt7461(data
, val
);
409 else if (data
->kind
== max6646
)
410 data
->temp8
[nr
] = temp_to_u8(val
);
412 data
->temp8
[nr
] = temp_to_s8(val
);
413 i2c_smbus_write_byte_data(client
, reg
[nr
], data
->temp8
[nr
]);
414 mutex_unlock(&data
->update_lock
);
418 static ssize_t
show_temp11(struct device
*dev
, struct device_attribute
*devattr
,
421 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
422 struct lm90_data
*data
= lm90_update_device(dev
);
425 if (data
->kind
== adt7461
)
426 temp
= temp_from_u16_adt7461(data
, data
->temp11
[attr
->index
]);
427 else if (data
->kind
== max6646
)
428 temp
= temp_from_u16(data
->temp11
[attr
->index
]);
430 temp
= temp_from_s16(data
->temp11
[attr
->index
]);
432 /* +16 degrees offset for temp2 for the LM99 */
433 if (data
->kind
== lm99
&& attr
->index
<= 2)
436 return sprintf(buf
, "%d\n", temp
);
439 static ssize_t
set_temp11(struct device
*dev
, struct device_attribute
*devattr
,
440 const char *buf
, size_t count
)
446 { LM90_REG_W_REMOTE_LOWH
, LM90_REG_W_REMOTE_LOWL
},
447 { LM90_REG_W_REMOTE_HIGHH
, LM90_REG_W_REMOTE_HIGHL
},
448 { LM90_REG_W_REMOTE_OFFSH
, LM90_REG_W_REMOTE_OFFSL
}
451 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
452 struct i2c_client
*client
= to_i2c_client(dev
);
453 struct lm90_data
*data
= i2c_get_clientdata(client
);
455 int index
= attr
->index
;
459 err
= strict_strtol(buf
, 10, &val
);
463 /* +16 degrees offset for temp2 for the LM99 */
464 if (data
->kind
== lm99
&& index
<= 2)
467 mutex_lock(&data
->update_lock
);
468 if (data
->kind
== adt7461
)
469 data
->temp11
[index
] = temp_to_u16_adt7461(data
, val
);
470 else if (data
->kind
== max6646
)
471 data
->temp11
[index
] = temp_to_u8(val
) << 8;
472 else if (data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
473 data
->temp11
[index
] = temp_to_s16(val
);
475 data
->temp11
[index
] = temp_to_s8(val
) << 8;
477 i2c_smbus_write_byte_data(client
, reg
[nr
].high
,
478 data
->temp11
[index
] >> 8);
479 if (data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
480 i2c_smbus_write_byte_data(client
, reg
[nr
].low
,
481 data
->temp11
[index
] & 0xff);
482 mutex_unlock(&data
->update_lock
);
486 static ssize_t
show_temphyst(struct device
*dev
,
487 struct device_attribute
*devattr
,
490 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
491 struct lm90_data
*data
= lm90_update_device(dev
);
494 if (data
->kind
== adt7461
)
495 temp
= temp_from_u8_adt7461(data
, data
->temp8
[attr
->index
]);
496 else if (data
->kind
== max6646
)
497 temp
= temp_from_u8(data
->temp8
[attr
->index
]);
499 temp
= temp_from_s8(data
->temp8
[attr
->index
]);
501 /* +16 degrees offset for temp2 for the LM99 */
502 if (data
->kind
== lm99
&& attr
->index
== 3)
505 return sprintf(buf
, "%d\n", temp
- temp_from_s8(data
->temp_hyst
));
508 static ssize_t
set_temphyst(struct device
*dev
, struct device_attribute
*dummy
,
509 const char *buf
, size_t count
)
511 struct i2c_client
*client
= to_i2c_client(dev
);
512 struct lm90_data
*data
= i2c_get_clientdata(client
);
517 err
= strict_strtol(buf
, 10, &val
);
521 mutex_lock(&data
->update_lock
);
522 if (data
->kind
== adt7461
)
523 temp
= temp_from_u8_adt7461(data
, data
->temp8
[2]);
524 else if (data
->kind
== max6646
)
525 temp
= temp_from_u8(data
->temp8
[2]);
527 temp
= temp_from_s8(data
->temp8
[2]);
529 data
->temp_hyst
= hyst_to_reg(temp
- val
);
530 i2c_smbus_write_byte_data(client
, LM90_REG_W_TCRIT_HYST
,
532 mutex_unlock(&data
->update_lock
);
536 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*dummy
,
539 struct lm90_data
*data
= lm90_update_device(dev
);
540 return sprintf(buf
, "%d\n", data
->alarms
);
543 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
546 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
547 struct lm90_data
*data
= lm90_update_device(dev
);
548 int bitnr
= attr
->index
;
550 return sprintf(buf
, "%d\n", (data
->alarms
>> bitnr
) & 1);
553 static SENSOR_DEVICE_ATTR_2(temp1_input
, S_IRUGO
, show_temp11
, NULL
, 0, 4);
554 static SENSOR_DEVICE_ATTR_2(temp2_input
, S_IRUGO
, show_temp11
, NULL
, 0, 0);
555 static SENSOR_DEVICE_ATTR(temp1_min
, S_IWUSR
| S_IRUGO
, show_temp8
,
557 static SENSOR_DEVICE_ATTR_2(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp11
,
559 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp8
,
561 static SENSOR_DEVICE_ATTR_2(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp11
,
563 static SENSOR_DEVICE_ATTR(temp1_crit
, S_IWUSR
| S_IRUGO
, show_temp8
,
565 static SENSOR_DEVICE_ATTR(temp2_crit
, S_IWUSR
| S_IRUGO
, show_temp8
,
567 static SENSOR_DEVICE_ATTR(temp1_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temphyst
,
569 static SENSOR_DEVICE_ATTR(temp2_crit_hyst
, S_IRUGO
, show_temphyst
, NULL
, 3);
570 static SENSOR_DEVICE_ATTR_2(temp2_offset
, S_IWUSR
| S_IRUGO
, show_temp11
,
573 /* Individual alarm files */
574 static SENSOR_DEVICE_ATTR(temp1_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
575 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
576 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 2);
577 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
578 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
579 static SENSOR_DEVICE_ATTR(temp1_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 5);
580 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
581 /* Raw alarm file for compatibility */
582 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
584 static struct attribute
*lm90_attributes
[] = {
585 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
586 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
587 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
588 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
589 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
590 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
591 &sensor_dev_attr_temp1_crit
.dev_attr
.attr
,
592 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
593 &sensor_dev_attr_temp1_crit_hyst
.dev_attr
.attr
,
594 &sensor_dev_attr_temp2_crit_hyst
.dev_attr
.attr
,
596 &sensor_dev_attr_temp1_crit_alarm
.dev_attr
.attr
,
597 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
598 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
599 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
600 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
601 &sensor_dev_attr_temp1_min_alarm
.dev_attr
.attr
,
602 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
603 &dev_attr_alarms
.attr
,
607 static const struct attribute_group lm90_group
= {
608 .attrs
= lm90_attributes
,
611 /* pec used for ADM1032 only */
612 static ssize_t
show_pec(struct device
*dev
, struct device_attribute
*dummy
,
615 struct i2c_client
*client
= to_i2c_client(dev
);
616 return sprintf(buf
, "%d\n", !!(client
->flags
& I2C_CLIENT_PEC
));
619 static ssize_t
set_pec(struct device
*dev
, struct device_attribute
*dummy
,
620 const char *buf
, size_t count
)
622 struct i2c_client
*client
= to_i2c_client(dev
);
626 err
= strict_strtol(buf
, 10, &val
);
632 client
->flags
&= ~I2C_CLIENT_PEC
;
635 client
->flags
|= I2C_CLIENT_PEC
;
644 static DEVICE_ATTR(pec
, S_IWUSR
| S_IRUGO
, show_pec
, set_pec
);
651 * The ADM1032 supports PEC but not on write byte transactions, so we need
652 * to explicitly ask for a transaction without PEC.
654 static inline s32
adm1032_write_byte(struct i2c_client
*client
, u8 value
)
656 return i2c_smbus_xfer(client
->adapter
, client
->addr
,
657 client
->flags
& ~I2C_CLIENT_PEC
,
658 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
662 * It is assumed that client->update_lock is held (unless we are in
663 * detection or initialization steps). This matters when PEC is enabled,
664 * because we don't want the address pointer to change between the write
665 * byte and the read byte transactions.
667 static int lm90_read_reg(struct i2c_client
*client
, u8 reg
, u8
*value
)
671 if (client
->flags
& I2C_CLIENT_PEC
) {
672 err
= adm1032_write_byte(client
, reg
);
674 err
= i2c_smbus_read_byte(client
);
676 err
= i2c_smbus_read_byte_data(client
, reg
);
679 dev_warn(&client
->dev
, "Register %#02x read failed (%d)\n",
688 /* Return 0 if detection is successful, -ENODEV otherwise */
689 static int lm90_detect(struct i2c_client
*new_client
,
690 struct i2c_board_info
*info
)
692 struct i2c_adapter
*adapter
= new_client
->adapter
;
693 int address
= new_client
->addr
;
694 const char *name
= NULL
;
695 int man_id
, chip_id
, reg_config1
, reg_convrate
;
697 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
700 /* detection and identification */
701 if ((man_id
= i2c_smbus_read_byte_data(new_client
,
702 LM90_REG_R_MAN_ID
)) < 0
703 || (chip_id
= i2c_smbus_read_byte_data(new_client
,
704 LM90_REG_R_CHIP_ID
)) < 0
705 || (reg_config1
= i2c_smbus_read_byte_data(new_client
,
706 LM90_REG_R_CONFIG1
)) < 0
707 || (reg_convrate
= i2c_smbus_read_byte_data(new_client
,
708 LM90_REG_R_CONVRATE
)) < 0)
711 if ((address
== 0x4C || address
== 0x4D)
712 && man_id
== 0x01) { /* National Semiconductor */
715 reg_config2
= i2c_smbus_read_byte_data(new_client
,
720 if ((reg_config1
& 0x2A) == 0x00
721 && (reg_config2
& 0xF8) == 0x00
722 && reg_convrate
<= 0x09) {
724 && (chip_id
& 0xF0) == 0x20) { /* LM90 */
727 if ((chip_id
& 0xF0) == 0x30) { /* LM89/LM99 */
729 dev_info(&adapter
->dev
,
730 "Assuming LM99 chip at 0x%02x\n",
732 dev_info(&adapter
->dev
,
733 "If it is an LM89, instantiate it "
734 "with the new_device sysfs "
738 && (chip_id
& 0xF0) == 0x10) { /* LM86 */
743 if ((address
== 0x4C || address
== 0x4D)
744 && man_id
== 0x41) { /* Analog Devices */
745 if ((chip_id
& 0xF0) == 0x40 /* ADM1032 */
746 && (reg_config1
& 0x3F) == 0x00
747 && reg_convrate
<= 0x0A) {
749 /* The ADM1032 supports PEC, but only if combined
750 transactions are not used. */
751 if (i2c_check_functionality(adapter
,
752 I2C_FUNC_SMBUS_BYTE
))
753 info
->flags
|= I2C_CLIENT_PEC
;
755 if (chip_id
== 0x51 /* ADT7461 */
756 && (reg_config1
& 0x1B) == 0x00
757 && reg_convrate
<= 0x0A) {
761 if (man_id
== 0x4D) { /* Maxim */
763 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
764 * register. Reading from that address will return the last
765 * read value, which in our case is those of the man_id
766 * register. Likewise, the config1 register seems to lack a
767 * low nibble, so the value will be those of the previous
768 * read, so in our case those of the man_id register.
770 if (chip_id
== man_id
771 && (address
== 0x4C || address
== 0x4D)
772 && (reg_config1
& 0x1F) == (man_id
& 0x0F)
773 && reg_convrate
<= 0x09) {
777 * The chip_id register of the MAX6680 and MAX6681 holds the
778 * revision of the chip. The lowest bit of the config1 register
779 * is unused and should return zero when read, so should the
780 * second to last bit of config1 (software reset).
783 && (reg_config1
& 0x03) == 0x00
784 && reg_convrate
<= 0x07) {
788 * The chip_id register of the MAX6646/6647/6649 holds the
789 * revision of the chip. The lowest 6 bits of the config1
790 * register are unused and should return zero when read.
793 && (reg_config1
& 0x3f) == 0x00
794 && reg_convrate
<= 0x07) {
799 && man_id
== 0x5C) { /* Winbond/Nuvoton */
800 if ((chip_id
& 0xFE) == 0x10 /* W83L771AWG/ASG */
801 && (reg_config1
& 0x2A) == 0x00
802 && reg_convrate
<= 0x08) {
807 if (!name
) { /* identification failed */
808 dev_dbg(&adapter
->dev
,
809 "Unsupported chip at 0x%02x (man_id=0x%02X, "
810 "chip_id=0x%02X)\n", address
, man_id
, chip_id
);
814 strlcpy(info
->type
, name
, I2C_NAME_SIZE
);
819 static void lm90_remove_files(struct i2c_client
*client
, struct lm90_data
*data
)
821 if (data
->flags
& LM90_HAVE_OFFSET
)
822 device_remove_file(&client
->dev
,
823 &sensor_dev_attr_temp2_offset
.dev_attr
);
824 device_remove_file(&client
->dev
, &dev_attr_pec
);
825 sysfs_remove_group(&client
->dev
.kobj
, &lm90_group
);
828 static int lm90_probe(struct i2c_client
*new_client
,
829 const struct i2c_device_id
*id
)
831 struct i2c_adapter
*adapter
= to_i2c_adapter(new_client
->dev
.parent
);
832 struct lm90_data
*data
;
835 data
= kzalloc(sizeof(struct lm90_data
), GFP_KERNEL
);
840 i2c_set_clientdata(new_client
, data
);
841 mutex_init(&data
->update_lock
);
843 /* Set the device type */
844 data
->kind
= id
->driver_data
;
845 if (data
->kind
== adm1032
) {
846 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE
))
847 new_client
->flags
&= ~I2C_CLIENT_PEC
;
850 /* Different devices have different alarm bits triggering the
852 switch (data
->kind
) {
856 data
->alert_alarms
= 0x7b;
859 data
->alert_alarms
= 0x7c;
863 /* Set chip capabilities */
864 if (data
->kind
!= max6657
&& data
->kind
!= max6646
)
865 data
->flags
|= LM90_HAVE_OFFSET
;
867 if (data
->kind
== max6657
|| data
->kind
== max6646
)
868 data
->flags
|= LM90_HAVE_LOCAL_EXT
;
870 if (data
->kind
!= max6657
&& data
->kind
!= max6646
871 && data
->kind
!= max6680
)
872 data
->flags
|= LM90_HAVE_REM_LIMIT_EXT
;
874 /* Initialize the LM90 chip */
875 lm90_init_client(new_client
);
877 /* Register sysfs hooks */
878 err
= sysfs_create_group(&new_client
->dev
.kobj
, &lm90_group
);
881 if (new_client
->flags
& I2C_CLIENT_PEC
) {
882 err
= device_create_file(&new_client
->dev
, &dev_attr_pec
);
884 goto exit_remove_files
;
886 if (data
->flags
& LM90_HAVE_OFFSET
) {
887 err
= device_create_file(&new_client
->dev
,
888 &sensor_dev_attr_temp2_offset
.dev_attr
);
890 goto exit_remove_files
;
893 data
->hwmon_dev
= hwmon_device_register(&new_client
->dev
);
894 if (IS_ERR(data
->hwmon_dev
)) {
895 err
= PTR_ERR(data
->hwmon_dev
);
896 goto exit_remove_files
;
902 lm90_remove_files(new_client
, data
);
909 static void lm90_init_client(struct i2c_client
*client
)
912 struct lm90_data
*data
= i2c_get_clientdata(client
);
915 * Start the conversions.
917 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONVRATE
,
919 if (lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
) < 0) {
920 dev_warn(&client
->dev
, "Initialization failed!\n");
923 data
->config_orig
= config
;
925 /* Check Temperature Range Select */
926 if (data
->kind
== adt7461
) {
928 data
->flags
|= LM90_FLAG_ADT7461_EXT
;
932 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
933 * 0.125 degree resolution) and range (0x08, extend range
934 * to -64 degree) mode for the remote temperature sensor.
936 if (data
->kind
== max6680
)
939 config
&= 0xBF; /* run */
940 if (config
!= data
->config_orig
) /* Only write if changed */
941 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
, config
);
944 static int lm90_remove(struct i2c_client
*client
)
946 struct lm90_data
*data
= i2c_get_clientdata(client
);
948 hwmon_device_unregister(data
->hwmon_dev
);
949 lm90_remove_files(client
, data
);
951 /* Restore initial configuration */
952 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
,
959 static void lm90_alert(struct i2c_client
*client
, unsigned int flag
)
961 struct lm90_data
*data
= i2c_get_clientdata(client
);
964 lm90_read_reg(client
, LM90_REG_R_STATUS
, &alarms
);
965 if ((alarms
& 0x7f) == 0) {
966 dev_info(&client
->dev
, "Everything OK\n");
969 dev_warn(&client
->dev
,
970 "temp%d out of range, please check!\n", 1);
972 dev_warn(&client
->dev
,
973 "temp%d out of range, please check!\n", 2);
975 dev_warn(&client
->dev
,
976 "temp%d diode open, please check!\n", 2);
978 /* Disable ALERT# output, because these chips don't implement
979 SMBus alert correctly; they should only hold the alert line
981 if ((data
->kind
== adm1032
|| data
->kind
== adt7461
)
982 && (alarms
& data
->alert_alarms
)) {
983 dev_dbg(&client
->dev
, "Disabling ALERT#\n");
984 lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
);
985 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
,
991 static int lm90_read16(struct i2c_client
*client
, u8 regh
, u8 regl
, u16
*value
)
997 * There is a trick here. We have to read two registers to have the
998 * sensor temperature, but we have to beware a conversion could occur
999 * inbetween the readings. The datasheet says we should either use
1000 * the one-shot conversion register, which we don't want to do
1001 * (disables hardware monitoring) or monitor the busy bit, which is
1002 * impossible (we can't read the values and monitor that bit at the
1003 * exact same time). So the solution used here is to read the high
1004 * byte once, then the low byte, then the high byte again. If the new
1005 * high byte matches the old one, then we have a valid reading. Else
1006 * we have to read the low byte again, and now we believe we have a
1009 if ((err
= lm90_read_reg(client
, regh
, &oldh
))
1010 || (err
= lm90_read_reg(client
, regl
, &l
))
1011 || (err
= lm90_read_reg(client
, regh
, &newh
)))
1014 err
= lm90_read_reg(client
, regl
, &l
);
1018 *value
= (newh
<< 8) | l
;
1023 static struct lm90_data
*lm90_update_device(struct device
*dev
)
1025 struct i2c_client
*client
= to_i2c_client(dev
);
1026 struct lm90_data
*data
= i2c_get_clientdata(client
);
1028 mutex_lock(&data
->update_lock
);
1030 if (time_after(jiffies
, data
->last_updated
+ HZ
/ 2 + HZ
/ 10)
1034 dev_dbg(&client
->dev
, "Updating lm90 data.\n");
1035 lm90_read_reg(client
, LM90_REG_R_LOCAL_LOW
, &data
->temp8
[0]);
1036 lm90_read_reg(client
, LM90_REG_R_LOCAL_HIGH
, &data
->temp8
[1]);
1037 lm90_read_reg(client
, LM90_REG_R_LOCAL_CRIT
, &data
->temp8
[2]);
1038 lm90_read_reg(client
, LM90_REG_R_REMOTE_CRIT
, &data
->temp8
[3]);
1039 lm90_read_reg(client
, LM90_REG_R_TCRIT_HYST
, &data
->temp_hyst
);
1041 if (data
->flags
& LM90_HAVE_LOCAL_EXT
) {
1042 lm90_read16(client
, LM90_REG_R_LOCAL_TEMP
,
1043 MAX6657_REG_R_LOCAL_TEMPL
,
1046 if (lm90_read_reg(client
, LM90_REG_R_LOCAL_TEMP
,
1048 data
->temp11
[4] = h
<< 8;
1050 lm90_read16(client
, LM90_REG_R_REMOTE_TEMPH
,
1051 LM90_REG_R_REMOTE_TEMPL
, &data
->temp11
[0]);
1053 if (lm90_read_reg(client
, LM90_REG_R_REMOTE_LOWH
, &h
) == 0) {
1054 data
->temp11
[1] = h
<< 8;
1055 if ((data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
1056 && lm90_read_reg(client
, LM90_REG_R_REMOTE_LOWL
,
1058 data
->temp11
[1] |= l
;
1060 if (lm90_read_reg(client
, LM90_REG_R_REMOTE_HIGHH
, &h
) == 0) {
1061 data
->temp11
[2] = h
<< 8;
1062 if ((data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
1063 && lm90_read_reg(client
, LM90_REG_R_REMOTE_HIGHL
,
1065 data
->temp11
[2] |= l
;
1068 if (data
->flags
& LM90_HAVE_OFFSET
) {
1069 if (lm90_read_reg(client
, LM90_REG_R_REMOTE_OFFSH
,
1071 && lm90_read_reg(client
, LM90_REG_R_REMOTE_OFFSL
,
1073 data
->temp11
[3] = (h
<< 8) | l
;
1075 lm90_read_reg(client
, LM90_REG_R_STATUS
, &data
->alarms
);
1077 /* Re-enable ALERT# output if it was originally enabled and
1078 * relevant alarms are all clear */
1079 if ((data
->config_orig
& 0x80) == 0
1080 && (data
->alarms
& data
->alert_alarms
) == 0) {
1083 lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
);
1084 if (config
& 0x80) {
1085 dev_dbg(&client
->dev
, "Re-enabling ALERT#\n");
1086 i2c_smbus_write_byte_data(client
,
1092 data
->last_updated
= jiffies
;
1096 mutex_unlock(&data
->update_lock
);
1101 static int __init
sensors_lm90_init(void)
1103 return i2c_add_driver(&lm90_driver
);
1106 static void __exit
sensors_lm90_exit(void)
1108 i2c_del_driver(&lm90_driver
);
1111 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1112 MODULE_DESCRIPTION("LM90/ADM1032 driver");
1113 MODULE_LICENSE("GPL");
1115 module_init(sensors_lm90_init
);
1116 module_exit(sensors_lm90_exit
);