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