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 SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
,
163 show_temp
, set_temp
, 1);
164 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IWUSR
| S_IRUGO
,
165 show_temp
, set_temp
, 2);
166 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
168 static struct attribute
*lm75_attrs
[] = {
169 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
170 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
171 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
175 ATTRIBUTE_GROUPS(lm75
);
177 static const struct thermal_zone_of_device_ops lm75_of_thermal_ops
= {
178 .get_temp
= lm75_read_temp
,
181 /*-----------------------------------------------------------------------*/
183 /* device probe and removal */
185 static void lm75_remove(void *data
)
187 struct lm75_data
*lm75
= data
;
188 struct i2c_client
*client
= lm75
->client
;
190 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, lm75
->orig_conf
);
194 lm75_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
196 struct device
*dev
= &client
->dev
;
197 struct device
*hwmon_dev
;
198 struct lm75_data
*data
;
200 u8 set_mask
, clr_mask
;
202 enum lm75_type kind
= id
->driver_data
;
204 if (!i2c_check_functionality(client
->adapter
,
205 I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_WORD_DATA
))
208 data
= devm_kzalloc(dev
, sizeof(struct lm75_data
), GFP_KERNEL
);
212 data
->client
= client
;
213 i2c_set_clientdata(client
, data
);
214 mutex_init(&data
->update_lock
);
216 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
217 * Then tweak to be more precise when appropriate.
220 clr_mask
= LM75_SHUTDOWN
; /* continuous conversions */
224 clr_mask
|= 1 << 5; /* not one-shot mode */
225 data
->resolution
= 12;
226 data
->sample_time
= HZ
/ 8;
232 set_mask
|= 2 << 5; /* 11-bit mode */
233 data
->resolution
= 11;
234 data
->sample_time
= HZ
;
237 set_mask
|= 3 << 5; /* 12-bit mode */
238 data
->resolution
= 12;
239 data
->sample_time
= HZ
/ 4;
244 data
->resolution
= 9;
245 data
->sample_time
= HZ
/ 2;
248 data
->resolution
= 11;
249 data
->sample_time
= HZ
/ 4;
252 data
->resolution
= 9;
253 data
->sample_time
= HZ
/ 4;
256 data
->resolution
= 12;
257 data
->resolution_limits
= 9;
258 data
->sample_time
= HZ
/ 4;
261 data
->resolution
= 9;
262 data
->sample_time
= HZ
/ 8;
265 data
->resolution_limits
= 9;
269 set_mask
|= 3 << 5; /* 12-bit mode */
270 data
->resolution
= 12;
271 data
->sample_time
= HZ
;
272 clr_mask
|= 1 << 7; /* not one-shot mode */
275 set_mask
|= 3 << 5; /* 12-bit mode */
276 clr_mask
|= 1 << 7; /* not one-shot mode */
277 data
->resolution
= 12;
278 data
->sample_time
= HZ
/ 4;
284 set_mask
|= 3 << 5; /* 12-bit mode */
285 clr_mask
|= 1 << 7; /* not one-shot mode */
286 data
->resolution
= 12;
287 data
->sample_time
= HZ
/ 2;
290 clr_mask
|= 1 << 5; /* not one-shot mode */
291 data
->resolution
= 12;
292 data
->sample_time
= HZ
/ 4;
296 /* configure as specified */
297 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
299 dev_dbg(dev
, "Can't read config? %d\n", status
);
302 data
->orig_conf
= status
;
303 new = status
& ~clr_mask
;
306 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, new);
308 devm_add_action(dev
, lm75_remove
, data
);
310 dev_dbg(dev
, "Config %02x\n", new);
312 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, client
->name
,
314 if (IS_ERR(hwmon_dev
))
315 return PTR_ERR(hwmon_dev
);
317 devm_thermal_zone_of_sensor_register(hwmon_dev
, 0,
319 &lm75_of_thermal_ops
);
321 dev_info(dev
, "%s: sensor '%s'\n", dev_name(hwmon_dev
), client
->name
);
326 static const struct i2c_device_id lm75_ids
[] = {
328 { "ds1775", ds1775
, },
330 { "ds7505", ds7505
, },
335 { "max6625", max6625
, },
336 { "max6626", max6626
, },
337 { "mcp980x", mcp980x
, },
338 { "stds75", stds75
, },
340 { "tmp100", tmp100
, },
341 { "tmp101", tmp101
, },
342 { "tmp105", tmp105
, },
343 { "tmp112", tmp112
, },
344 { "tmp175", tmp175
, },
345 { "tmp275", tmp275
, },
347 { "tmp75c", tmp75c
, },
350 MODULE_DEVICE_TABLE(i2c
, lm75_ids
);
352 #define LM75A_ID 0xA1
354 /* Return 0 if detection is successful, -ENODEV otherwise */
355 static int lm75_detect(struct i2c_client
*new_client
,
356 struct i2c_board_info
*info
)
358 struct i2c_adapter
*adapter
= new_client
->adapter
;
363 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
|
364 I2C_FUNC_SMBUS_WORD_DATA
))
368 * Now, we do the remaining detection. There is no identification-
369 * dedicated register so we have to rely on several tricks:
370 * unused bits, registers cycling over 8-address boundaries,
371 * addresses 0x04-0x07 returning the last read value.
372 * The cycling+unused addresses combination is not tested,
373 * since it would significantly slow the detection down and would
374 * hardly add any value.
376 * The National Semiconductor LM75A is different than earlier
377 * LM75s. It has an ID byte of 0xaX (where X is the chip
378 * revision, with 1 being the only revision in existence) in
379 * register 7, and unused registers return 0xff rather than the
382 * Note that this function only detects the original National
383 * Semiconductor LM75 and the LM75A. Clones from other vendors
384 * aren't detected, on purpose, because they are typically never
385 * found on PC hardware. They are found on embedded designs where
386 * they can be instantiated explicitly so detection is not needed.
387 * The absence of identification registers on all these clones
388 * would make their exhaustive detection very difficult and weak,
389 * and odds are that the driver would bind to unsupported devices.
393 conf
= i2c_smbus_read_byte_data(new_client
, 1);
397 /* First check for LM75A */
398 if (i2c_smbus_read_byte_data(new_client
, 7) == LM75A_ID
) {
399 /* LM75A returns 0xff on unused registers so
400 just to be sure we check for that too. */
401 if (i2c_smbus_read_byte_data(new_client
, 4) != 0xff
402 || i2c_smbus_read_byte_data(new_client
, 5) != 0xff
403 || i2c_smbus_read_byte_data(new_client
, 6) != 0xff)
406 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
407 os
= i2c_smbus_read_byte_data(new_client
, 3);
408 } else { /* Traditional style LM75 detection */
409 /* Unused addresses */
410 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
411 if (i2c_smbus_read_byte_data(new_client
, 4) != hyst
412 || i2c_smbus_read_byte_data(new_client
, 5) != hyst
413 || i2c_smbus_read_byte_data(new_client
, 6) != hyst
414 || i2c_smbus_read_byte_data(new_client
, 7) != hyst
)
416 os
= i2c_smbus_read_byte_data(new_client
, 3);
417 if (i2c_smbus_read_byte_data(new_client
, 4) != os
418 || i2c_smbus_read_byte_data(new_client
, 5) != os
419 || i2c_smbus_read_byte_data(new_client
, 6) != os
420 || i2c_smbus_read_byte_data(new_client
, 7) != os
)
424 * It is very unlikely that this is a LM75 if both
425 * hysteresis and temperature limit registers are 0.
427 if (hyst
== 0 && os
== 0)
430 /* Addresses cycling */
431 for (i
= 8; i
<= 248; i
+= 40) {
432 if (i2c_smbus_read_byte_data(new_client
, i
+ 1) != conf
433 || i2c_smbus_read_byte_data(new_client
, i
+ 2) != hyst
434 || i2c_smbus_read_byte_data(new_client
, i
+ 3) != os
)
436 if (is_lm75a
&& i2c_smbus_read_byte_data(new_client
, i
+ 7)
441 strlcpy(info
->type
, is_lm75a
? "lm75a" : "lm75", I2C_NAME_SIZE
);
447 static int lm75_suspend(struct device
*dev
)
450 struct i2c_client
*client
= to_i2c_client(dev
);
451 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
453 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
456 status
= status
| LM75_SHUTDOWN
;
457 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, status
);
461 static int lm75_resume(struct device
*dev
)
464 struct i2c_client
*client
= to_i2c_client(dev
);
465 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
467 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
470 status
= status
& ~LM75_SHUTDOWN
;
471 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, status
);
475 static const struct dev_pm_ops lm75_dev_pm_ops
= {
476 .suspend
= lm75_suspend
,
477 .resume
= lm75_resume
,
479 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
481 #define LM75_DEV_PM_OPS NULL
482 #endif /* CONFIG_PM */
484 static struct i2c_driver lm75_driver
= {
485 .class = I2C_CLASS_HWMON
,
488 .pm
= LM75_DEV_PM_OPS
,
491 .id_table
= lm75_ids
,
492 .detect
= lm75_detect
,
493 .address_list
= normal_i2c
,
496 /*-----------------------------------------------------------------------*/
498 static struct lm75_data
*lm75_update_device(struct device
*dev
)
500 struct lm75_data
*data
= dev_get_drvdata(dev
);
501 struct i2c_client
*client
= data
->client
;
502 struct lm75_data
*ret
= data
;
504 mutex_lock(&data
->update_lock
);
506 if (time_after(jiffies
, data
->last_updated
+ data
->sample_time
)
509 dev_dbg(&client
->dev
, "Starting lm75 update\n");
511 for (i
= 0; i
< ARRAY_SIZE(data
->temp
); i
++) {
514 status
= i2c_smbus_read_word_swapped(client
,
516 if (unlikely(status
< 0)) {
518 "LM75: Failed to read value: reg %d, error %d\n",
519 LM75_REG_TEMP
[i
], status
);
520 ret
= ERR_PTR(status
);
524 data
->temp
[i
] = status
;
526 data
->last_updated
= jiffies
;
531 mutex_unlock(&data
->update_lock
);
535 module_i2c_driver(lm75_driver
);
537 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
538 MODULE_DESCRIPTION("LM75 driver");
539 MODULE_LICENSE("GPL");