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 */
61 /* Addresses scanned */
62 static const unsigned short normal_i2c
[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
63 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
};
66 /* The LM75 registers */
67 #define LM75_REG_CONF 0x01
68 static const u8 LM75_REG_TEMP
[3] = {
74 /* Each client has this additional data */
76 struct i2c_client
*client
;
77 struct device
*hwmon_dev
;
78 struct thermal_zone_device
*tz
;
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 int lm75_read_value(struct i2c_client
*client
, u8 reg
);
93 static int lm75_write_value(struct i2c_client
*client
, u8 reg
, u16 value
);
94 static struct lm75_data
*lm75_update_device(struct device
*dev
);
97 /*-----------------------------------------------------------------------*/
99 static inline long lm75_reg_to_mc(s16 temp
, u8 resolution
)
101 return ((temp
>> (16 - resolution
)) * 1000) >> (resolution
- 8);
104 /* sysfs attributes for hwmon */
106 static int lm75_read_temp(void *dev
, long *temp
)
108 struct lm75_data
*data
= lm75_update_device(dev
);
111 return PTR_ERR(data
);
113 *temp
= lm75_reg_to_mc(data
->temp
[0], data
->resolution
);
118 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*da
,
121 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
122 struct lm75_data
*data
= lm75_update_device(dev
);
125 return PTR_ERR(data
);
127 return sprintf(buf
, "%ld\n", lm75_reg_to_mc(data
->temp
[attr
->index
],
131 static ssize_t
set_temp(struct device
*dev
, struct device_attribute
*da
,
132 const char *buf
, size_t count
)
134 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
135 struct lm75_data
*data
= dev_get_drvdata(dev
);
136 struct i2c_client
*client
= data
->client
;
137 int nr
= attr
->index
;
142 error
= kstrtol(buf
, 10, &temp
);
147 * Resolution of limit registers is assumed to be the same as the
148 * temperature input register resolution unless given explicitly.
150 if (attr
->index
&& data
->resolution_limits
)
151 resolution
= data
->resolution_limits
;
153 resolution
= data
->resolution
;
155 mutex_lock(&data
->update_lock
);
156 temp
= clamp_val(temp
, LM75_TEMP_MIN
, LM75_TEMP_MAX
);
157 data
->temp
[nr
] = DIV_ROUND_CLOSEST(temp
<< (resolution
- 8),
158 1000) << (16 - resolution
);
159 lm75_write_value(client
, LM75_REG_TEMP
[nr
], data
->temp
[nr
]);
160 mutex_unlock(&data
->update_lock
);
164 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
,
165 show_temp
, set_temp
, 1);
166 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IWUSR
| S_IRUGO
,
167 show_temp
, set_temp
, 2);
168 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
, 0);
170 static struct attribute
*lm75_attrs
[] = {
171 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
172 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
173 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
177 ATTRIBUTE_GROUPS(lm75
);
179 /*-----------------------------------------------------------------------*/
181 /* device probe and removal */
184 lm75_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
186 struct device
*dev
= &client
->dev
;
187 struct lm75_data
*data
;
189 u8 set_mask
, clr_mask
;
191 enum lm75_type kind
= id
->driver_data
;
193 if (!i2c_check_functionality(client
->adapter
,
194 I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_WORD_DATA
))
197 data
= devm_kzalloc(dev
, sizeof(struct lm75_data
), GFP_KERNEL
);
201 data
->client
= client
;
202 i2c_set_clientdata(client
, data
);
203 mutex_init(&data
->update_lock
);
205 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
206 * Then tweak to be more precise when appropriate.
209 clr_mask
= LM75_SHUTDOWN
; /* continuous conversions */
213 clr_mask
|= 1 << 5; /* not one-shot mode */
214 data
->resolution
= 12;
215 data
->sample_time
= HZ
/ 8;
221 set_mask
|= 2 << 5; /* 11-bit mode */
222 data
->resolution
= 11;
223 data
->sample_time
= HZ
;
226 set_mask
|= 3 << 5; /* 12-bit mode */
227 data
->resolution
= 12;
228 data
->sample_time
= HZ
/ 4;
233 data
->resolution
= 9;
234 data
->sample_time
= HZ
/ 2;
237 data
->resolution
= 9;
238 data
->sample_time
= HZ
/ 4;
241 data
->resolution
= 12;
242 data
->resolution_limits
= 9;
243 data
->sample_time
= HZ
/ 4;
246 data
->resolution
= 9;
247 data
->sample_time
= HZ
/ 8;
250 data
->resolution_limits
= 9;
254 set_mask
|= 3 << 5; /* 12-bit mode */
255 data
->resolution
= 12;
256 data
->sample_time
= HZ
;
257 clr_mask
|= 1 << 7; /* not one-shot mode */
260 set_mask
|= 3 << 5; /* 12-bit mode */
261 clr_mask
|= 1 << 7; /* not one-shot mode */
262 data
->resolution
= 12;
263 data
->sample_time
= HZ
/ 4;
269 set_mask
|= 3 << 5; /* 12-bit mode */
270 clr_mask
|= 1 << 7; /* not one-shot mode */
271 data
->resolution
= 12;
272 data
->sample_time
= HZ
/ 2;
276 /* configure as specified */
277 status
= lm75_read_value(client
, LM75_REG_CONF
);
279 dev_dbg(dev
, "Can't read config? %d\n", status
);
282 data
->orig_conf
= status
;
283 new = status
& ~clr_mask
;
286 lm75_write_value(client
, LM75_REG_CONF
, new);
287 dev_dbg(dev
, "Config %02x\n", new);
289 data
->hwmon_dev
= hwmon_device_register_with_groups(dev
, client
->name
,
291 if (IS_ERR(data
->hwmon_dev
))
292 return PTR_ERR(data
->hwmon_dev
);
294 data
->tz
= thermal_zone_of_sensor_register(data
->hwmon_dev
,
297 lm75_read_temp
, NULL
);
298 if (IS_ERR(data
->tz
))
301 dev_info(dev
, "%s: sensor '%s'\n",
302 dev_name(data
->hwmon_dev
), client
->name
);
307 static int lm75_remove(struct i2c_client
*client
)
309 struct lm75_data
*data
= i2c_get_clientdata(client
);
311 thermal_zone_of_sensor_unregister(data
->hwmon_dev
, data
->tz
);
312 hwmon_device_unregister(data
->hwmon_dev
);
313 lm75_write_value(client
, LM75_REG_CONF
, data
->orig_conf
);
317 static const struct i2c_device_id lm75_ids
[] = {
319 { "ds1775", ds1775
, },
321 { "ds7505", ds7505
, },
325 { "max6625", max6625
, },
326 { "max6626", max6626
, },
327 { "mcp980x", mcp980x
, },
328 { "stds75", stds75
, },
330 { "tmp100", tmp100
, },
331 { "tmp101", tmp101
, },
332 { "tmp105", tmp105
, },
333 { "tmp112", tmp112
, },
334 { "tmp175", tmp175
, },
335 { "tmp275", tmp275
, },
339 MODULE_DEVICE_TABLE(i2c
, lm75_ids
);
341 #define LM75A_ID 0xA1
343 /* Return 0 if detection is successful, -ENODEV otherwise */
344 static int lm75_detect(struct i2c_client
*new_client
,
345 struct i2c_board_info
*info
)
347 struct i2c_adapter
*adapter
= new_client
->adapter
;
352 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
|
353 I2C_FUNC_SMBUS_WORD_DATA
))
357 * Now, we do the remaining detection. There is no identification-
358 * dedicated register so we have to rely on several tricks:
359 * unused bits, registers cycling over 8-address boundaries,
360 * addresses 0x04-0x07 returning the last read value.
361 * The cycling+unused addresses combination is not tested,
362 * since it would significantly slow the detection down and would
363 * hardly add any value.
365 * The National Semiconductor LM75A is different than earlier
366 * LM75s. It has an ID byte of 0xaX (where X is the chip
367 * revision, with 1 being the only revision in existence) in
368 * register 7, and unused registers return 0xff rather than the
371 * Note that this function only detects the original National
372 * Semiconductor LM75 and the LM75A. Clones from other vendors
373 * aren't detected, on purpose, because they are typically never
374 * found on PC hardware. They are found on embedded designs where
375 * they can be instantiated explicitly so detection is not needed.
376 * The absence of identification registers on all these clones
377 * would make their exhaustive detection very difficult and weak,
378 * and odds are that the driver would bind to unsupported devices.
382 conf
= i2c_smbus_read_byte_data(new_client
, 1);
386 /* First check for LM75A */
387 if (i2c_smbus_read_byte_data(new_client
, 7) == LM75A_ID
) {
388 /* LM75A returns 0xff on unused registers so
389 just to be sure we check for that too. */
390 if (i2c_smbus_read_byte_data(new_client
, 4) != 0xff
391 || i2c_smbus_read_byte_data(new_client
, 5) != 0xff
392 || i2c_smbus_read_byte_data(new_client
, 6) != 0xff)
395 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
396 os
= i2c_smbus_read_byte_data(new_client
, 3);
397 } else { /* Traditional style LM75 detection */
398 /* Unused addresses */
399 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
400 if (i2c_smbus_read_byte_data(new_client
, 4) != hyst
401 || i2c_smbus_read_byte_data(new_client
, 5) != hyst
402 || i2c_smbus_read_byte_data(new_client
, 6) != hyst
403 || i2c_smbus_read_byte_data(new_client
, 7) != hyst
)
405 os
= i2c_smbus_read_byte_data(new_client
, 3);
406 if (i2c_smbus_read_byte_data(new_client
, 4) != os
407 || i2c_smbus_read_byte_data(new_client
, 5) != os
408 || i2c_smbus_read_byte_data(new_client
, 6) != os
409 || i2c_smbus_read_byte_data(new_client
, 7) != os
)
413 /* Addresses cycling */
414 for (i
= 8; i
<= 248; i
+= 40) {
415 if (i2c_smbus_read_byte_data(new_client
, i
+ 1) != conf
416 || i2c_smbus_read_byte_data(new_client
, i
+ 2) != hyst
417 || i2c_smbus_read_byte_data(new_client
, i
+ 3) != os
)
419 if (is_lm75a
&& i2c_smbus_read_byte_data(new_client
, i
+ 7)
424 strlcpy(info
->type
, is_lm75a
? "lm75a" : "lm75", I2C_NAME_SIZE
);
430 static int lm75_suspend(struct device
*dev
)
433 struct i2c_client
*client
= to_i2c_client(dev
);
434 status
= lm75_read_value(client
, LM75_REG_CONF
);
436 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
439 status
= status
| LM75_SHUTDOWN
;
440 lm75_write_value(client
, LM75_REG_CONF
, status
);
444 static int lm75_resume(struct device
*dev
)
447 struct i2c_client
*client
= to_i2c_client(dev
);
448 status
= lm75_read_value(client
, LM75_REG_CONF
);
450 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
453 status
= status
& ~LM75_SHUTDOWN
;
454 lm75_write_value(client
, LM75_REG_CONF
, status
);
458 static const struct dev_pm_ops lm75_dev_pm_ops
= {
459 .suspend
= lm75_suspend
,
460 .resume
= lm75_resume
,
462 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
464 #define LM75_DEV_PM_OPS NULL
465 #endif /* CONFIG_PM */
467 static struct i2c_driver lm75_driver
= {
468 .class = I2C_CLASS_HWMON
,
471 .pm
= LM75_DEV_PM_OPS
,
474 .remove
= lm75_remove
,
475 .id_table
= lm75_ids
,
476 .detect
= lm75_detect
,
477 .address_list
= normal_i2c
,
480 /*-----------------------------------------------------------------------*/
482 /* register access */
485 * All registers are word-sized, except for the configuration register.
486 * LM75 uses a high-byte first convention, which is exactly opposite to
487 * the SMBus standard.
489 static int lm75_read_value(struct i2c_client
*client
, u8 reg
)
491 if (reg
== LM75_REG_CONF
)
492 return i2c_smbus_read_byte_data(client
, reg
);
494 return i2c_smbus_read_word_swapped(client
, reg
);
497 static int lm75_write_value(struct i2c_client
*client
, u8 reg
, u16 value
)
499 if (reg
== LM75_REG_CONF
)
500 return i2c_smbus_write_byte_data(client
, reg
, value
);
502 return i2c_smbus_write_word_swapped(client
, reg
, value
);
505 static struct lm75_data
*lm75_update_device(struct device
*dev
)
507 struct lm75_data
*data
= dev_get_drvdata(dev
);
508 struct i2c_client
*client
= data
->client
;
509 struct lm75_data
*ret
= data
;
511 mutex_lock(&data
->update_lock
);
513 if (time_after(jiffies
, data
->last_updated
+ data
->sample_time
)
516 dev_dbg(&client
->dev
, "Starting lm75 update\n");
518 for (i
= 0; i
< ARRAY_SIZE(data
->temp
); i
++) {
521 status
= lm75_read_value(client
, LM75_REG_TEMP
[i
]);
522 if (unlikely(status
< 0)) {
524 "LM75: Failed to read value: reg %d, error %d\n",
525 LM75_REG_TEMP
[i
], status
);
526 ret
= ERR_PTR(status
);
530 data
->temp
[i
] = status
;
532 data
->last_updated
= jiffies
;
537 mutex_unlock(&data
->update_lock
);
541 module_i2c_driver(lm75_driver
);
543 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
544 MODULE_DESCRIPTION("LM75 driver");
545 MODULE_LICENSE("GPL");