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