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 */
55 /* Addresses scanned */
56 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
57 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
60 /* The LM75 registers */
61 #define LM75_REG_CONF 0x01
62 static const u8 LM75_REG_TEMP[3] = {
68 /* Each client has this additional data */
70 struct device *hwmon_dev;
71 struct mutex update_lock;
73 char valid; /* !=0 if registers are valid */
74 unsigned long last_updated; /* In jiffies */
75 u16 temp[3]; /* Register values,
81 static int lm75_read_value(struct i2c_client *client, u8 reg);
82 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
83 static struct lm75_data *lm75_update_device(struct device *dev);
86 /*-----------------------------------------------------------------------*/
88 /* sysfs attributes for hwmon */
90 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
93 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
94 struct lm75_data *data = lm75_update_device(dev);
95 return sprintf(buf, "%d\n",
96 LM75_TEMP_FROM_REG(data->temp[attr->index]));
99 static ssize_t set_temp(struct device *dev, struct device_attribute *da,
100 const char *buf, size_t count)
102 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
103 struct i2c_client *client = to_i2c_client(dev);
104 struct lm75_data *data = i2c_get_clientdata(client);
105 int nr = attr->index;
109 error = strict_strtol(buf, 10, &temp);
113 mutex_lock(&data->update_lock);
114 data->temp[nr] = LM75_TEMP_TO_REG(temp);
115 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
116 mutex_unlock(&data->update_lock);
120 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
121 show_temp, set_temp, 1);
122 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
123 show_temp, set_temp, 2);
124 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
126 static struct attribute *lm75_attributes[] = {
127 &sensor_dev_attr_temp1_input.dev_attr.attr,
128 &sensor_dev_attr_temp1_max.dev_attr.attr,
129 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
134 static const struct attribute_group lm75_group = {
135 .attrs = lm75_attributes,
138 /*-----------------------------------------------------------------------*/
140 /* device probe and removal */
143 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
145 struct lm75_data *data;
147 u8 set_mask, clr_mask;
150 if (!i2c_check_functionality(client->adapter,
151 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
154 data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
158 i2c_set_clientdata(client, data);
159 mutex_init(&data->update_lock);
161 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
162 * Then tweak to be more precise when appropriate.
165 clr_mask = (1 << 0) /* continuous conversions */
166 | (1 << 6) | (1 << 5); /* 9-bit mode */
168 /* configure as specified */
169 status = lm75_read_value(client, LM75_REG_CONF);
171 dev_dbg(&client->dev, "Can't read config? %d\n", status);
174 data->orig_conf = status;
175 new = status & ~clr_mask;
178 lm75_write_value(client, LM75_REG_CONF, new);
179 dev_dbg(&client->dev, "Config %02x\n", new);
181 /* Register sysfs hooks */
182 status = sysfs_create_group(&client->dev.kobj, &lm75_group);
186 data->hwmon_dev = hwmon_device_register(&client->dev);
187 if (IS_ERR(data->hwmon_dev)) {
188 status = PTR_ERR(data->hwmon_dev);
192 dev_info(&client->dev, "%s: sensor '%s'\n",
193 dev_name(data->hwmon_dev), client->name);
198 sysfs_remove_group(&client->dev.kobj, &lm75_group);
204 static int lm75_remove(struct i2c_client *client)
206 struct lm75_data *data = i2c_get_clientdata(client);
208 hwmon_device_unregister(data->hwmon_dev);
209 sysfs_remove_group(&client->dev.kobj, &lm75_group);
210 lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
215 static const struct i2c_device_id lm75_ids[] = {
216 { "ds1775", ds1775, },
220 { "max6625", max6625, },
221 { "max6626", max6626, },
222 { "mcp980x", mcp980x, },
223 { "stds75", stds75, },
225 { "tmp100", tmp100, },
226 { "tmp101", tmp101, },
227 { "tmp105", tmp105, },
228 { "tmp175", tmp175, },
229 { "tmp275", tmp275, },
233 MODULE_DEVICE_TABLE(i2c, lm75_ids);
235 #define LM75A_ID 0xA1
237 /* Return 0 if detection is successful, -ENODEV otherwise */
238 static int lm75_detect(struct i2c_client *new_client,
239 struct i2c_board_info *info)
241 struct i2c_adapter *adapter = new_client->adapter;
243 int cur, conf, hyst, os;
246 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
247 I2C_FUNC_SMBUS_WORD_DATA))
250 /* Now, we do the remaining detection. There is no identification-
251 dedicated register so we have to rely on several tricks:
252 unused bits, registers cycling over 8-address boundaries,
253 addresses 0x04-0x07 returning the last read value.
254 The cycling+unused addresses combination is not tested,
255 since it would significantly slow the detection down and would
256 hardly add any value.
258 The National Semiconductor LM75A is different than earlier
259 LM75s. It has an ID byte of 0xaX (where X is the chip
260 revision, with 1 being the only revision in existence) in
261 register 7, and unused registers return 0xff rather than the
264 cur = i2c_smbus_read_word_data(new_client, 0);
265 conf = i2c_smbus_read_byte_data(new_client, 1);
267 /* First check for LM75A */
268 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
269 /* LM75A returns 0xff on unused registers so
270 just to be sure we check for that too. */
271 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
272 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
273 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
276 hyst = i2c_smbus_read_word_data(new_client, 2);
277 os = i2c_smbus_read_word_data(new_client, 3);
278 } else { /* Traditional style LM75 detection */
279 /* Unused addresses */
280 hyst = i2c_smbus_read_word_data(new_client, 2);
281 if (i2c_smbus_read_word_data(new_client, 4) != hyst
282 || i2c_smbus_read_word_data(new_client, 5) != hyst
283 || i2c_smbus_read_word_data(new_client, 6) != hyst
284 || i2c_smbus_read_word_data(new_client, 7) != hyst)
286 os = i2c_smbus_read_word_data(new_client, 3);
287 if (i2c_smbus_read_word_data(new_client, 4) != os
288 || i2c_smbus_read_word_data(new_client, 5) != os
289 || i2c_smbus_read_word_data(new_client, 6) != os
290 || i2c_smbus_read_word_data(new_client, 7) != os)
298 /* Addresses cycling */
299 for (i = 8; i < 0xff; i += 8) {
300 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
301 || i2c_smbus_read_word_data(new_client, i + 2) != hyst
302 || i2c_smbus_read_word_data(new_client, i + 3) != os)
304 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
309 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
315 static int lm75_suspend(struct device *dev)
318 struct i2c_client *client = to_i2c_client(dev);
319 status = lm75_read_value(client, LM75_REG_CONF);
321 dev_dbg(&client->dev, "Can't read config? %d\n", status);
324 status = status | LM75_SHUTDOWN;
325 lm75_write_value(client, LM75_REG_CONF, status);
329 static int lm75_resume(struct device *dev)
332 struct i2c_client *client = to_i2c_client(dev);
333 status = lm75_read_value(client, LM75_REG_CONF);
335 dev_dbg(&client->dev, "Can't read config? %d\n", status);
338 status = status & ~LM75_SHUTDOWN;
339 lm75_write_value(client, LM75_REG_CONF, status);
343 static const struct dev_pm_ops lm75_dev_pm_ops = {
344 .suspend = lm75_suspend,
345 .resume = lm75_resume,
347 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
349 #define LM75_DEV_PM_OPS NULL
350 #endif /* CONFIG_PM */
352 static struct i2c_driver lm75_driver = {
353 .class = I2C_CLASS_HWMON,
356 .pm = LM75_DEV_PM_OPS,
359 .remove = lm75_remove,
360 .id_table = lm75_ids,
361 .detect = lm75_detect,
362 .address_list = normal_i2c,
365 /*-----------------------------------------------------------------------*/
367 /* register access */
370 * All registers are word-sized, except for the configuration register.
371 * LM75 uses a high-byte first convention, which is exactly opposite to
372 * the SMBus standard.
374 static int lm75_read_value(struct i2c_client *client, u8 reg)
378 if (reg == LM75_REG_CONF)
379 return i2c_smbus_read_byte_data(client, reg);
381 value = i2c_smbus_read_word_data(client, reg);
382 return (value < 0) ? value : swab16(value);
385 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
387 if (reg == LM75_REG_CONF)
388 return i2c_smbus_write_byte_data(client, reg, value);
390 return i2c_smbus_write_word_data(client, reg, swab16(value));
393 static struct lm75_data *lm75_update_device(struct device *dev)
395 struct i2c_client *client = to_i2c_client(dev);
396 struct lm75_data *data = i2c_get_clientdata(client);
398 mutex_lock(&data->update_lock);
400 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
403 dev_dbg(&client->dev, "Starting lm75 update\n");
405 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
408 status = lm75_read_value(client, LM75_REG_TEMP[i]);
410 dev_dbg(&client->dev, "reg %d, err %d\n",
411 LM75_REG_TEMP[i], status);
413 data->temp[i] = status;
415 data->last_updated = jiffies;
419 mutex_unlock(&data->update_lock);
424 /*-----------------------------------------------------------------------*/
428 static int __init sensors_lm75_init(void)
430 return i2c_add_driver(&lm75_driver);
433 static void __exit sensors_lm75_exit(void)
435 i2c_del_driver(&lm75_driver);
438 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
439 MODULE_DESCRIPTION("LM75 driver");
440 MODULE_LICENSE("GPL");
442 module_init(sensors_lm75_init);
443 module_exit(sensors_lm75_exit);