xref: /openbmc/linux/drivers/hwmon/lm77.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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     You should have received a copy of the GNU General Public License
24     along with this program; if not, write to the Free Software
25     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 */
27 
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/jiffies.h>
32 #include <linux/i2c.h>
33 #include <linux/hwmon.h>
34 #include <linux/err.h>
35 
36 /* Addresses to scan */
37 static unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, I2C_CLIENT_END };
38 
39 /* Insmod parameters */
40 I2C_CLIENT_INSMOD_1(lm77);
41 
42 /* The LM77 registers */
43 #define LM77_REG_TEMP		0x00
44 #define LM77_REG_CONF		0x01
45 #define LM77_REG_TEMP_HYST	0x02
46 #define LM77_REG_TEMP_CRIT	0x03
47 #define LM77_REG_TEMP_MIN	0x04
48 #define LM77_REG_TEMP_MAX	0x05
49 
50 /* Each client has this additional data */
51 struct lm77_data {
52 	struct i2c_client	client;
53 	struct class_device *class_dev;
54 	struct semaphore	update_lock;
55 	char			valid;
56 	unsigned long		last_updated;	/* In jiffies */
57 	int			temp_input;	/* Temperatures */
58 	int			temp_crit;
59 	int			temp_min;
60 	int			temp_max;
61 	int			temp_hyst;
62 	u8			alarms;
63 };
64 
65 static int lm77_attach_adapter(struct i2c_adapter *adapter);
66 static int lm77_detect(struct i2c_adapter *adapter, int address, int kind);
67 static void lm77_init_client(struct i2c_client *client);
68 static int lm77_detach_client(struct i2c_client *client);
69 static u16 lm77_read_value(struct i2c_client *client, u8 reg);
70 static int lm77_write_value(struct i2c_client *client, u8 reg, u16 value);
71 
72 static struct lm77_data *lm77_update_device(struct device *dev);
73 
74 
75 /* This is the driver that will be inserted */
76 static struct i2c_driver lm77_driver = {
77 	.owner		= THIS_MODULE,
78 	.name		= "lm77",
79 	.flags		= I2C_DF_NOTIFY,
80 	.attach_adapter = lm77_attach_adapter,
81 	.detach_client	= lm77_detach_client,
82 };
83 
84 /* straight from the datasheet */
85 #define LM77_TEMP_MIN (-55000)
86 #define LM77_TEMP_MAX 125000
87 
88 /* In the temperature registers, the low 3 bits are not part of the
89    temperature values; they are the status bits. */
90 static inline u16 LM77_TEMP_TO_REG(int temp)
91 {
92 	int ntemp = SENSORS_LIMIT(temp, LM77_TEMP_MIN, LM77_TEMP_MAX);
93 	return (u16)((ntemp / 500) * 8);
94 }
95 
96 static inline int LM77_TEMP_FROM_REG(u16 reg)
97 {
98 	return ((int)reg / 8) * 500;
99 }
100 
101 /* sysfs stuff */
102 
103 /* read routines for temperature limits */
104 #define show(value)	\
105 static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf)	\
106 {								\
107 	struct lm77_data *data = lm77_update_device(dev);	\
108 	return sprintf(buf, "%d\n", data->value);		\
109 }
110 
111 show(temp_input);
112 show(temp_crit);
113 show(temp_min);
114 show(temp_max);
115 show(alarms);
116 
117 /* read routines for hysteresis values */
118 static ssize_t show_temp_crit_hyst(struct device *dev, struct device_attribute *attr, char *buf)
119 {
120 	struct lm77_data *data = lm77_update_device(dev);
121 	return sprintf(buf, "%d\n", data->temp_crit - data->temp_hyst);
122 }
123 static ssize_t show_temp_min_hyst(struct device *dev, struct device_attribute *attr, char *buf)
124 {
125 	struct lm77_data *data = lm77_update_device(dev);
126 	return sprintf(buf, "%d\n", data->temp_min + data->temp_hyst);
127 }
128 static ssize_t show_temp_max_hyst(struct device *dev, struct device_attribute *attr, char *buf)
129 {
130 	struct lm77_data *data = lm77_update_device(dev);
131 	return sprintf(buf, "%d\n", data->temp_max - data->temp_hyst);
132 }
133 
134 /* write routines */
135 #define set(value, reg)	\
136 static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)	\
137 {										\
138 	struct i2c_client *client = to_i2c_client(dev);				\
139 	struct lm77_data *data = i2c_get_clientdata(client);			\
140 	long val = simple_strtoul(buf, NULL, 10);				\
141 										\
142 	down(&data->update_lock);						\
143 	data->value = val;				\
144 	lm77_write_value(client, reg, LM77_TEMP_TO_REG(data->value));		\
145 	up(&data->update_lock);							\
146 	return count;								\
147 }
148 
149 set(temp_min, LM77_REG_TEMP_MIN);
150 set(temp_max, LM77_REG_TEMP_MAX);
151 
152 /* hysteresis is stored as a relative value on the chip, so it has to be
153    converted first */
154 static ssize_t set_temp_crit_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
155 {
156 	struct i2c_client *client = to_i2c_client(dev);
157 	struct lm77_data *data = i2c_get_clientdata(client);
158 	unsigned long val = simple_strtoul(buf, NULL, 10);
159 
160 	down(&data->update_lock);
161 	data->temp_hyst = data->temp_crit - val;
162 	lm77_write_value(client, LM77_REG_TEMP_HYST,
163 			 LM77_TEMP_TO_REG(data->temp_hyst));
164 	up(&data->update_lock);
165 	return count;
166 }
167 
168 /* preserve hysteresis when setting T_crit */
169 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
170 {
171 	struct i2c_client *client = to_i2c_client(dev);
172 	struct lm77_data *data = i2c_get_clientdata(client);
173 	long val = simple_strtoul(buf, NULL, 10);
174 	int oldcrithyst;
175 
176 	down(&data->update_lock);
177 	oldcrithyst = data->temp_crit - data->temp_hyst;
178 	data->temp_crit = val;
179 	data->temp_hyst = data->temp_crit - oldcrithyst;
180 	lm77_write_value(client, LM77_REG_TEMP_CRIT,
181 			 LM77_TEMP_TO_REG(data->temp_crit));
182 	lm77_write_value(client, LM77_REG_TEMP_HYST,
183 			 LM77_TEMP_TO_REG(data->temp_hyst));
184 	up(&data->update_lock);
185 	return count;
186 }
187 
188 static DEVICE_ATTR(temp1_input, S_IRUGO,
189 		   show_temp_input, NULL);
190 static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO,
191 		   show_temp_crit, set_temp_crit);
192 static DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
193 		   show_temp_min, set_temp_min);
194 static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
195 		   show_temp_max, set_temp_max);
196 
197 static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO,
198 		   show_temp_crit_hyst, set_temp_crit_hyst);
199 static DEVICE_ATTR(temp1_min_hyst, S_IRUGO,
200 		   show_temp_min_hyst, NULL);
201 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO,
202 		   show_temp_max_hyst, NULL);
203 
204 static DEVICE_ATTR(alarms, S_IRUGO,
205 		   show_alarms, NULL);
206 
207 static int lm77_attach_adapter(struct i2c_adapter *adapter)
208 {
209 	if (!(adapter->class & I2C_CLASS_HWMON))
210 		return 0;
211 	return i2c_probe(adapter, &addr_data, lm77_detect);
212 }
213 
214 /* This function is called by i2c_probe */
215 static int lm77_detect(struct i2c_adapter *adapter, int address, int kind)
216 {
217 	struct i2c_client *new_client;
218 	struct lm77_data *data;
219 	int err = 0;
220 	const char *name = "";
221 
222 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
223 				     I2C_FUNC_SMBUS_WORD_DATA))
224 		goto exit;
225 
226 	/* OK. For now, we presume we have a valid client. We now create the
227 	   client structure, even though we cannot fill it completely yet.
228 	   But it allows us to access lm77_{read,write}_value. */
229 	if (!(data = kzalloc(sizeof(struct lm77_data), GFP_KERNEL))) {
230 		err = -ENOMEM;
231 		goto exit;
232 	}
233 
234 	new_client = &data->client;
235 	i2c_set_clientdata(new_client, data);
236 	new_client->addr = address;
237 	new_client->adapter = adapter;
238 	new_client->driver = &lm77_driver;
239 	new_client->flags = 0;
240 
241 	/* Here comes the remaining detection.  Since the LM77 has no
242 	   register dedicated to identification, we have to rely on the
243 	   following tricks:
244 
245 	   1. the high 4 bits represent the sign and thus they should
246 	      always be the same
247 	   2. the high 3 bits are unused in the configuration register
248 	   3. addresses 0x06 and 0x07 return the last read value
249 	   4. registers cycling over 8-address boundaries
250 
251 	   Word-sized registers are high-byte first. */
252 	if (kind < 0) {
253 		int i, cur, conf, hyst, crit, min, max;
254 
255 		/* addresses cycling */
256 		cur = i2c_smbus_read_word_data(new_client, 0);
257 		conf = i2c_smbus_read_byte_data(new_client, 1);
258 		hyst = i2c_smbus_read_word_data(new_client, 2);
259 		crit = i2c_smbus_read_word_data(new_client, 3);
260 		min = i2c_smbus_read_word_data(new_client, 4);
261 		max = i2c_smbus_read_word_data(new_client, 5);
262 		for (i = 8; i <= 0xff; i += 8)
263 			if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
264 			    || i2c_smbus_read_word_data(new_client, i + 2) != hyst
265 			    || i2c_smbus_read_word_data(new_client, i + 3) != crit
266 			    || i2c_smbus_read_word_data(new_client, i + 4) != min
267 			    || i2c_smbus_read_word_data(new_client, i + 5) != max)
268 				goto exit_free;
269 
270 		/* sign bits */
271 		if (((cur & 0x00f0) != 0xf0 && (cur & 0x00f0) != 0x0)
272 		    || ((hyst & 0x00f0) != 0xf0 && (hyst & 0x00f0) != 0x0)
273 		    || ((crit & 0x00f0) != 0xf0 && (crit & 0x00f0) != 0x0)
274 		    || ((min & 0x00f0) != 0xf0 && (min & 0x00f0) != 0x0)
275 		    || ((max & 0x00f0) != 0xf0 && (max & 0x00f0) != 0x0))
276 			goto exit_free;
277 
278 		/* unused bits */
279 		if (conf & 0xe0)
280 			goto exit_free;
281 
282 		/* 0x06 and 0x07 return the last read value */
283 		cur = i2c_smbus_read_word_data(new_client, 0);
284 		if (i2c_smbus_read_word_data(new_client, 6) != cur
285 		    || i2c_smbus_read_word_data(new_client, 7) != cur)
286 			goto exit_free;
287 		hyst = i2c_smbus_read_word_data(new_client, 2);
288 		if (i2c_smbus_read_word_data(new_client, 6) != hyst
289 		    || i2c_smbus_read_word_data(new_client, 7) != hyst)
290 			goto exit_free;
291 		min = i2c_smbus_read_word_data(new_client, 4);
292 		if (i2c_smbus_read_word_data(new_client, 6) != min
293 		    || i2c_smbus_read_word_data(new_client, 7) != min)
294 			goto exit_free;
295 
296 	}
297 
298 	/* Determine the chip type - only one kind supported! */
299 	if (kind <= 0)
300 		kind = lm77;
301 
302 	if (kind == lm77) {
303 		name = "lm77";
304 	}
305 
306 	/* Fill in the remaining client fields and put it into the global list */
307 	strlcpy(new_client->name, name, I2C_NAME_SIZE);
308 	data->valid = 0;
309 	init_MUTEX(&data->update_lock);
310 
311 	/* Tell the I2C layer a new client has arrived */
312 	if ((err = i2c_attach_client(new_client)))
313 		goto exit_free;
314 
315 	/* Initialize the LM77 chip */
316 	lm77_init_client(new_client);
317 
318 	/* Register sysfs hooks */
319 	data->class_dev = hwmon_device_register(&new_client->dev);
320 	if (IS_ERR(data->class_dev)) {
321 		err = PTR_ERR(data->class_dev);
322 		goto exit_detach;
323 	}
324 
325 	device_create_file(&new_client->dev, &dev_attr_temp1_input);
326 	device_create_file(&new_client->dev, &dev_attr_temp1_crit);
327 	device_create_file(&new_client->dev, &dev_attr_temp1_min);
328 	device_create_file(&new_client->dev, &dev_attr_temp1_max);
329 	device_create_file(&new_client->dev, &dev_attr_temp1_crit_hyst);
330 	device_create_file(&new_client->dev, &dev_attr_temp1_min_hyst);
331 	device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
332 	device_create_file(&new_client->dev, &dev_attr_alarms);
333 	return 0;
334 
335 exit_detach:
336 	i2c_detach_client(new_client);
337 exit_free:
338 	kfree(data);
339 exit:
340 	return err;
341 }
342 
343 static int lm77_detach_client(struct i2c_client *client)
344 {
345 	struct lm77_data *data = i2c_get_clientdata(client);
346 	hwmon_device_unregister(data->class_dev);
347 	i2c_detach_client(client);
348 	kfree(data);
349 	return 0;
350 }
351 
352 /* All registers are word-sized, except for the configuration register.
353    The LM77 uses the high-byte first convention. */
354 static u16 lm77_read_value(struct i2c_client *client, u8 reg)
355 {
356 	if (reg == LM77_REG_CONF)
357 		return i2c_smbus_read_byte_data(client, reg);
358 	else
359 		return swab16(i2c_smbus_read_word_data(client, reg));
360 }
361 
362 static int lm77_write_value(struct i2c_client *client, u8 reg, u16 value)
363 {
364 	if (reg == LM77_REG_CONF)
365 		return i2c_smbus_write_byte_data(client, reg, value);
366 	else
367 		return i2c_smbus_write_word_data(client, reg, swab16(value));
368 }
369 
370 static void lm77_init_client(struct i2c_client *client)
371 {
372 	/* Initialize the LM77 chip - turn off shutdown mode */
373 	int conf = lm77_read_value(client, LM77_REG_CONF);
374 	if (conf & 1)
375 		lm77_write_value(client, LM77_REG_CONF, conf & 0xfe);
376 }
377 
378 static struct lm77_data *lm77_update_device(struct device *dev)
379 {
380 	struct i2c_client *client = to_i2c_client(dev);
381 	struct lm77_data *data = i2c_get_clientdata(client);
382 
383 	down(&data->update_lock);
384 
385 	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
386 	    || !data->valid) {
387 		dev_dbg(&client->dev, "Starting lm77 update\n");
388 		data->temp_input =
389 			LM77_TEMP_FROM_REG(lm77_read_value(client,
390 							   LM77_REG_TEMP));
391 		data->temp_hyst =
392 			LM77_TEMP_FROM_REG(lm77_read_value(client,
393 							   LM77_REG_TEMP_HYST));
394 		data->temp_crit =
395 			LM77_TEMP_FROM_REG(lm77_read_value(client,
396 							   LM77_REG_TEMP_CRIT));
397 		data->temp_min =
398 			LM77_TEMP_FROM_REG(lm77_read_value(client,
399 							   LM77_REG_TEMP_MIN));
400 		data->temp_max =
401 			LM77_TEMP_FROM_REG(lm77_read_value(client,
402 							   LM77_REG_TEMP_MAX));
403 		data->alarms =
404 			lm77_read_value(client, LM77_REG_TEMP) & 0x0007;
405 		data->last_updated = jiffies;
406 		data->valid = 1;
407 	}
408 
409 	up(&data->update_lock);
410 
411 	return data;
412 }
413 
414 static int __init sensors_lm77_init(void)
415 {
416 	return i2c_add_driver(&lm77_driver);
417 }
418 
419 static void __exit sensors_lm77_exit(void)
420 {
421 	i2c_del_driver(&lm77_driver);
422 }
423 
424 MODULE_AUTHOR("Andras BALI <drewie@freemail.hu>");
425 MODULE_DESCRIPTION("LM77 driver");
426 MODULE_LICENSE("GPL");
427 
428 module_init(sensors_lm77_init);
429 module_exit(sensors_lm77_exit);
430