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// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
4 * monitoring
5 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
6 */
7
8#include <linux/module.h>
9#include <linux/init.h>
10#include <linux/slab.h>
11#include <linux/jiffies.h>
12#include <linux/i2c.h>
13#include <linux/hwmon.h>
14#include <linux/hwmon-sysfs.h>
15#include <linux/err.h>
16#include <linux/of_device.h>
17#include <linux/of.h>
18#include <linux/regmap.h>
19#include <linux/util_macros.h>
20#include "lm75.h"
21
22/*
23 * This driver handles the LM75 and compatible digital temperature sensors.
24 */
25
26enum lm75_type { /* keep sorted in alphabetical order */
27 adt75,
28 ds1775,
29 ds75,
30 ds7505,
31 g751,
32 lm75,
33 lm75a,
34 lm75b,
35 max6625,
36 max6626,
37 max31725,
38 mcp980x,
39 pct2075,
40 stds75,
41 stlm75,
42 tcn75,
43 tmp100,
44 tmp101,
45 tmp105,
46 tmp112,
47 tmp175,
48 tmp275,
49 tmp75,
50 tmp75b,
51 tmp75c,
52};
53
54/**
55 * struct lm75_params - lm75 configuration parameters.
56 * @set_mask: Bits to set in configuration register when configuring
57 * the chip.
58 * @clr_mask: Bits to clear in configuration register when configuring
59 * the chip.
60 * @default_resolution: Default number of bits to represent the temperature
61 * value.
62 * @resolution_limits: Limit register resolution. Optional. Should be set if
63 * the resolution of limit registers does not match the
64 * resolution of the temperature register.
65 * @resolutions: List of resolutions associated with sample times.
66 * Optional. Should be set if num_sample_times is larger
67 * than 1, and if the resolution changes with sample times.
68 * If set, number of entries must match num_sample_times.
69 * @default_sample_time:Sample time to be set by default.
70 * @num_sample_times: Number of possible sample times to be set. Optional.
71 * Should be set if the number of sample times is larger
72 * than one.
73 * @sample_times: All the possible sample times to be set. Mandatory if
74 * num_sample_times is larger than 1. If set, number of
75 * entries must match num_sample_times.
76 */
77
78struct lm75_params {
79 u8 set_mask;
80 u8 clr_mask;
81 u8 default_resolution;
82 u8 resolution_limits;
83 const u8 *resolutions;
84 unsigned int default_sample_time;
85 u8 num_sample_times;
86 const unsigned int *sample_times;
87};
88
89/* Addresses scanned */
90static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
91 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
92
93/* The LM75 registers */
94#define LM75_REG_TEMP 0x00
95#define LM75_REG_CONF 0x01
96#define LM75_REG_HYST 0x02
97#define LM75_REG_MAX 0x03
98#define PCT2075_REG_IDLE 0x04
99
100/* Each client has this additional data */
101struct lm75_data {
102 struct i2c_client *client;
103 struct regmap *regmap;
104 u8 orig_conf;
105 u8 current_conf;
106 u8 resolution; /* In bits, 9 to 16 */
107 unsigned int sample_time; /* In ms */
108 enum lm75_type kind;
109 const struct lm75_params *params;
110};
111
112/*-----------------------------------------------------------------------*/
113
114static const u8 lm75_sample_set_masks[] = { 0 << 5, 1 << 5, 2 << 5, 3 << 5 };
115
116#define LM75_SAMPLE_CLEAR_MASK (3 << 5)
117
118/* The structure below stores the configuration values of the supported devices.
119 * In case of being supported multiple configurations, the default one must
120 * always be the first element of the array
121 */
122static const struct lm75_params device_params[] = {
123 [adt75] = {
124 .clr_mask = 1 << 5, /* not one-shot mode */
125 .default_resolution = 12,
126 .default_sample_time = MSEC_PER_SEC / 10,
127 },
128 [ds1775] = {
129 .clr_mask = 3 << 5,
130 .set_mask = 2 << 5, /* 11-bit mode */
131 .default_resolution = 11,
132 .default_sample_time = 500,
133 .num_sample_times = 4,
134 .sample_times = (unsigned int []){ 125, 250, 500, 1000 },
135 .resolutions = (u8 []) {9, 10, 11, 12 },
136 },
137 [ds75] = {
138 .clr_mask = 3 << 5,
139 .set_mask = 2 << 5, /* 11-bit mode */
140 .default_resolution = 11,
141 .default_sample_time = 600,
142 .num_sample_times = 4,
143 .sample_times = (unsigned int []){ 150, 300, 600, 1200 },
144 .resolutions = (u8 []) {9, 10, 11, 12 },
145 },
146 [stds75] = {
147 .clr_mask = 3 << 5,
148 .set_mask = 2 << 5, /* 11-bit mode */
149 .default_resolution = 11,
150 .default_sample_time = 600,
151 .num_sample_times = 4,
152 .sample_times = (unsigned int []){ 150, 300, 600, 1200 },
153 .resolutions = (u8 []) {9, 10, 11, 12 },
154 },
155 [stlm75] = {
156 .default_resolution = 9,
157 .default_sample_time = MSEC_PER_SEC / 6,
158 },
159 [ds7505] = {
160 .set_mask = 3 << 5, /* 12-bit mode*/
161 .default_resolution = 12,
162 .default_sample_time = 200,
163 .num_sample_times = 4,
164 .sample_times = (unsigned int []){ 25, 50, 100, 200 },
165 .resolutions = (u8 []) {9, 10, 11, 12 },
166 },
167 [g751] = {
168 .default_resolution = 9,
169 .default_sample_time = MSEC_PER_SEC / 10,
170 },
171 [lm75] = {
172 .default_resolution = 9,
173 .default_sample_time = MSEC_PER_SEC / 10,
174 },
175 [lm75a] = {
176 .default_resolution = 9,
177 .default_sample_time = MSEC_PER_SEC / 10,
178 },
179 [lm75b] = {
180 .default_resolution = 11,
181 .default_sample_time = MSEC_PER_SEC / 10,
182 },
183 [max6625] = {
184 .default_resolution = 9,
185 .default_sample_time = MSEC_PER_SEC / 7,
186 },
187 [max6626] = {
188 .default_resolution = 12,
189 .default_sample_time = MSEC_PER_SEC / 7,
190 .resolution_limits = 9,
191 },
192 [max31725] = {
193 .default_resolution = 16,
194 .default_sample_time = MSEC_PER_SEC / 20,
195 },
196 [tcn75] = {
197 .default_resolution = 9,
198 .default_sample_time = MSEC_PER_SEC / 18,
199 },
200 [pct2075] = {
201 .default_resolution = 11,
202 .default_sample_time = MSEC_PER_SEC / 10,
203 .num_sample_times = 31,
204 .sample_times = (unsigned int []){ 100, 200, 300, 400, 500, 600,
205 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700,
206 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700,
207 2800, 2900, 3000, 3100 },
208 },
209 [mcp980x] = {
210 .set_mask = 3 << 5, /* 12-bit mode */
211 .clr_mask = 1 << 7, /* not one-shot mode */
212 .default_resolution = 12,
213 .resolution_limits = 9,
214 .default_sample_time = 240,
215 .num_sample_times = 4,
216 .sample_times = (unsigned int []){ 30, 60, 120, 240 },
217 .resolutions = (u8 []) {9, 10, 11, 12 },
218 },
219 [tmp100] = {
220 .set_mask = 3 << 5, /* 12-bit mode */
221 .clr_mask = 1 << 7, /* not one-shot mode */
222 .default_resolution = 12,
223 .default_sample_time = 320,
224 .num_sample_times = 4,
225 .sample_times = (unsigned int []){ 40, 80, 160, 320 },
226 .resolutions = (u8 []) {9, 10, 11, 12 },
227 },
228 [tmp101] = {
229 .set_mask = 3 << 5, /* 12-bit mode */
230 .clr_mask = 1 << 7, /* not one-shot mode */
231 .default_resolution = 12,
232 .default_sample_time = 320,
233 .num_sample_times = 4,
234 .sample_times = (unsigned int []){ 40, 80, 160, 320 },
235 .resolutions = (u8 []) {9, 10, 11, 12 },
236 },
237 [tmp105] = {
238 .set_mask = 3 << 5, /* 12-bit mode */
239 .clr_mask = 1 << 7, /* not one-shot mode*/
240 .default_resolution = 12,
241 .default_sample_time = 220,
242 .num_sample_times = 4,
243 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
244 .resolutions = (u8 []) {9, 10, 11, 12 },
245 },
246 [tmp112] = {
247 .set_mask = 3 << 5, /* 8 samples / second */
248 .clr_mask = 1 << 7, /* no one-shot mode*/
249 .default_resolution = 12,
250 .default_sample_time = 125,
251 .num_sample_times = 4,
252 .sample_times = (unsigned int []){ 125, 250, 1000, 4000 },
253 },
254 [tmp175] = {
255 .set_mask = 3 << 5, /* 12-bit mode */
256 .clr_mask = 1 << 7, /* not one-shot mode*/
257 .default_resolution = 12,
258 .default_sample_time = 220,
259 .num_sample_times = 4,
260 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
261 .resolutions = (u8 []) {9, 10, 11, 12 },
262 },
263 [tmp275] = {
264 .set_mask = 3 << 5, /* 12-bit mode */
265 .clr_mask = 1 << 7, /* not one-shot mode*/
266 .default_resolution = 12,
267 .default_sample_time = 220,
268 .num_sample_times = 4,
269 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
270 .resolutions = (u8 []) {9, 10, 11, 12 },
271 },
272 [tmp75] = {
273 .set_mask = 3 << 5, /* 12-bit mode */
274 .clr_mask = 1 << 7, /* not one-shot mode*/
275 .default_resolution = 12,
276 .default_sample_time = 220,
277 .num_sample_times = 4,
278 .sample_times = (unsigned int []){ 28, 55, 110, 220 },
279 .resolutions = (u8 []) {9, 10, 11, 12 },
280 },
281 [tmp75b] = { /* not one-shot mode, Conversion rate 37Hz */
282 .clr_mask = 1 << 7 | 3 << 5,
283 .default_resolution = 12,
284 .default_sample_time = MSEC_PER_SEC / 37,
285 .sample_times = (unsigned int []){ MSEC_PER_SEC / 37,
286 MSEC_PER_SEC / 18,
287 MSEC_PER_SEC / 9, MSEC_PER_SEC / 4 },
288 .num_sample_times = 4,
289 },
290 [tmp75c] = {
291 .clr_mask = 1 << 5, /*not one-shot mode*/
292 .default_resolution = 12,
293 .default_sample_time = MSEC_PER_SEC / 12,
294 }
295};
296
297static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
298{
299 return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
300}
301
302static int lm75_write_config(struct lm75_data *data, u8 set_mask,
303 u8 clr_mask)
304{
305 u8 value;
306
307 clr_mask |= LM75_SHUTDOWN;
308 value = data->current_conf & ~clr_mask;
309 value |= set_mask;
310
311 if (data->current_conf != value) {
312 s32 err;
313
314 err = i2c_smbus_write_byte_data(data->client, LM75_REG_CONF,
315 value);
316 if (err)
317 return err;
318 data->current_conf = value;
319 }
320 return 0;
321}
322
323static int lm75_read(struct device *dev, enum hwmon_sensor_types type,
324 u32 attr, int channel, long *val)
325{
326 struct lm75_data *data = dev_get_drvdata(dev);
327 unsigned int regval;
328 int err, reg;
329
330 switch (type) {
331 case hwmon_chip:
332 switch (attr) {
333 case hwmon_chip_update_interval:
334 *val = data->sample_time;
335 break;
336 default:
337 return -EINVAL;
338 }
339 break;
340 case hwmon_temp:
341 switch (attr) {
342 case hwmon_temp_input:
343 reg = LM75_REG_TEMP;
344 break;
345 case hwmon_temp_max:
346 reg = LM75_REG_MAX;
347 break;
348 case hwmon_temp_max_hyst:
349 reg = LM75_REG_HYST;
350 break;
351 default:
352 return -EINVAL;
353 }
354 err = regmap_read(data->regmap, reg, ®val);
355 if (err < 0)
356 return err;
357
358 *val = lm75_reg_to_mc(regval, data->resolution);
359 break;
360 default:
361 return -EINVAL;
362 }
363 return 0;
364}
365
366static int lm75_write_temp(struct device *dev, u32 attr, long temp)
367{
368 struct lm75_data *data = dev_get_drvdata(dev);
369 u8 resolution;
370 int reg;
371
372 switch (attr) {
373 case hwmon_temp_max:
374 reg = LM75_REG_MAX;
375 break;
376 case hwmon_temp_max_hyst:
377 reg = LM75_REG_HYST;
378 break;
379 default:
380 return -EINVAL;
381 }
382
383 /*
384 * Resolution of limit registers is assumed to be the same as the
385 * temperature input register resolution unless given explicitly.
386 */
387 if (data->params->resolution_limits)
388 resolution = data->params->resolution_limits;
389 else
390 resolution = data->resolution;
391
392 temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
393 temp = DIV_ROUND_CLOSEST(temp << (resolution - 8),
394 1000) << (16 - resolution);
395
396 return regmap_write(data->regmap, reg, (u16)temp);
397}
398
399static int lm75_update_interval(struct device *dev, long val)
400{
401 struct lm75_data *data = dev_get_drvdata(dev);
402 unsigned int reg;
403 u8 index;
404 s32 err;
405
406 index = find_closest(val, data->params->sample_times,
407 (int)data->params->num_sample_times);
408
409 switch (data->kind) {
410 default:
411 err = lm75_write_config(data, lm75_sample_set_masks[index],
412 LM75_SAMPLE_CLEAR_MASK);
413 if (err)
414 return err;
415
416 data->sample_time = data->params->sample_times[index];
417 if (data->params->resolutions)
418 data->resolution = data->params->resolutions[index];
419 break;
420 case tmp112:
421 err = regmap_read(data->regmap, LM75_REG_CONF, ®);
422 if (err < 0)
423 return err;
424 reg &= ~0x00c0;
425 reg |= (3 - index) << 6;
426 err = regmap_write(data->regmap, LM75_REG_CONF, reg);
427 if (err < 0)
428 return err;
429 data->sample_time = data->params->sample_times[index];
430 break;
431 case pct2075:
432 err = i2c_smbus_write_byte_data(data->client, PCT2075_REG_IDLE,
433 index + 1);
434 if (err)
435 return err;
436 data->sample_time = data->params->sample_times[index];
437 break;
438 }
439 return 0;
440}
441
442static int lm75_write_chip(struct device *dev, u32 attr, long val)
443{
444 switch (attr) {
445 case hwmon_chip_update_interval:
446 return lm75_update_interval(dev, val);
447 default:
448 return -EINVAL;
449 }
450 return 0;
451}
452
453static int lm75_write(struct device *dev, enum hwmon_sensor_types type,
454 u32 attr, int channel, long val)
455{
456 switch (type) {
457 case hwmon_chip:
458 return lm75_write_chip(dev, attr, val);
459 case hwmon_temp:
460 return lm75_write_temp(dev, attr, val);
461 default:
462 return -EINVAL;
463 }
464 return 0;
465}
466
467static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type,
468 u32 attr, int channel)
469{
470 const struct lm75_data *config_data = data;
471
472 switch (type) {
473 case hwmon_chip:
474 switch (attr) {
475 case hwmon_chip_update_interval:
476 if (config_data->params->num_sample_times > 1)
477 return 0644;
478 return 0444;
479 }
480 break;
481 case hwmon_temp:
482 switch (attr) {
483 case hwmon_temp_input:
484 return 0444;
485 case hwmon_temp_max:
486 case hwmon_temp_max_hyst:
487 return 0644;
488 }
489 break;
490 default:
491 break;
492 }
493 return 0;
494}
495
496static const struct hwmon_channel_info *lm75_info[] = {
497 HWMON_CHANNEL_INFO(chip,
498 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
499 HWMON_CHANNEL_INFO(temp,
500 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST),
501 NULL
502};
503
504static const struct hwmon_ops lm75_hwmon_ops = {
505 .is_visible = lm75_is_visible,
506 .read = lm75_read,
507 .write = lm75_write,
508};
509
510static const struct hwmon_chip_info lm75_chip_info = {
511 .ops = &lm75_hwmon_ops,
512 .info = lm75_info,
513};
514
515static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
516{
517 return reg != LM75_REG_TEMP;
518}
519
520static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg)
521{
522 return reg == LM75_REG_TEMP || reg == LM75_REG_CONF;
523}
524
525static const struct regmap_config lm75_regmap_config = {
526 .reg_bits = 8,
527 .val_bits = 16,
528 .max_register = PCT2075_REG_IDLE,
529 .writeable_reg = lm75_is_writeable_reg,
530 .volatile_reg = lm75_is_volatile_reg,
531 .val_format_endian = REGMAP_ENDIAN_BIG,
532 .cache_type = REGCACHE_RBTREE,
533 .use_single_read = true,
534 .use_single_write = true,
535};
536
537static void lm75_remove(void *data)
538{
539 struct lm75_data *lm75 = data;
540 struct i2c_client *client = lm75->client;
541
542 i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
543}
544
545static int
546lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
547{
548 struct device *dev = &client->dev;
549 struct device *hwmon_dev;
550 struct lm75_data *data;
551 int status, err;
552 enum lm75_type kind;
553
554 if (client->dev.of_node)
555 kind = (enum lm75_type)of_device_get_match_data(&client->dev);
556 else
557 kind = id->driver_data;
558
559 if (!i2c_check_functionality(client->adapter,
560 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
561 return -EIO;
562
563 data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL);
564 if (!data)
565 return -ENOMEM;
566
567 data->client = client;
568 data->kind = kind;
569
570 data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
571 if (IS_ERR(data->regmap))
572 return PTR_ERR(data->regmap);
573
574 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
575 * Then tweak to be more precise when appropriate.
576 */
577
578 data->params = &device_params[data->kind];
579
580 /* Save default sample time and resolution*/
581 data->sample_time = data->params->default_sample_time;
582 data->resolution = data->params->default_resolution;
583
584 /* Cache original configuration */
585 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
586 if (status < 0) {
587 dev_dbg(dev, "Can't read config? %d\n", status);
588 return status;
589 }
590 data->orig_conf = status;
591 data->current_conf = status;
592
593 err = lm75_write_config(data, data->params->set_mask,
594 data->params->clr_mask);
595 if (err)
596 return err;
597
598 err = devm_add_action_or_reset(dev, lm75_remove, data);
599 if (err)
600 return err;
601
602 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
603 data, &lm75_chip_info,
604 NULL);
605 if (IS_ERR(hwmon_dev))
606 return PTR_ERR(hwmon_dev);
607
608 dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
609
610 return 0;
611}
612
613static const struct i2c_device_id lm75_ids[] = {
614 { "adt75", adt75, },
615 { "ds1775", ds1775, },
616 { "ds75", ds75, },
617 { "ds7505", ds7505, },
618 { "g751", g751, },
619 { "lm75", lm75, },
620 { "lm75a", lm75a, },
621 { "lm75b", lm75b, },
622 { "max6625", max6625, },
623 { "max6626", max6626, },
624 { "max31725", max31725, },
625 { "max31726", max31725, },
626 { "mcp980x", mcp980x, },
627 { "pct2075", pct2075, },
628 { "stds75", stds75, },
629 { "stlm75", stlm75, },
630 { "tcn75", tcn75, },
631 { "tmp100", tmp100, },
632 { "tmp101", tmp101, },
633 { "tmp105", tmp105, },
634 { "tmp112", tmp112, },
635 { "tmp175", tmp175, },
636 { "tmp275", tmp275, },
637 { "tmp75", tmp75, },
638 { "tmp75b", tmp75b, },
639 { "tmp75c", tmp75c, },
640 { /* LIST END */ }
641};
642MODULE_DEVICE_TABLE(i2c, lm75_ids);
643
644static const struct of_device_id __maybe_unused lm75_of_match[] = {
645 {
646 .compatible = "adi,adt75",
647 .data = (void *)adt75
648 },
649 {
650 .compatible = "dallas,ds1775",
651 .data = (void *)ds1775
652 },
653 {
654 .compatible = "dallas,ds75",
655 .data = (void *)ds75
656 },
657 {
658 .compatible = "dallas,ds7505",
659 .data = (void *)ds7505
660 },
661 {
662 .compatible = "gmt,g751",
663 .data = (void *)g751
664 },
665 {
666 .compatible = "national,lm75",
667 .data = (void *)lm75
668 },
669 {
670 .compatible = "national,lm75a",
671 .data = (void *)lm75a
672 },
673 {
674 .compatible = "national,lm75b",
675 .data = (void *)lm75b
676 },
677 {
678 .compatible = "maxim,max6625",
679 .data = (void *)max6625
680 },
681 {
682 .compatible = "maxim,max6626",
683 .data = (void *)max6626
684 },
685 {
686 .compatible = "maxim,max31725",
687 .data = (void *)max31725
688 },
689 {
690 .compatible = "maxim,max31726",
691 .data = (void *)max31725
692 },
693 {
694 .compatible = "maxim,mcp980x",
695 .data = (void *)mcp980x
696 },
697 {
698 .compatible = "nxp,pct2075",
699 .data = (void *)pct2075
700 },
701 {
702 .compatible = "st,stds75",
703 .data = (void *)stds75
704 },
705 {
706 .compatible = "st,stlm75",
707 .data = (void *)stlm75
708 },
709 {
710 .compatible = "microchip,tcn75",
711 .data = (void *)tcn75
712 },
713 {
714 .compatible = "ti,tmp100",
715 .data = (void *)tmp100
716 },
717 {
718 .compatible = "ti,tmp101",
719 .data = (void *)tmp101
720 },
721 {
722 .compatible = "ti,tmp105",
723 .data = (void *)tmp105
724 },
725 {
726 .compatible = "ti,tmp112",
727 .data = (void *)tmp112
728 },
729 {
730 .compatible = "ti,tmp175",
731 .data = (void *)tmp175
732 },
733 {
734 .compatible = "ti,tmp275",
735 .data = (void *)tmp275
736 },
737 {
738 .compatible = "ti,tmp75",
739 .data = (void *)tmp75
740 },
741 {
742 .compatible = "ti,tmp75b",
743 .data = (void *)tmp75b
744 },
745 {
746 .compatible = "ti,tmp75c",
747 .data = (void *)tmp75c
748 },
749 { },
750};
751MODULE_DEVICE_TABLE(of, lm75_of_match);
752
753#define LM75A_ID 0xA1
754
755/* Return 0 if detection is successful, -ENODEV otherwise */
756static int lm75_detect(struct i2c_client *new_client,
757 struct i2c_board_info *info)
758{
759 struct i2c_adapter *adapter = new_client->adapter;
760 int i;
761 int conf, hyst, os;
762 bool is_lm75a = 0;
763
764 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
765 I2C_FUNC_SMBUS_WORD_DATA))
766 return -ENODEV;
767
768 /*
769 * Now, we do the remaining detection. There is no identification-
770 * dedicated register so we have to rely on several tricks:
771 * unused bits, registers cycling over 8-address boundaries,
772 * addresses 0x04-0x07 returning the last read value.
773 * The cycling+unused addresses combination is not tested,
774 * since it would significantly slow the detection down and would
775 * hardly add any value.
776 *
777 * The National Semiconductor LM75A is different than earlier
778 * LM75s. It has an ID byte of 0xaX (where X is the chip
779 * revision, with 1 being the only revision in existence) in
780 * register 7, and unused registers return 0xff rather than the
781 * last read value.
782 *
783 * Note that this function only detects the original National
784 * Semiconductor LM75 and the LM75A. Clones from other vendors
785 * aren't detected, on purpose, because they are typically never
786 * found on PC hardware. They are found on embedded designs where
787 * they can be instantiated explicitly so detection is not needed.
788 * The absence of identification registers on all these clones
789 * would make their exhaustive detection very difficult and weak,
790 * and odds are that the driver would bind to unsupported devices.
791 */
792
793 /* Unused bits */
794 conf = i2c_smbus_read_byte_data(new_client, 1);
795 if (conf & 0xe0)
796 return -ENODEV;
797
798 /* First check for LM75A */
799 if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
800 /*
801 * LM75A returns 0xff on unused registers so
802 * just to be sure we check for that too.
803 */
804 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
805 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
806 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
807 return -ENODEV;
808 is_lm75a = 1;
809 hyst = i2c_smbus_read_byte_data(new_client, 2);
810 os = i2c_smbus_read_byte_data(new_client, 3);
811 } else { /* Traditional style LM75 detection */
812 /* Unused addresses */
813 hyst = i2c_smbus_read_byte_data(new_client, 2);
814 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
815 || i2c_smbus_read_byte_data(new_client, 5) != hyst
816 || i2c_smbus_read_byte_data(new_client, 6) != hyst
817 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
818 return -ENODEV;
819 os = i2c_smbus_read_byte_data(new_client, 3);
820 if (i2c_smbus_read_byte_data(new_client, 4) != os
821 || i2c_smbus_read_byte_data(new_client, 5) != os
822 || i2c_smbus_read_byte_data(new_client, 6) != os
823 || i2c_smbus_read_byte_data(new_client, 7) != os)
824 return -ENODEV;
825 }
826 /*
827 * It is very unlikely that this is a LM75 if both
828 * hysteresis and temperature limit registers are 0.
829 */
830 if (hyst == 0 && os == 0)
831 return -ENODEV;
832
833 /* Addresses cycling */
834 for (i = 8; i <= 248; i += 40) {
835 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
836 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
837 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
838 return -ENODEV;
839 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
840 != LM75A_ID)
841 return -ENODEV;
842 }
843
844 strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
845
846 return 0;
847}
848
849#ifdef CONFIG_PM
850static int lm75_suspend(struct device *dev)
851{
852 int status;
853 struct i2c_client *client = to_i2c_client(dev);
854
855 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
856 if (status < 0) {
857 dev_dbg(&client->dev, "Can't read config? %d\n", status);
858 return status;
859 }
860 status = status | LM75_SHUTDOWN;
861 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
862 return 0;
863}
864
865static int lm75_resume(struct device *dev)
866{
867 int status;
868 struct i2c_client *client = to_i2c_client(dev);
869
870 status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
871 if (status < 0) {
872 dev_dbg(&client->dev, "Can't read config? %d\n", status);
873 return status;
874 }
875 status = status & ~LM75_SHUTDOWN;
876 i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
877 return 0;
878}
879
880static const struct dev_pm_ops lm75_dev_pm_ops = {
881 .suspend = lm75_suspend,
882 .resume = lm75_resume,
883};
884#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
885#else
886#define LM75_DEV_PM_OPS NULL
887#endif /* CONFIG_PM */
888
889static struct i2c_driver lm75_driver = {
890 .class = I2C_CLASS_HWMON,
891 .driver = {
892 .name = "lm75",
893 .of_match_table = of_match_ptr(lm75_of_match),
894 .pm = LM75_DEV_PM_OPS,
895 },
896 .probe = lm75_probe,
897 .id_table = lm75_ids,
898 .detect = lm75_detect,
899 .address_list = normal_i2c,
900};
901
902module_i2c_driver(lm75_driver);
903
904MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
905MODULE_DESCRIPTION("LM75 driver");
906MODULE_LICENSE("GPL");