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