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