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>
34 * This driver handles the LM75 and compatible digital temperature sensors.
37 enum lm75_type { /* keep sorted in alphabetical order */
58 /* Addresses scanned */
59 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
60 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
63 /* The LM75 registers */
64 #define LM75_REG_CONF 0x01
65 static const u8 LM75_REG_TEMP[3] = {
71 /* Each client has this additional data */
73 struct device *hwmon_dev;
74 struct mutex update_lock;
76 u8 resolution; /* In bits, between 9 and 12 */
78 char valid; /* !=0 if registers are valid */
79 unsigned long last_updated; /* In jiffies */
80 unsigned long sample_time; /* In jiffies */
81 s16 temp[3]; /* Register values,
87 static int lm75_read_value(struct i2c_client *client, u8 reg);
88 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
89 static struct lm75_data *lm75_update_device(struct device *dev);
92 /*-----------------------------------------------------------------------*/
94 /* sysfs attributes for hwmon */
96 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
99 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
100 struct lm75_data *data = lm75_update_device(dev);
104 return PTR_ERR(data);
106 temp = ((data->temp[attr->index] >> (16 - data->resolution)) * 1000)
107 >> (data->resolution - 8);
109 return sprintf(buf, "%ld\n", temp);
112 static ssize_t set_temp(struct device *dev, struct device_attribute *da,
113 const char *buf, size_t count)
115 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
116 struct i2c_client *client = to_i2c_client(dev);
117 struct lm75_data *data = i2c_get_clientdata(client);
118 int nr = attr->index;
123 error = kstrtol(buf, 10, &temp);
128 * Resolution of limit registers is assumed to be the same as the
129 * temperature input register resolution unless given explicitly.
131 if (attr->index && data->resolution_limits)
132 resolution = data->resolution_limits;
134 resolution = data->resolution;
136 mutex_lock(&data->update_lock);
137 temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
138 data->temp[nr] = DIV_ROUND_CLOSEST(temp << (resolution - 8),
139 1000) << (16 - resolution);
140 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
141 mutex_unlock(&data->update_lock);
145 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
146 show_temp, set_temp, 1);
147 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
148 show_temp, set_temp, 2);
149 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
151 static struct attribute *lm75_attributes[] = {
152 &sensor_dev_attr_temp1_input.dev_attr.attr,
153 &sensor_dev_attr_temp1_max.dev_attr.attr,
154 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
159 static const struct attribute_group lm75_group = {
160 .attrs = lm75_attributes,
163 /*-----------------------------------------------------------------------*/
165 /* device probe and removal */
168 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
170 struct lm75_data *data;
172 u8 set_mask, clr_mask;
174 enum lm75_type kind = id->driver_data;
176 if (!i2c_check_functionality(client->adapter,
177 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
180 data = devm_kzalloc(&client->dev, sizeof(struct lm75_data), GFP_KERNEL);
184 i2c_set_clientdata(client, data);
185 mutex_init(&data->update_lock);
187 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
188 * Then tweak to be more precise when appropriate.
191 clr_mask = LM75_SHUTDOWN; /* continuous conversions */
195 clr_mask |= 1 << 5; /* not one-shot mode */
196 data->resolution = 12;
197 data->sample_time = HZ / 8;
203 set_mask |= 2 << 5; /* 11-bit mode */
204 data->resolution = 11;
205 data->sample_time = HZ;
208 set_mask |= 3 << 5; /* 12-bit mode */
209 data->resolution = 12;
210 data->sample_time = HZ / 4;
215 data->resolution = 9;
216 data->sample_time = HZ / 2;
219 data->resolution = 9;
220 data->sample_time = HZ / 4;
223 data->resolution = 12;
224 data->resolution_limits = 9;
225 data->sample_time = HZ / 4;
228 data->resolution = 9;
229 data->sample_time = HZ / 8;
232 data->resolution_limits = 9;
236 set_mask |= 3 << 5; /* 12-bit mode */
237 data->resolution = 12;
238 data->sample_time = HZ;
239 clr_mask |= 1 << 7; /* not one-shot mode */
245 set_mask |= 3 << 5; /* 12-bit mode */
246 clr_mask |= 1 << 7; /* not one-shot mode */
247 data->resolution = 12;
248 data->sample_time = HZ / 2;
252 /* configure as specified */
253 status = lm75_read_value(client, LM75_REG_CONF);
255 dev_dbg(&client->dev, "Can't read config? %d\n", status);
258 data->orig_conf = status;
259 new = status & ~clr_mask;
262 lm75_write_value(client, LM75_REG_CONF, new);
263 dev_dbg(&client->dev, "Config %02x\n", new);
265 /* Register sysfs hooks */
266 status = sysfs_create_group(&client->dev.kobj, &lm75_group);
270 data->hwmon_dev = hwmon_device_register(&client->dev);
271 if (IS_ERR(data->hwmon_dev)) {
272 status = PTR_ERR(data->hwmon_dev);
276 dev_info(&client->dev, "%s: sensor '%s'\n",
277 dev_name(data->hwmon_dev), client->name);
282 sysfs_remove_group(&client->dev.kobj, &lm75_group);
286 static int lm75_remove(struct i2c_client *client)
288 struct lm75_data *data = i2c_get_clientdata(client);
290 hwmon_device_unregister(data->hwmon_dev);
291 sysfs_remove_group(&client->dev.kobj, &lm75_group);
292 lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
296 static const struct i2c_device_id lm75_ids[] = {
298 { "ds1775", ds1775, },
300 { "ds7505", ds7505, },
304 { "max6625", max6625, },
305 { "max6626", max6626, },
306 { "mcp980x", mcp980x, },
307 { "stds75", stds75, },
309 { "tmp100", tmp100, },
310 { "tmp101", tmp101, },
311 { "tmp105", tmp105, },
312 { "tmp175", tmp175, },
313 { "tmp275", tmp275, },
317 MODULE_DEVICE_TABLE(i2c, lm75_ids);
319 #define LM75A_ID 0xA1
321 /* Return 0 if detection is successful, -ENODEV otherwise */
322 static int lm75_detect(struct i2c_client *new_client,
323 struct i2c_board_info *info)
325 struct i2c_adapter *adapter = new_client->adapter;
330 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
331 I2C_FUNC_SMBUS_WORD_DATA))
335 * Now, we do the remaining detection. There is no identification-
336 * dedicated register so we have to rely on several tricks:
337 * unused bits, registers cycling over 8-address boundaries,
338 * addresses 0x04-0x07 returning the last read value.
339 * The cycling+unused addresses combination is not tested,
340 * since it would significantly slow the detection down and would
341 * hardly add any value.
343 * The National Semiconductor LM75A is different than earlier
344 * LM75s. It has an ID byte of 0xaX (where X is the chip
345 * revision, with 1 being the only revision in existence) in
346 * register 7, and unused registers return 0xff rather than the
349 * Note that this function only detects the original National
350 * Semiconductor LM75 and the LM75A. Clones from other vendors
351 * aren't detected, on purpose, because they are typically never
352 * found on PC hardware. They are found on embedded designs where
353 * they can be instantiated explicitly so detection is not needed.
354 * The absence of identification registers on all these clones
355 * would make their exhaustive detection very difficult and weak,
356 * and odds are that the driver would bind to unsupported devices.
360 conf = i2c_smbus_read_byte_data(new_client, 1);
364 /* First check for LM75A */
365 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
366 /* LM75A returns 0xff on unused registers so
367 just to be sure we check for that too. */
368 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
369 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
370 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
373 hyst = i2c_smbus_read_byte_data(new_client, 2);
374 os = i2c_smbus_read_byte_data(new_client, 3);
375 } else { /* Traditional style LM75 detection */
376 /* Unused addresses */
377 hyst = i2c_smbus_read_byte_data(new_client, 2);
378 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
379 || i2c_smbus_read_byte_data(new_client, 5) != hyst
380 || i2c_smbus_read_byte_data(new_client, 6) != hyst
381 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
383 os = i2c_smbus_read_byte_data(new_client, 3);
384 if (i2c_smbus_read_byte_data(new_client, 4) != os
385 || i2c_smbus_read_byte_data(new_client, 5) != os
386 || i2c_smbus_read_byte_data(new_client, 6) != os
387 || i2c_smbus_read_byte_data(new_client, 7) != os)
391 /* Addresses cycling */
392 for (i = 8; i <= 248; i += 40) {
393 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
394 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
395 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
397 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
402 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
408 static int lm75_suspend(struct device *dev)
411 struct i2c_client *client = to_i2c_client(dev);
412 status = lm75_read_value(client, LM75_REG_CONF);
414 dev_dbg(&client->dev, "Can't read config? %d\n", status);
417 status = status | LM75_SHUTDOWN;
418 lm75_write_value(client, LM75_REG_CONF, status);
422 static int lm75_resume(struct device *dev)
425 struct i2c_client *client = to_i2c_client(dev);
426 status = lm75_read_value(client, LM75_REG_CONF);
428 dev_dbg(&client->dev, "Can't read config? %d\n", status);
431 status = status & ~LM75_SHUTDOWN;
432 lm75_write_value(client, LM75_REG_CONF, status);
436 static const struct dev_pm_ops lm75_dev_pm_ops = {
437 .suspend = lm75_suspend,
438 .resume = lm75_resume,
440 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
442 #define LM75_DEV_PM_OPS NULL
443 #endif /* CONFIG_PM */
445 static struct i2c_driver lm75_driver = {
446 .class = I2C_CLASS_HWMON,
449 .pm = LM75_DEV_PM_OPS,
452 .remove = lm75_remove,
453 .id_table = lm75_ids,
454 .detect = lm75_detect,
455 .address_list = normal_i2c,
458 /*-----------------------------------------------------------------------*/
460 /* register access */
463 * All registers are word-sized, except for the configuration register.
464 * LM75 uses a high-byte first convention, which is exactly opposite to
465 * the SMBus standard.
467 static int lm75_read_value(struct i2c_client *client, u8 reg)
469 if (reg == LM75_REG_CONF)
470 return i2c_smbus_read_byte_data(client, reg);
472 return i2c_smbus_read_word_swapped(client, reg);
475 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
477 if (reg == LM75_REG_CONF)
478 return i2c_smbus_write_byte_data(client, reg, value);
480 return i2c_smbus_write_word_swapped(client, reg, value);
483 static struct lm75_data *lm75_update_device(struct device *dev)
485 struct i2c_client *client = to_i2c_client(dev);
486 struct lm75_data *data = i2c_get_clientdata(client);
487 struct lm75_data *ret = data;
489 mutex_lock(&data->update_lock);
491 if (time_after(jiffies, data->last_updated + data->sample_time)
494 dev_dbg(&client->dev, "Starting lm75 update\n");
496 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
499 status = lm75_read_value(client, LM75_REG_TEMP[i]);
500 if (unlikely(status < 0)) {
502 "LM75: Failed to read value: reg %d, error %d\n",
503 LM75_REG_TEMP[i], status);
504 ret = ERR_PTR(status);
508 data->temp[i] = status;
510 data->last_updated = jiffies;
515 mutex_unlock(&data->update_lock);
519 module_i2c_driver(lm75_driver);
521 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
522 MODULE_DESCRIPTION("LM75 driver");
523 MODULE_LICENSE("GPL");