2 * Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com>
4 * The LM95245 is a sensor chip made by TI / National Semiconductor.
5 * It reports up to two temperatures (its own plus an external one).
7 * This driver is based on lm95241.c
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 #include <linux/err.h>
21 #include <linux/init.h>
22 #include <linux/hwmon.h>
23 #include <linux/i2c.h>
24 #include <linux/module.h>
25 #include <linux/mutex.h>
26 #include <linux/regmap.h>
27 #include <linux/slab.h>
29 static const unsigned short normal_i2c
[] = {
30 0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END
};
32 /* LM95245 registers */
33 /* general registers */
34 #define LM95245_REG_RW_CONFIG1 0x03
35 #define LM95245_REG_RW_CONVERS_RATE 0x04
36 #define LM95245_REG_W_ONE_SHOT 0x0F
38 /* diode configuration */
39 #define LM95245_REG_RW_CONFIG2 0xBF
40 #define LM95245_REG_RW_REMOTE_OFFH 0x11
41 #define LM95245_REG_RW_REMOTE_OFFL 0x12
43 /* status registers */
44 #define LM95245_REG_R_STATUS1 0x02
45 #define LM95245_REG_R_STATUS2 0x33
48 #define LM95245_REG_RW_REMOTE_OS_LIMIT 0x07
49 #define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT 0x20
50 #define LM95245_REG_RW_REMOTE_TCRIT_LIMIT 0x19
51 #define LM95245_REG_RW_COMMON_HYSTERESIS 0x21
53 /* temperature signed */
54 #define LM95245_REG_R_LOCAL_TEMPH_S 0x00
55 #define LM95245_REG_R_LOCAL_TEMPL_S 0x30
56 #define LM95245_REG_R_REMOTE_TEMPH_S 0x01
57 #define LM95245_REG_R_REMOTE_TEMPL_S 0x10
58 /* temperature unsigned */
59 #define LM95245_REG_R_REMOTE_TEMPH_U 0x31
60 #define LM95245_REG_R_REMOTE_TEMPL_U 0x32
63 #define LM95245_REG_R_MAN_ID 0xFE
64 #define LM95245_REG_R_CHIP_ID 0xFF
66 /* LM95245 specific bitfields */
68 #define CFG_REMOTE_TCRIT_MASK 0x10
69 #define CFG_REMOTE_OS_MASK 0x08
70 #define CFG_LOCAL_TCRIT_MASK 0x04
71 #define CFG_LOCAL_OS_MASK 0x02
73 #define CFG2_OS_A0 0x40
74 #define CFG2_DIODE_FAULT_OS 0x20
75 #define CFG2_DIODE_FAULT_TCRIT 0x10
76 #define CFG2_REMOTE_TT 0x08
77 #define CFG2_REMOTE_FILTER_DIS 0x00
78 #define CFG2_REMOTE_FILTER_EN 0x06
80 /* conversation rate in ms */
81 #define RATE_CR0063 0x00
82 #define RATE_CR0364 0x01
83 #define RATE_CR1000 0x02
84 #define RATE_CR2500 0x03
86 #define STATUS1_ROS 0x10
87 #define STATUS1_DIODE_FAULT 0x04
88 #define STATUS1_RTCRIT 0x02
89 #define STATUS1_LOC 0x01
91 #define MANUFACTURER_ID 0x01
92 #define LM95235_REVISION 0xB1
93 #define LM95245_REVISION 0xB3
95 /* Client data (each client gets its own) */
97 struct regmap
*regmap
;
98 struct mutex update_lock
;
99 int interval
; /* in msecs */
103 static int temp_from_reg_unsigned(u8 val_h
, u8 val_l
)
105 return val_h
* 1000 + val_l
* 1000 / 256;
108 static int temp_from_reg_signed(u8 val_h
, u8 val_l
)
111 return (val_h
- 0x100) * 1000;
112 return temp_from_reg_unsigned(val_h
, val_l
);
115 static int lm95245_read_conversion_rate(struct lm95245_data
*data
)
120 ret
= regmap_read(data
->regmap
, LM95245_REG_RW_CONVERS_RATE
, &rate
);
129 data
->interval
= 364;
132 data
->interval
= 1000;
136 data
->interval
= 2500;
142 static int lm95245_set_conversion_rate(struct lm95245_data
*data
, long interval
)
146 if (interval
<= 63) {
149 } else if (interval
<= 364) {
152 } else if (interval
<= 1000) {
160 ret
= regmap_write(data
->regmap
, LM95245_REG_RW_CONVERS_RATE
, rate
);
164 data
->interval
= interval
;
168 static int lm95245_read_temp(struct device
*dev
, u32 attr
, int channel
,
171 struct lm95245_data
*data
= dev_get_drvdata(dev
);
172 struct regmap
*regmap
= data
->regmap
;
173 int ret
, regl
, regh
, regvall
, regvalh
;
176 case hwmon_temp_input
:
177 regl
= channel
? LM95245_REG_R_REMOTE_TEMPL_S
:
178 LM95245_REG_R_LOCAL_TEMPL_S
;
179 regh
= channel
? LM95245_REG_R_REMOTE_TEMPH_S
:
180 LM95245_REG_R_LOCAL_TEMPH_S
;
181 ret
= regmap_read(regmap
, regl
, ®vall
);
184 ret
= regmap_read(regmap
, regh
, ®valh
);
188 * Local temp is always signed.
189 * Remote temp has both signed and unsigned data.
190 * Use signed calculation for remote if signed bit is set
191 * or if reported temperature is below signed limit.
193 if (!channel
|| (regvalh
& 0x80) || regvalh
< 0x7f) {
194 *val
= temp_from_reg_signed(regvalh
, regvall
);
197 ret
= regmap_read(regmap
, LM95245_REG_R_REMOTE_TEMPL_U
,
201 ret
= regmap_read(regmap
, LM95245_REG_R_REMOTE_TEMPH_U
,
205 *val
= temp_from_reg_unsigned(regvalh
, regvall
);
208 ret
= regmap_read(regmap
, LM95245_REG_RW_REMOTE_OS_LIMIT
,
212 *val
= regvalh
* 1000;
214 case hwmon_temp_crit
:
215 regh
= channel
? LM95245_REG_RW_REMOTE_TCRIT_LIMIT
:
216 LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT
;
217 ret
= regmap_read(regmap
, regh
, ®valh
);
220 *val
= regvalh
* 1000;
222 case hwmon_temp_max_hyst
:
223 ret
= regmap_read(regmap
, LM95245_REG_RW_REMOTE_OS_LIMIT
,
227 ret
= regmap_read(regmap
, LM95245_REG_RW_COMMON_HYSTERESIS
,
231 *val
= (regvalh
- regvall
) * 1000;
233 case hwmon_temp_crit_hyst
:
234 regh
= channel
? LM95245_REG_RW_REMOTE_TCRIT_LIMIT
:
235 LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT
;
236 ret
= regmap_read(regmap
, regh
, ®valh
);
239 ret
= regmap_read(regmap
, LM95245_REG_RW_COMMON_HYSTERESIS
,
243 *val
= (regvalh
- regvall
) * 1000;
245 case hwmon_temp_type
:
246 ret
= regmap_read(regmap
, LM95245_REG_RW_CONFIG2
, ®valh
);
249 *val
= (regvalh
& CFG2_REMOTE_TT
) ? 1 : 2;
251 case hwmon_temp_offset
:
252 ret
= regmap_read(regmap
, LM95245_REG_RW_REMOTE_OFFL
,
256 ret
= regmap_read(regmap
, LM95245_REG_RW_REMOTE_OFFH
,
260 *val
= temp_from_reg_signed(regvalh
, regvall
);
262 case hwmon_temp_max_alarm
:
263 ret
= regmap_read(regmap
, LM95245_REG_R_STATUS1
, ®valh
);
266 *val
= !!(regvalh
& STATUS1_ROS
);
268 case hwmon_temp_crit_alarm
:
269 ret
= regmap_read(regmap
, LM95245_REG_R_STATUS1
, ®valh
);
272 *val
= !!(regvalh
& (channel
? STATUS1_RTCRIT
: STATUS1_LOC
));
274 case hwmon_temp_fault
:
275 ret
= regmap_read(regmap
, LM95245_REG_R_STATUS1
, ®valh
);
278 *val
= !!(regvalh
& STATUS1_DIODE_FAULT
);
285 static int lm95245_write_temp(struct device
*dev
, u32 attr
, int channel
,
288 struct lm95245_data
*data
= dev_get_drvdata(dev
);
289 struct regmap
*regmap
= data
->regmap
;
295 val
= clamp_val(val
/ 1000, 0, 255);
296 ret
= regmap_write(regmap
, LM95245_REG_RW_REMOTE_OS_LIMIT
, val
);
298 case hwmon_temp_crit
:
299 reg
= channel
? LM95245_REG_RW_REMOTE_TCRIT_LIMIT
:
300 LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT
;
301 val
= clamp_val(val
/ 1000, 0, channel
? 255 : 127);
302 ret
= regmap_write(regmap
, reg
, val
);
304 case hwmon_temp_crit_hyst
:
305 mutex_lock(&data
->update_lock
);
306 ret
= regmap_read(regmap
, LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT
,
309 mutex_unlock(&data
->update_lock
);
312 /* Clamp to reasonable range to prevent overflow */
313 val
= clamp_val(val
, -1000000, 1000000);
314 val
= regval
- val
/ 1000;
315 val
= clamp_val(val
, 0, 31);
316 ret
= regmap_write(regmap
, LM95245_REG_RW_COMMON_HYSTERESIS
,
318 mutex_unlock(&data
->update_lock
);
320 case hwmon_temp_offset
:
321 val
= clamp_val(val
, -128000, 127875);
322 val
= val
* 256 / 1000;
323 mutex_lock(&data
->update_lock
);
324 ret
= regmap_write(regmap
, LM95245_REG_RW_REMOTE_OFFL
,
327 mutex_unlock(&data
->update_lock
);
330 ret
= regmap_write(regmap
, LM95245_REG_RW_REMOTE_OFFH
,
332 mutex_unlock(&data
->update_lock
);
334 case hwmon_temp_type
:
335 if (val
!= 1 && val
!= 2)
337 ret
= regmap_update_bits(regmap
, LM95245_REG_RW_CONFIG2
,
339 val
== 1 ? CFG2_REMOTE_TT
: 0);
346 static int lm95245_read_chip(struct device
*dev
, u32 attr
, int channel
,
349 struct lm95245_data
*data
= dev_get_drvdata(dev
);
352 case hwmon_chip_update_interval
:
353 *val
= data
->interval
;
360 static int lm95245_write_chip(struct device
*dev
, u32 attr
, int channel
,
363 struct lm95245_data
*data
= dev_get_drvdata(dev
);
367 case hwmon_chip_update_interval
:
368 mutex_lock(&data
->update_lock
);
369 ret
= lm95245_set_conversion_rate(data
, val
);
370 mutex_unlock(&data
->update_lock
);
377 static int lm95245_read(struct device
*dev
, enum hwmon_sensor_types type
,
378 u32 attr
, int channel
, long *val
)
382 return lm95245_read_chip(dev
, attr
, channel
, val
);
384 return lm95245_read_temp(dev
, attr
, channel
, val
);
390 static int lm95245_write(struct device
*dev
, enum hwmon_sensor_types type
,
391 u32 attr
, int channel
, long val
)
395 return lm95245_write_chip(dev
, attr
, channel
, val
);
397 return lm95245_write_temp(dev
, attr
, channel
, val
);
403 static umode_t
lm95245_temp_is_visible(const void *data
, u32 attr
, int channel
)
406 case hwmon_temp_input
:
407 case hwmon_temp_max_alarm
:
408 case hwmon_temp_max_hyst
:
409 case hwmon_temp_crit_alarm
:
410 case hwmon_temp_fault
:
412 case hwmon_temp_type
:
414 case hwmon_temp_crit
:
415 case hwmon_temp_offset
:
417 case hwmon_temp_crit_hyst
:
418 return (channel
== 0) ? 0644 : 0444;
424 static umode_t
lm95245_is_visible(const void *data
,
425 enum hwmon_sensor_types type
,
426 u32 attr
, int channel
)
431 case hwmon_chip_update_interval
:
437 return lm95245_temp_is_visible(data
, attr
, channel
);
443 /* Return 0 if detection is successful, -ENODEV otherwise */
444 static int lm95245_detect(struct i2c_client
*new_client
,
445 struct i2c_board_info
*info
)
447 struct i2c_adapter
*adapter
= new_client
->adapter
;
448 int address
= new_client
->addr
;
452 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
455 id
= i2c_smbus_read_byte_data(new_client
, LM95245_REG_R_MAN_ID
);
456 if (id
!= MANUFACTURER_ID
)
459 rev
= i2c_smbus_read_byte_data(new_client
, LM95245_REG_R_CHIP_ID
);
461 case LM95235_REVISION
:
462 if (address
!= 0x18 && address
!= 0x29 && address
!= 0x4c)
466 case LM95245_REVISION
:
473 strlcpy(info
->type
, name
, I2C_NAME_SIZE
);
477 static int lm95245_init_client(struct lm95245_data
*data
)
481 ret
= lm95245_read_conversion_rate(data
);
485 return regmap_update_bits(data
->regmap
, LM95245_REG_RW_CONFIG1
,
489 static bool lm95245_is_writeable_reg(struct device
*dev
, unsigned int reg
)
492 case LM95245_REG_RW_CONFIG1
:
493 case LM95245_REG_RW_CONVERS_RATE
:
494 case LM95245_REG_W_ONE_SHOT
:
495 case LM95245_REG_RW_CONFIG2
:
496 case LM95245_REG_RW_REMOTE_OFFH
:
497 case LM95245_REG_RW_REMOTE_OFFL
:
498 case LM95245_REG_RW_REMOTE_OS_LIMIT
:
499 case LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT
:
500 case LM95245_REG_RW_REMOTE_TCRIT_LIMIT
:
501 case LM95245_REG_RW_COMMON_HYSTERESIS
:
508 static bool lm95245_is_volatile_reg(struct device
*dev
, unsigned int reg
)
511 case LM95245_REG_R_STATUS1
:
512 case LM95245_REG_R_STATUS2
:
513 case LM95245_REG_R_LOCAL_TEMPH_S
:
514 case LM95245_REG_R_LOCAL_TEMPL_S
:
515 case LM95245_REG_R_REMOTE_TEMPH_S
:
516 case LM95245_REG_R_REMOTE_TEMPL_S
:
517 case LM95245_REG_R_REMOTE_TEMPH_U
:
518 case LM95245_REG_R_REMOTE_TEMPL_U
:
525 static const struct regmap_config lm95245_regmap_config
= {
528 .writeable_reg
= lm95245_is_writeable_reg
,
529 .volatile_reg
= lm95245_is_volatile_reg
,
530 .cache_type
= REGCACHE_RBTREE
,
531 .use_single_read
= true,
532 .use_single_write
= true,
535 static const struct hwmon_channel_info
*lm95245_info
[] = {
536 HWMON_CHANNEL_INFO(chip
,
537 HWMON_C_UPDATE_INTERVAL
),
538 HWMON_CHANNEL_INFO(temp
,
539 HWMON_T_INPUT
| HWMON_T_CRIT
| HWMON_T_CRIT_HYST
|
541 HWMON_T_INPUT
| HWMON_T_MAX
| HWMON_T_MAX_HYST
|
542 HWMON_T_CRIT
| HWMON_T_CRIT_HYST
| HWMON_T_FAULT
|
543 HWMON_T_MAX_ALARM
| HWMON_T_CRIT_ALARM
|
544 HWMON_T_TYPE
| HWMON_T_OFFSET
),
548 static const struct hwmon_ops lm95245_hwmon_ops
= {
549 .is_visible
= lm95245_is_visible
,
550 .read
= lm95245_read
,
551 .write
= lm95245_write
,
554 static const struct hwmon_chip_info lm95245_chip_info
= {
555 .ops
= &lm95245_hwmon_ops
,
556 .info
= lm95245_info
,
559 static int lm95245_probe(struct i2c_client
*client
,
560 const struct i2c_device_id
*id
)
562 struct device
*dev
= &client
->dev
;
563 struct lm95245_data
*data
;
564 struct device
*hwmon_dev
;
567 data
= devm_kzalloc(dev
, sizeof(struct lm95245_data
), GFP_KERNEL
);
571 data
->regmap
= devm_regmap_init_i2c(client
, &lm95245_regmap_config
);
572 if (IS_ERR(data
->regmap
))
573 return PTR_ERR(data
->regmap
);
575 mutex_init(&data
->update_lock
);
577 /* Initialize the LM95245 chip */
578 ret
= lm95245_init_client(data
);
582 hwmon_dev
= devm_hwmon_device_register_with_info(dev
, client
->name
,
586 return PTR_ERR_OR_ZERO(hwmon_dev
);
589 /* Driver data (common to all clients) */
590 static const struct i2c_device_id lm95245_id
[] = {
595 MODULE_DEVICE_TABLE(i2c
, lm95245_id
);
597 static const struct of_device_id __maybe_unused lm95245_of_match
[] = {
598 { .compatible
= "national,lm95235" },
599 { .compatible
= "national,lm95245" },
602 MODULE_DEVICE_TABLE(of
, lm95245_of_match
);
604 static struct i2c_driver lm95245_driver
= {
605 .class = I2C_CLASS_HWMON
,
608 .of_match_table
= of_match_ptr(lm95245_of_match
),
610 .probe
= lm95245_probe
,
611 .id_table
= lm95245_id
,
612 .detect
= lm95245_detect
,
613 .address_list
= normal_i2c
,
616 module_i2c_driver(lm95245_driver
);
618 MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
619 MODULE_DESCRIPTION("LM95235/LM95245 sensor driver");
620 MODULE_LICENSE("GPL");