2 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/hwmon.h>
27 #include <linux/hwmon-sysfs.h>
28 #include <linux/err.h>
29 #include <linux/mutex.h>
31 #include <linux/thermal.h>
36 * This driver handles the LM75 and compatible digital temperature sensors.
39 enum lm75_type
{ /* keep sorted in alphabetical order */
63 /* Addresses scanned */
64 static const unsigned short normal_i2c
[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
65 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
};
68 /* The LM75 registers */
69 #define LM75_REG_CONF 0x01
70 static const u8 LM75_REG_TEMP
[3] = {
76 /* Each client has this additional data */
78 struct i2c_client
*client
;
79 struct mutex update_lock
;
81 u8 resolution
; /* In bits, between 9 and 12 */
83 char valid
; /* !=0 if registers are valid */
84 unsigned long last_updated
; /* In jiffies */
85 unsigned long sample_time
; /* In jiffies */
86 s16 temp
[3]; /* Register values,
92 static struct lm75_data
*lm75_update_device(struct device
*dev
);
95 /*-----------------------------------------------------------------------*/
97 static inline long lm75_reg_to_mc(s16 temp
, u8 resolution
)
99 return ((temp
>> (16 - resolution
)) * 1000) >> (resolution
- 8);
102 /* sysfs attributes for hwmon */
104 static int lm75_read_temp(void *dev
, int *temp
)
106 struct lm75_data
*data
= lm75_update_device(dev
);
109 return PTR_ERR(data
);
111 *temp
= lm75_reg_to_mc(data
->temp
[0], data
->resolution
);
116 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*da
,
119 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
120 struct lm75_data
*data
= lm75_update_device(dev
);
123 return PTR_ERR(data
);
125 return sprintf(buf
, "%ld\n", lm75_reg_to_mc(data
->temp
[attr
->index
],
129 static ssize_t
set_temp(struct device
*dev
, struct device_attribute
*da
,
130 const char *buf
, size_t count
)
132 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
133 struct lm75_data
*data
= dev_get_drvdata(dev
);
134 struct i2c_client
*client
= data
->client
;
135 int nr
= attr
->index
;
140 error
= kstrtol(buf
, 10, &temp
);
145 * Resolution of limit registers is assumed to be the same as the
146 * temperature input register resolution unless given explicitly.
148 if (attr
->index
&& data
->resolution_limits
)
149 resolution
= data
->resolution_limits
;
151 resolution
= data
->resolution
;
153 mutex_lock(&data
->update_lock
);
154 temp
= clamp_val(temp
, LM75_TEMP_MIN
, LM75_TEMP_MAX
);
155 data
->temp
[nr
] = DIV_ROUND_CLOSEST(temp
<< (resolution
- 8),
156 1000) << (16 - resolution
);
157 i2c_smbus_write_word_swapped(client
, LM75_REG_TEMP
[nr
], data
->temp
[nr
]);
158 mutex_unlock(&data
->update_lock
);
162 static ssize_t
show_update_interval(struct device
*dev
,
163 struct device_attribute
*da
, char *buf
)
165 struct lm75_data
*data
= lm75_update_device(dev
);
168 return PTR_ERR(data
);
170 return sprintf(buf
, "%u\n", jiffies_to_msecs(data
->sample_time
));
173 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
,
174 show_temp
, set_temp
, 1);
175 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IWUSR
| S_IRUGO
,
176 show_temp
, set_temp
, 2);
177 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
178 static DEVICE_ATTR(update_interval
, S_IRUGO
, show_update_interval
, NULL
);
180 static struct attribute
*lm75_attrs
[] = {
181 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
182 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
183 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
184 &dev_attr_update_interval
.attr
,
188 ATTRIBUTE_GROUPS(lm75
);
190 static const struct thermal_zone_of_device_ops lm75_of_thermal_ops
= {
191 .get_temp
= lm75_read_temp
,
194 /*-----------------------------------------------------------------------*/
196 /* device probe and removal */
198 static void lm75_remove(void *data
)
200 struct lm75_data
*lm75
= data
;
201 struct i2c_client
*client
= lm75
->client
;
203 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, lm75
->orig_conf
);
207 lm75_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
209 struct device
*dev
= &client
->dev
;
210 struct device
*hwmon_dev
;
211 struct lm75_data
*data
;
213 u8 set_mask
, clr_mask
;
215 enum lm75_type kind
= id
->driver_data
;
217 if (!i2c_check_functionality(client
->adapter
,
218 I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_WORD_DATA
))
221 data
= devm_kzalloc(dev
, sizeof(struct lm75_data
), GFP_KERNEL
);
225 data
->client
= client
;
226 i2c_set_clientdata(client
, data
);
227 mutex_init(&data
->update_lock
);
229 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
230 * Then tweak to be more precise when appropriate.
233 clr_mask
= LM75_SHUTDOWN
; /* continuous conversions */
237 clr_mask
|= 1 << 5; /* not one-shot mode */
238 data
->resolution
= 12;
239 data
->sample_time
= HZ
/ 8;
245 set_mask
|= 2 << 5; /* 11-bit mode */
246 data
->resolution
= 11;
247 data
->sample_time
= HZ
;
250 set_mask
|= 3 << 5; /* 12-bit mode */
251 data
->resolution
= 12;
252 data
->sample_time
= HZ
/ 4;
257 data
->resolution
= 9;
258 data
->sample_time
= HZ
/ 2;
261 data
->resolution
= 11;
262 data
->sample_time
= HZ
/ 4;
265 data
->resolution
= 9;
266 data
->sample_time
= HZ
/ 4;
269 data
->resolution
= 12;
270 data
->resolution_limits
= 9;
271 data
->sample_time
= HZ
/ 4;
274 data
->resolution
= 9;
275 data
->sample_time
= HZ
/ 8;
278 data
->resolution_limits
= 9;
282 set_mask
|= 3 << 5; /* 12-bit mode */
283 data
->resolution
= 12;
284 data
->sample_time
= HZ
;
285 clr_mask
|= 1 << 7; /* not one-shot mode */
288 set_mask
|= 3 << 5; /* 12-bit mode */
289 clr_mask
|= 1 << 7; /* not one-shot mode */
290 data
->resolution
= 12;
291 data
->sample_time
= HZ
/ 4;
297 set_mask
|= 3 << 5; /* 12-bit mode */
298 clr_mask
|= 1 << 7; /* not one-shot mode */
299 data
->resolution
= 12;
300 data
->sample_time
= HZ
/ 2;
303 clr_mask
|= 1 << 5; /* not one-shot mode */
304 data
->resolution
= 12;
305 data
->sample_time
= HZ
/ 4;
309 /* configure as specified */
310 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
312 dev_dbg(dev
, "Can't read config? %d\n", status
);
315 data
->orig_conf
= status
;
316 new = status
& ~clr_mask
;
319 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, new);
321 devm_add_action(dev
, lm75_remove
, data
);
323 dev_dbg(dev
, "Config %02x\n", new);
325 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, client
->name
,
327 if (IS_ERR(hwmon_dev
))
328 return PTR_ERR(hwmon_dev
);
330 devm_thermal_zone_of_sensor_register(hwmon_dev
, 0,
332 &lm75_of_thermal_ops
);
334 dev_info(dev
, "%s: sensor '%s'\n", dev_name(hwmon_dev
), client
->name
);
339 static const struct i2c_device_id lm75_ids
[] = {
341 { "ds1775", ds1775
, },
343 { "ds7505", ds7505
, },
348 { "max6625", max6625
, },
349 { "max6626", max6626
, },
350 { "mcp980x", mcp980x
, },
351 { "stds75", stds75
, },
353 { "tmp100", tmp100
, },
354 { "tmp101", tmp101
, },
355 { "tmp105", tmp105
, },
356 { "tmp112", tmp112
, },
357 { "tmp175", tmp175
, },
358 { "tmp275", tmp275
, },
360 { "tmp75c", tmp75c
, },
363 MODULE_DEVICE_TABLE(i2c
, lm75_ids
);
365 #define LM75A_ID 0xA1
367 /* Return 0 if detection is successful, -ENODEV otherwise */
368 static int lm75_detect(struct i2c_client
*new_client
,
369 struct i2c_board_info
*info
)
371 struct i2c_adapter
*adapter
= new_client
->adapter
;
376 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
|
377 I2C_FUNC_SMBUS_WORD_DATA
))
381 * Now, we do the remaining detection. There is no identification-
382 * dedicated register so we have to rely on several tricks:
383 * unused bits, registers cycling over 8-address boundaries,
384 * addresses 0x04-0x07 returning the last read value.
385 * The cycling+unused addresses combination is not tested,
386 * since it would significantly slow the detection down and would
387 * hardly add any value.
389 * The National Semiconductor LM75A is different than earlier
390 * LM75s. It has an ID byte of 0xaX (where X is the chip
391 * revision, with 1 being the only revision in existence) in
392 * register 7, and unused registers return 0xff rather than the
395 * Note that this function only detects the original National
396 * Semiconductor LM75 and the LM75A. Clones from other vendors
397 * aren't detected, on purpose, because they are typically never
398 * found on PC hardware. They are found on embedded designs where
399 * they can be instantiated explicitly so detection is not needed.
400 * The absence of identification registers on all these clones
401 * would make their exhaustive detection very difficult and weak,
402 * and odds are that the driver would bind to unsupported devices.
406 conf
= i2c_smbus_read_byte_data(new_client
, 1);
410 /* First check for LM75A */
411 if (i2c_smbus_read_byte_data(new_client
, 7) == LM75A_ID
) {
412 /* LM75A returns 0xff on unused registers so
413 just to be sure we check for that too. */
414 if (i2c_smbus_read_byte_data(new_client
, 4) != 0xff
415 || i2c_smbus_read_byte_data(new_client
, 5) != 0xff
416 || i2c_smbus_read_byte_data(new_client
, 6) != 0xff)
419 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
420 os
= i2c_smbus_read_byte_data(new_client
, 3);
421 } else { /* Traditional style LM75 detection */
422 /* Unused addresses */
423 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
424 if (i2c_smbus_read_byte_data(new_client
, 4) != hyst
425 || i2c_smbus_read_byte_data(new_client
, 5) != hyst
426 || i2c_smbus_read_byte_data(new_client
, 6) != hyst
427 || i2c_smbus_read_byte_data(new_client
, 7) != hyst
)
429 os
= i2c_smbus_read_byte_data(new_client
, 3);
430 if (i2c_smbus_read_byte_data(new_client
, 4) != os
431 || i2c_smbus_read_byte_data(new_client
, 5) != os
432 || i2c_smbus_read_byte_data(new_client
, 6) != os
433 || i2c_smbus_read_byte_data(new_client
, 7) != os
)
437 * It is very unlikely that this is a LM75 if both
438 * hysteresis and temperature limit registers are 0.
440 if (hyst
== 0 && os
== 0)
443 /* Addresses cycling */
444 for (i
= 8; i
<= 248; i
+= 40) {
445 if (i2c_smbus_read_byte_data(new_client
, i
+ 1) != conf
446 || i2c_smbus_read_byte_data(new_client
, i
+ 2) != hyst
447 || i2c_smbus_read_byte_data(new_client
, i
+ 3) != os
)
449 if (is_lm75a
&& i2c_smbus_read_byte_data(new_client
, i
+ 7)
454 strlcpy(info
->type
, is_lm75a
? "lm75a" : "lm75", I2C_NAME_SIZE
);
460 static int lm75_suspend(struct device
*dev
)
463 struct i2c_client
*client
= to_i2c_client(dev
);
464 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
466 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
469 status
= status
| LM75_SHUTDOWN
;
470 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, status
);
474 static int lm75_resume(struct device
*dev
)
477 struct i2c_client
*client
= to_i2c_client(dev
);
478 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
480 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
483 status
= status
& ~LM75_SHUTDOWN
;
484 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, status
);
488 static const struct dev_pm_ops lm75_dev_pm_ops
= {
489 .suspend
= lm75_suspend
,
490 .resume
= lm75_resume
,
492 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
494 #define LM75_DEV_PM_OPS NULL
495 #endif /* CONFIG_PM */
497 static struct i2c_driver lm75_driver
= {
498 .class = I2C_CLASS_HWMON
,
501 .pm
= LM75_DEV_PM_OPS
,
504 .id_table
= lm75_ids
,
505 .detect
= lm75_detect
,
506 .address_list
= normal_i2c
,
509 /*-----------------------------------------------------------------------*/
511 static struct lm75_data
*lm75_update_device(struct device
*dev
)
513 struct lm75_data
*data
= dev_get_drvdata(dev
);
514 struct i2c_client
*client
= data
->client
;
515 struct lm75_data
*ret
= data
;
517 mutex_lock(&data
->update_lock
);
519 if (time_after(jiffies
, data
->last_updated
+ data
->sample_time
)
522 dev_dbg(&client
->dev
, "Starting lm75 update\n");
524 for (i
= 0; i
< ARRAY_SIZE(data
->temp
); i
++) {
527 status
= i2c_smbus_read_word_swapped(client
,
529 if (unlikely(status
< 0)) {
531 "LM75: Failed to read value: reg %d, error %d\n",
532 LM75_REG_TEMP
[i
], status
);
533 ret
= ERR_PTR(status
);
537 data
->temp
[i
] = status
;
539 data
->last_updated
= jiffies
;
544 mutex_unlock(&data
->update_lock
);
548 module_i2c_driver(lm75_driver
);
550 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
551 MODULE_DESCRIPTION("LM75 driver");
552 MODULE_LICENSE("GPL");