Loading...
1/*
2 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring
4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 *
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.
10 *
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.
15 *
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.
19 */
20
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>
30#include "lm75.h"
31
32
33/*
34 * This driver handles the LM75 and compatible digital temperature sensors.
35 */
36
37enum lm75_type { /* keep sorted in alphabetical order */
38 ds1775,
39 ds75,
40 lm75,
41 lm75a,
42 max6625,
43 max6626,
44 mcp980x,
45 stds75,
46 tcn75,
47 tmp100,
48 tmp101,
49 tmp105,
50 tmp175,
51 tmp275,
52 tmp75,
53};
54
55/* Addresses scanned */
56static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
57 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
58
59
60/* The LM75 registers */
61#define LM75_REG_CONF 0x01
62static const u8 LM75_REG_TEMP[3] = {
63 0x00, /* input */
64 0x03, /* max */
65 0x02, /* hyst */
66};
67
68/* Each client has this additional data */
69struct lm75_data {
70 struct device *hwmon_dev;
71 struct mutex update_lock;
72 u8 orig_conf;
73 char valid; /* !=0 if registers are valid */
74 unsigned long last_updated; /* In jiffies */
75 u16 temp[3]; /* Register values,
76 0 = input
77 1 = max
78 2 = hyst */
79};
80
81static int lm75_read_value(struct i2c_client *client, u8 reg);
82static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
83static struct lm75_data *lm75_update_device(struct device *dev);
84
85
86/*-----------------------------------------------------------------------*/
87
88/* sysfs attributes for hwmon */
89
90static ssize_t show_temp(struct device *dev, struct device_attribute *da,
91 char *buf)
92{
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]));
97}
98
99static ssize_t set_temp(struct device *dev, struct device_attribute *da,
100 const char *buf, size_t count)
101{
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;
106 long temp;
107 int error;
108
109 error = strict_strtol(buf, 10, &temp);
110 if (error)
111 return error;
112
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);
117 return count;
118}
119
120static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
121 show_temp, set_temp, 1);
122static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
123 show_temp, set_temp, 2);
124static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
125
126static 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,
130
131 NULL
132};
133
134static const struct attribute_group lm75_group = {
135 .attrs = lm75_attributes,
136};
137
138/*-----------------------------------------------------------------------*/
139
140/* device probe and removal */
141
142static int
143lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
144{
145 struct lm75_data *data;
146 int status;
147 u8 set_mask, clr_mask;
148 int new;
149
150 if (!i2c_check_functionality(client->adapter,
151 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
152 return -EIO;
153
154 data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
155 if (!data)
156 return -ENOMEM;
157
158 i2c_set_clientdata(client, data);
159 mutex_init(&data->update_lock);
160
161 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
162 * Then tweak to be more precise when appropriate.
163 */
164 set_mask = 0;
165 clr_mask = (1 << 0) /* continuous conversions */
166 | (1 << 6) | (1 << 5); /* 9-bit mode */
167
168 /* configure as specified */
169 status = lm75_read_value(client, LM75_REG_CONF);
170 if (status < 0) {
171 dev_dbg(&client->dev, "Can't read config? %d\n", status);
172 goto exit_free;
173 }
174 data->orig_conf = status;
175 new = status & ~clr_mask;
176 new |= set_mask;
177 if (status != new)
178 lm75_write_value(client, LM75_REG_CONF, new);
179 dev_dbg(&client->dev, "Config %02x\n", new);
180
181 /* Register sysfs hooks */
182 status = sysfs_create_group(&client->dev.kobj, &lm75_group);
183 if (status)
184 goto exit_free;
185
186 data->hwmon_dev = hwmon_device_register(&client->dev);
187 if (IS_ERR(data->hwmon_dev)) {
188 status = PTR_ERR(data->hwmon_dev);
189 goto exit_remove;
190 }
191
192 dev_info(&client->dev, "%s: sensor '%s'\n",
193 dev_name(data->hwmon_dev), client->name);
194
195 return 0;
196
197exit_remove:
198 sysfs_remove_group(&client->dev.kobj, &lm75_group);
199exit_free:
200 kfree(data);
201 return status;
202}
203
204static int lm75_remove(struct i2c_client *client)
205{
206 struct lm75_data *data = i2c_get_clientdata(client);
207
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);
211 kfree(data);
212 return 0;
213}
214
215static const struct i2c_device_id lm75_ids[] = {
216 { "ds1775", ds1775, },
217 { "ds75", ds75, },
218 { "lm75", lm75, },
219 { "lm75a", lm75a, },
220 { "max6625", max6625, },
221 { "max6626", max6626, },
222 { "mcp980x", mcp980x, },
223 { "stds75", stds75, },
224 { "tcn75", tcn75, },
225 { "tmp100", tmp100, },
226 { "tmp101", tmp101, },
227 { "tmp105", tmp105, },
228 { "tmp175", tmp175, },
229 { "tmp275", tmp275, },
230 { "tmp75", tmp75, },
231 { /* LIST END */ }
232};
233MODULE_DEVICE_TABLE(i2c, lm75_ids);
234
235#define LM75A_ID 0xA1
236
237/* Return 0 if detection is successful, -ENODEV otherwise */
238static int lm75_detect(struct i2c_client *new_client,
239 struct i2c_board_info *info)
240{
241 struct i2c_adapter *adapter = new_client->adapter;
242 int i;
243 int conf, hyst, os;
244 bool is_lm75a = 0;
245
246 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
247 I2C_FUNC_SMBUS_WORD_DATA))
248 return -ENODEV;
249
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.
257
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
262 last read value. */
263
264 /* Unused bits */
265 conf = i2c_smbus_read_byte_data(new_client, 1);
266 if (conf & 0xe0)
267 return -ENODEV;
268
269 /* First check for LM75A */
270 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
271 /* LM75A returns 0xff on unused registers so
272 just to be sure we check for that too. */
273 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
274 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
275 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
276 return -ENODEV;
277 is_lm75a = 1;
278 hyst = i2c_smbus_read_byte_data(new_client, 2);
279 os = i2c_smbus_read_byte_data(new_client, 3);
280 } else { /* Traditional style LM75 detection */
281 /* Unused addresses */
282 hyst = i2c_smbus_read_byte_data(new_client, 2);
283 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
284 || i2c_smbus_read_byte_data(new_client, 5) != hyst
285 || i2c_smbus_read_byte_data(new_client, 6) != hyst
286 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
287 return -ENODEV;
288 os = i2c_smbus_read_byte_data(new_client, 3);
289 if (i2c_smbus_read_byte_data(new_client, 4) != os
290 || i2c_smbus_read_byte_data(new_client, 5) != os
291 || i2c_smbus_read_byte_data(new_client, 6) != os
292 || i2c_smbus_read_byte_data(new_client, 7) != os)
293 return -ENODEV;
294 }
295
296 /* Addresses cycling */
297 for (i = 8; i <= 248; i += 40) {
298 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
299 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
300 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
301 return -ENODEV;
302 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
303 != LM75A_ID)
304 return -ENODEV;
305 }
306
307 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
308
309 return 0;
310}
311
312#ifdef CONFIG_PM
313static int lm75_suspend(struct device *dev)
314{
315 int status;
316 struct i2c_client *client = to_i2c_client(dev);
317 status = lm75_read_value(client, LM75_REG_CONF);
318 if (status < 0) {
319 dev_dbg(&client->dev, "Can't read config? %d\n", status);
320 return status;
321 }
322 status = status | LM75_SHUTDOWN;
323 lm75_write_value(client, LM75_REG_CONF, status);
324 return 0;
325}
326
327static int lm75_resume(struct device *dev)
328{
329 int status;
330 struct i2c_client *client = to_i2c_client(dev);
331 status = lm75_read_value(client, LM75_REG_CONF);
332 if (status < 0) {
333 dev_dbg(&client->dev, "Can't read config? %d\n", status);
334 return status;
335 }
336 status = status & ~LM75_SHUTDOWN;
337 lm75_write_value(client, LM75_REG_CONF, status);
338 return 0;
339}
340
341static const struct dev_pm_ops lm75_dev_pm_ops = {
342 .suspend = lm75_suspend,
343 .resume = lm75_resume,
344};
345#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
346#else
347#define LM75_DEV_PM_OPS NULL
348#endif /* CONFIG_PM */
349
350static struct i2c_driver lm75_driver = {
351 .class = I2C_CLASS_HWMON,
352 .driver = {
353 .name = "lm75",
354 .pm = LM75_DEV_PM_OPS,
355 },
356 .probe = lm75_probe,
357 .remove = lm75_remove,
358 .id_table = lm75_ids,
359 .detect = lm75_detect,
360 .address_list = normal_i2c,
361};
362
363/*-----------------------------------------------------------------------*/
364
365/* register access */
366
367/*
368 * All registers are word-sized, except for the configuration register.
369 * LM75 uses a high-byte first convention, which is exactly opposite to
370 * the SMBus standard.
371 */
372static int lm75_read_value(struct i2c_client *client, u8 reg)
373{
374 int value;
375
376 if (reg == LM75_REG_CONF)
377 return i2c_smbus_read_byte_data(client, reg);
378
379 value = i2c_smbus_read_word_data(client, reg);
380 return (value < 0) ? value : swab16(value);
381}
382
383static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
384{
385 if (reg == LM75_REG_CONF)
386 return i2c_smbus_write_byte_data(client, reg, value);
387 else
388 return i2c_smbus_write_word_data(client, reg, swab16(value));
389}
390
391static struct lm75_data *lm75_update_device(struct device *dev)
392{
393 struct i2c_client *client = to_i2c_client(dev);
394 struct lm75_data *data = i2c_get_clientdata(client);
395
396 mutex_lock(&data->update_lock);
397
398 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
399 || !data->valid) {
400 int i;
401 dev_dbg(&client->dev, "Starting lm75 update\n");
402
403 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
404 int status;
405
406 status = lm75_read_value(client, LM75_REG_TEMP[i]);
407 if (status < 0)
408 dev_dbg(&client->dev, "reg %d, err %d\n",
409 LM75_REG_TEMP[i], status);
410 else
411 data->temp[i] = status;
412 }
413 data->last_updated = jiffies;
414 data->valid = 1;
415 }
416
417 mutex_unlock(&data->update_lock);
418
419 return data;
420}
421
422/*-----------------------------------------------------------------------*/
423
424/* module glue */
425
426static int __init sensors_lm75_init(void)
427{
428 return i2c_add_driver(&lm75_driver);
429}
430
431static void __exit sensors_lm75_exit(void)
432{
433 i2c_del_driver(&lm75_driver);
434}
435
436MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
437MODULE_DESCRIPTION("LM75 driver");
438MODULE_LICENSE("GPL");
439
440module_init(sensors_lm75_init);
441module_exit(sensors_lm75_exit);
1/*
2 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring
4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 *
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.
10 *
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.
15 *
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.
19 */
20
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>
30#include "lm75.h"
31
32
33/*
34 * This driver handles the LM75 and compatible digital temperature sensors.
35 */
36
37enum lm75_type { /* keep sorted in alphabetical order */
38 adt75,
39 ds1775,
40 ds75,
41 lm75,
42 lm75a,
43 max6625,
44 max6626,
45 mcp980x,
46 stds75,
47 tcn75,
48 tmp100,
49 tmp101,
50 tmp105,
51 tmp175,
52 tmp275,
53 tmp75,
54};
55
56/* Addresses scanned */
57static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
58 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
59
60
61/* The LM75 registers */
62#define LM75_REG_CONF 0x01
63static const u8 LM75_REG_TEMP[3] = {
64 0x00, /* input */
65 0x03, /* max */
66 0x02, /* hyst */
67};
68
69/* Each client has this additional data */
70struct lm75_data {
71 struct device *hwmon_dev;
72 struct mutex update_lock;
73 u8 orig_conf;
74 char valid; /* !=0 if registers are valid */
75 unsigned long last_updated; /* In jiffies */
76 u16 temp[3]; /* Register values,
77 0 = input
78 1 = max
79 2 = hyst */
80};
81
82static int lm75_read_value(struct i2c_client *client, u8 reg);
83static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
84static struct lm75_data *lm75_update_device(struct device *dev);
85
86
87/*-----------------------------------------------------------------------*/
88
89/* sysfs attributes for hwmon */
90
91static ssize_t show_temp(struct device *dev, struct device_attribute *da,
92 char *buf)
93{
94 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
95 struct lm75_data *data = lm75_update_device(dev);
96
97 if (IS_ERR(data))
98 return PTR_ERR(data);
99
100 return sprintf(buf, "%d\n",
101 LM75_TEMP_FROM_REG(data->temp[attr->index]));
102}
103
104static ssize_t set_temp(struct device *dev, struct device_attribute *da,
105 const char *buf, size_t count)
106{
107 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
108 struct i2c_client *client = to_i2c_client(dev);
109 struct lm75_data *data = i2c_get_clientdata(client);
110 int nr = attr->index;
111 long temp;
112 int error;
113
114 error = kstrtol(buf, 10, &temp);
115 if (error)
116 return error;
117
118 mutex_lock(&data->update_lock);
119 data->temp[nr] = LM75_TEMP_TO_REG(temp);
120 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
121 mutex_unlock(&data->update_lock);
122 return count;
123}
124
125static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
126 show_temp, set_temp, 1);
127static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
128 show_temp, set_temp, 2);
129static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
130
131static struct attribute *lm75_attributes[] = {
132 &sensor_dev_attr_temp1_input.dev_attr.attr,
133 &sensor_dev_attr_temp1_max.dev_attr.attr,
134 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
135
136 NULL
137};
138
139static const struct attribute_group lm75_group = {
140 .attrs = lm75_attributes,
141};
142
143/*-----------------------------------------------------------------------*/
144
145/* device probe and removal */
146
147static int
148lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
149{
150 struct lm75_data *data;
151 int status;
152 u8 set_mask, clr_mask;
153 int new;
154
155 if (!i2c_check_functionality(client->adapter,
156 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
157 return -EIO;
158
159 data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
160 if (!data)
161 return -ENOMEM;
162
163 i2c_set_clientdata(client, data);
164 mutex_init(&data->update_lock);
165
166 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
167 * Then tweak to be more precise when appropriate.
168 */
169 set_mask = 0;
170 clr_mask = (1 << 0) /* continuous conversions */
171 | (1 << 6) | (1 << 5); /* 9-bit mode */
172
173 /* configure as specified */
174 status = lm75_read_value(client, LM75_REG_CONF);
175 if (status < 0) {
176 dev_dbg(&client->dev, "Can't read config? %d\n", status);
177 goto exit_free;
178 }
179 data->orig_conf = status;
180 new = status & ~clr_mask;
181 new |= set_mask;
182 if (status != new)
183 lm75_write_value(client, LM75_REG_CONF, new);
184 dev_dbg(&client->dev, "Config %02x\n", new);
185
186 /* Register sysfs hooks */
187 status = sysfs_create_group(&client->dev.kobj, &lm75_group);
188 if (status)
189 goto exit_free;
190
191 data->hwmon_dev = hwmon_device_register(&client->dev);
192 if (IS_ERR(data->hwmon_dev)) {
193 status = PTR_ERR(data->hwmon_dev);
194 goto exit_remove;
195 }
196
197 dev_info(&client->dev, "%s: sensor '%s'\n",
198 dev_name(data->hwmon_dev), client->name);
199
200 return 0;
201
202exit_remove:
203 sysfs_remove_group(&client->dev.kobj, &lm75_group);
204exit_free:
205 kfree(data);
206 return status;
207}
208
209static int lm75_remove(struct i2c_client *client)
210{
211 struct lm75_data *data = i2c_get_clientdata(client);
212
213 hwmon_device_unregister(data->hwmon_dev);
214 sysfs_remove_group(&client->dev.kobj, &lm75_group);
215 lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
216 kfree(data);
217 return 0;
218}
219
220static const struct i2c_device_id lm75_ids[] = {
221 { "adt75", adt75, },
222 { "ds1775", ds1775, },
223 { "ds75", ds75, },
224 { "lm75", lm75, },
225 { "lm75a", lm75a, },
226 { "max6625", max6625, },
227 { "max6626", max6626, },
228 { "mcp980x", mcp980x, },
229 { "stds75", stds75, },
230 { "tcn75", tcn75, },
231 { "tmp100", tmp100, },
232 { "tmp101", tmp101, },
233 { "tmp105", tmp105, },
234 { "tmp175", tmp175, },
235 { "tmp275", tmp275, },
236 { "tmp75", tmp75, },
237 { /* LIST END */ }
238};
239MODULE_DEVICE_TABLE(i2c, lm75_ids);
240
241#define LM75A_ID 0xA1
242
243/* Return 0 if detection is successful, -ENODEV otherwise */
244static int lm75_detect(struct i2c_client *new_client,
245 struct i2c_board_info *info)
246{
247 struct i2c_adapter *adapter = new_client->adapter;
248 int i;
249 int conf, hyst, os;
250 bool is_lm75a = 0;
251
252 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
253 I2C_FUNC_SMBUS_WORD_DATA))
254 return -ENODEV;
255
256 /*
257 * Now, we do the remaining detection. There is no identification-
258 * dedicated register so we have to rely on several tricks:
259 * unused bits, registers cycling over 8-address boundaries,
260 * addresses 0x04-0x07 returning the last read value.
261 * The cycling+unused addresses combination is not tested,
262 * since it would significantly slow the detection down and would
263 * hardly add any value.
264 *
265 * The National Semiconductor LM75A is different than earlier
266 * LM75s. It has an ID byte of 0xaX (where X is the chip
267 * revision, with 1 being the only revision in existence) in
268 * register 7, and unused registers return 0xff rather than the
269 * last read value.
270 *
271 * Note that this function only detects the original National
272 * Semiconductor LM75 and the LM75A. Clones from other vendors
273 * aren't detected, on purpose, because they are typically never
274 * found on PC hardware. They are found on embedded designs where
275 * they can be instantiated explicitly so detection is not needed.
276 * The absence of identification registers on all these clones
277 * would make their exhaustive detection very difficult and weak,
278 * and odds are that the driver would bind to unsupported devices.
279 */
280
281 /* Unused bits */
282 conf = i2c_smbus_read_byte_data(new_client, 1);
283 if (conf & 0xe0)
284 return -ENODEV;
285
286 /* First check for LM75A */
287 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
288 /* LM75A returns 0xff on unused registers so
289 just to be sure we check for that too. */
290 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
291 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
292 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
293 return -ENODEV;
294 is_lm75a = 1;
295 hyst = i2c_smbus_read_byte_data(new_client, 2);
296 os = i2c_smbus_read_byte_data(new_client, 3);
297 } else { /* Traditional style LM75 detection */
298 /* Unused addresses */
299 hyst = i2c_smbus_read_byte_data(new_client, 2);
300 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
301 || i2c_smbus_read_byte_data(new_client, 5) != hyst
302 || i2c_smbus_read_byte_data(new_client, 6) != hyst
303 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
304 return -ENODEV;
305 os = i2c_smbus_read_byte_data(new_client, 3);
306 if (i2c_smbus_read_byte_data(new_client, 4) != os
307 || i2c_smbus_read_byte_data(new_client, 5) != os
308 || i2c_smbus_read_byte_data(new_client, 6) != os
309 || i2c_smbus_read_byte_data(new_client, 7) != os)
310 return -ENODEV;
311 }
312
313 /* Addresses cycling */
314 for (i = 8; i <= 248; i += 40) {
315 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
316 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
317 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
318 return -ENODEV;
319 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
320 != LM75A_ID)
321 return -ENODEV;
322 }
323
324 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
325
326 return 0;
327}
328
329#ifdef CONFIG_PM
330static int lm75_suspend(struct device *dev)
331{
332 int status;
333 struct i2c_client *client = to_i2c_client(dev);
334 status = lm75_read_value(client, LM75_REG_CONF);
335 if (status < 0) {
336 dev_dbg(&client->dev, "Can't read config? %d\n", status);
337 return status;
338 }
339 status = status | LM75_SHUTDOWN;
340 lm75_write_value(client, LM75_REG_CONF, status);
341 return 0;
342}
343
344static int lm75_resume(struct device *dev)
345{
346 int status;
347 struct i2c_client *client = to_i2c_client(dev);
348 status = lm75_read_value(client, LM75_REG_CONF);
349 if (status < 0) {
350 dev_dbg(&client->dev, "Can't read config? %d\n", status);
351 return status;
352 }
353 status = status & ~LM75_SHUTDOWN;
354 lm75_write_value(client, LM75_REG_CONF, status);
355 return 0;
356}
357
358static const struct dev_pm_ops lm75_dev_pm_ops = {
359 .suspend = lm75_suspend,
360 .resume = lm75_resume,
361};
362#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
363#else
364#define LM75_DEV_PM_OPS NULL
365#endif /* CONFIG_PM */
366
367static struct i2c_driver lm75_driver = {
368 .class = I2C_CLASS_HWMON,
369 .driver = {
370 .name = "lm75",
371 .pm = LM75_DEV_PM_OPS,
372 },
373 .probe = lm75_probe,
374 .remove = lm75_remove,
375 .id_table = lm75_ids,
376 .detect = lm75_detect,
377 .address_list = normal_i2c,
378};
379
380/*-----------------------------------------------------------------------*/
381
382/* register access */
383
384/*
385 * All registers are word-sized, except for the configuration register.
386 * LM75 uses a high-byte first convention, which is exactly opposite to
387 * the SMBus standard.
388 */
389static int lm75_read_value(struct i2c_client *client, u8 reg)
390{
391 if (reg == LM75_REG_CONF)
392 return i2c_smbus_read_byte_data(client, reg);
393 else
394 return i2c_smbus_read_word_swapped(client, reg);
395}
396
397static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
398{
399 if (reg == LM75_REG_CONF)
400 return i2c_smbus_write_byte_data(client, reg, value);
401 else
402 return i2c_smbus_write_word_swapped(client, reg, value);
403}
404
405static struct lm75_data *lm75_update_device(struct device *dev)
406{
407 struct i2c_client *client = to_i2c_client(dev);
408 struct lm75_data *data = i2c_get_clientdata(client);
409 struct lm75_data *ret = data;
410
411 mutex_lock(&data->update_lock);
412
413 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
414 || !data->valid) {
415 int i;
416 dev_dbg(&client->dev, "Starting lm75 update\n");
417
418 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
419 int status;
420
421 status = lm75_read_value(client, LM75_REG_TEMP[i]);
422 if (unlikely(status < 0)) {
423 dev_dbg(dev,
424 "LM75: Failed to read value: reg %d, error %d\n",
425 LM75_REG_TEMP[i], status);
426 ret = ERR_PTR(status);
427 data->valid = 0;
428 goto abort;
429 }
430 data->temp[i] = status;
431 }
432 data->last_updated = jiffies;
433 data->valid = 1;
434 }
435
436abort:
437 mutex_unlock(&data->update_lock);
438 return ret;
439}
440
441module_i2c_driver(lm75_driver);
442
443MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
444MODULE_DESCRIPTION("LM75 driver");
445MODULE_LICENSE("GPL");