2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
4 * Copyright (C) 2003-2010 Jean Delvare <jdelvare@suse.de>
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. We use the device address to detect MAX6659, which will result
32 * in a detection as max6657 if it is on address 0x4c. The extra address
33 * and features of the MAX6659 are only supported if the chip is configured
34 * explicitly as max6659, or if its address is not 0x4c.
35 * These chips lack the remote temperature offset feature.
37 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
38 * MAX6692 chips made by Maxim. These are again similar to the LM86,
39 * but they use unsigned temperature values and can report temperatures
40 * from 0 to 145 degrees.
42 * This driver also supports the MAX6680 and MAX6681, two other sensor
43 * chips made by Maxim. These are quite similar to the other Maxim
44 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
45 * be treated identically.
47 * This driver also supports the MAX6695 and MAX6696, two other sensor
48 * chips made by Maxim. These are also quite similar to other Maxim
49 * chips, but support three temperature sensors instead of two. MAX6695
50 * and MAX6696 only differ in the pinout so they can be treated identically.
52 * This driver also supports ADT7461 and ADT7461A from Analog Devices as well as
53 * NCT1008 from ON Semiconductor. The chips are supported in both compatibility
54 * and extended mode. They are mostly compatible with LM90 except for a data
55 * format difference for the temperature value registers.
57 * This driver also supports the SA56004 from Philips. This device is
58 * pin-compatible with the LM86, the ED/EDP parts are also address-compatible.
60 * This driver also supports the G781 from GMT. This device is compatible
63 * This driver also supports TMP451 from Texas Instruments. This device is
64 * supported in both compatibility and extended mode. It's mostly compatible
65 * with ADT7461 except for local temperature low byte register and max
68 * Since the LM90 was the first chipset supported by this driver, most
69 * comments will refer to this chipset, but are actually general and
70 * concern all supported chipsets, unless mentioned otherwise.
72 * This program is free software; you can redistribute it and/or modify
73 * it under the terms of the GNU General Public License as published by
74 * the Free Software Foundation; either version 2 of the License, or
75 * (at your option) any later version.
77 * This program is distributed in the hope that it will be useful,
78 * but WITHOUT ANY WARRANTY; without even the implied warranty of
79 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
80 * GNU General Public License for more details.
82 * You should have received a copy of the GNU General Public License
83 * along with this program; if not, write to the Free Software
84 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
87 #include <linux/module.h>
88 #include <linux/init.h>
89 #include <linux/slab.h>
90 #include <linux/jiffies.h>
91 #include <linux/i2c.h>
92 #include <linux/hwmon-sysfs.h>
93 #include <linux/hwmon.h>
94 #include <linux/err.h>
95 #include <linux/mutex.h>
96 #include <linux/sysfs.h>
97 #include <linux/interrupt.h>
98 #include <linux/regulator/consumer.h>
102 * Address is fully defined internally and cannot be changed except for
103 * MAX6659, MAX6680 and MAX6681.
104 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649,
105 * MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c.
106 * ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D
108 * MAX6647 has address 0x4e.
109 * MAX6659 can have address 0x4c, 0x4d or 0x4e.
110 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
111 * 0x4c, 0x4d or 0x4e.
112 * SA56004 can have address 0x48 through 0x4F.
115 static const unsigned short normal_i2c
[] = {
116 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
117 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
};
119 enum chips
{ lm90
, adm1032
, lm99
, lm86
, max6657
, max6659
, adt7461
, max6680
,
120 max6646
, w83l771
, max6696
, sa56004
, g781
, tmp451
};
126 #define LM90_REG_R_MAN_ID 0xFE
127 #define LM90_REG_R_CHIP_ID 0xFF
128 #define LM90_REG_R_CONFIG1 0x03
129 #define LM90_REG_W_CONFIG1 0x09
130 #define LM90_REG_R_CONFIG2 0xBF
131 #define LM90_REG_W_CONFIG2 0xBF
132 #define LM90_REG_R_CONVRATE 0x04
133 #define LM90_REG_W_CONVRATE 0x0A
134 #define LM90_REG_R_STATUS 0x02
135 #define LM90_REG_R_LOCAL_TEMP 0x00
136 #define LM90_REG_R_LOCAL_HIGH 0x05
137 #define LM90_REG_W_LOCAL_HIGH 0x0B
138 #define LM90_REG_R_LOCAL_LOW 0x06
139 #define LM90_REG_W_LOCAL_LOW 0x0C
140 #define LM90_REG_R_LOCAL_CRIT 0x20
141 #define LM90_REG_W_LOCAL_CRIT 0x20
142 #define LM90_REG_R_REMOTE_TEMPH 0x01
143 #define LM90_REG_R_REMOTE_TEMPL 0x10
144 #define LM90_REG_R_REMOTE_OFFSH 0x11
145 #define LM90_REG_W_REMOTE_OFFSH 0x11
146 #define LM90_REG_R_REMOTE_OFFSL 0x12
147 #define LM90_REG_W_REMOTE_OFFSL 0x12
148 #define LM90_REG_R_REMOTE_HIGHH 0x07
149 #define LM90_REG_W_REMOTE_HIGHH 0x0D
150 #define LM90_REG_R_REMOTE_HIGHL 0x13
151 #define LM90_REG_W_REMOTE_HIGHL 0x13
152 #define LM90_REG_R_REMOTE_LOWH 0x08
153 #define LM90_REG_W_REMOTE_LOWH 0x0E
154 #define LM90_REG_R_REMOTE_LOWL 0x14
155 #define LM90_REG_W_REMOTE_LOWL 0x14
156 #define LM90_REG_R_REMOTE_CRIT 0x19
157 #define LM90_REG_W_REMOTE_CRIT 0x19
158 #define LM90_REG_R_TCRIT_HYST 0x21
159 #define LM90_REG_W_TCRIT_HYST 0x21
161 /* MAX6646/6647/6649/6657/6658/6659/6695/6696 registers */
163 #define MAX6657_REG_R_LOCAL_TEMPL 0x11
164 #define MAX6696_REG_R_STATUS2 0x12
165 #define MAX6659_REG_R_REMOTE_EMERG 0x16
166 #define MAX6659_REG_W_REMOTE_EMERG 0x16
167 #define MAX6659_REG_R_LOCAL_EMERG 0x17
168 #define MAX6659_REG_W_LOCAL_EMERG 0x17
170 /* SA56004 registers */
172 #define SA56004_REG_R_LOCAL_TEMPL 0x22
174 #define LM90_DEF_CONVRATE_RVAL 6 /* Def conversion rate register value */
175 #define LM90_MAX_CONVRATE_MS 16000 /* Maximum conversion rate in ms */
177 /* TMP451 registers */
178 #define TMP451_REG_R_LOCAL_TEMPL 0x15
183 #define LM90_FLAG_ADT7461_EXT (1 << 0) /* ADT7461 extended mode */
184 /* Device features */
185 #define LM90_HAVE_OFFSET (1 << 1) /* temperature offset register */
186 #define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit */
187 #define LM90_HAVE_EMERGENCY (1 << 4) /* 3rd upper (emergency) limit */
188 #define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm */
189 #define LM90_HAVE_TEMP3 (1 << 6) /* 3rd temperature sensor */
190 #define LM90_HAVE_BROKEN_ALERT (1 << 7) /* Broken alert */
193 #define LM90_STATUS_LTHRM (1 << 0) /* local THERM limit tripped */
194 #define LM90_STATUS_RTHRM (1 << 1) /* remote THERM limit tripped */
195 #define LM90_STATUS_ROPEN (1 << 2) /* remote is an open circuit */
196 #define LM90_STATUS_RLOW (1 << 3) /* remote low temp limit tripped */
197 #define LM90_STATUS_RHIGH (1 << 4) /* remote high temp limit tripped */
198 #define LM90_STATUS_LLOW (1 << 5) /* local low temp limit tripped */
199 #define LM90_STATUS_LHIGH (1 << 6) /* local high temp limit tripped */
201 #define MAX6696_STATUS2_R2THRM (1 << 1) /* remote2 THERM limit tripped */
202 #define MAX6696_STATUS2_R2OPEN (1 << 2) /* remote2 is an open circuit */
203 #define MAX6696_STATUS2_R2LOW (1 << 3) /* remote2 low temp limit tripped */
204 #define MAX6696_STATUS2_R2HIGH (1 << 4) /* remote2 high temp limit tripped */
205 #define MAX6696_STATUS2_ROT2 (1 << 5) /* remote emergency limit tripped */
206 #define MAX6696_STATUS2_R2OT2 (1 << 6) /* remote2 emergency limit tripped */
207 #define MAX6696_STATUS2_LOT2 (1 << 7) /* local emergency limit tripped */
210 * Driver data (common to all clients)
213 static const struct i2c_device_id lm90_id
[] = {
214 { "adm1032", adm1032
},
215 { "adt7461", adt7461
},
216 { "adt7461a", adt7461
},
222 { "max6646", max6646
},
223 { "max6647", max6646
},
224 { "max6649", max6646
},
225 { "max6657", max6657
},
226 { "max6658", max6657
},
227 { "max6659", max6659
},
228 { "max6680", max6680
},
229 { "max6681", max6680
},
230 { "max6695", max6696
},
231 { "max6696", max6696
},
232 { "nct1008", adt7461
},
233 { "w83l771", w83l771
},
234 { "sa56004", sa56004
},
235 { "tmp451", tmp451
},
238 MODULE_DEVICE_TABLE(i2c
, lm90_id
);
241 * chip type specific parameters
244 u32 flags
; /* Capabilities */
245 u16 alert_alarms
; /* Which alarm bits trigger ALERT# */
246 /* Upper 8 bits for max6695/96 */
247 u8 max_convrate
; /* Maximum conversion rate register value */
248 u8 reg_local_ext
; /* Extended local temp register (optional) */
251 static const struct lm90_params lm90_params
[] = {
253 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
254 | LM90_HAVE_BROKEN_ALERT
,
255 .alert_alarms
= 0x7c,
259 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
260 | LM90_HAVE_BROKEN_ALERT
,
261 .alert_alarms
= 0x7c,
265 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
266 | LM90_HAVE_BROKEN_ALERT
,
267 .alert_alarms
= 0x7c,
271 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
,
272 .alert_alarms
= 0x7b,
276 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
,
277 .alert_alarms
= 0x7b,
281 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
,
282 .alert_alarms
= 0x7b,
286 .alert_alarms
= 0x7c,
288 .reg_local_ext
= MAX6657_REG_R_LOCAL_TEMPL
,
291 .alert_alarms
= 0x7c,
293 .reg_local_ext
= MAX6657_REG_R_LOCAL_TEMPL
,
296 .flags
= LM90_HAVE_EMERGENCY
,
297 .alert_alarms
= 0x7c,
299 .reg_local_ext
= MAX6657_REG_R_LOCAL_TEMPL
,
302 .flags
= LM90_HAVE_OFFSET
,
303 .alert_alarms
= 0x7c,
307 .flags
= LM90_HAVE_EMERGENCY
308 | LM90_HAVE_EMERGENCY_ALARM
| LM90_HAVE_TEMP3
,
309 .alert_alarms
= 0x1c7c,
311 .reg_local_ext
= MAX6657_REG_R_LOCAL_TEMPL
,
314 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
,
315 .alert_alarms
= 0x7c,
319 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
,
320 .alert_alarms
= 0x7b,
322 .reg_local_ext
= SA56004_REG_R_LOCAL_TEMPL
,
325 .flags
= LM90_HAVE_OFFSET
| LM90_HAVE_REM_LIMIT_EXT
326 | LM90_HAVE_BROKEN_ALERT
,
327 .alert_alarms
= 0x7c,
329 .reg_local_ext
= TMP451_REG_R_LOCAL_TEMPL
,
334 * TEMP8 register index
336 enum lm90_temp8_reg_index
{
341 LOCAL_EMERG
, /* max6659 and max6695/96 */
342 REMOTE_EMERG
, /* max6659 and max6695/96 */
343 REMOTE2_CRIT
, /* max6695/96 only */
344 REMOTE2_EMERG
, /* max6695/96 only */
349 * TEMP11 register index
351 enum lm90_temp11_reg_index
{
355 REMOTE_OFFSET
, /* except max6646, max6657/58/59, and max6695/96 */
357 REMOTE2_TEMP
, /* max6695/96 only */
358 REMOTE2_LOW
, /* max6695/96 only */
359 REMOTE2_HIGH
, /* max6695/96 only */
364 * Client data (each client gets its own)
368 struct i2c_client
*client
;
369 const struct attribute_group
*groups
[6];
370 struct mutex update_lock
;
371 char valid
; /* zero until following fields are valid */
372 unsigned long last_updated
; /* in jiffies */
376 unsigned int update_interval
; /* in milliseconds */
378 u8 config_orig
; /* Original configuration register value */
379 u8 convrate_orig
; /* Original conversion rate register value */
380 u16 alert_alarms
; /* Which alarm bits trigger ALERT# */
381 /* Upper 8 bits for max6695/96 */
382 u8 max_convrate
; /* Maximum conversion rate */
383 u8 reg_local_ext
; /* local extension register offset */
385 /* registers values */
386 s8 temp8
[TEMP8_REG_NUM
];
387 s16 temp11
[TEMP11_REG_NUM
];
389 u16 alarms
; /* bitvector (upper 8 bits for max6695/96) */
397 * The ADM1032 supports PEC but not on write byte transactions, so we need
398 * to explicitly ask for a transaction without PEC.
400 static inline s32
adm1032_write_byte(struct i2c_client
*client
, u8 value
)
402 return i2c_smbus_xfer(client
->adapter
, client
->addr
,
403 client
->flags
& ~I2C_CLIENT_PEC
,
404 I2C_SMBUS_WRITE
, value
, I2C_SMBUS_BYTE
, NULL
);
408 * It is assumed that client->update_lock is held (unless we are in
409 * detection or initialization steps). This matters when PEC is enabled,
410 * because we don't want the address pointer to change between the write
411 * byte and the read byte transactions.
413 static int lm90_read_reg(struct i2c_client
*client
, u8 reg
, u8
*value
)
417 if (client
->flags
& I2C_CLIENT_PEC
) {
418 err
= adm1032_write_byte(client
, reg
);
420 err
= i2c_smbus_read_byte(client
);
422 err
= i2c_smbus_read_byte_data(client
, reg
);
425 dev_warn(&client
->dev
, "Register %#02x read failed (%d)\n",
434 static int lm90_read16(struct i2c_client
*client
, u8 regh
, u8 regl
, u16
*value
)
440 * There is a trick here. We have to read two registers to have the
441 * sensor temperature, but we have to beware a conversion could occur
442 * between the readings. The datasheet says we should either use
443 * the one-shot conversion register, which we don't want to do
444 * (disables hardware monitoring) or monitor the busy bit, which is
445 * impossible (we can't read the values and monitor that bit at the
446 * exact same time). So the solution used here is to read the high
447 * byte once, then the low byte, then the high byte again. If the new
448 * high byte matches the old one, then we have a valid reading. Else
449 * we have to read the low byte again, and now we believe we have a
452 if ((err
= lm90_read_reg(client
, regh
, &oldh
))
453 || (err
= lm90_read_reg(client
, regl
, &l
))
454 || (err
= lm90_read_reg(client
, regh
, &newh
)))
457 err
= lm90_read_reg(client
, regl
, &l
);
461 *value
= (newh
<< 8) | l
;
467 * client->update_lock must be held when calling this function (unless we are
468 * in detection or initialization steps), and while a remote channel other
469 * than channel 0 is selected. Also, calling code must make sure to re-select
470 * external channel 0 before releasing the lock. This is necessary because
471 * various registers have different meanings as a result of selecting a
472 * non-default remote channel.
474 static inline void lm90_select_remote_channel(struct i2c_client
*client
,
475 struct lm90_data
*data
,
480 if (data
->kind
== max6696
) {
481 lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
);
485 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
,
491 * Set conversion rate.
492 * client->update_lock must be held when calling this function (unless we are
493 * in detection or initialization steps).
495 static void lm90_set_convrate(struct i2c_client
*client
, struct lm90_data
*data
,
496 unsigned int interval
)
499 unsigned int update_interval
;
501 /* Shift calculations to avoid rounding errors */
504 /* find the nearest update rate */
505 for (i
= 0, update_interval
= LM90_MAX_CONVRATE_MS
<< 6;
506 i
< data
->max_convrate
; i
++, update_interval
>>= 1)
507 if (interval
>= update_interval
* 3 / 4)
510 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONVRATE
, i
);
511 data
->update_interval
= DIV_ROUND_CLOSEST(update_interval
, 64);
514 static struct lm90_data
*lm90_update_device(struct device
*dev
)
516 struct lm90_data
*data
= dev_get_drvdata(dev
);
517 struct i2c_client
*client
= data
->client
;
518 unsigned long next_update
;
520 mutex_lock(&data
->update_lock
);
522 next_update
= data
->last_updated
+
523 msecs_to_jiffies(data
->update_interval
);
524 if (time_after(jiffies
, next_update
) || !data
->valid
) {
528 dev_dbg(&client
->dev
, "Updating lm90 data.\n");
529 lm90_read_reg(client
, LM90_REG_R_LOCAL_LOW
,
530 &data
->temp8
[LOCAL_LOW
]);
531 lm90_read_reg(client
, LM90_REG_R_LOCAL_HIGH
,
532 &data
->temp8
[LOCAL_HIGH
]);
533 lm90_read_reg(client
, LM90_REG_R_LOCAL_CRIT
,
534 &data
->temp8
[LOCAL_CRIT
]);
535 lm90_read_reg(client
, LM90_REG_R_REMOTE_CRIT
,
536 &data
->temp8
[REMOTE_CRIT
]);
537 lm90_read_reg(client
, LM90_REG_R_TCRIT_HYST
, &data
->temp_hyst
);
539 if (data
->reg_local_ext
) {
540 lm90_read16(client
, LM90_REG_R_LOCAL_TEMP
,
542 &data
->temp11
[LOCAL_TEMP
]);
544 if (lm90_read_reg(client
, LM90_REG_R_LOCAL_TEMP
,
546 data
->temp11
[LOCAL_TEMP
] = h
<< 8;
548 lm90_read16(client
, LM90_REG_R_REMOTE_TEMPH
,
549 LM90_REG_R_REMOTE_TEMPL
,
550 &data
->temp11
[REMOTE_TEMP
]);
552 if (lm90_read_reg(client
, LM90_REG_R_REMOTE_LOWH
, &h
) == 0) {
553 data
->temp11
[REMOTE_LOW
] = h
<< 8;
554 if ((data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
555 && lm90_read_reg(client
, LM90_REG_R_REMOTE_LOWL
,
557 data
->temp11
[REMOTE_LOW
] |= l
;
559 if (lm90_read_reg(client
, LM90_REG_R_REMOTE_HIGHH
, &h
) == 0) {
560 data
->temp11
[REMOTE_HIGH
] = h
<< 8;
561 if ((data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
562 && lm90_read_reg(client
, LM90_REG_R_REMOTE_HIGHL
,
564 data
->temp11
[REMOTE_HIGH
] |= l
;
567 if (data
->flags
& LM90_HAVE_OFFSET
) {
568 if (lm90_read_reg(client
, LM90_REG_R_REMOTE_OFFSH
,
570 && lm90_read_reg(client
, LM90_REG_R_REMOTE_OFFSL
,
572 data
->temp11
[REMOTE_OFFSET
] = (h
<< 8) | l
;
574 if (data
->flags
& LM90_HAVE_EMERGENCY
) {
575 lm90_read_reg(client
, MAX6659_REG_R_LOCAL_EMERG
,
576 &data
->temp8
[LOCAL_EMERG
]);
577 lm90_read_reg(client
, MAX6659_REG_R_REMOTE_EMERG
,
578 &data
->temp8
[REMOTE_EMERG
]);
580 lm90_read_reg(client
, LM90_REG_R_STATUS
, &alarms
);
581 data
->alarms
= alarms
; /* save as 16 bit value */
583 if (data
->kind
== max6696
) {
584 lm90_select_remote_channel(client
, data
, 1);
585 lm90_read_reg(client
, LM90_REG_R_REMOTE_CRIT
,
586 &data
->temp8
[REMOTE2_CRIT
]);
587 lm90_read_reg(client
, MAX6659_REG_R_REMOTE_EMERG
,
588 &data
->temp8
[REMOTE2_EMERG
]);
589 lm90_read16(client
, LM90_REG_R_REMOTE_TEMPH
,
590 LM90_REG_R_REMOTE_TEMPL
,
591 &data
->temp11
[REMOTE2_TEMP
]);
592 if (!lm90_read_reg(client
, LM90_REG_R_REMOTE_LOWH
, &h
))
593 data
->temp11
[REMOTE2_LOW
] = h
<< 8;
594 if (!lm90_read_reg(client
, LM90_REG_R_REMOTE_HIGHH
, &h
))
595 data
->temp11
[REMOTE2_HIGH
] = h
<< 8;
596 lm90_select_remote_channel(client
, data
, 0);
598 if (!lm90_read_reg(client
, MAX6696_REG_R_STATUS2
,
600 data
->alarms
|= alarms
<< 8;
604 * Re-enable ALERT# output if it was originally enabled and
605 * relevant alarms are all clear
607 if ((data
->config_orig
& 0x80) == 0
608 && (data
->alarms
& data
->alert_alarms
) == 0) {
611 lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
);
613 dev_dbg(&client
->dev
, "Re-enabling ALERT#\n");
614 i2c_smbus_write_byte_data(client
,
620 data
->last_updated
= jiffies
;
624 mutex_unlock(&data
->update_lock
);
631 * For local temperatures and limits, critical limits and the hysteresis
632 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
633 * For remote temperatures and limits, it uses signed 11-bit values with
634 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some
635 * Maxim chips use unsigned values.
638 static inline int temp_from_s8(s8 val
)
643 static inline int temp_from_u8(u8 val
)
648 static inline int temp_from_s16(s16 val
)
650 return val
/ 32 * 125;
653 static inline int temp_from_u16(u16 val
)
655 return val
/ 32 * 125;
658 static s8
temp_to_s8(long val
)
665 return (val
- 500) / 1000;
666 return (val
+ 500) / 1000;
669 static u8
temp_to_u8(long val
)
675 return (val
+ 500) / 1000;
678 static s16
temp_to_s16(long val
)
685 return (val
- 62) / 125 * 32;
686 return (val
+ 62) / 125 * 32;
689 static u8
hyst_to_reg(long val
)
695 return (val
+ 500) / 1000;
699 * ADT7461 in compatibility mode is almost identical to LM90 except that
700 * attempts to write values that are outside the range 0 < temp < 127 are
701 * treated as the boundary value.
703 * ADT7461 in "extended mode" operation uses unsigned integers offset by
704 * 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC.
706 static inline int temp_from_u8_adt7461(struct lm90_data
*data
, u8 val
)
708 if (data
->flags
& LM90_FLAG_ADT7461_EXT
)
709 return (val
- 64) * 1000;
711 return temp_from_s8(val
);
714 static inline int temp_from_u16_adt7461(struct lm90_data
*data
, u16 val
)
716 if (data
->flags
& LM90_FLAG_ADT7461_EXT
)
717 return (val
- 0x4000) / 64 * 250;
719 return temp_from_s16(val
);
722 static u8
temp_to_u8_adt7461(struct lm90_data
*data
, long val
)
724 if (data
->flags
& LM90_FLAG_ADT7461_EXT
) {
729 return (val
+ 500 + 64000) / 1000;
735 return (val
+ 500) / 1000;
739 static u16
temp_to_u16_adt7461(struct lm90_data
*data
, long val
)
741 if (data
->flags
& LM90_FLAG_ADT7461_EXT
) {
746 return (val
+ 64000 + 125) / 250 * 64;
752 return (val
+ 125) / 250 * 64;
760 static ssize_t
show_temp8(struct device
*dev
, struct device_attribute
*devattr
,
763 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
764 struct lm90_data
*data
= lm90_update_device(dev
);
767 if (data
->kind
== adt7461
|| data
->kind
== tmp451
)
768 temp
= temp_from_u8_adt7461(data
, data
->temp8
[attr
->index
]);
769 else if (data
->kind
== max6646
)
770 temp
= temp_from_u8(data
->temp8
[attr
->index
]);
772 temp
= temp_from_s8(data
->temp8
[attr
->index
]);
774 /* +16 degrees offset for temp2 for the LM99 */
775 if (data
->kind
== lm99
&& attr
->index
== 3)
778 return sprintf(buf
, "%d\n", temp
);
781 static ssize_t
set_temp8(struct device
*dev
, struct device_attribute
*devattr
,
782 const char *buf
, size_t count
)
784 static const u8 reg
[TEMP8_REG_NUM
] = {
785 LM90_REG_W_LOCAL_LOW
,
786 LM90_REG_W_LOCAL_HIGH
,
787 LM90_REG_W_LOCAL_CRIT
,
788 LM90_REG_W_REMOTE_CRIT
,
789 MAX6659_REG_W_LOCAL_EMERG
,
790 MAX6659_REG_W_REMOTE_EMERG
,
791 LM90_REG_W_REMOTE_CRIT
,
792 MAX6659_REG_W_REMOTE_EMERG
,
795 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
796 struct lm90_data
*data
= dev_get_drvdata(dev
);
797 struct i2c_client
*client
= data
->client
;
798 int nr
= attr
->index
;
802 err
= kstrtol(buf
, 10, &val
);
806 /* +16 degrees offset for temp2 for the LM99 */
807 if (data
->kind
== lm99
&& attr
->index
== 3)
810 mutex_lock(&data
->update_lock
);
811 if (data
->kind
== adt7461
|| data
->kind
== tmp451
)
812 data
->temp8
[nr
] = temp_to_u8_adt7461(data
, val
);
813 else if (data
->kind
== max6646
)
814 data
->temp8
[nr
] = temp_to_u8(val
);
816 data
->temp8
[nr
] = temp_to_s8(val
);
818 lm90_select_remote_channel(client
, data
, nr
>= 6);
819 i2c_smbus_write_byte_data(client
, reg
[nr
], data
->temp8
[nr
]);
820 lm90_select_remote_channel(client
, data
, 0);
822 mutex_unlock(&data
->update_lock
);
826 static ssize_t
show_temp11(struct device
*dev
, struct device_attribute
*devattr
,
829 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
830 struct lm90_data
*data
= lm90_update_device(dev
);
833 if (data
->kind
== adt7461
|| data
->kind
== tmp451
)
834 temp
= temp_from_u16_adt7461(data
, data
->temp11
[attr
->index
]);
835 else if (data
->kind
== max6646
)
836 temp
= temp_from_u16(data
->temp11
[attr
->index
]);
838 temp
= temp_from_s16(data
->temp11
[attr
->index
]);
840 /* +16 degrees offset for temp2 for the LM99 */
841 if (data
->kind
== lm99
&& attr
->index
<= 2)
844 return sprintf(buf
, "%d\n", temp
);
847 static ssize_t
set_temp11(struct device
*dev
, struct device_attribute
*devattr
,
848 const char *buf
, size_t count
)
855 { LM90_REG_W_REMOTE_LOWH
, LM90_REG_W_REMOTE_LOWL
, 0 },
856 { LM90_REG_W_REMOTE_HIGHH
, LM90_REG_W_REMOTE_HIGHL
, 0 },
857 { LM90_REG_W_REMOTE_OFFSH
, LM90_REG_W_REMOTE_OFFSL
, 0 },
858 { LM90_REG_W_REMOTE_LOWH
, LM90_REG_W_REMOTE_LOWL
, 1 },
859 { LM90_REG_W_REMOTE_HIGHH
, LM90_REG_W_REMOTE_HIGHL
, 1 }
862 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
863 struct lm90_data
*data
= dev_get_drvdata(dev
);
864 struct i2c_client
*client
= data
->client
;
866 int index
= attr
->index
;
870 err
= kstrtol(buf
, 10, &val
);
874 /* +16 degrees offset for temp2 for the LM99 */
875 if (data
->kind
== lm99
&& index
<= 2)
878 mutex_lock(&data
->update_lock
);
879 if (data
->kind
== adt7461
|| data
->kind
== tmp451
)
880 data
->temp11
[index
] = temp_to_u16_adt7461(data
, val
);
881 else if (data
->kind
== max6646
)
882 data
->temp11
[index
] = temp_to_u8(val
) << 8;
883 else if (data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
884 data
->temp11
[index
] = temp_to_s16(val
);
886 data
->temp11
[index
] = temp_to_s8(val
) << 8;
888 lm90_select_remote_channel(client
, data
, reg
[nr
].channel
);
889 i2c_smbus_write_byte_data(client
, reg
[nr
].high
,
890 data
->temp11
[index
] >> 8);
891 if (data
->flags
& LM90_HAVE_REM_LIMIT_EXT
)
892 i2c_smbus_write_byte_data(client
, reg
[nr
].low
,
893 data
->temp11
[index
] & 0xff);
894 lm90_select_remote_channel(client
, data
, 0);
896 mutex_unlock(&data
->update_lock
);
900 static ssize_t
show_temphyst(struct device
*dev
,
901 struct device_attribute
*devattr
,
904 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
905 struct lm90_data
*data
= lm90_update_device(dev
);
908 if (data
->kind
== adt7461
|| data
->kind
== tmp451
)
909 temp
= temp_from_u8_adt7461(data
, data
->temp8
[attr
->index
]);
910 else if (data
->kind
== max6646
)
911 temp
= temp_from_u8(data
->temp8
[attr
->index
]);
913 temp
= temp_from_s8(data
->temp8
[attr
->index
]);
915 /* +16 degrees offset for temp2 for the LM99 */
916 if (data
->kind
== lm99
&& attr
->index
== 3)
919 return sprintf(buf
, "%d\n", temp
- temp_from_s8(data
->temp_hyst
));
922 static ssize_t
set_temphyst(struct device
*dev
, struct device_attribute
*dummy
,
923 const char *buf
, size_t count
)
925 struct lm90_data
*data
= dev_get_drvdata(dev
);
926 struct i2c_client
*client
= data
->client
;
931 err
= kstrtol(buf
, 10, &val
);
935 mutex_lock(&data
->update_lock
);
936 if (data
->kind
== adt7461
|| data
->kind
== tmp451
)
937 temp
= temp_from_u8_adt7461(data
, data
->temp8
[LOCAL_CRIT
]);
938 else if (data
->kind
== max6646
)
939 temp
= temp_from_u8(data
->temp8
[LOCAL_CRIT
]);
941 temp
= temp_from_s8(data
->temp8
[LOCAL_CRIT
]);
943 data
->temp_hyst
= hyst_to_reg(temp
- val
);
944 i2c_smbus_write_byte_data(client
, LM90_REG_W_TCRIT_HYST
,
946 mutex_unlock(&data
->update_lock
);
950 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*dummy
,
953 struct lm90_data
*data
= lm90_update_device(dev
);
954 return sprintf(buf
, "%d\n", data
->alarms
);
957 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
960 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
961 struct lm90_data
*data
= lm90_update_device(dev
);
962 int bitnr
= attr
->index
;
964 return sprintf(buf
, "%d\n", (data
->alarms
>> bitnr
) & 1);
967 static ssize_t
show_update_interval(struct device
*dev
,
968 struct device_attribute
*attr
, char *buf
)
970 struct lm90_data
*data
= dev_get_drvdata(dev
);
972 return sprintf(buf
, "%u\n", data
->update_interval
);
975 static ssize_t
set_update_interval(struct device
*dev
,
976 struct device_attribute
*attr
,
977 const char *buf
, size_t count
)
979 struct lm90_data
*data
= dev_get_drvdata(dev
);
980 struct i2c_client
*client
= data
->client
;
984 err
= kstrtoul(buf
, 10, &val
);
988 mutex_lock(&data
->update_lock
);
989 lm90_set_convrate(client
, data
, clamp_val(val
, 0, 100000));
990 mutex_unlock(&data
->update_lock
);
995 static SENSOR_DEVICE_ATTR_2(temp1_input
, S_IRUGO
, show_temp11
, NULL
,
997 static SENSOR_DEVICE_ATTR_2(temp2_input
, S_IRUGO
, show_temp11
, NULL
,
999 static SENSOR_DEVICE_ATTR(temp1_min
, S_IWUSR
| S_IRUGO
, show_temp8
,
1000 set_temp8
, LOCAL_LOW
);
1001 static SENSOR_DEVICE_ATTR_2(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp11
,
1002 set_temp11
, 0, REMOTE_LOW
);
1003 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp8
,
1004 set_temp8
, LOCAL_HIGH
);
1005 static SENSOR_DEVICE_ATTR_2(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp11
,
1006 set_temp11
, 1, REMOTE_HIGH
);
1007 static SENSOR_DEVICE_ATTR(temp1_crit
, S_IWUSR
| S_IRUGO
, show_temp8
,
1008 set_temp8
, LOCAL_CRIT
);
1009 static SENSOR_DEVICE_ATTR(temp2_crit
, S_IWUSR
| S_IRUGO
, show_temp8
,
1010 set_temp8
, REMOTE_CRIT
);
1011 static SENSOR_DEVICE_ATTR(temp1_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temphyst
,
1012 set_temphyst
, LOCAL_CRIT
);
1013 static SENSOR_DEVICE_ATTR(temp2_crit_hyst
, S_IRUGO
, show_temphyst
, NULL
,
1015 static SENSOR_DEVICE_ATTR_2(temp2_offset
, S_IWUSR
| S_IRUGO
, show_temp11
,
1016 set_temp11
, 2, REMOTE_OFFSET
);
1018 /* Individual alarm files */
1019 static SENSOR_DEVICE_ATTR(temp1_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
1020 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
1021 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 2);
1022 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
1023 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
1024 static SENSOR_DEVICE_ATTR(temp1_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 5);
1025 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
1026 /* Raw alarm file for compatibility */
1027 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
1029 static DEVICE_ATTR(update_interval
, S_IRUGO
| S_IWUSR
, show_update_interval
,
1030 set_update_interval
);
1032 static struct attribute
*lm90_attributes
[] = {
1033 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
1034 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
1035 &sensor_dev_attr_temp1_min
.dev_attr
.attr
,
1036 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
1037 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
1038 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
1039 &sensor_dev_attr_temp1_crit
.dev_attr
.attr
,
1040 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
1041 &sensor_dev_attr_temp1_crit_hyst
.dev_attr
.attr
,
1042 &sensor_dev_attr_temp2_crit_hyst
.dev_attr
.attr
,
1044 &sensor_dev_attr_temp1_crit_alarm
.dev_attr
.attr
,
1045 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
1046 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
1047 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
1048 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
1049 &sensor_dev_attr_temp1_min_alarm
.dev_attr
.attr
,
1050 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
1051 &dev_attr_alarms
.attr
,
1052 &dev_attr_update_interval
.attr
,
1056 static const struct attribute_group lm90_group
= {
1057 .attrs
= lm90_attributes
,
1060 static struct attribute
*lm90_temp2_offset_attributes
[] = {
1061 &sensor_dev_attr_temp2_offset
.dev_attr
.attr
,
1065 static const struct attribute_group lm90_temp2_offset_group
= {
1066 .attrs
= lm90_temp2_offset_attributes
,
1070 * Additional attributes for devices with emergency sensors
1072 static SENSOR_DEVICE_ATTR(temp1_emergency
, S_IWUSR
| S_IRUGO
, show_temp8
,
1073 set_temp8
, LOCAL_EMERG
);
1074 static SENSOR_DEVICE_ATTR(temp2_emergency
, S_IWUSR
| S_IRUGO
, show_temp8
,
1075 set_temp8
, REMOTE_EMERG
);
1076 static SENSOR_DEVICE_ATTR(temp1_emergency_hyst
, S_IRUGO
, show_temphyst
,
1078 static SENSOR_DEVICE_ATTR(temp2_emergency_hyst
, S_IRUGO
, show_temphyst
,
1079 NULL
, REMOTE_EMERG
);
1081 static struct attribute
*lm90_emergency_attributes
[] = {
1082 &sensor_dev_attr_temp1_emergency
.dev_attr
.attr
,
1083 &sensor_dev_attr_temp2_emergency
.dev_attr
.attr
,
1084 &sensor_dev_attr_temp1_emergency_hyst
.dev_attr
.attr
,
1085 &sensor_dev_attr_temp2_emergency_hyst
.dev_attr
.attr
,
1089 static const struct attribute_group lm90_emergency_group
= {
1090 .attrs
= lm90_emergency_attributes
,
1093 static SENSOR_DEVICE_ATTR(temp1_emergency_alarm
, S_IRUGO
, show_alarm
, NULL
, 15);
1094 static SENSOR_DEVICE_ATTR(temp2_emergency_alarm
, S_IRUGO
, show_alarm
, NULL
, 13);
1096 static struct attribute
*lm90_emergency_alarm_attributes
[] = {
1097 &sensor_dev_attr_temp1_emergency_alarm
.dev_attr
.attr
,
1098 &sensor_dev_attr_temp2_emergency_alarm
.dev_attr
.attr
,
1102 static const struct attribute_group lm90_emergency_alarm_group
= {
1103 .attrs
= lm90_emergency_alarm_attributes
,
1107 * Additional attributes for devices with 3 temperature sensors
1109 static SENSOR_DEVICE_ATTR_2(temp3_input
, S_IRUGO
, show_temp11
, NULL
,
1111 static SENSOR_DEVICE_ATTR_2(temp3_min
, S_IWUSR
| S_IRUGO
, show_temp11
,
1112 set_temp11
, 3, REMOTE2_LOW
);
1113 static SENSOR_DEVICE_ATTR_2(temp3_max
, S_IWUSR
| S_IRUGO
, show_temp11
,
1114 set_temp11
, 4, REMOTE2_HIGH
);
1115 static SENSOR_DEVICE_ATTR(temp3_crit
, S_IWUSR
| S_IRUGO
, show_temp8
,
1116 set_temp8
, REMOTE2_CRIT
);
1117 static SENSOR_DEVICE_ATTR(temp3_crit_hyst
, S_IRUGO
, show_temphyst
, NULL
,
1119 static SENSOR_DEVICE_ATTR(temp3_emergency
, S_IWUSR
| S_IRUGO
, show_temp8
,
1120 set_temp8
, REMOTE2_EMERG
);
1121 static SENSOR_DEVICE_ATTR(temp3_emergency_hyst
, S_IRUGO
, show_temphyst
,
1122 NULL
, REMOTE2_EMERG
);
1124 static SENSOR_DEVICE_ATTR(temp3_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 9);
1125 static SENSOR_DEVICE_ATTR(temp3_fault
, S_IRUGO
, show_alarm
, NULL
, 10);
1126 static SENSOR_DEVICE_ATTR(temp3_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
1127 static SENSOR_DEVICE_ATTR(temp3_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 12);
1128 static SENSOR_DEVICE_ATTR(temp3_emergency_alarm
, S_IRUGO
, show_alarm
, NULL
, 14);
1130 static struct attribute
*lm90_temp3_attributes
[] = {
1131 &sensor_dev_attr_temp3_input
.dev_attr
.attr
,
1132 &sensor_dev_attr_temp3_min
.dev_attr
.attr
,
1133 &sensor_dev_attr_temp3_max
.dev_attr
.attr
,
1134 &sensor_dev_attr_temp3_crit
.dev_attr
.attr
,
1135 &sensor_dev_attr_temp3_crit_hyst
.dev_attr
.attr
,
1136 &sensor_dev_attr_temp3_emergency
.dev_attr
.attr
,
1137 &sensor_dev_attr_temp3_emergency_hyst
.dev_attr
.attr
,
1139 &sensor_dev_attr_temp3_fault
.dev_attr
.attr
,
1140 &sensor_dev_attr_temp3_min_alarm
.dev_attr
.attr
,
1141 &sensor_dev_attr_temp3_max_alarm
.dev_attr
.attr
,
1142 &sensor_dev_attr_temp3_crit_alarm
.dev_attr
.attr
,
1143 &sensor_dev_attr_temp3_emergency_alarm
.dev_attr
.attr
,
1147 static const struct attribute_group lm90_temp3_group
= {
1148 .attrs
= lm90_temp3_attributes
,
1151 /* pec used for ADM1032 only */
1152 static ssize_t
show_pec(struct device
*dev
, struct device_attribute
*dummy
,
1155 struct i2c_client
*client
= to_i2c_client(dev
);
1156 return sprintf(buf
, "%d\n", !!(client
->flags
& I2C_CLIENT_PEC
));
1159 static ssize_t
set_pec(struct device
*dev
, struct device_attribute
*dummy
,
1160 const char *buf
, size_t count
)
1162 struct i2c_client
*client
= to_i2c_client(dev
);
1166 err
= kstrtol(buf
, 10, &val
);
1172 client
->flags
&= ~I2C_CLIENT_PEC
;
1175 client
->flags
|= I2C_CLIENT_PEC
;
1184 static DEVICE_ATTR(pec
, S_IWUSR
| S_IRUGO
, show_pec
, set_pec
);
1190 /* Return 0 if detection is successful, -ENODEV otherwise */
1191 static int lm90_detect(struct i2c_client
*client
,
1192 struct i2c_board_info
*info
)
1194 struct i2c_adapter
*adapter
= client
->adapter
;
1195 int address
= client
->addr
;
1196 const char *name
= NULL
;
1197 int man_id
, chip_id
, config1
, config2
, convrate
;
1199 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
1202 /* detection and identification */
1203 man_id
= i2c_smbus_read_byte_data(client
, LM90_REG_R_MAN_ID
);
1204 chip_id
= i2c_smbus_read_byte_data(client
, LM90_REG_R_CHIP_ID
);
1205 config1
= i2c_smbus_read_byte_data(client
, LM90_REG_R_CONFIG1
);
1206 convrate
= i2c_smbus_read_byte_data(client
, LM90_REG_R_CONVRATE
);
1207 if (man_id
< 0 || chip_id
< 0 || config1
< 0 || convrate
< 0)
1210 if (man_id
== 0x01 || man_id
== 0x5C || man_id
== 0x41) {
1211 config2
= i2c_smbus_read_byte_data(client
, LM90_REG_R_CONFIG2
);
1215 config2
= 0; /* Make compiler happy */
1217 if ((address
== 0x4C || address
== 0x4D)
1218 && man_id
== 0x01) { /* National Semiconductor */
1219 if ((config1
& 0x2A) == 0x00
1220 && (config2
& 0xF8) == 0x00
1221 && convrate
<= 0x09) {
1223 && (chip_id
& 0xF0) == 0x20) { /* LM90 */
1226 if ((chip_id
& 0xF0) == 0x30) { /* LM89/LM99 */
1228 dev_info(&adapter
->dev
,
1229 "Assuming LM99 chip at 0x%02x\n",
1231 dev_info(&adapter
->dev
,
1232 "If it is an LM89, instantiate it "
1233 "with the new_device sysfs "
1237 && (chip_id
& 0xF0) == 0x10) { /* LM86 */
1242 if ((address
== 0x4C || address
== 0x4D)
1243 && man_id
== 0x41) { /* Analog Devices */
1244 if ((chip_id
& 0xF0) == 0x40 /* ADM1032 */
1245 && (config1
& 0x3F) == 0x00
1246 && convrate
<= 0x0A) {
1249 * The ADM1032 supports PEC, but only if combined
1250 * transactions are not used.
1252 if (i2c_check_functionality(adapter
,
1253 I2C_FUNC_SMBUS_BYTE
))
1254 info
->flags
|= I2C_CLIENT_PEC
;
1256 if (chip_id
== 0x51 /* ADT7461 */
1257 && (config1
& 0x1B) == 0x00
1258 && convrate
<= 0x0A) {
1261 if (chip_id
== 0x57 /* ADT7461A, NCT1008 */
1262 && (config1
& 0x1B) == 0x00
1263 && convrate
<= 0x0A) {
1267 if (man_id
== 0x4D) { /* Maxim */
1268 int emerg
, emerg2
, status2
;
1271 * We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read
1272 * LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG
1273 * exists, both readings will reflect the same value. Otherwise,
1274 * the readings will be different.
1276 emerg
= i2c_smbus_read_byte_data(client
,
1277 MAX6659_REG_R_REMOTE_EMERG
);
1278 man_id
= i2c_smbus_read_byte_data(client
,
1280 emerg2
= i2c_smbus_read_byte_data(client
,
1281 MAX6659_REG_R_REMOTE_EMERG
);
1282 status2
= i2c_smbus_read_byte_data(client
,
1283 MAX6696_REG_R_STATUS2
);
1284 if (emerg
< 0 || man_id
< 0 || emerg2
< 0 || status2
< 0)
1288 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
1289 * register. Reading from that address will return the last
1290 * read value, which in our case is those of the man_id
1291 * register. Likewise, the config1 register seems to lack a
1292 * low nibble, so the value will be those of the previous
1293 * read, so in our case those of the man_id register.
1294 * MAX6659 has a third set of upper temperature limit registers.
1295 * Those registers also return values on MAX6657 and MAX6658,
1296 * thus the only way to detect MAX6659 is by its address.
1297 * For this reason it will be mis-detected as MAX6657 if its
1300 if (chip_id
== man_id
1301 && (address
== 0x4C || address
== 0x4D || address
== 0x4E)
1302 && (config1
& 0x1F) == (man_id
& 0x0F)
1303 && convrate
<= 0x09) {
1304 if (address
== 0x4C)
1310 * Even though MAX6695 and MAX6696 do not have a chip ID
1311 * register, reading it returns 0x01. Bit 4 of the config1
1312 * register is unused and should return zero when read. Bit 0 of
1313 * the status2 register is unused and should return zero when
1316 * MAX6695 and MAX6696 have an additional set of temperature
1317 * limit registers. We can detect those chips by checking if
1318 * one of those registers exists.
1321 && (config1
& 0x10) == 0x00
1322 && (status2
& 0x01) == 0x00
1324 && convrate
<= 0x07) {
1328 * The chip_id register of the MAX6680 and MAX6681 holds the
1329 * revision of the chip. The lowest bit of the config1 register
1330 * is unused and should return zero when read, so should the
1331 * second to last bit of config1 (software reset).
1334 && (config1
& 0x03) == 0x00
1335 && convrate
<= 0x07) {
1339 * The chip_id register of the MAX6646/6647/6649 holds the
1340 * revision of the chip. The lowest 6 bits of the config1
1341 * register are unused and should return zero when read.
1344 && (config1
& 0x3f) == 0x00
1345 && convrate
<= 0x07) {
1350 && man_id
== 0x5C) { /* Winbond/Nuvoton */
1351 if ((config1
& 0x2A) == 0x00
1352 && (config2
& 0xF8) == 0x00) {
1353 if (chip_id
== 0x01 /* W83L771W/G */
1354 && convrate
<= 0x09) {
1357 if ((chip_id
& 0xFE) == 0x10 /* W83L771AWG/ASG */
1358 && convrate
<= 0x08) {
1363 if (address
>= 0x48 && address
<= 0x4F
1364 && man_id
== 0xA1) { /* NXP Semiconductor/Philips */
1366 && (config1
& 0x2A) == 0x00
1367 && (config2
& 0xFE) == 0x00
1368 && convrate
<= 0x09) {
1372 if ((address
== 0x4C || address
== 0x4D)
1373 && man_id
== 0x47) { /* GMT */
1374 if (chip_id
== 0x01 /* G781 */
1375 && (config1
& 0x3F) == 0x00
1376 && convrate
<= 0x08)
1380 && man_id
== 0x55) { /* Texas Instruments */
1383 local_ext
= i2c_smbus_read_byte_data(client
,
1384 TMP451_REG_R_LOCAL_TEMPL
);
1386 if (chip_id
== 0x00 /* TMP451 */
1387 && (config1
& 0x1B) == 0x00
1389 && (local_ext
& 0x0F) == 0x00)
1393 if (!name
) { /* identification failed */
1394 dev_dbg(&adapter
->dev
,
1395 "Unsupported chip at 0x%02x (man_id=0x%02X, "
1396 "chip_id=0x%02X)\n", address
, man_id
, chip_id
);
1400 strlcpy(info
->type
, name
, I2C_NAME_SIZE
);
1405 static void lm90_restore_conf(void *_data
)
1407 struct lm90_data
*data
= _data
;
1408 struct i2c_client
*client
= data
->client
;
1410 /* Restore initial configuration */
1411 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONVRATE
,
1412 data
->convrate_orig
);
1413 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
,
1417 static void lm90_init_client(struct i2c_client
*client
, struct lm90_data
*data
)
1419 u8 config
, convrate
;
1421 if (lm90_read_reg(client
, LM90_REG_R_CONVRATE
, &convrate
) < 0) {
1422 dev_warn(&client
->dev
, "Failed to read convrate register!\n");
1423 convrate
= LM90_DEF_CONVRATE_RVAL
;
1425 data
->convrate_orig
= convrate
;
1428 * Start the conversions.
1430 lm90_set_convrate(client
, data
, 500); /* 500ms; 2Hz conversion rate */
1431 if (lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
) < 0) {
1432 dev_warn(&client
->dev
, "Initialization failed!\n");
1435 data
->config_orig
= config
;
1437 /* Check Temperature Range Select */
1438 if (data
->kind
== adt7461
|| data
->kind
== tmp451
) {
1440 data
->flags
|= LM90_FLAG_ADT7461_EXT
;
1444 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
1445 * 0.125 degree resolution) and range (0x08, extend range
1446 * to -64 degree) mode for the remote temperature sensor.
1448 if (data
->kind
== max6680
)
1452 * Select external channel 0 for max6695/96
1454 if (data
->kind
== max6696
)
1457 config
&= 0xBF; /* run */
1458 if (config
!= data
->config_orig
) /* Only write if changed */
1459 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
, config
);
1461 devm_add_action(&client
->dev
, lm90_restore_conf
, data
);
1464 static bool lm90_is_tripped(struct i2c_client
*client
, u16
*status
)
1466 struct lm90_data
*data
= i2c_get_clientdata(client
);
1469 lm90_read_reg(client
, LM90_REG_R_STATUS
, &st
);
1471 if (data
->kind
== max6696
)
1472 lm90_read_reg(client
, MAX6696_REG_R_STATUS2
, &st2
);
1474 *status
= st
| (st2
<< 8);
1476 if ((st
& 0x7f) == 0 && (st2
& 0xfe) == 0)
1479 if ((st
& (LM90_STATUS_LLOW
| LM90_STATUS_LHIGH
| LM90_STATUS_LTHRM
)) ||
1480 (st2
& MAX6696_STATUS2_LOT2
))
1481 dev_warn(&client
->dev
,
1482 "temp%d out of range, please check!\n", 1);
1483 if ((st
& (LM90_STATUS_RLOW
| LM90_STATUS_RHIGH
| LM90_STATUS_RTHRM
)) ||
1484 (st2
& MAX6696_STATUS2_ROT2
))
1485 dev_warn(&client
->dev
,
1486 "temp%d out of range, please check!\n", 2);
1487 if (st
& LM90_STATUS_ROPEN
)
1488 dev_warn(&client
->dev
,
1489 "temp%d diode open, please check!\n", 2);
1490 if (st2
& (MAX6696_STATUS2_R2LOW
| MAX6696_STATUS2_R2HIGH
|
1491 MAX6696_STATUS2_R2THRM
| MAX6696_STATUS2_R2OT2
))
1492 dev_warn(&client
->dev
,
1493 "temp%d out of range, please check!\n", 3);
1494 if (st2
& MAX6696_STATUS2_R2OPEN
)
1495 dev_warn(&client
->dev
,
1496 "temp%d diode open, please check!\n", 3);
1501 static irqreturn_t
lm90_irq_thread(int irq
, void *dev_id
)
1503 struct i2c_client
*client
= dev_id
;
1506 if (lm90_is_tripped(client
, &status
))
1512 static void lm90_remove_pec(void *dev
)
1514 device_remove_file(dev
, &dev_attr_pec
);
1517 static void lm90_regulator_disable(void *regulator
)
1519 regulator_disable(regulator
);
1522 static int lm90_probe(struct i2c_client
*client
,
1523 const struct i2c_device_id
*id
)
1525 struct device
*dev
= &client
->dev
;
1526 struct i2c_adapter
*adapter
= to_i2c_adapter(dev
->parent
);
1527 struct lm90_data
*data
;
1528 struct regulator
*regulator
;
1529 struct device
*hwmon_dev
;
1533 regulator
= devm_regulator_get(dev
, "vcc");
1534 if (IS_ERR(regulator
))
1535 return PTR_ERR(regulator
);
1537 err
= regulator_enable(regulator
);
1539 dev_err(dev
, "Failed to enable regulator: %d\n", err
);
1543 devm_add_action(dev
, lm90_regulator_disable
, regulator
);
1545 data
= devm_kzalloc(dev
, sizeof(struct lm90_data
), GFP_KERNEL
);
1549 data
->client
= client
;
1550 i2c_set_clientdata(client
, data
);
1551 mutex_init(&data
->update_lock
);
1553 /* Set the device type */
1554 data
->kind
= id
->driver_data
;
1555 if (data
->kind
== adm1032
) {
1556 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE
))
1557 client
->flags
&= ~I2C_CLIENT_PEC
;
1561 * Different devices have different alarm bits triggering the
1564 data
->alert_alarms
= lm90_params
[data
->kind
].alert_alarms
;
1566 /* Set chip capabilities */
1567 data
->flags
= lm90_params
[data
->kind
].flags
;
1568 data
->reg_local_ext
= lm90_params
[data
->kind
].reg_local_ext
;
1570 /* Set maximum conversion rate */
1571 data
->max_convrate
= lm90_params
[data
->kind
].max_convrate
;
1573 /* Initialize the LM90 chip */
1574 lm90_init_client(client
, data
);
1576 /* Register sysfs hooks */
1577 data
->groups
[groups
++] = &lm90_group
;
1579 if (data
->flags
& LM90_HAVE_OFFSET
)
1580 data
->groups
[groups
++] = &lm90_temp2_offset_group
;
1582 if (data
->flags
& LM90_HAVE_EMERGENCY
)
1583 data
->groups
[groups
++] = &lm90_emergency_group
;
1585 if (data
->flags
& LM90_HAVE_EMERGENCY_ALARM
)
1586 data
->groups
[groups
++] = &lm90_emergency_alarm_group
;
1588 if (data
->flags
& LM90_HAVE_TEMP3
)
1589 data
->groups
[groups
++] = &lm90_temp3_group
;
1591 if (client
->flags
& I2C_CLIENT_PEC
) {
1592 err
= device_create_file(dev
, &dev_attr_pec
);
1595 devm_add_action(dev
, lm90_remove_pec
, dev
);
1598 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, client
->name
,
1599 data
, data
->groups
);
1600 if (IS_ERR(hwmon_dev
))
1601 return PTR_ERR(hwmon_dev
);
1604 dev_dbg(dev
, "IRQ: %d\n", client
->irq
);
1605 err
= devm_request_threaded_irq(dev
, client
->irq
,
1606 NULL
, lm90_irq_thread
,
1607 IRQF_TRIGGER_LOW
| IRQF_ONESHOT
,
1610 dev_err(dev
, "cannot request IRQ %d\n", client
->irq
);
1618 static void lm90_alert(struct i2c_client
*client
, unsigned int flag
)
1622 if (lm90_is_tripped(client
, &alarms
)) {
1624 * Disable ALERT# output, because these chips don't implement
1625 * SMBus alert correctly; they should only hold the alert line
1628 struct lm90_data
*data
= i2c_get_clientdata(client
);
1630 if ((data
->flags
& LM90_HAVE_BROKEN_ALERT
)
1631 && (alarms
& data
->alert_alarms
)) {
1633 dev_dbg(&client
->dev
, "Disabling ALERT#\n");
1634 lm90_read_reg(client
, LM90_REG_R_CONFIG1
, &config
);
1635 i2c_smbus_write_byte_data(client
, LM90_REG_W_CONFIG1
,
1639 dev_info(&client
->dev
, "Everything OK\n");
1643 static struct i2c_driver lm90_driver
= {
1644 .class = I2C_CLASS_HWMON
,
1648 .probe
= lm90_probe
,
1649 .alert
= lm90_alert
,
1650 .id_table
= lm90_id
,
1651 .detect
= lm90_detect
,
1652 .address_list
= normal_i2c
,
1655 module_i2c_driver(lm90_driver
);
1657 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1658 MODULE_DESCRIPTION("LM90/ADM1032 driver");
1659 MODULE_LICENSE("GPL");