1/*
2 * lm77.c - Part of lm_sensors, Linux kernel modules for hardware
3 *	    monitoring
4 *
5 * Copyright (c) 2004  Andras BALI <drewie@freemail.hu>
6 *
7 * Heavily based on lm75.c by Frodo Looijaard <frodol@dds.nl>.  The LM77
8 * is a temperature sensor and thermal window comparator with 0.5 deg
9 * resolution made by National Semiconductor.  Complete datasheet can be
10 * obtained at their site:
11 *	http://www.national.com/pf/LM/LM77.html
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 * GNU General Public License for more details.
22 */
23
24#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/slab.h>
27#include <linux/jiffies.h>
28#include <linux/i2c.h>
29#include <linux/hwmon.h>
30#include <linux/hwmon-sysfs.h>
31#include <linux/err.h>
32#include <linux/mutex.h>
33
34/* Addresses to scan */
35static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b,
36						I2C_CLIENT_END };
37
38/* The LM77 registers */
39#define LM77_REG_TEMP		0x00
40#define LM77_REG_CONF		0x01
41#define LM77_REG_TEMP_HYST	0x02
42#define LM77_REG_TEMP_CRIT	0x03
43#define LM77_REG_TEMP_MIN	0x04
44#define LM77_REG_TEMP_MAX	0x05
45
46enum temp_index {
47	t_input = 0,
48	t_crit,
49	t_min,
50	t_max,
51	t_hyst,
52	t_num_temp
53};
54
55static const u8 temp_regs[t_num_temp] = {
56	[t_input] = LM77_REG_TEMP,
57	[t_min] = LM77_REG_TEMP_MIN,
58	[t_max] = LM77_REG_TEMP_MAX,
59	[t_crit] = LM77_REG_TEMP_CRIT,
60	[t_hyst] = LM77_REG_TEMP_HYST,
61};
62
63/* Each client has this additional data */
64struct lm77_data {
65	struct i2c_client	*client;
66	struct mutex		update_lock;
67	char			valid;
68	unsigned long		last_updated;	/* In jiffies */
69	int			temp[t_num_temp]; /* index using temp_index */
70	u8			alarms;
71};
72
73/* straight from the datasheet */
74#define LM77_TEMP_MIN (-55000)
75#define LM77_TEMP_MAX 125000
76
77/*
78 * In the temperature registers, the low 3 bits are not part of the
79 * temperature values; they are the status bits.
80 */
81static inline s16 LM77_TEMP_TO_REG(int temp)
82{
83	return (temp / 500) * 8;
84}
85
86static inline int LM77_TEMP_FROM_REG(s16 reg)
87{
88	return (reg / 8) * 500;
89}
90
91/*
92 * All registers are word-sized, except for the configuration register.
93 * The LM77 uses the high-byte first convention.
94 */
95static u16 lm77_read_value(struct i2c_client *client, u8 reg)
96{
97	if (reg == LM77_REG_CONF)
98		return i2c_smbus_read_byte_data(client, reg);
99	else
100		return i2c_smbus_read_word_swapped(client, reg);
101}
102
103static int lm77_write_value(struct i2c_client *client, u8 reg, u16 value)
104{
105	if (reg == LM77_REG_CONF)
106		return i2c_smbus_write_byte_data(client, reg, value);
107	else
108		return i2c_smbus_write_word_swapped(client, reg, value);
109}
110
111static struct lm77_data *lm77_update_device(struct device *dev)
112{
113	struct lm77_data *data = dev_get_drvdata(dev);
114	struct i2c_client *client = data->client;
115	int i;
116
117	mutex_lock(&data->update_lock);
118
119	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
120	    || !data->valid) {
121		dev_dbg(&client->dev, "Starting lm77 update\n");
122		for (i = 0; i < t_num_temp; i++) {
123			data->temp[i] =
124			  LM77_TEMP_FROM_REG(lm77_read_value(client,
125							     temp_regs[i]));
126		}
127		data->alarms =
128			lm77_read_value(client, LM77_REG_TEMP) & 0x0007;
129		data->last_updated = jiffies;
130		data->valid = 1;
131	}
132
133	mutex_unlock(&data->update_lock);
134
135	return data;
136}
137
138/* sysfs stuff */
139
140static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
141			 char *buf)
142{
143	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
144	struct lm77_data *data = lm77_update_device(dev);
145
146	return sprintf(buf, "%d\n", data->temp[attr->index]);
147}
148
149static ssize_t show_temp_hyst(struct device *dev,
150			      struct device_attribute *devattr, char *buf)
151{
152	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
153	struct lm77_data *data = lm77_update_device(dev);
154	int nr = attr->index;
155	int temp;
156
157	temp = nr == t_min ? data->temp[nr] + data->temp[t_hyst] :
158			     data->temp[nr] - data->temp[t_hyst];
159
160	return sprintf(buf, "%d\n", temp);
161}
162
163static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,
164			const char *buf, size_t count)
165{
166	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
167	struct lm77_data *data = dev_get_drvdata(dev);
168	struct i2c_client *client = data->client;
169	int nr = attr->index;
170	long val;
171	int err;
172
173	err = kstrtol(buf, 10, &val);
174	if (err)
175		return err;
176
177	val = clamp_val(val, LM77_TEMP_MIN, LM77_TEMP_MAX);
178	mutex_lock(&data->update_lock);
179	data->temp[nr] = val;
180	lm77_write_value(client, temp_regs[nr], LM77_TEMP_TO_REG(val));
181	mutex_unlock(&data->update_lock);
182	return count;
183}
184
185/*
186 * hysteresis is stored as a relative value on the chip, so it has to be
187 * converted first.
188 */
189static ssize_t set_temp_hyst(struct device *dev,
190			     struct device_attribute *devattr,
191			     const char *buf, size_t count)
192{
193	struct lm77_data *data = dev_get_drvdata(dev);
194	struct i2c_client *client = data->client;
195	long val;
196	int err;
197
198	err = kstrtol(buf, 10, &val);
199	if (err)
200		return err;
201
202	mutex_lock(&data->update_lock);
203	val = clamp_val(data->temp[t_crit] - val, LM77_TEMP_MIN, LM77_TEMP_MAX);
204	data->temp[t_hyst] = val;
205	lm77_write_value(client, LM77_REG_TEMP_HYST,
206			 LM77_TEMP_TO_REG(data->temp[t_hyst]));
207	mutex_unlock(&data->update_lock);
208	return count;
209}
210
211static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
212			  char *buf)
213{
214	int bitnr = to_sensor_dev_attr(attr)->index;
215	struct lm77_data *data = lm77_update_device(dev);
216	return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
217}
218
219static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, t_input);
220static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp, set_temp,
221			  t_crit);
222static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp, set_temp,
223			  t_min);
224static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp, set_temp,
225			  t_max);
226
227static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_hyst,
228			  set_temp_hyst, t_crit);
229static SENSOR_DEVICE_ATTR(temp1_min_hyst, S_IRUGO, show_temp_hyst, NULL, t_min);
230static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO, show_temp_hyst, NULL, t_max);
231
232static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 2);
233static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 0);
234static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 1);
235
236static struct attribute *lm77_attrs[] = {
237	&sensor_dev_attr_temp1_input.dev_attr.attr,
238	&sensor_dev_attr_temp1_crit.dev_attr.attr,
239	&sensor_dev_attr_temp1_min.dev_attr.attr,
240	&sensor_dev_attr_temp1_max.dev_attr.attr,
241	&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
242	&sensor_dev_attr_temp1_min_hyst.dev_attr.attr,
243	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
244	&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
245	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
246	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
247	NULL
248};
249ATTRIBUTE_GROUPS(lm77);
250
251/* Return 0 if detection is successful, -ENODEV otherwise */
252static int lm77_detect(struct i2c_client *client, struct i2c_board_info *info)
253{
254	struct i2c_adapter *adapter = client->adapter;
255	int i, cur, conf, hyst, crit, min, max;
256
257	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
258				     I2C_FUNC_SMBUS_WORD_DATA))
259		return -ENODEV;
260
261	/*
262	 * Here comes the remaining detection.  Since the LM77 has no
263	 * register dedicated to identification, we have to rely on the
264	 * following tricks:
265	 *
266	 * 1. the high 4 bits represent the sign and thus they should
267	 *    always be the same
268	 * 2. the high 3 bits are unused in the configuration register
269	 * 3. addresses 0x06 and 0x07 return the last read value
270	 * 4. registers cycling over 8-address boundaries
271	 *
272	 * Word-sized registers are high-byte first.
273	 */
274
275	/* addresses cycling */
276	cur = i2c_smbus_read_word_data(client, 0);
277	conf = i2c_smbus_read_byte_data(client, 1);
278	hyst = i2c_smbus_read_word_data(client, 2);
279	crit = i2c_smbus_read_word_data(client, 3);
280	min = i2c_smbus_read_word_data(client, 4);
281	max = i2c_smbus_read_word_data(client, 5);
282	for (i = 8; i <= 0xff; i += 8) {
283		if (i2c_smbus_read_byte_data(client, i + 1) != conf
284		 || i2c_smbus_read_word_data(client, i + 2) != hyst
285		 || i2c_smbus_read_word_data(client, i + 3) != crit
286		 || i2c_smbus_read_word_data(client, i + 4) != min
287		 || i2c_smbus_read_word_data(client, i + 5) != max)
288			return -ENODEV;
289	}
290
291	/* sign bits */
292	if (((cur & 0x00f0) != 0xf0 && (cur & 0x00f0) != 0x0)
293	 || ((hyst & 0x00f0) != 0xf0 && (hyst & 0x00f0) != 0x0)
294	 || ((crit & 0x00f0) != 0xf0 && (crit & 0x00f0) != 0x0)
295	 || ((min & 0x00f0) != 0xf0 && (min & 0x00f0) != 0x0)
296	 || ((max & 0x00f0) != 0xf0 && (max & 0x00f0) != 0x0))
297		return -ENODEV;
298
299	/* unused bits */
300	if (conf & 0xe0)
301		return -ENODEV;
302
303	/* 0x06 and 0x07 return the last read value */
304	cur = i2c_smbus_read_word_data(client, 0);
305	if (i2c_smbus_read_word_data(client, 6) != cur
306	 || i2c_smbus_read_word_data(client, 7) != cur)
307		return -ENODEV;
308	hyst = i2c_smbus_read_word_data(client, 2);
309	if (i2c_smbus_read_word_data(client, 6) != hyst
310	 || i2c_smbus_read_word_data(client, 7) != hyst)
311		return -ENODEV;
312	min = i2c_smbus_read_word_data(client, 4);
313	if (i2c_smbus_read_word_data(client, 6) != min
314	 || i2c_smbus_read_word_data(client, 7) != min)
315		return -ENODEV;
316
317	strlcpy(info->type, "lm77", I2C_NAME_SIZE);
318
319	return 0;
320}
321
322static void lm77_init_client(struct i2c_client *client)
323{
324	/* Initialize the LM77 chip - turn off shutdown mode */
325	int conf = lm77_read_value(client, LM77_REG_CONF);
326	if (conf & 1)
327		lm77_write_value(client, LM77_REG_CONF, conf & 0xfe);
328}
329
330static int lm77_probe(struct i2c_client *client, const struct i2c_device_id *id)
331{
332	struct device *dev = &client->dev;
333	struct device *hwmon_dev;
334	struct lm77_data *data;
335
336	data = devm_kzalloc(dev, sizeof(struct lm77_data), GFP_KERNEL);
337	if (!data)
338		return -ENOMEM;
339
340	data->client = client;
341	mutex_init(&data->update_lock);
342
343	/* Initialize the LM77 chip */
344	lm77_init_client(client);
345
346	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
347							   data, lm77_groups);
348	return PTR_ERR_OR_ZERO(hwmon_dev);
349}
350
351static const struct i2c_device_id lm77_id[] = {
352	{ "lm77", 0 },
353	{ }
354};
355MODULE_DEVICE_TABLE(i2c, lm77_id);
356
357/* This is the driver that will be inserted */
358static struct i2c_driver lm77_driver = {
359	.class		= I2C_CLASS_HWMON,
360	.driver = {
361		.name	= "lm77",
362	},
363	.probe		= lm77_probe,
364	.id_table	= lm77_id,
365	.detect		= lm77_detect,
366	.address_list	= normal_i2c,
367};
368
369module_i2c_driver(lm77_driver);
370
371MODULE_AUTHOR("Andras BALI <drewie@freemail.hu>");
372MODULE_DESCRIPTION("LM77 driver");
373MODULE_LICENSE("GPL");
374