xref: /openbmc/linux/drivers/hwmon/lm85.c (revision 4800cd83)
1 /*
2     lm85.c - Part of lm_sensors, Linux kernel modules for hardware
3              monitoring
4     Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
5     Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
6     Copyright (c) 2003        Margit Schubert-While <margitsw@t-online.de>
7     Copyright (c) 2004        Justin Thiessen <jthiessen@penguincomputing.com>
8     Copyright (C) 2007--2009  Jean Delvare <khali@linux-fr.org>
9 
10     Chip details at	      <http://www.national.com/ds/LM/LM85.pdf>
11 
12     This program is free software; you can redistribute it and/or modify
13     it under the terms of the GNU General Public License as published by
14     the Free Software Foundation; either version 2 of the License, or
15     (at your option) any later version.
16 
17     This program is distributed in the hope that it will be useful,
18     but WITHOUT ANY WARRANTY; without even the implied warranty of
19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20     GNU General Public License for more details.
21 
22     You should have received a copy of the GNU General Public License
23     along with this program; if not, write to the Free Software
24     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26 
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/jiffies.h>
31 #include <linux/i2c.h>
32 #include <linux/hwmon.h>
33 #include <linux/hwmon-vid.h>
34 #include <linux/hwmon-sysfs.h>
35 #include <linux/err.h>
36 #include <linux/mutex.h>
37 
38 /* Addresses to scan */
39 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
40 
41 enum chips {
42 	any_chip, lm85b, lm85c,
43 	adm1027, adt7463, adt7468,
44 	emc6d100, emc6d102, emc6d103
45 };
46 
47 /* The LM85 registers */
48 
49 #define	LM85_REG_IN(nr)			(0x20 + (nr))
50 #define	LM85_REG_IN_MIN(nr)		(0x44 + (nr) * 2)
51 #define	LM85_REG_IN_MAX(nr)		(0x45 + (nr) * 2)
52 
53 #define	LM85_REG_TEMP(nr)		(0x25 + (nr))
54 #define	LM85_REG_TEMP_MIN(nr)		(0x4e + (nr) * 2)
55 #define	LM85_REG_TEMP_MAX(nr)		(0x4f + (nr) * 2)
56 
57 /* Fan speeds are LSB, MSB (2 bytes) */
58 #define	LM85_REG_FAN(nr)		(0x28 + (nr) * 2)
59 #define	LM85_REG_FAN_MIN(nr)		(0x54 + (nr) * 2)
60 
61 #define	LM85_REG_PWM(nr)		(0x30 + (nr))
62 
63 #define	LM85_REG_COMPANY		0x3e
64 #define	LM85_REG_VERSTEP		0x3f
65 
66 #define	ADT7468_REG_CFG5		0x7c
67 #define		ADT7468_OFF64		(1 << 0)
68 #define		ADT7468_HFPWM		(1 << 1)
69 #define	IS_ADT7468_OFF64(data)		\
70 	((data)->type == adt7468 && !((data)->cfg5 & ADT7468_OFF64))
71 #define	IS_ADT7468_HFPWM(data)		\
72 	((data)->type == adt7468 && !((data)->cfg5 & ADT7468_HFPWM))
73 
74 /* These are the recognized values for the above regs */
75 #define	LM85_COMPANY_NATIONAL		0x01
76 #define	LM85_COMPANY_ANALOG_DEV		0x41
77 #define	LM85_COMPANY_SMSC		0x5c
78 #define	LM85_VERSTEP_VMASK              0xf0
79 #define	LM85_VERSTEP_GENERIC		0x60
80 #define	LM85_VERSTEP_GENERIC2		0x70
81 #define	LM85_VERSTEP_LM85C		0x60
82 #define	LM85_VERSTEP_LM85B		0x62
83 #define	LM85_VERSTEP_LM96000_1		0x68
84 #define	LM85_VERSTEP_LM96000_2		0x69
85 #define	LM85_VERSTEP_ADM1027		0x60
86 #define	LM85_VERSTEP_ADT7463		0x62
87 #define	LM85_VERSTEP_ADT7463C		0x6A
88 #define	LM85_VERSTEP_ADT7468_1		0x71
89 #define	LM85_VERSTEP_ADT7468_2		0x72
90 #define	LM85_VERSTEP_EMC6D100_A0        0x60
91 #define	LM85_VERSTEP_EMC6D100_A1        0x61
92 #define	LM85_VERSTEP_EMC6D102		0x65
93 #define	LM85_VERSTEP_EMC6D103_A0	0x68
94 #define	LM85_VERSTEP_EMC6D103_A1	0x69
95 #define	LM85_VERSTEP_EMC6D103S		0x6A	/* Also known as EMC6D103:A2 */
96 
97 #define	LM85_REG_CONFIG			0x40
98 
99 #define	LM85_REG_ALARM1			0x41
100 #define	LM85_REG_ALARM2			0x42
101 
102 #define	LM85_REG_VID			0x43
103 
104 /* Automated FAN control */
105 #define	LM85_REG_AFAN_CONFIG(nr)	(0x5c + (nr))
106 #define	LM85_REG_AFAN_RANGE(nr)		(0x5f + (nr))
107 #define	LM85_REG_AFAN_SPIKE1		0x62
108 #define	LM85_REG_AFAN_MINPWM(nr)	(0x64 + (nr))
109 #define	LM85_REG_AFAN_LIMIT(nr)		(0x67 + (nr))
110 #define	LM85_REG_AFAN_CRITICAL(nr)	(0x6a + (nr))
111 #define	LM85_REG_AFAN_HYST1		0x6d
112 #define	LM85_REG_AFAN_HYST2		0x6e
113 
114 #define	ADM1027_REG_EXTEND_ADC1		0x76
115 #define	ADM1027_REG_EXTEND_ADC2		0x77
116 
117 #define EMC6D100_REG_ALARM3             0x7d
118 /* IN5, IN6 and IN7 */
119 #define	EMC6D100_REG_IN(nr)             (0x70 + ((nr) - 5))
120 #define	EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr) - 5) * 2)
121 #define	EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr) - 5) * 2)
122 #define	EMC6D102_REG_EXTEND_ADC1	0x85
123 #define	EMC6D102_REG_EXTEND_ADC2	0x86
124 #define	EMC6D102_REG_EXTEND_ADC3	0x87
125 #define	EMC6D102_REG_EXTEND_ADC4	0x88
126 
127 
128 /* Conversions. Rounding and limit checking is only done on the TO_REG
129    variants. Note that you should be a bit careful with which arguments
130    these macros are called: arguments may be evaluated more than once.
131  */
132 
133 /* IN are scaled acording to built-in resistors */
134 static const int lm85_scaling[] = {  /* .001 Volts */
135 	2500, 2250, 3300, 5000, 12000,
136 	3300, 1500, 1800 /*EMC6D100*/
137 };
138 #define SCALE(val, from, to)	(((val) * (to) + ((from) / 2)) / (from))
139 
140 #define INS_TO_REG(n, val)	\
141 		SENSORS_LIMIT(SCALE(val, lm85_scaling[n], 192), 0, 255)
142 
143 #define INSEXT_FROM_REG(n, val, ext)	\
144 		SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n])
145 
146 #define INS_FROM_REG(n, val)	SCALE((val), 192, lm85_scaling[n])
147 
148 /* FAN speed is measured using 90kHz clock */
149 static inline u16 FAN_TO_REG(unsigned long val)
150 {
151 	if (!val)
152 		return 0xffff;
153 	return SENSORS_LIMIT(5400000 / val, 1, 0xfffe);
154 }
155 #define FAN_FROM_REG(val)	((val) == 0 ? -1 : (val) == 0xffff ? 0 : \
156 				 5400000 / (val))
157 
158 /* Temperature is reported in .001 degC increments */
159 #define TEMP_TO_REG(val)	\
160 		SENSORS_LIMIT(SCALE(val, 1000, 1), -127, 127)
161 #define TEMPEXT_FROM_REG(val, ext)	\
162 		SCALE(((val) << 4) + (ext), 16, 1000)
163 #define TEMP_FROM_REG(val)	((val) * 1000)
164 
165 #define PWM_TO_REG(val)			SENSORS_LIMIT(val, 0, 255)
166 #define PWM_FROM_REG(val)		(val)
167 
168 
169 /* ZONEs have the following parameters:
170  *    Limit (low) temp,           1. degC
171  *    Hysteresis (below limit),   1. degC (0-15)
172  *    Range of speed control,     .1 degC (2-80)
173  *    Critical (high) temp,       1. degC
174  *
175  * FAN PWMs have the following parameters:
176  *    Reference Zone,                 1, 2, 3, etc.
177  *    Spinup time,                    .05 sec
178  *    PWM value at limit/low temp,    1 count
179  *    PWM Frequency,                  1. Hz
180  *    PWM is Min or OFF below limit,  flag
181  *    Invert PWM output,              flag
182  *
183  * Some chips filter the temp, others the fan.
184  *    Filter constant (or disabled)   .1 seconds
185  */
186 
187 /* These are the zone temperature range encodings in .001 degree C */
188 static const int lm85_range_map[] = {
189 	2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000,
190 	13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000
191 };
192 
193 static int RANGE_TO_REG(int range)
194 {
195 	int i;
196 
197 	/* Find the closest match */
198 	for (i = 0; i < 15; ++i) {
199 		if (range <= (lm85_range_map[i] + lm85_range_map[i + 1]) / 2)
200 			break;
201 	}
202 
203 	return i;
204 }
205 #define RANGE_FROM_REG(val)	lm85_range_map[(val) & 0x0f]
206 
207 /* These are the PWM frequency encodings */
208 static const int lm85_freq_map[8] = { /* 1 Hz */
209 	10, 15, 23, 30, 38, 47, 61, 94
210 };
211 static const int adm1027_freq_map[8] = { /* 1 Hz */
212 	11, 15, 22, 29, 35, 44, 59, 88
213 };
214 
215 static int FREQ_TO_REG(const int *map, int freq)
216 {
217 	int i;
218 
219 	/* Find the closest match */
220 	for (i = 0; i < 7; ++i)
221 		if (freq <= (map[i] + map[i + 1]) / 2)
222 			break;
223 	return i;
224 }
225 
226 static int FREQ_FROM_REG(const int *map, u8 reg)
227 {
228 	return map[reg & 0x07];
229 }
230 
231 /* Since we can't use strings, I'm abusing these numbers
232  *   to stand in for the following meanings:
233  *      1 -- PWM responds to Zone 1
234  *      2 -- PWM responds to Zone 2
235  *      3 -- PWM responds to Zone 3
236  *     23 -- PWM responds to the higher temp of Zone 2 or 3
237  *    123 -- PWM responds to highest of Zone 1, 2, or 3
238  *      0 -- PWM is always at 0% (ie, off)
239  *     -1 -- PWM is always at 100%
240  *     -2 -- PWM responds to manual control
241  */
242 
243 static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
244 #define ZONE_FROM_REG(val)	lm85_zone_map[(val) >> 5]
245 
246 static int ZONE_TO_REG(int zone)
247 {
248 	int i;
249 
250 	for (i = 0; i <= 7; ++i)
251 		if (zone == lm85_zone_map[i])
252 			break;
253 	if (i > 7)   /* Not found. */
254 		i = 3;  /* Always 100% */
255 	return i << 5;
256 }
257 
258 #define HYST_TO_REG(val)	SENSORS_LIMIT(((val) + 500) / 1000, 0, 15)
259 #define HYST_FROM_REG(val)	((val) * 1000)
260 
261 /* Chip sampling rates
262  *
263  * Some sensors are not updated more frequently than once per second
264  *    so it doesn't make sense to read them more often than that.
265  *    We cache the results and return the saved data if the driver
266  *    is called again before a second has elapsed.
267  *
268  * Also, there is significant configuration data for this chip
269  *    given the automatic PWM fan control that is possible.  There
270  *    are about 47 bytes of config data to only 22 bytes of actual
271  *    readings.  So, we keep the config data up to date in the cache
272  *    when it is written and only sample it once every 1 *minute*
273  */
274 #define LM85_DATA_INTERVAL  (HZ + HZ / 2)
275 #define LM85_CONFIG_INTERVAL  (1 * 60 * HZ)
276 
277 /* LM85 can automatically adjust fan speeds based on temperature
278  * This structure encapsulates an entire Zone config.  There are
279  * three zones (one for each temperature input) on the lm85
280  */
281 struct lm85_zone {
282 	s8 limit;	/* Low temp limit */
283 	u8 hyst;	/* Low limit hysteresis. (0-15) */
284 	u8 range;	/* Temp range, encoded */
285 	s8 critical;	/* "All fans ON" temp limit */
286 	u8 off_desired; /* Actual "off" temperature specified.  Preserved
287 			 * to prevent "drift" as other autofan control
288 			 * values change.
289 			 */
290 	u8 max_desired; /* Actual "max" temperature specified.  Preserved
291 			 * to prevent "drift" as other autofan control
292 			 * values change.
293 			 */
294 };
295 
296 struct lm85_autofan {
297 	u8 config;	/* Register value */
298 	u8 min_pwm;	/* Minimum PWM value, encoded */
299 	u8 min_off;	/* Min PWM or OFF below "limit", flag */
300 };
301 
302 /* For each registered chip, we need to keep some data in memory.
303    The structure is dynamically allocated. */
304 struct lm85_data {
305 	struct device *hwmon_dev;
306 	const int *freq_map;
307 	enum chips type;
308 
309 	struct mutex update_lock;
310 	int valid;		/* !=0 if following fields are valid */
311 	unsigned long last_reading;	/* In jiffies */
312 	unsigned long last_config;	/* In jiffies */
313 
314 	u8 in[8];		/* Register value */
315 	u8 in_max[8];		/* Register value */
316 	u8 in_min[8];		/* Register value */
317 	s8 temp[3];		/* Register value */
318 	s8 temp_min[3];		/* Register value */
319 	s8 temp_max[3];		/* Register value */
320 	u16 fan[4];		/* Register value */
321 	u16 fan_min[4];		/* Register value */
322 	u8 pwm[3];		/* Register value */
323 	u8 pwm_freq[3];		/* Register encoding */
324 	u8 temp_ext[3];		/* Decoded values */
325 	u8 in_ext[8];		/* Decoded values */
326 	u8 vid;			/* Register value */
327 	u8 vrm;			/* VRM version */
328 	u32 alarms;		/* Register encoding, combined */
329 	u8 cfg5;		/* Config Register 5 on ADT7468 */
330 	struct lm85_autofan autofan[3];
331 	struct lm85_zone zone[3];
332 };
333 
334 static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info);
335 static int lm85_probe(struct i2c_client *client,
336 		      const struct i2c_device_id *id);
337 static int lm85_remove(struct i2c_client *client);
338 
339 static int lm85_read_value(struct i2c_client *client, u8 reg);
340 static void lm85_write_value(struct i2c_client *client, u8 reg, int value);
341 static struct lm85_data *lm85_update_device(struct device *dev);
342 
343 
344 static const struct i2c_device_id lm85_id[] = {
345 	{ "adm1027", adm1027 },
346 	{ "adt7463", adt7463 },
347 	{ "adt7468", adt7468 },
348 	{ "lm85", any_chip },
349 	{ "lm85b", lm85b },
350 	{ "lm85c", lm85c },
351 	{ "emc6d100", emc6d100 },
352 	{ "emc6d101", emc6d100 },
353 	{ "emc6d102", emc6d102 },
354 	{ "emc6d103", emc6d103 },
355 	{ }
356 };
357 MODULE_DEVICE_TABLE(i2c, lm85_id);
358 
359 static struct i2c_driver lm85_driver = {
360 	.class		= I2C_CLASS_HWMON,
361 	.driver = {
362 		.name   = "lm85",
363 	},
364 	.probe		= lm85_probe,
365 	.remove		= lm85_remove,
366 	.id_table	= lm85_id,
367 	.detect		= lm85_detect,
368 	.address_list	= normal_i2c,
369 };
370 
371 
372 /* 4 Fans */
373 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
374 		char *buf)
375 {
376 	int nr = to_sensor_dev_attr(attr)->index;
377 	struct lm85_data *data = lm85_update_device(dev);
378 	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr]));
379 }
380 
381 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
382 		char *buf)
383 {
384 	int nr = to_sensor_dev_attr(attr)->index;
385 	struct lm85_data *data = lm85_update_device(dev);
386 	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr]));
387 }
388 
389 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
390 		const char *buf, size_t count)
391 {
392 	int nr = to_sensor_dev_attr(attr)->index;
393 	struct i2c_client *client = to_i2c_client(dev);
394 	struct lm85_data *data = i2c_get_clientdata(client);
395 	unsigned long val = simple_strtoul(buf, NULL, 10);
396 
397 	mutex_lock(&data->update_lock);
398 	data->fan_min[nr] = FAN_TO_REG(val);
399 	lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]);
400 	mutex_unlock(&data->update_lock);
401 	return count;
402 }
403 
404 #define show_fan_offset(offset)						\
405 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,			\
406 		show_fan, NULL, offset - 1);				\
407 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,		\
408 		show_fan_min, set_fan_min, offset - 1)
409 
410 show_fan_offset(1);
411 show_fan_offset(2);
412 show_fan_offset(3);
413 show_fan_offset(4);
414 
415 /* vid, vrm, alarms */
416 
417 static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr,
418 		char *buf)
419 {
420 	struct lm85_data *data = lm85_update_device(dev);
421 	int vid;
422 
423 	if ((data->type == adt7463 || data->type == adt7468) &&
424 	    (data->vid & 0x80)) {
425 		/* 6-pin VID (VRM 10) */
426 		vid = vid_from_reg(data->vid & 0x3f, data->vrm);
427 	} else {
428 		/* 5-pin VID (VRM 9) */
429 		vid = vid_from_reg(data->vid & 0x1f, data->vrm);
430 	}
431 
432 	return sprintf(buf, "%d\n", vid);
433 }
434 
435 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
436 
437 static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr,
438 		char *buf)
439 {
440 	struct lm85_data *data = dev_get_drvdata(dev);
441 	return sprintf(buf, "%ld\n", (long) data->vrm);
442 }
443 
444 static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
445 		const char *buf, size_t count)
446 {
447 	struct lm85_data *data = dev_get_drvdata(dev);
448 	data->vrm = simple_strtoul(buf, NULL, 10);
449 	return count;
450 }
451 
452 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
453 
454 static ssize_t show_alarms_reg(struct device *dev, struct device_attribute
455 		*attr, char *buf)
456 {
457 	struct lm85_data *data = lm85_update_device(dev);
458 	return sprintf(buf, "%u\n", data->alarms);
459 }
460 
461 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
462 
463 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
464 		char *buf)
465 {
466 	int nr = to_sensor_dev_attr(attr)->index;
467 	struct lm85_data *data = lm85_update_device(dev);
468 	return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
469 }
470 
471 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
472 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
473 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
474 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
475 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
476 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 18);
477 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 16);
478 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 17);
479 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
480 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_alarm, NULL, 14);
481 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
482 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 6);
483 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 15);
484 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10);
485 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11);
486 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 12);
487 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 13);
488 
489 /* pwm */
490 
491 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
492 		char *buf)
493 {
494 	int nr = to_sensor_dev_attr(attr)->index;
495 	struct lm85_data *data = lm85_update_device(dev);
496 	return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
497 }
498 
499 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
500 		const char *buf, size_t count)
501 {
502 	int nr = to_sensor_dev_attr(attr)->index;
503 	struct i2c_client *client = to_i2c_client(dev);
504 	struct lm85_data *data = i2c_get_clientdata(client);
505 	long val = simple_strtol(buf, NULL, 10);
506 
507 	mutex_lock(&data->update_lock);
508 	data->pwm[nr] = PWM_TO_REG(val);
509 	lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);
510 	mutex_unlock(&data->update_lock);
511 	return count;
512 }
513 
514 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
515 		*attr, char *buf)
516 {
517 	int nr = to_sensor_dev_attr(attr)->index;
518 	struct lm85_data *data = lm85_update_device(dev);
519 	int pwm_zone, enable;
520 
521 	pwm_zone = ZONE_FROM_REG(data->autofan[nr].config);
522 	switch (pwm_zone) {
523 	case -1:	/* PWM is always at 100% */
524 		enable = 0;
525 		break;
526 	case 0:		/* PWM is always at 0% */
527 	case -2:	/* PWM responds to manual control */
528 		enable = 1;
529 		break;
530 	default:	/* PWM in automatic mode */
531 		enable = 2;
532 	}
533 	return sprintf(buf, "%d\n", enable);
534 }
535 
536 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
537 		*attr, const char *buf, size_t count)
538 {
539 	int nr = to_sensor_dev_attr(attr)->index;
540 	struct i2c_client *client = to_i2c_client(dev);
541 	struct lm85_data *data = i2c_get_clientdata(client);
542 	long val = simple_strtol(buf, NULL, 10);
543 	u8 config;
544 
545 	switch (val) {
546 	case 0:
547 		config = 3;
548 		break;
549 	case 1:
550 		config = 7;
551 		break;
552 	case 2:
553 		/* Here we have to choose arbitrarily one of the 5 possible
554 		   configurations; I go for the safest */
555 		config = 6;
556 		break;
557 	default:
558 		return -EINVAL;
559 	}
560 
561 	mutex_lock(&data->update_lock);
562 	data->autofan[nr].config = lm85_read_value(client,
563 		LM85_REG_AFAN_CONFIG(nr));
564 	data->autofan[nr].config = (data->autofan[nr].config & ~0xe0)
565 		| (config << 5);
566 	lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
567 		data->autofan[nr].config);
568 	mutex_unlock(&data->update_lock);
569 	return count;
570 }
571 
572 static ssize_t show_pwm_freq(struct device *dev,
573 		struct device_attribute *attr, char *buf)
574 {
575 	int nr = to_sensor_dev_attr(attr)->index;
576 	struct lm85_data *data = lm85_update_device(dev);
577 	int freq;
578 
579 	if (IS_ADT7468_HFPWM(data))
580 		freq = 22500;
581 	else
582 		freq = FREQ_FROM_REG(data->freq_map, data->pwm_freq[nr]);
583 
584 	return sprintf(buf, "%d\n", freq);
585 }
586 
587 static ssize_t set_pwm_freq(struct device *dev,
588 		struct device_attribute *attr, const char *buf, size_t count)
589 {
590 	int nr = to_sensor_dev_attr(attr)->index;
591 	struct i2c_client *client = to_i2c_client(dev);
592 	struct lm85_data *data = i2c_get_clientdata(client);
593 	long val = simple_strtol(buf, NULL, 10);
594 
595 	mutex_lock(&data->update_lock);
596 	/* The ADT7468 has a special high-frequency PWM output mode,
597 	 * where all PWM outputs are driven by a 22.5 kHz clock.
598 	 * This might confuse the user, but there's not much we can do. */
599 	if (data->type == adt7468 && val >= 11300) {	/* High freq. mode */
600 		data->cfg5 &= ~ADT7468_HFPWM;
601 		lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);
602 	} else {					/* Low freq. mode */
603 		data->pwm_freq[nr] = FREQ_TO_REG(data->freq_map, val);
604 		lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
605 				 (data->zone[nr].range << 4)
606 				 | data->pwm_freq[nr]);
607 		if (data->type == adt7468) {
608 			data->cfg5 |= ADT7468_HFPWM;
609 			lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);
610 		}
611 	}
612 	mutex_unlock(&data->update_lock);
613 	return count;
614 }
615 
616 #define show_pwm_reg(offset)						\
617 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,		\
618 		show_pwm, set_pwm, offset - 1);				\
619 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,	\
620 		show_pwm_enable, set_pwm_enable, offset - 1);		\
621 static SENSOR_DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR,	\
622 		show_pwm_freq, set_pwm_freq, offset - 1)
623 
624 show_pwm_reg(1);
625 show_pwm_reg(2);
626 show_pwm_reg(3);
627 
628 /* Voltages */
629 
630 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
631 		char *buf)
632 {
633 	int nr = to_sensor_dev_attr(attr)->index;
634 	struct lm85_data *data = lm85_update_device(dev);
635 	return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr],
636 						    data->in_ext[nr]));
637 }
638 
639 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
640 		char *buf)
641 {
642 	int nr = to_sensor_dev_attr(attr)->index;
643 	struct lm85_data *data = lm85_update_device(dev);
644 	return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
645 }
646 
647 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
648 		const char *buf, size_t count)
649 {
650 	int nr = to_sensor_dev_attr(attr)->index;
651 	struct i2c_client *client = to_i2c_client(dev);
652 	struct lm85_data *data = i2c_get_clientdata(client);
653 	long val = simple_strtol(buf, NULL, 10);
654 
655 	mutex_lock(&data->update_lock);
656 	data->in_min[nr] = INS_TO_REG(nr, val);
657 	lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]);
658 	mutex_unlock(&data->update_lock);
659 	return count;
660 }
661 
662 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
663 		char *buf)
664 {
665 	int nr = to_sensor_dev_attr(attr)->index;
666 	struct lm85_data *data = lm85_update_device(dev);
667 	return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
668 }
669 
670 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
671 		const char *buf, size_t count)
672 {
673 	int nr = to_sensor_dev_attr(attr)->index;
674 	struct i2c_client *client = to_i2c_client(dev);
675 	struct lm85_data *data = i2c_get_clientdata(client);
676 	long val = simple_strtol(buf, NULL, 10);
677 
678 	mutex_lock(&data->update_lock);
679 	data->in_max[nr] = INS_TO_REG(nr, val);
680 	lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]);
681 	mutex_unlock(&data->update_lock);
682 	return count;
683 }
684 
685 #define show_in_reg(offset)						\
686 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,			\
687 		show_in, NULL, offset);					\
688 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,		\
689 		show_in_min, set_in_min, offset);			\
690 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,		\
691 		show_in_max, set_in_max, offset)
692 
693 show_in_reg(0);
694 show_in_reg(1);
695 show_in_reg(2);
696 show_in_reg(3);
697 show_in_reg(4);
698 show_in_reg(5);
699 show_in_reg(6);
700 show_in_reg(7);
701 
702 /* Temps */
703 
704 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
705 		char *buf)
706 {
707 	int nr = to_sensor_dev_attr(attr)->index;
708 	struct lm85_data *data = lm85_update_device(dev);
709 	return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr],
710 						     data->temp_ext[nr]));
711 }
712 
713 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
714 		char *buf)
715 {
716 	int nr = to_sensor_dev_attr(attr)->index;
717 	struct lm85_data *data = lm85_update_device(dev);
718 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
719 }
720 
721 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
722 		const char *buf, size_t count)
723 {
724 	int nr = to_sensor_dev_attr(attr)->index;
725 	struct i2c_client *client = to_i2c_client(dev);
726 	struct lm85_data *data = i2c_get_clientdata(client);
727 	long val = simple_strtol(buf, NULL, 10);
728 
729 	if (IS_ADT7468_OFF64(data))
730 		val += 64;
731 
732 	mutex_lock(&data->update_lock);
733 	data->temp_min[nr] = TEMP_TO_REG(val);
734 	lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]);
735 	mutex_unlock(&data->update_lock);
736 	return count;
737 }
738 
739 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
740 		char *buf)
741 {
742 	int nr = to_sensor_dev_attr(attr)->index;
743 	struct lm85_data *data = lm85_update_device(dev);
744 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
745 }
746 
747 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
748 		const char *buf, size_t count)
749 {
750 	int nr = to_sensor_dev_attr(attr)->index;
751 	struct i2c_client *client = to_i2c_client(dev);
752 	struct lm85_data *data = i2c_get_clientdata(client);
753 	long val = simple_strtol(buf, NULL, 10);
754 
755 	if (IS_ADT7468_OFF64(data))
756 		val += 64;
757 
758 	mutex_lock(&data->update_lock);
759 	data->temp_max[nr] = TEMP_TO_REG(val);
760 	lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]);
761 	mutex_unlock(&data->update_lock);
762 	return count;
763 }
764 
765 #define show_temp_reg(offset)						\
766 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,		\
767 		show_temp, NULL, offset - 1);				\
768 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,	\
769 		show_temp_min, set_temp_min, offset - 1);		\
770 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,	\
771 		show_temp_max, set_temp_max, offset - 1);
772 
773 show_temp_reg(1);
774 show_temp_reg(2);
775 show_temp_reg(3);
776 
777 
778 /* Automatic PWM control */
779 
780 static ssize_t show_pwm_auto_channels(struct device *dev,
781 		struct device_attribute *attr, char *buf)
782 {
783 	int nr = to_sensor_dev_attr(attr)->index;
784 	struct lm85_data *data = lm85_update_device(dev);
785 	return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config));
786 }
787 
788 static ssize_t set_pwm_auto_channels(struct device *dev,
789 		struct device_attribute *attr, const char *buf, size_t count)
790 {
791 	int nr = to_sensor_dev_attr(attr)->index;
792 	struct i2c_client *client = to_i2c_client(dev);
793 	struct lm85_data *data = i2c_get_clientdata(client);
794 	long val = simple_strtol(buf, NULL, 10);
795 
796 	mutex_lock(&data->update_lock);
797 	data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
798 		| ZONE_TO_REG(val);
799 	lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
800 		data->autofan[nr].config);
801 	mutex_unlock(&data->update_lock);
802 	return count;
803 }
804 
805 static ssize_t show_pwm_auto_pwm_min(struct device *dev,
806 		struct device_attribute *attr, char *buf)
807 {
808 	int nr = to_sensor_dev_attr(attr)->index;
809 	struct lm85_data *data = lm85_update_device(dev);
810 	return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
811 }
812 
813 static ssize_t set_pwm_auto_pwm_min(struct device *dev,
814 		struct device_attribute *attr, const char *buf, size_t count)
815 {
816 	int nr = to_sensor_dev_attr(attr)->index;
817 	struct i2c_client *client = to_i2c_client(dev);
818 	struct lm85_data *data = i2c_get_clientdata(client);
819 	long val = simple_strtol(buf, NULL, 10);
820 
821 	mutex_lock(&data->update_lock);
822 	data->autofan[nr].min_pwm = PWM_TO_REG(val);
823 	lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),
824 		data->autofan[nr].min_pwm);
825 	mutex_unlock(&data->update_lock);
826 	return count;
827 }
828 
829 static ssize_t show_pwm_auto_pwm_minctl(struct device *dev,
830 		struct device_attribute *attr, char *buf)
831 {
832 	int nr = to_sensor_dev_attr(attr)->index;
833 	struct lm85_data *data = lm85_update_device(dev);
834 	return sprintf(buf, "%d\n", data->autofan[nr].min_off);
835 }
836 
837 static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
838 		struct device_attribute *attr, const char *buf, size_t count)
839 {
840 	int nr = to_sensor_dev_attr(attr)->index;
841 	struct i2c_client *client = to_i2c_client(dev);
842 	struct lm85_data *data = i2c_get_clientdata(client);
843 	long val = simple_strtol(buf, NULL, 10);
844 	u8 tmp;
845 
846 	mutex_lock(&data->update_lock);
847 	data->autofan[nr].min_off = val;
848 	tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
849 	tmp &= ~(0x20 << nr);
850 	if (data->autofan[nr].min_off)
851 		tmp |= 0x20 << nr;
852 	lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp);
853 	mutex_unlock(&data->update_lock);
854 	return count;
855 }
856 
857 #define pwm_auto(offset)						\
858 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_channels,			\
859 		S_IRUGO | S_IWUSR, show_pwm_auto_channels,		\
860 		set_pwm_auto_channels, offset - 1);			\
861 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_min,			\
862 		S_IRUGO | S_IWUSR, show_pwm_auto_pwm_min,		\
863 		set_pwm_auto_pwm_min, offset - 1);			\
864 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_minctl,		\
865 		S_IRUGO | S_IWUSR, show_pwm_auto_pwm_minctl,		\
866 		set_pwm_auto_pwm_minctl, offset - 1)
867 
868 pwm_auto(1);
869 pwm_auto(2);
870 pwm_auto(3);
871 
872 /* Temperature settings for automatic PWM control */
873 
874 static ssize_t show_temp_auto_temp_off(struct device *dev,
875 		struct device_attribute *attr, char *buf)
876 {
877 	int nr = to_sensor_dev_attr(attr)->index;
878 	struct lm85_data *data = lm85_update_device(dev);
879 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
880 		HYST_FROM_REG(data->zone[nr].hyst));
881 }
882 
883 static ssize_t set_temp_auto_temp_off(struct device *dev,
884 		struct device_attribute *attr, const char *buf, size_t count)
885 {
886 	int nr = to_sensor_dev_attr(attr)->index;
887 	struct i2c_client *client = to_i2c_client(dev);
888 	struct lm85_data *data = i2c_get_clientdata(client);
889 	int min;
890 	long val = simple_strtol(buf, NULL, 10);
891 
892 	mutex_lock(&data->update_lock);
893 	min = TEMP_FROM_REG(data->zone[nr].limit);
894 	data->zone[nr].off_desired = TEMP_TO_REG(val);
895 	data->zone[nr].hyst = HYST_TO_REG(min - val);
896 	if (nr == 0 || nr == 1) {
897 		lm85_write_value(client, LM85_REG_AFAN_HYST1,
898 			(data->zone[0].hyst << 4)
899 			| data->zone[1].hyst);
900 	} else {
901 		lm85_write_value(client, LM85_REG_AFAN_HYST2,
902 			(data->zone[2].hyst << 4));
903 	}
904 	mutex_unlock(&data->update_lock);
905 	return count;
906 }
907 
908 static ssize_t show_temp_auto_temp_min(struct device *dev,
909 		struct device_attribute *attr, char *buf)
910 {
911 	int nr = to_sensor_dev_attr(attr)->index;
912 	struct lm85_data *data = lm85_update_device(dev);
913 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));
914 }
915 
916 static ssize_t set_temp_auto_temp_min(struct device *dev,
917 		struct device_attribute *attr, const char *buf, size_t count)
918 {
919 	int nr = to_sensor_dev_attr(attr)->index;
920 	struct i2c_client *client = to_i2c_client(dev);
921 	struct lm85_data *data = i2c_get_clientdata(client);
922 	long val = simple_strtol(buf, NULL, 10);
923 
924 	mutex_lock(&data->update_lock);
925 	data->zone[nr].limit = TEMP_TO_REG(val);
926 	lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),
927 		data->zone[nr].limit);
928 
929 /* Update temp_auto_max and temp_auto_range */
930 	data->zone[nr].range = RANGE_TO_REG(
931 		TEMP_FROM_REG(data->zone[nr].max_desired) -
932 		TEMP_FROM_REG(data->zone[nr].limit));
933 	lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
934 		((data->zone[nr].range & 0x0f) << 4)
935 		| (data->pwm_freq[nr] & 0x07));
936 
937 /* Update temp_auto_hyst and temp_auto_off */
938 	data->zone[nr].hyst = HYST_TO_REG(TEMP_FROM_REG(
939 		data->zone[nr].limit) - TEMP_FROM_REG(
940 		data->zone[nr].off_desired));
941 	if (nr == 0 || nr == 1) {
942 		lm85_write_value(client, LM85_REG_AFAN_HYST1,
943 			(data->zone[0].hyst << 4)
944 			| data->zone[1].hyst);
945 	} else {
946 		lm85_write_value(client, LM85_REG_AFAN_HYST2,
947 			(data->zone[2].hyst << 4));
948 	}
949 	mutex_unlock(&data->update_lock);
950 	return count;
951 }
952 
953 static ssize_t show_temp_auto_temp_max(struct device *dev,
954 		struct device_attribute *attr, char *buf)
955 {
956 	int nr = to_sensor_dev_attr(attr)->index;
957 	struct lm85_data *data = lm85_update_device(dev);
958 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
959 		RANGE_FROM_REG(data->zone[nr].range));
960 }
961 
962 static ssize_t set_temp_auto_temp_max(struct device *dev,
963 		struct device_attribute *attr, const char *buf, size_t count)
964 {
965 	int nr = to_sensor_dev_attr(attr)->index;
966 	struct i2c_client *client = to_i2c_client(dev);
967 	struct lm85_data *data = i2c_get_clientdata(client);
968 	int min;
969 	long val = simple_strtol(buf, NULL, 10);
970 
971 	mutex_lock(&data->update_lock);
972 	min = TEMP_FROM_REG(data->zone[nr].limit);
973 	data->zone[nr].max_desired = TEMP_TO_REG(val);
974 	data->zone[nr].range = RANGE_TO_REG(
975 		val - min);
976 	lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
977 		((data->zone[nr].range & 0x0f) << 4)
978 		| (data->pwm_freq[nr] & 0x07));
979 	mutex_unlock(&data->update_lock);
980 	return count;
981 }
982 
983 static ssize_t show_temp_auto_temp_crit(struct device *dev,
984 		struct device_attribute *attr, char *buf)
985 {
986 	int nr = to_sensor_dev_attr(attr)->index;
987 	struct lm85_data *data = lm85_update_device(dev);
988 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical));
989 }
990 
991 static ssize_t set_temp_auto_temp_crit(struct device *dev,
992 		struct device_attribute *attr, const char *buf, size_t count)
993 {
994 	int nr = to_sensor_dev_attr(attr)->index;
995 	struct i2c_client *client = to_i2c_client(dev);
996 	struct lm85_data *data = i2c_get_clientdata(client);
997 	long val = simple_strtol(buf, NULL, 10);
998 
999 	mutex_lock(&data->update_lock);
1000 	data->zone[nr].critical = TEMP_TO_REG(val);
1001 	lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),
1002 		data->zone[nr].critical);
1003 	mutex_unlock(&data->update_lock);
1004 	return count;
1005 }
1006 
1007 #define temp_auto(offset)						\
1008 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_off,			\
1009 		S_IRUGO | S_IWUSR, show_temp_auto_temp_off,		\
1010 		set_temp_auto_temp_off, offset - 1);			\
1011 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_min,			\
1012 		S_IRUGO | S_IWUSR, show_temp_auto_temp_min,		\
1013 		set_temp_auto_temp_min, offset - 1);			\
1014 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_max,			\
1015 		S_IRUGO | S_IWUSR, show_temp_auto_temp_max,		\
1016 		set_temp_auto_temp_max, offset - 1);			\
1017 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_crit,		\
1018 		S_IRUGO | S_IWUSR, show_temp_auto_temp_crit,		\
1019 		set_temp_auto_temp_crit, offset - 1);
1020 
1021 temp_auto(1);
1022 temp_auto(2);
1023 temp_auto(3);
1024 
1025 static struct attribute *lm85_attributes[] = {
1026 	&sensor_dev_attr_fan1_input.dev_attr.attr,
1027 	&sensor_dev_attr_fan2_input.dev_attr.attr,
1028 	&sensor_dev_attr_fan3_input.dev_attr.attr,
1029 	&sensor_dev_attr_fan4_input.dev_attr.attr,
1030 	&sensor_dev_attr_fan1_min.dev_attr.attr,
1031 	&sensor_dev_attr_fan2_min.dev_attr.attr,
1032 	&sensor_dev_attr_fan3_min.dev_attr.attr,
1033 	&sensor_dev_attr_fan4_min.dev_attr.attr,
1034 	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
1035 	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
1036 	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
1037 	&sensor_dev_attr_fan4_alarm.dev_attr.attr,
1038 
1039 	&sensor_dev_attr_pwm1.dev_attr.attr,
1040 	&sensor_dev_attr_pwm2.dev_attr.attr,
1041 	&sensor_dev_attr_pwm3.dev_attr.attr,
1042 	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
1043 	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
1044 	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
1045 	&sensor_dev_attr_pwm1_freq.dev_attr.attr,
1046 	&sensor_dev_attr_pwm2_freq.dev_attr.attr,
1047 	&sensor_dev_attr_pwm3_freq.dev_attr.attr,
1048 
1049 	&sensor_dev_attr_in0_input.dev_attr.attr,
1050 	&sensor_dev_attr_in1_input.dev_attr.attr,
1051 	&sensor_dev_attr_in2_input.dev_attr.attr,
1052 	&sensor_dev_attr_in3_input.dev_attr.attr,
1053 	&sensor_dev_attr_in0_min.dev_attr.attr,
1054 	&sensor_dev_attr_in1_min.dev_attr.attr,
1055 	&sensor_dev_attr_in2_min.dev_attr.attr,
1056 	&sensor_dev_attr_in3_min.dev_attr.attr,
1057 	&sensor_dev_attr_in0_max.dev_attr.attr,
1058 	&sensor_dev_attr_in1_max.dev_attr.attr,
1059 	&sensor_dev_attr_in2_max.dev_attr.attr,
1060 	&sensor_dev_attr_in3_max.dev_attr.attr,
1061 	&sensor_dev_attr_in0_alarm.dev_attr.attr,
1062 	&sensor_dev_attr_in1_alarm.dev_attr.attr,
1063 	&sensor_dev_attr_in2_alarm.dev_attr.attr,
1064 	&sensor_dev_attr_in3_alarm.dev_attr.attr,
1065 
1066 	&sensor_dev_attr_temp1_input.dev_attr.attr,
1067 	&sensor_dev_attr_temp2_input.dev_attr.attr,
1068 	&sensor_dev_attr_temp3_input.dev_attr.attr,
1069 	&sensor_dev_attr_temp1_min.dev_attr.attr,
1070 	&sensor_dev_attr_temp2_min.dev_attr.attr,
1071 	&sensor_dev_attr_temp3_min.dev_attr.attr,
1072 	&sensor_dev_attr_temp1_max.dev_attr.attr,
1073 	&sensor_dev_attr_temp2_max.dev_attr.attr,
1074 	&sensor_dev_attr_temp3_max.dev_attr.attr,
1075 	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
1076 	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
1077 	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
1078 	&sensor_dev_attr_temp1_fault.dev_attr.attr,
1079 	&sensor_dev_attr_temp3_fault.dev_attr.attr,
1080 
1081 	&sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
1082 	&sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
1083 	&sensor_dev_attr_pwm3_auto_channels.dev_attr.attr,
1084 	&sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
1085 	&sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
1086 	&sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
1087 	&sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr,
1088 	&sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr,
1089 	&sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr,
1090 
1091 	&sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr,
1092 	&sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr,
1093 	&sensor_dev_attr_temp3_auto_temp_off.dev_attr.attr,
1094 	&sensor_dev_attr_temp1_auto_temp_min.dev_attr.attr,
1095 	&sensor_dev_attr_temp2_auto_temp_min.dev_attr.attr,
1096 	&sensor_dev_attr_temp3_auto_temp_min.dev_attr.attr,
1097 	&sensor_dev_attr_temp1_auto_temp_max.dev_attr.attr,
1098 	&sensor_dev_attr_temp2_auto_temp_max.dev_attr.attr,
1099 	&sensor_dev_attr_temp3_auto_temp_max.dev_attr.attr,
1100 	&sensor_dev_attr_temp1_auto_temp_crit.dev_attr.attr,
1101 	&sensor_dev_attr_temp2_auto_temp_crit.dev_attr.attr,
1102 	&sensor_dev_attr_temp3_auto_temp_crit.dev_attr.attr,
1103 
1104 	&dev_attr_vrm.attr,
1105 	&dev_attr_cpu0_vid.attr,
1106 	&dev_attr_alarms.attr,
1107 	NULL
1108 };
1109 
1110 static const struct attribute_group lm85_group = {
1111 	.attrs = lm85_attributes,
1112 };
1113 
1114 static struct attribute *lm85_attributes_in4[] = {
1115 	&sensor_dev_attr_in4_input.dev_attr.attr,
1116 	&sensor_dev_attr_in4_min.dev_attr.attr,
1117 	&sensor_dev_attr_in4_max.dev_attr.attr,
1118 	&sensor_dev_attr_in4_alarm.dev_attr.attr,
1119 	NULL
1120 };
1121 
1122 static const struct attribute_group lm85_group_in4 = {
1123 	.attrs = lm85_attributes_in4,
1124 };
1125 
1126 static struct attribute *lm85_attributes_in567[] = {
1127 	&sensor_dev_attr_in5_input.dev_attr.attr,
1128 	&sensor_dev_attr_in6_input.dev_attr.attr,
1129 	&sensor_dev_attr_in7_input.dev_attr.attr,
1130 	&sensor_dev_attr_in5_min.dev_attr.attr,
1131 	&sensor_dev_attr_in6_min.dev_attr.attr,
1132 	&sensor_dev_attr_in7_min.dev_attr.attr,
1133 	&sensor_dev_attr_in5_max.dev_attr.attr,
1134 	&sensor_dev_attr_in6_max.dev_attr.attr,
1135 	&sensor_dev_attr_in7_max.dev_attr.attr,
1136 	&sensor_dev_attr_in5_alarm.dev_attr.attr,
1137 	&sensor_dev_attr_in6_alarm.dev_attr.attr,
1138 	&sensor_dev_attr_in7_alarm.dev_attr.attr,
1139 	NULL
1140 };
1141 
1142 static const struct attribute_group lm85_group_in567 = {
1143 	.attrs = lm85_attributes_in567,
1144 };
1145 
1146 static void lm85_init_client(struct i2c_client *client)
1147 {
1148 	int value;
1149 
1150 	/* Start monitoring if needed */
1151 	value = lm85_read_value(client, LM85_REG_CONFIG);
1152 	if (!(value & 0x01)) {
1153 		dev_info(&client->dev, "Starting monitoring\n");
1154 		lm85_write_value(client, LM85_REG_CONFIG, value | 0x01);
1155 	}
1156 
1157 	/* Warn about unusual configuration bits */
1158 	if (value & 0x02)
1159 		dev_warn(&client->dev, "Device configuration is locked\n");
1160 	if (!(value & 0x04))
1161 		dev_warn(&client->dev, "Device is not ready\n");
1162 }
1163 
1164 static int lm85_is_fake(struct i2c_client *client)
1165 {
1166 	/*
1167 	 * Differenciate between real LM96000 and Winbond WPCD377I. The latter
1168 	 * emulate the former except that it has no hardware monitoring function
1169 	 * so the readings are always 0.
1170 	 */
1171 	int i;
1172 	u8 in_temp, fan;
1173 
1174 	for (i = 0; i < 8; i++) {
1175 		in_temp = i2c_smbus_read_byte_data(client, 0x20 + i);
1176 		fan = i2c_smbus_read_byte_data(client, 0x28 + i);
1177 		if (in_temp != 0x00 || fan != 0xff)
1178 			return 0;
1179 	}
1180 
1181 	return 1;
1182 }
1183 
1184 /* Return 0 if detection is successful, -ENODEV otherwise */
1185 static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info)
1186 {
1187 	struct i2c_adapter *adapter = client->adapter;
1188 	int address = client->addr;
1189 	const char *type_name;
1190 	int company, verstep;
1191 
1192 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1193 		/* We need to be able to do byte I/O */
1194 		return -ENODEV;
1195 	}
1196 
1197 	/* Determine the chip type */
1198 	company = lm85_read_value(client, LM85_REG_COMPANY);
1199 	verstep = lm85_read_value(client, LM85_REG_VERSTEP);
1200 
1201 	dev_dbg(&adapter->dev, "Detecting device at 0x%02x with "
1202 		"COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
1203 		address, company, verstep);
1204 
1205 	/* All supported chips have the version in common */
1206 	if ((verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC &&
1207 	    (verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC2) {
1208 		dev_dbg(&adapter->dev,
1209 			"Autodetection failed: unsupported version\n");
1210 		return -ENODEV;
1211 	}
1212 	type_name = "lm85";
1213 
1214 	/* Now, refine the detection */
1215 	if (company == LM85_COMPANY_NATIONAL) {
1216 		switch (verstep) {
1217 		case LM85_VERSTEP_LM85C:
1218 			type_name = "lm85c";
1219 			break;
1220 		case LM85_VERSTEP_LM85B:
1221 			type_name = "lm85b";
1222 			break;
1223 		case LM85_VERSTEP_LM96000_1:
1224 		case LM85_VERSTEP_LM96000_2:
1225 			/* Check for Winbond WPCD377I */
1226 			if (lm85_is_fake(client)) {
1227 				dev_dbg(&adapter->dev,
1228 					"Found Winbond WPCD377I, ignoring\n");
1229 				return -ENODEV;
1230 			}
1231 			break;
1232 		}
1233 	} else if (company == LM85_COMPANY_ANALOG_DEV) {
1234 		switch (verstep) {
1235 		case LM85_VERSTEP_ADM1027:
1236 			type_name = "adm1027";
1237 			break;
1238 		case LM85_VERSTEP_ADT7463:
1239 		case LM85_VERSTEP_ADT7463C:
1240 			type_name = "adt7463";
1241 			break;
1242 		case LM85_VERSTEP_ADT7468_1:
1243 		case LM85_VERSTEP_ADT7468_2:
1244 			type_name = "adt7468";
1245 			break;
1246 		}
1247 	} else if (company == LM85_COMPANY_SMSC) {
1248 		switch (verstep) {
1249 		case LM85_VERSTEP_EMC6D100_A0:
1250 		case LM85_VERSTEP_EMC6D100_A1:
1251 			/* Note: we can't tell a '100 from a '101 */
1252 			type_name = "emc6d100";
1253 			break;
1254 		case LM85_VERSTEP_EMC6D102:
1255 			type_name = "emc6d102";
1256 			break;
1257 		case LM85_VERSTEP_EMC6D103_A0:
1258 		case LM85_VERSTEP_EMC6D103_A1:
1259 			type_name = "emc6d103";
1260 			break;
1261 		/*
1262 		 * Registers apparently missing in EMC6D103S/EMC6D103:A2
1263 		 * compared to EMC6D103:A0, EMC6D103:A1, and EMC6D102
1264 		 * (according to the data sheets), but used unconditionally
1265 		 * in the driver: 62[5:7], 6D[0:7], and 6E[0:7].
1266 		 * So skip EMC6D103S for now.
1267 		case LM85_VERSTEP_EMC6D103S:
1268 			type_name = "emc6d103s";
1269 			break;
1270 		 */
1271 		}
1272 	} else {
1273 		dev_dbg(&adapter->dev,
1274 			"Autodetection failed: unknown vendor\n");
1275 		return -ENODEV;
1276 	}
1277 
1278 	strlcpy(info->type, type_name, I2C_NAME_SIZE);
1279 
1280 	return 0;
1281 }
1282 
1283 static int lm85_probe(struct i2c_client *client,
1284 		      const struct i2c_device_id *id)
1285 {
1286 	struct lm85_data *data;
1287 	int err;
1288 
1289 	data = kzalloc(sizeof(struct lm85_data), GFP_KERNEL);
1290 	if (!data)
1291 		return -ENOMEM;
1292 
1293 	i2c_set_clientdata(client, data);
1294 	data->type = id->driver_data;
1295 	mutex_init(&data->update_lock);
1296 
1297 	/* Fill in the chip specific driver values */
1298 	switch (data->type) {
1299 	case adm1027:
1300 	case adt7463:
1301 	case adt7468:
1302 	case emc6d100:
1303 	case emc6d102:
1304 	case emc6d103:
1305 		data->freq_map = adm1027_freq_map;
1306 		break;
1307 	default:
1308 		data->freq_map = lm85_freq_map;
1309 	}
1310 
1311 	/* Set the VRM version */
1312 	data->vrm = vid_which_vrm();
1313 
1314 	/* Initialize the LM85 chip */
1315 	lm85_init_client(client);
1316 
1317 	/* Register sysfs hooks */
1318 	err = sysfs_create_group(&client->dev.kobj, &lm85_group);
1319 	if (err)
1320 		goto err_kfree;
1321 
1322 	/* The ADT7463/68 have an optional VRM 10 mode where pin 21 is used
1323 	   as a sixth digital VID input rather than an analog input. */
1324 	data->vid = lm85_read_value(client, LM85_REG_VID);
1325 	if (!((data->type == adt7463 || data->type == adt7468) &&
1326 	    (data->vid & 0x80)))
1327 		if ((err = sysfs_create_group(&client->dev.kobj,
1328 					&lm85_group_in4)))
1329 			goto err_remove_files;
1330 
1331 	/* The EMC6D100 has 3 additional voltage inputs */
1332 	if (data->type == emc6d100)
1333 		if ((err = sysfs_create_group(&client->dev.kobj,
1334 					&lm85_group_in567)))
1335 			goto err_remove_files;
1336 
1337 	data->hwmon_dev = hwmon_device_register(&client->dev);
1338 	if (IS_ERR(data->hwmon_dev)) {
1339 		err = PTR_ERR(data->hwmon_dev);
1340 		goto err_remove_files;
1341 	}
1342 
1343 	return 0;
1344 
1345 	/* Error out and cleanup code */
1346  err_remove_files:
1347 	sysfs_remove_group(&client->dev.kobj, &lm85_group);
1348 	sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
1349 	if (data->type == emc6d100)
1350 		sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
1351  err_kfree:
1352 	kfree(data);
1353 	return err;
1354 }
1355 
1356 static int lm85_remove(struct i2c_client *client)
1357 {
1358 	struct lm85_data *data = i2c_get_clientdata(client);
1359 	hwmon_device_unregister(data->hwmon_dev);
1360 	sysfs_remove_group(&client->dev.kobj, &lm85_group);
1361 	sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
1362 	if (data->type == emc6d100)
1363 		sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
1364 	kfree(data);
1365 	return 0;
1366 }
1367 
1368 
1369 static int lm85_read_value(struct i2c_client *client, u8 reg)
1370 {
1371 	int res;
1372 
1373 	/* What size location is it? */
1374 	switch (reg) {
1375 	case LM85_REG_FAN(0):  /* Read WORD data */
1376 	case LM85_REG_FAN(1):
1377 	case LM85_REG_FAN(2):
1378 	case LM85_REG_FAN(3):
1379 	case LM85_REG_FAN_MIN(0):
1380 	case LM85_REG_FAN_MIN(1):
1381 	case LM85_REG_FAN_MIN(2):
1382 	case LM85_REG_FAN_MIN(3):
1383 	case LM85_REG_ALARM1:	/* Read both bytes at once */
1384 		res = i2c_smbus_read_byte_data(client, reg) & 0xff;
1385 		res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
1386 		break;
1387 	default:	/* Read BYTE data */
1388 		res = i2c_smbus_read_byte_data(client, reg);
1389 		break;
1390 	}
1391 
1392 	return res;
1393 }
1394 
1395 static void lm85_write_value(struct i2c_client *client, u8 reg, int value)
1396 {
1397 	switch (reg) {
1398 	case LM85_REG_FAN(0):  /* Write WORD data */
1399 	case LM85_REG_FAN(1):
1400 	case LM85_REG_FAN(2):
1401 	case LM85_REG_FAN(3):
1402 	case LM85_REG_FAN_MIN(0):
1403 	case LM85_REG_FAN_MIN(1):
1404 	case LM85_REG_FAN_MIN(2):
1405 	case LM85_REG_FAN_MIN(3):
1406 	/* NOTE: ALARM is read only, so not included here */
1407 		i2c_smbus_write_byte_data(client, reg, value & 0xff);
1408 		i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
1409 		break;
1410 	default:	/* Write BYTE data */
1411 		i2c_smbus_write_byte_data(client, reg, value);
1412 		break;
1413 	}
1414 }
1415 
1416 static struct lm85_data *lm85_update_device(struct device *dev)
1417 {
1418 	struct i2c_client *client = to_i2c_client(dev);
1419 	struct lm85_data *data = i2c_get_clientdata(client);
1420 	int i;
1421 
1422 	mutex_lock(&data->update_lock);
1423 
1424 	if (!data->valid ||
1425 	     time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {
1426 		/* Things that change quickly */
1427 		dev_dbg(&client->dev, "Reading sensor values\n");
1428 
1429 		/* Have to read extended bits first to "freeze" the
1430 		 * more significant bits that are read later.
1431 		 * There are 2 additional resolution bits per channel and we
1432 		 * have room for 4, so we shift them to the left.
1433 		 */
1434 		if (data->type == adm1027 || data->type == adt7463 ||
1435 		    data->type == adt7468) {
1436 			int ext1 = lm85_read_value(client,
1437 						   ADM1027_REG_EXTEND_ADC1);
1438 			int ext2 =  lm85_read_value(client,
1439 						    ADM1027_REG_EXTEND_ADC2);
1440 			int val = (ext1 << 8) + ext2;
1441 
1442 			for (i = 0; i <= 4; i++)
1443 				data->in_ext[i] =
1444 					((val >> (i * 2)) & 0x03) << 2;
1445 
1446 			for (i = 0; i <= 2; i++)
1447 				data->temp_ext[i] =
1448 					(val >> ((i + 4) * 2)) & 0x0c;
1449 		}
1450 
1451 		data->vid = lm85_read_value(client, LM85_REG_VID);
1452 
1453 		for (i = 0; i <= 3; ++i) {
1454 			data->in[i] =
1455 			    lm85_read_value(client, LM85_REG_IN(i));
1456 			data->fan[i] =
1457 			    lm85_read_value(client, LM85_REG_FAN(i));
1458 		}
1459 
1460 		if (!((data->type == adt7463 || data->type == adt7468) &&
1461 		    (data->vid & 0x80))) {
1462 			data->in[4] = lm85_read_value(client,
1463 				      LM85_REG_IN(4));
1464 		}
1465 
1466 		if (data->type == adt7468)
1467 			data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5);
1468 
1469 		for (i = 0; i <= 2; ++i) {
1470 			data->temp[i] =
1471 			    lm85_read_value(client, LM85_REG_TEMP(i));
1472 			data->pwm[i] =
1473 			    lm85_read_value(client, LM85_REG_PWM(i));
1474 
1475 			if (IS_ADT7468_OFF64(data))
1476 				data->temp[i] -= 64;
1477 		}
1478 
1479 		data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
1480 
1481 		if (data->type == emc6d100) {
1482 			/* Three more voltage sensors */
1483 			for (i = 5; i <= 7; ++i) {
1484 				data->in[i] = lm85_read_value(client,
1485 							EMC6D100_REG_IN(i));
1486 			}
1487 			/* More alarm bits */
1488 			data->alarms |= lm85_read_value(client,
1489 						EMC6D100_REG_ALARM3) << 16;
1490 		} else if (data->type == emc6d102 || data->type == emc6d103) {
1491 			/* Have to read LSB bits after the MSB ones because
1492 			   the reading of the MSB bits has frozen the
1493 			   LSBs (backward from the ADM1027).
1494 			 */
1495 			int ext1 = lm85_read_value(client,
1496 						   EMC6D102_REG_EXTEND_ADC1);
1497 			int ext2 = lm85_read_value(client,
1498 						   EMC6D102_REG_EXTEND_ADC2);
1499 			int ext3 = lm85_read_value(client,
1500 						   EMC6D102_REG_EXTEND_ADC3);
1501 			int ext4 = lm85_read_value(client,
1502 						   EMC6D102_REG_EXTEND_ADC4);
1503 			data->in_ext[0] = ext3 & 0x0f;
1504 			data->in_ext[1] = ext4 & 0x0f;
1505 			data->in_ext[2] = ext4 >> 4;
1506 			data->in_ext[3] = ext3 >> 4;
1507 			data->in_ext[4] = ext2 >> 4;
1508 
1509 			data->temp_ext[0] = ext1 & 0x0f;
1510 			data->temp_ext[1] = ext2 & 0x0f;
1511 			data->temp_ext[2] = ext1 >> 4;
1512 		}
1513 
1514 		data->last_reading = jiffies;
1515 	}  /* last_reading */
1516 
1517 	if (!data->valid ||
1518 	     time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
1519 		/* Things that don't change often */
1520 		dev_dbg(&client->dev, "Reading config values\n");
1521 
1522 		for (i = 0; i <= 3; ++i) {
1523 			data->in_min[i] =
1524 			    lm85_read_value(client, LM85_REG_IN_MIN(i));
1525 			data->in_max[i] =
1526 			    lm85_read_value(client, LM85_REG_IN_MAX(i));
1527 			data->fan_min[i] =
1528 			    lm85_read_value(client, LM85_REG_FAN_MIN(i));
1529 		}
1530 
1531 		if (!((data->type == adt7463 || data->type == adt7468) &&
1532 		    (data->vid & 0x80))) {
1533 			data->in_min[4] = lm85_read_value(client,
1534 					  LM85_REG_IN_MIN(4));
1535 			data->in_max[4] = lm85_read_value(client,
1536 					  LM85_REG_IN_MAX(4));
1537 		}
1538 
1539 		if (data->type == emc6d100) {
1540 			for (i = 5; i <= 7; ++i) {
1541 				data->in_min[i] = lm85_read_value(client,
1542 						EMC6D100_REG_IN_MIN(i));
1543 				data->in_max[i] = lm85_read_value(client,
1544 						EMC6D100_REG_IN_MAX(i));
1545 			}
1546 		}
1547 
1548 		for (i = 0; i <= 2; ++i) {
1549 			int val;
1550 
1551 			data->temp_min[i] =
1552 			    lm85_read_value(client, LM85_REG_TEMP_MIN(i));
1553 			data->temp_max[i] =
1554 			    lm85_read_value(client, LM85_REG_TEMP_MAX(i));
1555 
1556 			data->autofan[i].config =
1557 			    lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
1558 			val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
1559 			data->pwm_freq[i] = val & 0x07;
1560 			data->zone[i].range = val >> 4;
1561 			data->autofan[i].min_pwm =
1562 			    lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
1563 			data->zone[i].limit =
1564 			    lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
1565 			data->zone[i].critical =
1566 			    lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
1567 
1568 			if (IS_ADT7468_OFF64(data)) {
1569 				data->temp_min[i] -= 64;
1570 				data->temp_max[i] -= 64;
1571 				data->zone[i].limit -= 64;
1572 				data->zone[i].critical -= 64;
1573 			}
1574 		}
1575 
1576 		i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
1577 		data->autofan[0].min_off = (i & 0x20) != 0;
1578 		data->autofan[1].min_off = (i & 0x40) != 0;
1579 		data->autofan[2].min_off = (i & 0x80) != 0;
1580 
1581 		i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
1582 		data->zone[0].hyst = i >> 4;
1583 		data->zone[1].hyst = i & 0x0f;
1584 
1585 		i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
1586 		data->zone[2].hyst = i >> 4;
1587 
1588 		data->last_config = jiffies;
1589 	}  /* last_config */
1590 
1591 	data->valid = 1;
1592 
1593 	mutex_unlock(&data->update_lock);
1594 
1595 	return data;
1596 }
1597 
1598 
1599 static int __init sm_lm85_init(void)
1600 {
1601 	return i2c_add_driver(&lm85_driver);
1602 }
1603 
1604 static void __exit sm_lm85_exit(void)
1605 {
1606 	i2c_del_driver(&lm85_driver);
1607 }
1608 
1609 MODULE_LICENSE("GPL");
1610 MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
1611 	"Margit Schubert-While <margitsw@t-online.de>, "
1612 	"Justin Thiessen <jthiessen@penguincomputing.com>");
1613 MODULE_DESCRIPTION("LM85-B, LM85-C driver");
1614 
1615 module_init(sm_lm85_init);
1616 module_exit(sm_lm85_exit);
1617