xref: /openbmc/linux/drivers/hwmon/lm75.c (revision c4ee0af3) 
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 
37 enum lm75_type {		/* keep sorted in alphabetical order */
38 	adt75,
39 	ds1775,
40 	ds75,
41 	ds7505,
42 	g751,
43 	lm75,
44 	lm75a,
45 	max6625,
46 	max6626,
47 	mcp980x,
48 	stds75,
49 	tcn75,
50 	tmp100,
51 	tmp101,
52 	tmp105,
53 	tmp175,
54 	tmp275,
55 	tmp75,
56 };
57 
58 /* Addresses scanned */
59 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
60 					0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
61 
62 
63 /* The LM75 registers */
64 #define LM75_REG_CONF		0x01
65 static const u8 LM75_REG_TEMP[3] = {
66 	0x00,		/* input */
67 	0x03,		/* max */
68 	0x02,		/* hyst */
69 };
70 
71 /* Each client has this additional data */
72 struct lm75_data {
73 	struct device		*hwmon_dev;
74 	struct mutex		update_lock;
75 	u8			orig_conf;
76 	u8			resolution;	/* In bits, between 9 and 12 */
77 	u8			resolution_limits;
78 	char			valid;		/* !=0 if registers are valid */
79 	unsigned long		last_updated;	/* In jiffies */
80 	unsigned long		sample_time;	/* In jiffies */
81 	s16			temp[3];	/* Register values,
82 						   0 = input
83 						   1 = max
84 						   2 = hyst */
85 };
86 
87 static int lm75_read_value(struct i2c_client *client, u8 reg);
88 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
89 static struct lm75_data *lm75_update_device(struct device *dev);
90 
91 
92 /*-----------------------------------------------------------------------*/
93 
94 /* sysfs attributes for hwmon */
95 
96 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
97 			 char *buf)
98 {
99 	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
100 	struct lm75_data *data = lm75_update_device(dev);
101 	long temp;
102 
103 	if (IS_ERR(data))
104 		return PTR_ERR(data);
105 
106 	temp = ((data->temp[attr->index] >> (16 - data->resolution)) * 1000)
107 	       >> (data->resolution - 8);
108 
109 	return sprintf(buf, "%ld\n", temp);
110 }
111 
112 static ssize_t set_temp(struct device *dev, struct device_attribute *da,
113 			const char *buf, size_t count)
114 {
115 	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
116 	struct i2c_client *client = to_i2c_client(dev);
117 	struct lm75_data *data = i2c_get_clientdata(client);
118 	int nr = attr->index;
119 	long temp;
120 	int error;
121 	u8 resolution;
122 
123 	error = kstrtol(buf, 10, &temp);
124 	if (error)
125 		return error;
126 
127 	/*
128 	 * Resolution of limit registers is assumed to be the same as the
129 	 * temperature input register resolution unless given explicitly.
130 	 */
131 	if (attr->index && data->resolution_limits)
132 		resolution = data->resolution_limits;
133 	else
134 		resolution = data->resolution;
135 
136 	mutex_lock(&data->update_lock);
137 	temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
138 	data->temp[nr] = DIV_ROUND_CLOSEST(temp  << (resolution - 8),
139 					   1000) << (16 - resolution);
140 	lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
141 	mutex_unlock(&data->update_lock);
142 	return count;
143 }
144 
145 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
146 			show_temp, set_temp, 1);
147 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
148 			show_temp, set_temp, 2);
149 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
150 
151 static struct attribute *lm75_attributes[] = {
152 	&sensor_dev_attr_temp1_input.dev_attr.attr,
153 	&sensor_dev_attr_temp1_max.dev_attr.attr,
154 	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
155 
156 	NULL
157 };
158 
159 static const struct attribute_group lm75_group = {
160 	.attrs = lm75_attributes,
161 };
162 
163 /*-----------------------------------------------------------------------*/
164 
165 /* device probe and removal */
166 
167 static int
168 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
169 {
170 	struct lm75_data *data;
171 	int status;
172 	u8 set_mask, clr_mask;
173 	int new;
174 	enum lm75_type kind = id->driver_data;
175 
176 	if (!i2c_check_functionality(client->adapter,
177 			I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
178 		return -EIO;
179 
180 	data = devm_kzalloc(&client->dev, sizeof(struct lm75_data), GFP_KERNEL);
181 	if (!data)
182 		return -ENOMEM;
183 
184 	i2c_set_clientdata(client, data);
185 	mutex_init(&data->update_lock);
186 
187 	/* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
188 	 * Then tweak to be more precise when appropriate.
189 	 */
190 	set_mask = 0;
191 	clr_mask = LM75_SHUTDOWN;		/* continuous conversions */
192 
193 	switch (kind) {
194 	case adt75:
195 		clr_mask |= 1 << 5;		/* not one-shot mode */
196 		data->resolution = 12;
197 		data->sample_time = HZ / 8;
198 		break;
199 	case ds1775:
200 	case ds75:
201 	case stds75:
202 		clr_mask |= 3 << 5;
203 		set_mask |= 2 << 5;		/* 11-bit mode */
204 		data->resolution = 11;
205 		data->sample_time = HZ;
206 		break;
207 	case ds7505:
208 		set_mask |= 3 << 5;		/* 12-bit mode */
209 		data->resolution = 12;
210 		data->sample_time = HZ / 4;
211 		break;
212 	case g751:
213 	case lm75:
214 	case lm75a:
215 		data->resolution = 9;
216 		data->sample_time = HZ / 2;
217 		break;
218 	case max6625:
219 		data->resolution = 9;
220 		data->sample_time = HZ / 4;
221 		break;
222 	case max6626:
223 		data->resolution = 12;
224 		data->resolution_limits = 9;
225 		data->sample_time = HZ / 4;
226 		break;
227 	case tcn75:
228 		data->resolution = 9;
229 		data->sample_time = HZ / 8;
230 		break;
231 	case mcp980x:
232 		data->resolution_limits = 9;
233 		/* fall through */
234 	case tmp100:
235 	case tmp101:
236 		set_mask |= 3 << 5;		/* 12-bit mode */
237 		data->resolution = 12;
238 		data->sample_time = HZ;
239 		clr_mask |= 1 << 7;		/* not one-shot mode */
240 		break;
241 	case tmp105:
242 	case tmp175:
243 	case tmp275:
244 	case tmp75:
245 		set_mask |= 3 << 5;		/* 12-bit mode */
246 		clr_mask |= 1 << 7;		/* not one-shot mode */
247 		data->resolution = 12;
248 		data->sample_time = HZ / 2;
249 		break;
250 	}
251 
252 	/* configure as specified */
253 	status = lm75_read_value(client, LM75_REG_CONF);
254 	if (status < 0) {
255 		dev_dbg(&client->dev, "Can't read config? %d\n", status);
256 		return status;
257 	}
258 	data->orig_conf = status;
259 	new = status & ~clr_mask;
260 	new |= set_mask;
261 	if (status != new)
262 		lm75_write_value(client, LM75_REG_CONF, new);
263 	dev_dbg(&client->dev, "Config %02x\n", new);
264 
265 	/* Register sysfs hooks */
266 	status = sysfs_create_group(&client->dev.kobj, &lm75_group);
267 	if (status)
268 		return status;
269 
270 	data->hwmon_dev = hwmon_device_register(&client->dev);
271 	if (IS_ERR(data->hwmon_dev)) {
272 		status = PTR_ERR(data->hwmon_dev);
273 		goto exit_remove;
274 	}
275 
276 	dev_info(&client->dev, "%s: sensor '%s'\n",
277 		 dev_name(data->hwmon_dev), client->name);
278 
279 	return 0;
280 
281 exit_remove:
282 	sysfs_remove_group(&client->dev.kobj, &lm75_group);
283 	return status;
284 }
285 
286 static int lm75_remove(struct i2c_client *client)
287 {
288 	struct lm75_data *data = i2c_get_clientdata(client);
289 
290 	hwmon_device_unregister(data->hwmon_dev);
291 	sysfs_remove_group(&client->dev.kobj, &lm75_group);
292 	lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
293 	return 0;
294 }
295 
296 static const struct i2c_device_id lm75_ids[] = {
297 	{ "adt75", adt75, },
298 	{ "ds1775", ds1775, },
299 	{ "ds75", ds75, },
300 	{ "ds7505", ds7505, },
301 	{ "g751", g751, },
302 	{ "lm75", lm75, },
303 	{ "lm75a", lm75a, },
304 	{ "max6625", max6625, },
305 	{ "max6626", max6626, },
306 	{ "mcp980x", mcp980x, },
307 	{ "stds75", stds75, },
308 	{ "tcn75", tcn75, },
309 	{ "tmp100", tmp100, },
310 	{ "tmp101", tmp101, },
311 	{ "tmp105", tmp105, },
312 	{ "tmp175", tmp175, },
313 	{ "tmp275", tmp275, },
314 	{ "tmp75", tmp75, },
315 	{ /* LIST END */ }
316 };
317 MODULE_DEVICE_TABLE(i2c, lm75_ids);
318 
319 #define LM75A_ID 0xA1
320 
321 /* Return 0 if detection is successful, -ENODEV otherwise */
322 static int lm75_detect(struct i2c_client *new_client,
323 		       struct i2c_board_info *info)
324 {
325 	struct i2c_adapter *adapter = new_client->adapter;
326 	int i;
327 	int conf, hyst, os;
328 	bool is_lm75a = 0;
329 
330 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
331 				     I2C_FUNC_SMBUS_WORD_DATA))
332 		return -ENODEV;
333 
334 	/*
335 	 * Now, we do the remaining detection. There is no identification-
336 	 * dedicated register so we have to rely on several tricks:
337 	 * unused bits, registers cycling over 8-address boundaries,
338 	 * addresses 0x04-0x07 returning the last read value.
339 	 * The cycling+unused addresses combination is not tested,
340 	 * since it would significantly slow the detection down and would
341 	 * hardly add any value.
342 	 *
343 	 * The National Semiconductor LM75A is different than earlier
344 	 * LM75s.  It has an ID byte of 0xaX (where X is the chip
345 	 * revision, with 1 being the only revision in existence) in
346 	 * register 7, and unused registers return 0xff rather than the
347 	 * last read value.
348 	 *
349 	 * Note that this function only detects the original National
350 	 * Semiconductor LM75 and the LM75A. Clones from other vendors
351 	 * aren't detected, on purpose, because they are typically never
352 	 * found on PC hardware. They are found on embedded designs where
353 	 * they can be instantiated explicitly so detection is not needed.
354 	 * The absence of identification registers on all these clones
355 	 * would make their exhaustive detection very difficult and weak,
356 	 * and odds are that the driver would bind to unsupported devices.
357 	 */
358 
359 	/* Unused bits */
360 	conf = i2c_smbus_read_byte_data(new_client, 1);
361 	if (conf & 0xe0)
362 		return -ENODEV;
363 
364 	/* First check for LM75A */
365 	if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
366 		/* LM75A returns 0xff on unused registers so
367 		   just to be sure we check for that too. */
368 		if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
369 		 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
370 		 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
371 			return -ENODEV;
372 		is_lm75a = 1;
373 		hyst = i2c_smbus_read_byte_data(new_client, 2);
374 		os = i2c_smbus_read_byte_data(new_client, 3);
375 	} else { /* Traditional style LM75 detection */
376 		/* Unused addresses */
377 		hyst = i2c_smbus_read_byte_data(new_client, 2);
378 		if (i2c_smbus_read_byte_data(new_client, 4) != hyst
379 		 || i2c_smbus_read_byte_data(new_client, 5) != hyst
380 		 || i2c_smbus_read_byte_data(new_client, 6) != hyst
381 		 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
382 			return -ENODEV;
383 		os = i2c_smbus_read_byte_data(new_client, 3);
384 		if (i2c_smbus_read_byte_data(new_client, 4) != os
385 		 || i2c_smbus_read_byte_data(new_client, 5) != os
386 		 || i2c_smbus_read_byte_data(new_client, 6) != os
387 		 || i2c_smbus_read_byte_data(new_client, 7) != os)
388 			return -ENODEV;
389 	}
390 
391 	/* Addresses cycling */
392 	for (i = 8; i <= 248; i += 40) {
393 		if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
394 		 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
395 		 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
396 			return -ENODEV;
397 		if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
398 				!= LM75A_ID)
399 			return -ENODEV;
400 	}
401 
402 	strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
403 
404 	return 0;
405 }
406 
407 #ifdef CONFIG_PM
408 static int lm75_suspend(struct device *dev)
409 {
410 	int status;
411 	struct i2c_client *client = to_i2c_client(dev);
412 	status = lm75_read_value(client, LM75_REG_CONF);
413 	if (status < 0) {
414 		dev_dbg(&client->dev, "Can't read config? %d\n", status);
415 		return status;
416 	}
417 	status = status | LM75_SHUTDOWN;
418 	lm75_write_value(client, LM75_REG_CONF, status);
419 	return 0;
420 }
421 
422 static int lm75_resume(struct device *dev)
423 {
424 	int status;
425 	struct i2c_client *client = to_i2c_client(dev);
426 	status = lm75_read_value(client, LM75_REG_CONF);
427 	if (status < 0) {
428 		dev_dbg(&client->dev, "Can't read config? %d\n", status);
429 		return status;
430 	}
431 	status = status & ~LM75_SHUTDOWN;
432 	lm75_write_value(client, LM75_REG_CONF, status);
433 	return 0;
434 }
435 
436 static const struct dev_pm_ops lm75_dev_pm_ops = {
437 	.suspend	= lm75_suspend,
438 	.resume		= lm75_resume,
439 };
440 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
441 #else
442 #define LM75_DEV_PM_OPS NULL
443 #endif /* CONFIG_PM */
444 
445 static struct i2c_driver lm75_driver = {
446 	.class		= I2C_CLASS_HWMON,
447 	.driver = {
448 		.name	= "lm75",
449 		.pm	= LM75_DEV_PM_OPS,
450 	},
451 	.probe		= lm75_probe,
452 	.remove		= lm75_remove,
453 	.id_table	= lm75_ids,
454 	.detect		= lm75_detect,
455 	.address_list	= normal_i2c,
456 };
457 
458 /*-----------------------------------------------------------------------*/
459 
460 /* register access */
461 
462 /*
463  * All registers are word-sized, except for the configuration register.
464  * LM75 uses a high-byte first convention, which is exactly opposite to
465  * the SMBus standard.
466  */
467 static int lm75_read_value(struct i2c_client *client, u8 reg)
468 {
469 	if (reg == LM75_REG_CONF)
470 		return i2c_smbus_read_byte_data(client, reg);
471 	else
472 		return i2c_smbus_read_word_swapped(client, reg);
473 }
474 
475 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
476 {
477 	if (reg == LM75_REG_CONF)
478 		return i2c_smbus_write_byte_data(client, reg, value);
479 	else
480 		return i2c_smbus_write_word_swapped(client, reg, value);
481 }
482 
483 static struct lm75_data *lm75_update_device(struct device *dev)
484 {
485 	struct i2c_client *client = to_i2c_client(dev);
486 	struct lm75_data *data = i2c_get_clientdata(client);
487 	struct lm75_data *ret = data;
488 
489 	mutex_lock(&data->update_lock);
490 
491 	if (time_after(jiffies, data->last_updated + data->sample_time)
492 	    || !data->valid) {
493 		int i;
494 		dev_dbg(&client->dev, "Starting lm75 update\n");
495 
496 		for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
497 			int status;
498 
499 			status = lm75_read_value(client, LM75_REG_TEMP[i]);
500 			if (unlikely(status < 0)) {
501 				dev_dbg(dev,
502 					"LM75: Failed to read value: reg %d, error %d\n",
503 					LM75_REG_TEMP[i], status);
504 				ret = ERR_PTR(status);
505 				data->valid = 0;
506 				goto abort;
507 			}
508 			data->temp[i] = status;
509 		}
510 		data->last_updated = jiffies;
511 		data->valid = 1;
512 	}
513 
514 abort:
515 	mutex_unlock(&data->update_lock);
516 	return ret;
517 }
518 
519 module_i2c_driver(lm75_driver);
520 
521 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
522 MODULE_DESCRIPTION("LM75 driver");
523 MODULE_LICENSE("GPL");
524