1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
35
36
37enum lm75_type {
38 adt75,
39 ds1775,
40 ds75,
41 ds7505,
42 lm75,
43 lm75a,
44 max6625,
45 max6626,
46 mcp980x,
47 stds75,
48 tcn75,
49 tmp100,
50 tmp101,
51 tmp105,
52 tmp175,
53 tmp275,
54 tmp75,
55};
56
57
58static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
59 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
60
61
62
63#define LM75_REG_CONF 0x01
64static const u8 LM75_REG_TEMP[3] = {
65 0x00,
66 0x03,
67 0x02,
68};
69
70
71struct lm75_data {
72 struct device *hwmon_dev;
73 struct mutex update_lock;
74 u8 orig_conf;
75 u8 resolution;
76 u8 resolution_limits;
77 char valid;
78 unsigned long last_updated;
79 unsigned long sample_time;
80 s16 temp[3];
81
82
83
84};
85
86static int lm75_read_value(struct i2c_client *client, u8 reg);
87static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
88static struct lm75_data *lm75_update_device(struct device *dev);
89
90
91
92
93
94
95static ssize_t show_temp(struct device *dev, struct device_attribute *da,
96 char *buf)
97{
98 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
99 struct lm75_data *data = lm75_update_device(dev);
100 long temp;
101
102 if (IS_ERR(data))
103 return PTR_ERR(data);
104
105 temp = ((data->temp[attr->index] >> (16 - data->resolution)) * 1000)
106 >> (data->resolution - 8);
107
108 return sprintf(buf, "%ld\n", temp);
109}
110
111static ssize_t set_temp(struct device *dev, struct device_attribute *da,
112 const char *buf, size_t count)
113{
114 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
115 struct i2c_client *client = to_i2c_client(dev);
116 struct lm75_data *data = i2c_get_clientdata(client);
117 int nr = attr->index;
118 long temp;
119 int error;
120 u8 resolution;
121
122 error = kstrtol(buf, 10, &temp);
123 if (error)
124 return error;
125
126
127
128
129
130 if (attr->index && data->resolution_limits)
131 resolution = data->resolution_limits;
132 else
133 resolution = data->resolution;
134
135 mutex_lock(&data->update_lock);
136 temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
137 data->temp[nr] = DIV_ROUND_CLOSEST(temp << (resolution - 8),
138 1000) << (16 - resolution);
139 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
140 mutex_unlock(&data->update_lock);
141 return count;
142}
143
144static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
145 show_temp, set_temp, 1);
146static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
147 show_temp, set_temp, 2);
148static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
149
150static struct attribute *lm75_attributes[] = {
151 &sensor_dev_attr_temp1_input.dev_attr.attr,
152 &sensor_dev_attr_temp1_max.dev_attr.attr,
153 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
154
155 NULL
156};
157
158static const struct attribute_group lm75_group = {
159 .attrs = lm75_attributes,
160};
161
162
163
164
165
166static int
167lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
168{
169 struct lm75_data *data;
170 int status;
171 u8 set_mask, clr_mask;
172 int new;
173 enum lm75_type kind = id->driver_data;
174
175 if (!i2c_check_functionality(client->adapter,
176 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
177 return -EIO;
178
179 data = devm_kzalloc(&client->dev, sizeof(struct lm75_data), GFP_KERNEL);
180 if (!data)
181 return -ENOMEM;
182
183 i2c_set_clientdata(client, data);
184 mutex_init(&data->update_lock);
185
186
187
188
189 set_mask = 0;
190 clr_mask = LM75_SHUTDOWN;
191
192 switch (kind) {
193 case adt75:
194 clr_mask |= 1 << 5;
195 data->resolution = 12;
196 data->sample_time = HZ / 8;
197 break;
198 case ds1775:
199 case ds75:
200 case stds75:
201 clr_mask |= 3 << 5;
202 set_mask |= 2 << 5;
203 data->resolution = 11;
204 data->sample_time = HZ;
205 break;
206 case ds7505:
207 set_mask |= 3 << 5;
208 data->resolution = 12;
209 data->sample_time = HZ / 4;
210 break;
211 case lm75:
212 case lm75a:
213 data->resolution = 9;
214 data->sample_time = HZ / 2;
215 break;
216 case max6625:
217 data->resolution = 9;
218 data->sample_time = HZ / 4;
219 break;
220 case max6626:
221 data->resolution = 12;
222 data->resolution_limits = 9;
223 data->sample_time = HZ / 4;
224 break;
225 case tcn75:
226 data->resolution = 9;
227 data->sample_time = HZ / 8;
228 break;
229 case mcp980x:
230 data->resolution_limits = 9;
231
232 case tmp100:
233 case tmp101:
234 set_mask |= 3 << 5;
235 data->resolution = 12;
236 data->sample_time = HZ;
237 clr_mask |= 1 << 7;
238 break;
239 case tmp105:
240 case tmp175:
241 case tmp275:
242 case tmp75:
243 set_mask |= 3 << 5;
244 clr_mask |= 1 << 7;
245 data->resolution = 12;
246 data->sample_time = HZ / 2;
247 break;
248 }
249
250
251 status = lm75_read_value(client, LM75_REG_CONF);
252 if (status < 0) {
253 dev_dbg(&client->dev, "Can't read config? %d\n", status);
254 return status;
255 }
256 data->orig_conf = status;
257 new = status & ~clr_mask;
258 new |= set_mask;
259 if (status != new)
260 lm75_write_value(client, LM75_REG_CONF, new);
261 dev_dbg(&client->dev, "Config %02x\n", new);
262
263
264 status = sysfs_create_group(&client->dev.kobj, &lm75_group);
265 if (status)
266 return status;
267
268 data->hwmon_dev = hwmon_device_register(&client->dev);
269 if (IS_ERR(data->hwmon_dev)) {
270 status = PTR_ERR(data->hwmon_dev);
271 goto exit_remove;
272 }
273
274 dev_info(&client->dev, "%s: sensor '%s'\n",
275 dev_name(data->hwmon_dev), client->name);
276
277 return 0;
278
279exit_remove:
280 sysfs_remove_group(&client->dev.kobj, &lm75_group);
281 return status;
282}
283
284static int lm75_remove(struct i2c_client *client)
285{
286 struct lm75_data *data = i2c_get_clientdata(client);
287
288 hwmon_device_unregister(data->hwmon_dev);
289 sysfs_remove_group(&client->dev.kobj, &lm75_group);
290 lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
291 return 0;
292}
293
294static const struct i2c_device_id lm75_ids[] = {
295 { "adt75", adt75, },
296 { "ds1775", ds1775, },
297 { "ds75", ds75, },
298 { "ds7505", ds7505, },
299 { "lm75", lm75, },
300 { "lm75a", lm75a, },
301 { "max6625", max6625, },
302 { "max6626", max6626, },
303 { "mcp980x", mcp980x, },
304 { "stds75", stds75, },
305 { "tcn75", tcn75, },
306 { "tmp100", tmp100, },
307 { "tmp101", tmp101, },
308 { "tmp105", tmp105, },
309 { "tmp175", tmp175, },
310 { "tmp275", tmp275, },
311 { "tmp75", tmp75, },
312 { }
313};
314MODULE_DEVICE_TABLE(i2c, lm75_ids);
315
316#define LM75A_ID 0xA1
317
318
319static int lm75_detect(struct i2c_client *new_client,
320 struct i2c_board_info *info)
321{
322 struct i2c_adapter *adapter = new_client->adapter;
323 int i;
324 int conf, hyst, os;
325 bool is_lm75a = 0;
326
327 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
328 I2C_FUNC_SMBUS_WORD_DATA))
329 return -ENODEV;
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357 conf = i2c_smbus_read_byte_data(new_client, 1);
358 if (conf & 0xe0)
359 return -ENODEV;
360
361
362 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
363
364
365 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
366 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
367 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
368 return -ENODEV;
369 is_lm75a = 1;
370 hyst = i2c_smbus_read_byte_data(new_client, 2);
371 os = i2c_smbus_read_byte_data(new_client, 3);
372 } else {
373
374 hyst = i2c_smbus_read_byte_data(new_client, 2);
375 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
376 || i2c_smbus_read_byte_data(new_client, 5) != hyst
377 || i2c_smbus_read_byte_data(new_client, 6) != hyst
378 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
379 return -ENODEV;
380 os = i2c_smbus_read_byte_data(new_client, 3);
381 if (i2c_smbus_read_byte_data(new_client, 4) != os
382 || i2c_smbus_read_byte_data(new_client, 5) != os
383 || i2c_smbus_read_byte_data(new_client, 6) != os
384 || i2c_smbus_read_byte_data(new_client, 7) != os)
385 return -ENODEV;
386 }
387
388
389 for (i = 8; i <= 248; i += 40) {
390 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
391 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
392 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
393 return -ENODEV;
394 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
395 != LM75A_ID)
396 return -ENODEV;
397 }
398
399 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
400
401 return 0;
402}
403
404#ifdef CONFIG_PM
405static int lm75_suspend(struct device *dev)
406{
407 int status;
408 struct i2c_client *client = to_i2c_client(dev);
409 status = lm75_read_value(client, LM75_REG_CONF);
410 if (status < 0) {
411 dev_dbg(&client->dev, "Can't read config? %d\n", status);
412 return status;
413 }
414 status = status | LM75_SHUTDOWN;
415 lm75_write_value(client, LM75_REG_CONF, status);
416 return 0;
417}
418
419static int lm75_resume(struct device *dev)
420{
421 int status;
422 struct i2c_client *client = to_i2c_client(dev);
423 status = lm75_read_value(client, LM75_REG_CONF);
424 if (status < 0) {
425 dev_dbg(&client->dev, "Can't read config? %d\n", status);
426 return status;
427 }
428 status = status & ~LM75_SHUTDOWN;
429 lm75_write_value(client, LM75_REG_CONF, status);
430 return 0;
431}
432
433static const struct dev_pm_ops lm75_dev_pm_ops = {
434 .suspend = lm75_suspend,
435 .resume = lm75_resume,
436};
437#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
438#else
439#define LM75_DEV_PM_OPS NULL
440#endif
441
442static struct i2c_driver lm75_driver = {
443 .class = I2C_CLASS_HWMON,
444 .driver = {
445 .name = "lm75",
446 .pm = LM75_DEV_PM_OPS,
447 },
448 .probe = lm75_probe,
449 .remove = lm75_remove,
450 .id_table = lm75_ids,
451 .detect = lm75_detect,
452 .address_list = normal_i2c,
453};
454
455
456
457
458
459
460
461
462
463
464static int lm75_read_value(struct i2c_client *client, u8 reg)
465{
466 if (reg == LM75_REG_CONF)
467 return i2c_smbus_read_byte_data(client, reg);
468 else
469 return i2c_smbus_read_word_swapped(client, reg);
470}
471
472static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
473{
474 if (reg == LM75_REG_CONF)
475 return i2c_smbus_write_byte_data(client, reg, value);
476 else
477 return i2c_smbus_write_word_swapped(client, reg, value);
478}
479
480static struct lm75_data *lm75_update_device(struct device *dev)
481{
482 struct i2c_client *client = to_i2c_client(dev);
483 struct lm75_data *data = i2c_get_clientdata(client);
484 struct lm75_data *ret = data;
485
486 mutex_lock(&data->update_lock);
487
488 if (time_after(jiffies, data->last_updated + data->sample_time)
489 || !data->valid) {
490 int i;
491 dev_dbg(&client->dev, "Starting lm75 update\n");
492
493 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
494 int status;
495
496 status = lm75_read_value(client, LM75_REG_TEMP[i]);
497 if (unlikely(status < 0)) {
498 dev_dbg(dev,
499 "LM75: Failed to read value: reg %d, error %d\n",
500 LM75_REG_TEMP[i], status);
501 ret = ERR_PTR(status);
502 data->valid = 0;
503 goto abort;
504 }
505 data->temp[i] = status;
506 }
507 data->last_updated = jiffies;
508 data->valid = 1;
509 }
510
511abort:
512 mutex_unlock(&data->update_lock);
513 return ret;
514}
515
516module_i2c_driver(lm75_driver);
517
518MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
519MODULE_DESCRIPTION("LM75 driver");
520MODULE_LICENSE("GPL");
521