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