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