xref: /openbmc/linux/drivers/hwmon/it87.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2     it87.c - Part of lm_sensors, Linux kernel modules for hardware
3              monitoring.
4 
5     Supports: IT8705F  Super I/O chip w/LPC interface
6               IT8712F  Super I/O chip w/LPC interface & SMBus
7               Sis950   A clone of the IT8705F
8 
9     Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com>
10     Largely inspired by lm78.c of the same package
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 /*
28     djg@pdp8.net David Gesswein 7/18/01
29     Modified to fix bug with not all alarms enabled.
30     Added ability to read battery voltage and select temperature sensor
31     type at module load time.
32 */
33 
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/jiffies.h>
38 #include <linux/i2c.h>
39 #include <linux/i2c-isa.h>
40 #include <linux/hwmon.h>
41 #include <linux/hwmon-sysfs.h>
42 #include <linux/hwmon-vid.h>
43 #include <linux/err.h>
44 #include <asm/io.h>
45 
46 
47 /* Addresses to scan */
48 static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
49 					0x2e, 0x2f, I2C_CLIENT_END };
50 static unsigned short isa_address;
51 
52 /* Insmod parameters */
53 I2C_CLIENT_INSMOD_2(it87, it8712);
54 
55 #define	REG	0x2e	/* The register to read/write */
56 #define	DEV	0x07	/* Register: Logical device select */
57 #define	VAL	0x2f	/* The value to read/write */
58 #define PME	0x04	/* The device with the fan registers in it */
59 #define	DEVID	0x20	/* Register: Device ID */
60 #define	DEVREV	0x22	/* Register: Device Revision */
61 
62 static inline int
63 superio_inb(int reg)
64 {
65 	outb(reg, REG);
66 	return inb(VAL);
67 }
68 
69 static int superio_inw(int reg)
70 {
71 	int val;
72 	outb(reg++, REG);
73 	val = inb(VAL) << 8;
74 	outb(reg, REG);
75 	val |= inb(VAL);
76 	return val;
77 }
78 
79 static inline void
80 superio_select(void)
81 {
82 	outb(DEV, REG);
83 	outb(PME, VAL);
84 }
85 
86 static inline void
87 superio_enter(void)
88 {
89 	outb(0x87, REG);
90 	outb(0x01, REG);
91 	outb(0x55, REG);
92 	outb(0x55, REG);
93 }
94 
95 static inline void
96 superio_exit(void)
97 {
98 	outb(0x02, REG);
99 	outb(0x02, VAL);
100 }
101 
102 #define IT8712F_DEVID 0x8712
103 #define IT8705F_DEVID 0x8705
104 #define IT87_ACT_REG  0x30
105 #define IT87_BASE_REG 0x60
106 
107 /* Update battery voltage after every reading if true */
108 static int update_vbat;
109 
110 /* Not all BIOSes properly configure the PWM registers */
111 static int fix_pwm_polarity;
112 
113 /* Chip Type */
114 
115 static u16 chip_type;
116 
117 /* Many IT87 constants specified below */
118 
119 /* Length of ISA address segment */
120 #define IT87_EXTENT 8
121 
122 /* Where are the ISA address/data registers relative to the base address */
123 #define IT87_ADDR_REG_OFFSET 5
124 #define IT87_DATA_REG_OFFSET 6
125 
126 /*----- The IT87 registers -----*/
127 
128 #define IT87_REG_CONFIG        0x00
129 
130 #define IT87_REG_ALARM1        0x01
131 #define IT87_REG_ALARM2        0x02
132 #define IT87_REG_ALARM3        0x03
133 
134 #define IT87_REG_VID           0x0a
135 #define IT87_REG_FAN_DIV       0x0b
136 
137 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
138 
139 #define IT87_REG_FAN(nr)       (0x0d + (nr))
140 #define IT87_REG_FAN_MIN(nr)   (0x10 + (nr))
141 #define IT87_REG_FAN_MAIN_CTRL 0x13
142 #define IT87_REG_FAN_CTL       0x14
143 #define IT87_REG_PWM(nr)       (0x15 + (nr))
144 
145 #define IT87_REG_VIN(nr)       (0x20 + (nr))
146 #define IT87_REG_TEMP(nr)      (0x29 + (nr))
147 
148 #define IT87_REG_VIN_MAX(nr)   (0x30 + (nr) * 2)
149 #define IT87_REG_VIN_MIN(nr)   (0x31 + (nr) * 2)
150 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
151 #define IT87_REG_TEMP_LOW(nr)  (0x41 + (nr) * 2)
152 
153 #define IT87_REG_I2C_ADDR      0x48
154 
155 #define IT87_REG_VIN_ENABLE    0x50
156 #define IT87_REG_TEMP_ENABLE   0x51
157 
158 #define IT87_REG_CHIPID        0x58
159 
160 #define IN_TO_REG(val)  (SENSORS_LIMIT((((val) + 8)/16),0,255))
161 #define IN_FROM_REG(val) ((val) * 16)
162 
163 static inline u8 FAN_TO_REG(long rpm, int div)
164 {
165 	if (rpm == 0)
166 		return 255;
167 	rpm = SENSORS_LIMIT(rpm, 1, 1000000);
168 	return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
169 			     254);
170 }
171 
172 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
173 
174 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
175 					((val)+500)/1000),-128,127))
176 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
177 
178 #define PWM_TO_REG(val)   ((val) >> 1)
179 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
180 
181 static int DIV_TO_REG(int val)
182 {
183 	int answer = 0;
184 	while ((val >>= 1) != 0)
185 		answer++;
186 	return answer;
187 }
188 #define DIV_FROM_REG(val) (1 << (val))
189 
190 
191 /* For each registered IT87, we need to keep some data in memory. That
192    data is pointed to by it87_list[NR]->data. The structure itself is
193    dynamically allocated, at the same time when a new it87 client is
194    allocated. */
195 struct it87_data {
196 	struct i2c_client client;
197 	struct class_device *class_dev;
198 	struct semaphore lock;
199 	enum chips type;
200 
201 	struct semaphore update_lock;
202 	char valid;		/* !=0 if following fields are valid */
203 	unsigned long last_updated;	/* In jiffies */
204 
205 	u8 in[9];		/* Register value */
206 	u8 in_max[9];		/* Register value */
207 	u8 in_min[9];		/* Register value */
208 	u8 fan[3];		/* Register value */
209 	u8 fan_min[3];		/* Register value */
210 	u8 temp[3];		/* Register value */
211 	u8 temp_high[3];	/* Register value */
212 	u8 temp_low[3];		/* Register value */
213 	u8 sensor;		/* Register value */
214 	u8 fan_div[3];		/* Register encoding, shifted right */
215 	u8 vid;			/* Register encoding, combined */
216 	int vrm;
217 	u32 alarms;		/* Register encoding, combined */
218 	u8 fan_main_ctrl;	/* Register value */
219 	u8 manual_pwm_ctl[3];   /* manual PWM value set by user */
220 };
221 
222 
223 static int it87_attach_adapter(struct i2c_adapter *adapter);
224 static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
225 static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
226 static int it87_detach_client(struct i2c_client *client);
227 
228 static int it87_read_value(struct i2c_client *client, u8 register);
229 static int it87_write_value(struct i2c_client *client, u8 register,
230 			u8 value);
231 static struct it87_data *it87_update_device(struct device *dev);
232 static int it87_check_pwm(struct i2c_client *client);
233 static void it87_init_client(struct i2c_client *client, struct it87_data *data);
234 
235 
236 static struct i2c_driver it87_driver = {
237 	.owner		= THIS_MODULE,
238 	.name		= "it87",
239 	.id		= I2C_DRIVERID_IT87,
240 	.flags		= I2C_DF_NOTIFY,
241 	.attach_adapter	= it87_attach_adapter,
242 	.detach_client	= it87_detach_client,
243 };
244 
245 static struct i2c_driver it87_isa_driver = {
246 	.owner		= THIS_MODULE,
247 	.name		= "it87-isa",
248 	.attach_adapter	= it87_isa_attach_adapter,
249 	.detach_client	= it87_detach_client,
250 };
251 
252 
253 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
254 		char *buf)
255 {
256 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
257 	int nr = sensor_attr->index;
258 
259 	struct it87_data *data = it87_update_device(dev);
260 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
261 }
262 
263 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
264 		char *buf)
265 {
266 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
267 	int nr = sensor_attr->index;
268 
269 	struct it87_data *data = it87_update_device(dev);
270 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
271 }
272 
273 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
274 		char *buf)
275 {
276 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
277 	int nr = sensor_attr->index;
278 
279 	struct it87_data *data = it87_update_device(dev);
280 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
281 }
282 
283 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
284 		const char *buf, size_t count)
285 {
286 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
287 	int nr = sensor_attr->index;
288 
289 	struct i2c_client *client = to_i2c_client(dev);
290 	struct it87_data *data = i2c_get_clientdata(client);
291 	unsigned long val = simple_strtoul(buf, NULL, 10);
292 
293 	down(&data->update_lock);
294 	data->in_min[nr] = IN_TO_REG(val);
295 	it87_write_value(client, IT87_REG_VIN_MIN(nr),
296 			data->in_min[nr]);
297 	up(&data->update_lock);
298 	return count;
299 }
300 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
301 		const char *buf, size_t count)
302 {
303 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
304 	int nr = sensor_attr->index;
305 
306 	struct i2c_client *client = to_i2c_client(dev);
307 	struct it87_data *data = i2c_get_clientdata(client);
308 	unsigned long val = simple_strtoul(buf, NULL, 10);
309 
310 	down(&data->update_lock);
311 	data->in_max[nr] = IN_TO_REG(val);
312 	it87_write_value(client, IT87_REG_VIN_MAX(nr),
313 			data->in_max[nr]);
314 	up(&data->update_lock);
315 	return count;
316 }
317 
318 #define show_in_offset(offset)					\
319 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,		\
320 		show_in, NULL, offset);
321 
322 #define limit_in_offset(offset)					\
323 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,	\
324 		show_in_min, set_in_min, offset);		\
325 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,	\
326 		show_in_max, set_in_max, offset);
327 
328 show_in_offset(0);
329 limit_in_offset(0);
330 show_in_offset(1);
331 limit_in_offset(1);
332 show_in_offset(2);
333 limit_in_offset(2);
334 show_in_offset(3);
335 limit_in_offset(3);
336 show_in_offset(4);
337 limit_in_offset(4);
338 show_in_offset(5);
339 limit_in_offset(5);
340 show_in_offset(6);
341 limit_in_offset(6);
342 show_in_offset(7);
343 limit_in_offset(7);
344 show_in_offset(8);
345 
346 /* 3 temperatures */
347 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
348 		char *buf)
349 {
350 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
351 	int nr = sensor_attr->index;
352 
353 	struct it87_data *data = it87_update_device(dev);
354 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
355 }
356 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
357 		char *buf)
358 {
359 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
360 	int nr = sensor_attr->index;
361 
362 	struct it87_data *data = it87_update_device(dev);
363 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
364 }
365 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
366 		char *buf)
367 {
368 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
369 	int nr = sensor_attr->index;
370 
371 	struct it87_data *data = it87_update_device(dev);
372 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
373 }
374 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
375 		const char *buf, size_t count)
376 {
377 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
378 	int nr = sensor_attr->index;
379 
380 	struct i2c_client *client = to_i2c_client(dev);
381 	struct it87_data *data = i2c_get_clientdata(client);
382 	int val = simple_strtol(buf, NULL, 10);
383 
384 	down(&data->update_lock);
385 	data->temp_high[nr] = TEMP_TO_REG(val);
386 	it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
387 	up(&data->update_lock);
388 	return count;
389 }
390 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
391 		const char *buf, size_t count)
392 {
393 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
394 	int nr = sensor_attr->index;
395 
396 	struct i2c_client *client = to_i2c_client(dev);
397 	struct it87_data *data = i2c_get_clientdata(client);
398 	int val = simple_strtol(buf, NULL, 10);
399 
400 	down(&data->update_lock);
401 	data->temp_low[nr] = TEMP_TO_REG(val);
402 	it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
403 	up(&data->update_lock);
404 	return count;
405 }
406 #define show_temp_offset(offset)					\
407 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,		\
408 		show_temp, NULL, offset - 1);				\
409 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,	\
410 		show_temp_max, set_temp_max, offset - 1);		\
411 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,	\
412 		show_temp_min, set_temp_min, offset - 1);
413 
414 show_temp_offset(1);
415 show_temp_offset(2);
416 show_temp_offset(3);
417 
418 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
419 		char *buf)
420 {
421 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
422 	int nr = sensor_attr->index;
423 
424 	struct it87_data *data = it87_update_device(dev);
425 	u8 reg = data->sensor; /* In case the value is updated while we use it */
426 
427 	if (reg & (1 << nr))
428 		return sprintf(buf, "3\n");  /* thermal diode */
429 	if (reg & (8 << nr))
430 		return sprintf(buf, "2\n");  /* thermistor */
431 	return sprintf(buf, "0\n");      /* disabled */
432 }
433 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
434 		const char *buf, size_t count)
435 {
436 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
437 	int nr = sensor_attr->index;
438 
439 	struct i2c_client *client = to_i2c_client(dev);
440 	struct it87_data *data = i2c_get_clientdata(client);
441 	int val = simple_strtol(buf, NULL, 10);
442 
443 	down(&data->update_lock);
444 
445 	data->sensor &= ~(1 << nr);
446 	data->sensor &= ~(8 << nr);
447 	/* 3 = thermal diode; 2 = thermistor; 0 = disabled */
448 	if (val == 3)
449 	    data->sensor |= 1 << nr;
450 	else if (val == 2)
451 	    data->sensor |= 8 << nr;
452 	else if (val != 0) {
453 		up(&data->update_lock);
454 		return -EINVAL;
455 	}
456 	it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
457 	up(&data->update_lock);
458 	return count;
459 }
460 #define show_sensor_offset(offset)					\
461 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR,	\
462 		show_sensor, set_sensor, offset - 1);
463 
464 show_sensor_offset(1);
465 show_sensor_offset(2);
466 show_sensor_offset(3);
467 
468 /* 3 Fans */
469 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
470 		char *buf)
471 {
472 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
473 	int nr = sensor_attr->index;
474 
475 	struct it87_data *data = it87_update_device(dev);
476 	return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
477 				DIV_FROM_REG(data->fan_div[nr])));
478 }
479 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
480 		char *buf)
481 {
482 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
483 	int nr = sensor_attr->index;
484 
485 	struct it87_data *data = it87_update_device(dev);
486 	return sprintf(buf,"%d\n",
487 		FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
488 }
489 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
490 		char *buf)
491 {
492 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
493 	int nr = sensor_attr->index;
494 
495 	struct it87_data *data = it87_update_device(dev);
496 	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
497 }
498 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
499 		char *buf)
500 {
501 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
502 	int nr = sensor_attr->index;
503 
504 	struct it87_data *data = it87_update_device(dev);
505 	return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
506 }
507 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
508 		char *buf)
509 {
510 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
511 	int nr = sensor_attr->index;
512 
513 	struct it87_data *data = it87_update_device(dev);
514 	return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
515 }
516 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
517 		const char *buf, size_t count)
518 {
519 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
520 	int nr = sensor_attr->index;
521 
522 	struct i2c_client *client = to_i2c_client(dev);
523 	struct it87_data *data = i2c_get_clientdata(client);
524 	int val = simple_strtol(buf, NULL, 10);
525 
526 	down(&data->update_lock);
527 	data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
528 	it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
529 	up(&data->update_lock);
530 	return count;
531 }
532 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
533 		const char *buf, size_t count)
534 {
535 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
536 	int nr = sensor_attr->index;
537 
538 	struct i2c_client *client = to_i2c_client(dev);
539 	struct it87_data *data = i2c_get_clientdata(client);
540 	int val = simple_strtol(buf, NULL, 10);
541 	int i, min[3];
542 	u8 old;
543 
544 	down(&data->update_lock);
545 	old = it87_read_value(client, IT87_REG_FAN_DIV);
546 
547 	for (i = 0; i < 3; i++)
548 		min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i]));
549 
550 	switch (nr) {
551 	case 0:
552 	case 1:
553 		data->fan_div[nr] = DIV_TO_REG(val);
554 		break;
555 	case 2:
556 		if (val < 8)
557 			data->fan_div[nr] = 1;
558 		else
559 			data->fan_div[nr] = 3;
560 	}
561 	val = old & 0x80;
562 	val |= (data->fan_div[0] & 0x07);
563 	val |= (data->fan_div[1] & 0x07) << 3;
564 	if (data->fan_div[2] == 3)
565 		val |= 0x1 << 6;
566 	it87_write_value(client, IT87_REG_FAN_DIV, val);
567 
568 	for (i = 0; i < 3; i++) {
569 		data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i]));
570 		it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
571 	}
572 	up(&data->update_lock);
573 	return count;
574 }
575 static ssize_t set_pwm_enable(struct device *dev,
576 		struct device_attribute *attr, const char *buf, size_t count)
577 {
578 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
579 	int nr = sensor_attr->index;
580 
581 	struct i2c_client *client = to_i2c_client(dev);
582 	struct it87_data *data = i2c_get_clientdata(client);
583 	int val = simple_strtol(buf, NULL, 10);
584 
585 	down(&data->update_lock);
586 
587 	if (val == 0) {
588 		int tmp;
589 		/* make sure the fan is on when in on/off mode */
590 		tmp = it87_read_value(client, IT87_REG_FAN_CTL);
591 		it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
592 		/* set on/off mode */
593 		data->fan_main_ctrl &= ~(1 << nr);
594 		it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
595 	} else if (val == 1) {
596 		/* set SmartGuardian mode */
597 		data->fan_main_ctrl |= (1 << nr);
598 		it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
599 		/* set saved pwm value, clear FAN_CTLX PWM mode bit */
600 		it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
601 	} else {
602 		up(&data->update_lock);
603 		return -EINVAL;
604 	}
605 
606 	up(&data->update_lock);
607 	return count;
608 }
609 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
610 		const char *buf, size_t count)
611 {
612 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
613 	int nr = sensor_attr->index;
614 
615 	struct i2c_client *client = to_i2c_client(dev);
616 	struct it87_data *data = i2c_get_clientdata(client);
617 	int val = simple_strtol(buf, NULL, 10);
618 
619 	if (val < 0 || val > 255)
620 		return -EINVAL;
621 
622 	down(&data->update_lock);
623 	data->manual_pwm_ctl[nr] = val;
624 	if (data->fan_main_ctrl & (1 << nr))
625 		it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
626 	up(&data->update_lock);
627 	return count;
628 }
629 
630 #define show_fan_offset(offset)					\
631 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,		\
632 		show_fan, NULL, offset - 1);			\
633 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
634 		show_fan_min, set_fan_min, offset - 1);		\
635 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
636 		show_fan_div, set_fan_div, offset - 1);
637 
638 show_fan_offset(1);
639 show_fan_offset(2);
640 show_fan_offset(3);
641 
642 #define show_pwm_offset(offset)						\
643 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,	\
644 		show_pwm_enable, set_pwm_enable, offset - 1);		\
645 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,		\
646 		show_pwm, set_pwm, offset - 1);
647 
648 show_pwm_offset(1);
649 show_pwm_offset(2);
650 show_pwm_offset(3);
651 
652 /* Alarms */
653 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
654 {
655 	struct it87_data *data = it87_update_device(dev);
656 	return sprintf(buf, "%u\n", data->alarms);
657 }
658 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
659 
660 static ssize_t
661 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
662 {
663 	struct it87_data *data = it87_update_device(dev);
664 	return sprintf(buf, "%ld\n", (long) data->vrm);
665 }
666 static ssize_t
667 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
668 {
669 	struct i2c_client *client = to_i2c_client(dev);
670 	struct it87_data *data = i2c_get_clientdata(client);
671 	u32 val;
672 
673 	val = simple_strtoul(buf, NULL, 10);
674 	data->vrm = val;
675 
676 	return count;
677 }
678 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
679 #define device_create_file_vrm(client) \
680 device_create_file(&client->dev, &dev_attr_vrm)
681 
682 static ssize_t
683 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
684 {
685 	struct it87_data *data = it87_update_device(dev);
686 	return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
687 }
688 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
689 #define device_create_file_vid(client) \
690 device_create_file(&client->dev, &dev_attr_cpu0_vid)
691 
692 /* This function is called when:
693      * it87_driver is inserted (when this module is loaded), for each
694        available adapter
695      * when a new adapter is inserted (and it87_driver is still present) */
696 static int it87_attach_adapter(struct i2c_adapter *adapter)
697 {
698 	if (!(adapter->class & I2C_CLASS_HWMON))
699 		return 0;
700 	return i2c_probe(adapter, &addr_data, it87_detect);
701 }
702 
703 static int it87_isa_attach_adapter(struct i2c_adapter *adapter)
704 {
705 	return it87_detect(adapter, isa_address, -1);
706 }
707 
708 /* SuperIO detection - will change isa_address if a chip is found */
709 static int __init it87_find(unsigned short *address)
710 {
711 	int err = -ENODEV;
712 
713 	superio_enter();
714 	chip_type = superio_inw(DEVID);
715 	if (chip_type != IT8712F_DEVID
716 	 && chip_type != IT8705F_DEVID)
717 	 	goto exit;
718 
719 	superio_select();
720 	if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
721 		pr_info("it87: Device not activated, skipping\n");
722 		goto exit;
723 	}
724 
725 	*address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
726 	if (*address == 0) {
727 		pr_info("it87: Base address not set, skipping\n");
728 		goto exit;
729 	}
730 
731 	err = 0;
732 	pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
733 		chip_type, *address, superio_inb(DEVREV) & 0x0f);
734 
735 exit:
736 	superio_exit();
737 	return err;
738 }
739 
740 /* This function is called by i2c_probe */
741 static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
742 {
743 	int i;
744 	struct i2c_client *new_client;
745 	struct it87_data *data;
746 	int err = 0;
747 	const char *name = "";
748 	int is_isa = i2c_is_isa_adapter(adapter);
749 	int enable_pwm_interface;
750 
751 	if (!is_isa &&
752 	    !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
753 		goto ERROR0;
754 
755 	/* Reserve the ISA region */
756 	if (is_isa)
757 		if (!request_region(address, IT87_EXTENT, it87_isa_driver.name))
758 			goto ERROR0;
759 
760 	/* For now, we presume we have a valid client. We create the
761 	   client structure, even though we cannot fill it completely yet.
762 	   But it allows us to access it87_{read,write}_value. */
763 
764 	if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
765 		err = -ENOMEM;
766 		goto ERROR1;
767 	}
768 
769 	new_client = &data->client;
770 	if (is_isa)
771 		init_MUTEX(&data->lock);
772 	i2c_set_clientdata(new_client, data);
773 	new_client->addr = address;
774 	new_client->adapter = adapter;
775 	new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
776 	new_client->flags = 0;
777 
778 	/* Now, we do the remaining detection. */
779 
780 	if (kind < 0) {
781 		if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
782 		  || (!is_isa
783 		   && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
784 		   	err = -ENODEV;
785 			goto ERROR2;
786 		}
787 	}
788 
789 	/* Determine the chip type. */
790 	if (kind <= 0) {
791 		i = it87_read_value(new_client, IT87_REG_CHIPID);
792 		if (i == 0x90) {
793 			kind = it87;
794 			if ((is_isa) && (chip_type == IT8712F_DEVID))
795 				kind = it8712;
796 		}
797 		else {
798 			if (kind == 0)
799 				dev_info(&adapter->dev,
800 					"Ignoring 'force' parameter for unknown chip at "
801 					"adapter %d, address 0x%02x\n",
802 					i2c_adapter_id(adapter), address);
803 			err = -ENODEV;
804 			goto ERROR2;
805 		}
806 	}
807 
808 	if (kind == it87) {
809 		name = "it87";
810 	} else if (kind == it8712) {
811 		name = "it8712";
812 	}
813 
814 	/* Fill in the remaining client fields and put it into the global list */
815 	strlcpy(new_client->name, name, I2C_NAME_SIZE);
816 	data->type = kind;
817 	data->valid = 0;
818 	init_MUTEX(&data->update_lock);
819 
820 	/* Tell the I2C layer a new client has arrived */
821 	if ((err = i2c_attach_client(new_client)))
822 		goto ERROR2;
823 
824 	/* Check PWM configuration */
825 	enable_pwm_interface = it87_check_pwm(new_client);
826 
827 	/* Initialize the IT87 chip */
828 	it87_init_client(new_client, data);
829 
830 	/* Register sysfs hooks */
831 	data->class_dev = hwmon_device_register(&new_client->dev);
832 	if (IS_ERR(data->class_dev)) {
833 		err = PTR_ERR(data->class_dev);
834 		goto ERROR3;
835 	}
836 
837 	device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
838 	device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
839 	device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
840 	device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
841 	device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
842 	device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
843 	device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
844 	device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
845 	device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
846 	device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
847 	device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
848 	device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
849 	device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
850 	device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
851 	device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
852 	device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
853 	device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
854 	device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
855 	device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
856 	device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
857 	device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
858 	device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
859 	device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
860 	device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
861 	device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
862 	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
863 	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
864 	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
865 	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
866 	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
867 	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
868 	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
869 	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
870 	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
871 	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
872 	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
873 	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
874 	device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
875 	device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
876 	device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
877 	device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
878 	device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
879 	device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
880 	device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
881 	device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
882 	device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
883 	device_create_file(&new_client->dev, &dev_attr_alarms);
884 	if (enable_pwm_interface) {
885 		device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
886 		device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
887 		device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
888 		device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
889 		device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
890 		device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
891 	}
892 
893 	if (data->type == it8712) {
894 		data->vrm = vid_which_vrm();
895 		device_create_file_vrm(new_client);
896 		device_create_file_vid(new_client);
897 	}
898 
899 	return 0;
900 
901 ERROR3:
902 	i2c_detach_client(new_client);
903 ERROR2:
904 	kfree(data);
905 ERROR1:
906 	if (is_isa)
907 		release_region(address, IT87_EXTENT);
908 ERROR0:
909 	return err;
910 }
911 
912 static int it87_detach_client(struct i2c_client *client)
913 {
914 	struct it87_data *data = i2c_get_clientdata(client);
915 	int err;
916 
917 	hwmon_device_unregister(data->class_dev);
918 
919 	if ((err = i2c_detach_client(client)))
920 		return err;
921 
922 	if(i2c_is_isa_client(client))
923 		release_region(client->addr, IT87_EXTENT);
924 	kfree(data);
925 
926 	return 0;
927 }
928 
929 /* The SMBus locks itself, but ISA access must be locked explicitly!
930    We don't want to lock the whole ISA bus, so we lock each client
931    separately.
932    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
933    would slow down the IT87 access and should not be necessary. */
934 static int it87_read_value(struct i2c_client *client, u8 reg)
935 {
936 	struct it87_data *data = i2c_get_clientdata(client);
937 
938 	int res;
939 	if (i2c_is_isa_client(client)) {
940 		down(&data->lock);
941 		outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
942 		res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
943 		up(&data->lock);
944 		return res;
945 	} else
946 		return i2c_smbus_read_byte_data(client, reg);
947 }
948 
949 /* The SMBus locks itself, but ISA access muse be locked explicitly!
950    We don't want to lock the whole ISA bus, so we lock each client
951    separately.
952    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
953    would slow down the IT87 access and should not be necessary. */
954 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
955 {
956 	struct it87_data *data = i2c_get_clientdata(client);
957 
958 	if (i2c_is_isa_client(client)) {
959 		down(&data->lock);
960 		outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
961 		outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
962 		up(&data->lock);
963 		return 0;
964 	} else
965 		return i2c_smbus_write_byte_data(client, reg, value);
966 }
967 
968 /* Return 1 if and only if the PWM interface is safe to use */
969 static int it87_check_pwm(struct i2c_client *client)
970 {
971 	/* Some BIOSes fail to correctly configure the IT87 fans. All fans off
972 	 * and polarity set to active low is sign that this is the case so we
973 	 * disable pwm control to protect the user. */
974 	int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
975 	if ((tmp & 0x87) == 0) {
976 		if (fix_pwm_polarity) {
977 			/* The user asks us to attempt a chip reconfiguration.
978 			 * This means switching to active high polarity and
979 			 * inverting all fan speed values. */
980 			int i;
981 			u8 pwm[3];
982 
983 			for (i = 0; i < 3; i++)
984 				pwm[i] = it87_read_value(client,
985 							 IT87_REG_PWM(i));
986 
987 			/* If any fan is in automatic pwm mode, the polarity
988 			 * might be correct, as suspicious as it seems, so we
989 			 * better don't change anything (but still disable the
990 			 * PWM interface). */
991 			if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
992 				dev_info(&client->dev, "Reconfiguring PWM to "
993 					 "active high polarity\n");
994 				it87_write_value(client, IT87_REG_FAN_CTL,
995 						 tmp | 0x87);
996 				for (i = 0; i < 3; i++)
997 					it87_write_value(client,
998 							 IT87_REG_PWM(i),
999 							 0x7f & ~pwm[i]);
1000 				return 1;
1001 			}
1002 
1003 			dev_info(&client->dev, "PWM configuration is "
1004 				 "too broken to be fixed\n");
1005 		}
1006 
1007 		dev_info(&client->dev, "Detected broken BIOS "
1008 			 "defaults, disabling PWM interface\n");
1009 		return 0;
1010 	} else if (fix_pwm_polarity) {
1011 		dev_info(&client->dev, "PWM configuration looks "
1012 			 "sane, won't touch\n");
1013 	}
1014 
1015 	return 1;
1016 }
1017 
1018 /* Called when we have found a new IT87. */
1019 static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1020 {
1021 	int tmp, i;
1022 
1023 	/* initialize to sane defaults:
1024 	 * - if the chip is in manual pwm mode, this will be overwritten with
1025 	 *   the actual settings on the chip (so in this case, initialization
1026 	 *   is not needed)
1027 	 * - if in automatic or on/off mode, we could switch to manual mode,
1028 	 *   read the registers and set manual_pwm_ctl accordingly, but currently
1029 	 *   this is not implemented, so we initialize to something sane */
1030 	for (i = 0; i < 3; i++) {
1031 		data->manual_pwm_ctl[i] = 0xff;
1032 	}
1033 
1034 	/* Check if temperature channnels are reset manually or by some reason */
1035 	tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1036 	if ((tmp & 0x3f) == 0) {
1037 		/* Temp1,Temp3=thermistor; Temp2=thermal diode */
1038 		tmp = (tmp & 0xc0) | 0x2a;
1039 		it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1040 	}
1041 	data->sensor = tmp;
1042 
1043 	/* Check if voltage monitors are reset manually or by some reason */
1044 	tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1045 	if ((tmp & 0xff) == 0) {
1046 		/* Enable all voltage monitors */
1047 		it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1048 	}
1049 
1050 	/* Check if tachometers are reset manually or by some reason */
1051 	data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1052 	if ((data->fan_main_ctrl & 0x70) == 0) {
1053 		/* Enable all fan tachometers */
1054 		data->fan_main_ctrl |= 0x70;
1055 		it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1056 	}
1057 
1058 	/* Set current fan mode registers and the default settings for the
1059 	 * other mode registers */
1060 	for (i = 0; i < 3; i++) {
1061 		if (data->fan_main_ctrl & (1 << i)) {
1062 			/* pwm mode */
1063 			tmp = it87_read_value(client, IT87_REG_PWM(i));
1064 			if (tmp & 0x80) {
1065 				/* automatic pwm - not yet implemented, but
1066 				 * leave the settings made by the BIOS alone
1067 				 * until a change is requested via the sysfs
1068 				 * interface */
1069 			} else {
1070 				/* manual pwm */
1071 				data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1072 			}
1073 		}
1074  	}
1075 
1076 	/* Start monitoring */
1077 	it87_write_value(client, IT87_REG_CONFIG,
1078 			 (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1079 			 | (update_vbat ? 0x41 : 0x01));
1080 }
1081 
1082 static struct it87_data *it87_update_device(struct device *dev)
1083 {
1084 	struct i2c_client *client = to_i2c_client(dev);
1085 	struct it87_data *data = i2c_get_clientdata(client);
1086 	int i;
1087 
1088 	down(&data->update_lock);
1089 
1090 	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1091 	    || !data->valid) {
1092 
1093 		if (update_vbat) {
1094 			/* Cleared after each update, so reenable.  Value
1095 		 	  returned by this read will be previous value */
1096 			it87_write_value(client, IT87_REG_CONFIG,
1097 			   it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1098 		}
1099 		for (i = 0; i <= 7; i++) {
1100 			data->in[i] =
1101 			    it87_read_value(client, IT87_REG_VIN(i));
1102 			data->in_min[i] =
1103 			    it87_read_value(client, IT87_REG_VIN_MIN(i));
1104 			data->in_max[i] =
1105 			    it87_read_value(client, IT87_REG_VIN_MAX(i));
1106 		}
1107 		data->in[8] =
1108 		    it87_read_value(client, IT87_REG_VIN(8));
1109 		/* Temperature sensor doesn't have limit registers, set
1110 		   to min and max value */
1111 		data->in_min[8] = 0;
1112 		data->in_max[8] = 255;
1113 
1114 		for (i = 0; i < 3; i++) {
1115 			data->fan[i] =
1116 			    it87_read_value(client, IT87_REG_FAN(i));
1117 			data->fan_min[i] =
1118 			    it87_read_value(client, IT87_REG_FAN_MIN(i));
1119 		}
1120 		for (i = 0; i < 3; i++) {
1121 			data->temp[i] =
1122 			    it87_read_value(client, IT87_REG_TEMP(i));
1123 			data->temp_high[i] =
1124 			    it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1125 			data->temp_low[i] =
1126 			    it87_read_value(client, IT87_REG_TEMP_LOW(i));
1127 		}
1128 
1129 		i = it87_read_value(client, IT87_REG_FAN_DIV);
1130 		data->fan_div[0] = i & 0x07;
1131 		data->fan_div[1] = (i >> 3) & 0x07;
1132 		data->fan_div[2] = (i & 0x40) ? 3 : 1;
1133 
1134 		data->alarms =
1135 			it87_read_value(client, IT87_REG_ALARM1) |
1136 			(it87_read_value(client, IT87_REG_ALARM2) << 8) |
1137 			(it87_read_value(client, IT87_REG_ALARM3) << 16);
1138 		data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1139 
1140 		data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1141 		/* The 8705 does not have VID capability */
1142 		if (data->type == it8712) {
1143 			data->vid = it87_read_value(client, IT87_REG_VID);
1144 			data->vid &= 0x1f;
1145 		}
1146 		data->last_updated = jiffies;
1147 		data->valid = 1;
1148 	}
1149 
1150 	up(&data->update_lock);
1151 
1152 	return data;
1153 }
1154 
1155 static int __init sm_it87_init(void)
1156 {
1157 	int res;
1158 
1159 	res = i2c_add_driver(&it87_driver);
1160 	if (res)
1161 		return res;
1162 
1163 	if (!it87_find(&isa_address)) {
1164 		res = i2c_isa_add_driver(&it87_isa_driver);
1165 		if (res) {
1166 			i2c_del_driver(&it87_driver);
1167 			return res;
1168 		}
1169 	}
1170 
1171 	return 0;
1172 }
1173 
1174 static void __exit sm_it87_exit(void)
1175 {
1176 	i2c_isa_del_driver(&it87_isa_driver);
1177 	i2c_del_driver(&it87_driver);
1178 }
1179 
1180 
1181 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1182 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1183 module_param(update_vbat, bool, 0);
1184 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1185 module_param(fix_pwm_polarity, bool, 0);
1186 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1187 MODULE_LICENSE("GPL");
1188 
1189 module_init(sm_it87_init);
1190 module_exit(sm_it87_exit);
1191