a61f5d00f10a2abf1cf0211c9f7d1355db0cf28e
[linux-2.6.git] / drivers / hwmon / it87.c
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         u8 reg = it87_read_value(client, IT87_REG_FAN_DIV);
526
527         down(&data->update_lock);
528         switch (nr) {
529         case 0: data->fan_div[nr] = reg & 0x07; break;
530         case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
531         case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
532         }
533
534         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
535         it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
536         up(&data->update_lock);
537         return count;
538 }
539 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
540                 const char *buf, size_t count)
541 {
542         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
543         int nr = sensor_attr->index;
544
545         struct i2c_client *client = to_i2c_client(dev);
546         struct it87_data *data = i2c_get_clientdata(client);
547         int val = simple_strtol(buf, NULL, 10);
548         int i, min[3];
549         u8 old;
550
551         down(&data->update_lock);
552         old = it87_read_value(client, IT87_REG_FAN_DIV);
553
554         for (i = 0; i < 3; i++)
555                 min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i]));
556
557         switch (nr) {
558         case 0:
559         case 1:
560                 data->fan_div[nr] = DIV_TO_REG(val);
561                 break;
562         case 2:
563                 if (val < 8)
564                         data->fan_div[nr] = 1;
565                 else
566                         data->fan_div[nr] = 3;
567         }
568         val = old & 0x80;
569         val |= (data->fan_div[0] & 0x07);
570         val |= (data->fan_div[1] & 0x07) << 3;
571         if (data->fan_div[2] == 3)
572                 val |= 0x1 << 6;
573         it87_write_value(client, IT87_REG_FAN_DIV, val);
574
575         for (i = 0; i < 3; i++) {
576                 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i]));
577                 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
578         }
579         up(&data->update_lock);
580         return count;
581 }
582 static ssize_t set_pwm_enable(struct device *dev,
583                 struct device_attribute *attr, const char *buf, size_t count)
584 {
585         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
586         int nr = sensor_attr->index;
587
588         struct i2c_client *client = to_i2c_client(dev);
589         struct it87_data *data = i2c_get_clientdata(client);
590         int val = simple_strtol(buf, NULL, 10);
591
592         down(&data->update_lock);
593
594         if (val == 0) {
595                 int tmp;
596                 /* make sure the fan is on when in on/off mode */
597                 tmp = it87_read_value(client, IT87_REG_FAN_CTL);
598                 it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
599                 /* set on/off mode */
600                 data->fan_main_ctrl &= ~(1 << nr);
601                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
602         } else if (val == 1) {
603                 /* set SmartGuardian mode */
604                 data->fan_main_ctrl |= (1 << nr);
605                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
606                 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
607                 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
608         } else {
609                 up(&data->update_lock);
610                 return -EINVAL;
611         }
612
613         up(&data->update_lock);
614         return count;
615 }
616 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
617                 const char *buf, size_t count)
618 {
619         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
620         int nr = sensor_attr->index;
621
622         struct i2c_client *client = to_i2c_client(dev);
623         struct it87_data *data = i2c_get_clientdata(client);
624         int val = simple_strtol(buf, NULL, 10);
625
626         if (val < 0 || val > 255)
627                 return -EINVAL;
628
629         down(&data->update_lock);
630         data->manual_pwm_ctl[nr] = val;
631         if (data->fan_main_ctrl & (1 << nr))
632                 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
633         up(&data->update_lock);
634         return count;
635 }
636
637 #define show_fan_offset(offset)                                 \
638 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
639                 show_fan, NULL, offset - 1);                    \
640 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
641                 show_fan_min, set_fan_min, offset - 1);         \
642 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
643                 show_fan_div, set_fan_div, offset - 1);
644
645 show_fan_offset(1);
646 show_fan_offset(2);
647 show_fan_offset(3);
648
649 #define show_pwm_offset(offset)                                         \
650 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,      \
651                 show_pwm_enable, set_pwm_enable, offset - 1);           \
652 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,               \
653                 show_pwm, set_pwm, offset - 1);
654
655 show_pwm_offset(1);
656 show_pwm_offset(2);
657 show_pwm_offset(3);
658
659 /* Alarms */
660 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
661 {
662         struct it87_data *data = it87_update_device(dev);
663         return sprintf(buf, "%u\n", data->alarms);
664 }
665 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
666
667 static ssize_t
668 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
669 {
670         struct it87_data *data = it87_update_device(dev);
671         return sprintf(buf, "%ld\n", (long) data->vrm);
672 }
673 static ssize_t
674 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
675 {
676         struct i2c_client *client = to_i2c_client(dev);
677         struct it87_data *data = i2c_get_clientdata(client);
678         u32 val;
679
680         val = simple_strtoul(buf, NULL, 10);
681         data->vrm = val;
682
683         return count;
684 }
685 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
686 #define device_create_file_vrm(client) \
687 device_create_file(&client->dev, &dev_attr_vrm)
688
689 static ssize_t
690 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
691 {
692         struct it87_data *data = it87_update_device(dev);
693         return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
694 }
695 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
696 #define device_create_file_vid(client) \
697 device_create_file(&client->dev, &dev_attr_cpu0_vid)
698
699 /* This function is called when:
700      * it87_driver is inserted (when this module is loaded), for each
701        available adapter
702      * when a new adapter is inserted (and it87_driver is still present) */
703 static int it87_attach_adapter(struct i2c_adapter *adapter)
704 {
705         if (!(adapter->class & I2C_CLASS_HWMON))
706                 return 0;
707         return i2c_probe(adapter, &addr_data, it87_detect);
708 }
709
710 static int it87_isa_attach_adapter(struct i2c_adapter *adapter)
711 {
712         return it87_detect(adapter, isa_address, -1);
713 }
714
715 /* SuperIO detection - will change isa_address if a chip is found */
716 static int __init it87_find(unsigned short *address)
717 {
718         int err = -ENODEV;
719
720         superio_enter();
721         chip_type = superio_inw(DEVID);
722         if (chip_type != IT8712F_DEVID
723          && chip_type != IT8705F_DEVID)
724                 goto exit;
725
726         superio_select();
727         if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
728                 pr_info("it87: Device not activated, skipping\n");
729                 goto exit;
730         }
731
732         *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
733         if (*address == 0) {
734                 pr_info("it87: Base address not set, skipping\n");
735                 goto exit;
736         }
737
738         err = 0;
739         pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
740                 chip_type, *address, superio_inb(DEVREV) & 0x0f);
741
742 exit:
743         superio_exit();
744         return err;
745 }
746
747 /* This function is called by i2c_probe */
748 static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
749 {
750         int i;
751         struct i2c_client *new_client;
752         struct it87_data *data;
753         int err = 0;
754         const char *name = "";
755         int is_isa = i2c_is_isa_adapter(adapter);
756         int enable_pwm_interface;
757
758         if (!is_isa && 
759             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
760                 goto ERROR0;
761
762         /* Reserve the ISA region */
763         if (is_isa)
764                 if (!request_region(address, IT87_EXTENT, it87_isa_driver.name))
765                         goto ERROR0;
766
767         /* For now, we presume we have a valid client. We create the
768            client structure, even though we cannot fill it completely yet.
769            But it allows us to access it87_{read,write}_value. */
770
771         if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
772                 err = -ENOMEM;
773                 goto ERROR1;
774         }
775
776         new_client = &data->client;
777         if (is_isa)
778                 init_MUTEX(&data->lock);
779         i2c_set_clientdata(new_client, data);
780         new_client->addr = address;
781         new_client->adapter = adapter;
782         new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
783         new_client->flags = 0;
784
785         /* Now, we do the remaining detection. */
786
787         if (kind < 0) {
788                 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
789                   || (!is_isa
790                    && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
791                         err = -ENODEV;
792                         goto ERROR2;
793                 }
794         }
795
796         /* Determine the chip type. */
797         if (kind <= 0) {
798                 i = it87_read_value(new_client, IT87_REG_CHIPID);
799                 if (i == 0x90) {
800                         kind = it87;
801                         if ((is_isa) && (chip_type == IT8712F_DEVID))
802                                 kind = it8712;
803                 }
804                 else {
805                         if (kind == 0)
806                                 dev_info(&adapter->dev, 
807                                         "Ignoring 'force' parameter for unknown chip at "
808                                         "adapter %d, address 0x%02x\n",
809                                         i2c_adapter_id(adapter), address);
810                         err = -ENODEV;
811                         goto ERROR2;
812                 }
813         }
814
815         if (kind == it87) {
816                 name = "it87";
817         } else if (kind == it8712) {
818                 name = "it8712";
819         }
820
821         /* Fill in the remaining client fields and put it into the global list */
822         strlcpy(new_client->name, name, I2C_NAME_SIZE);
823         data->type = kind;
824         data->valid = 0;
825         init_MUTEX(&data->update_lock);
826
827         /* Tell the I2C layer a new client has arrived */
828         if ((err = i2c_attach_client(new_client)))
829                 goto ERROR2;
830
831         /* Check PWM configuration */
832         enable_pwm_interface = it87_check_pwm(new_client);
833
834         /* Initialize the IT87 chip */
835         it87_init_client(new_client, data);
836
837         /* Register sysfs hooks */
838         data->class_dev = hwmon_device_register(&new_client->dev);
839         if (IS_ERR(data->class_dev)) {
840                 err = PTR_ERR(data->class_dev);
841                 goto ERROR3;
842         }
843
844         device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
845         device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
846         device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
847         device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
848         device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
849         device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
850         device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
851         device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
852         device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
853         device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
854         device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
855         device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
856         device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
857         device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
858         device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
859         device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
860         device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
861         device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
862         device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
863         device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
864         device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
865         device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
866         device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
867         device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
868         device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
869         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
870         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
871         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
872         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
873         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
874         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
875         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
876         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
877         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
878         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
879         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
880         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
881         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
882         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
883         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
884         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
885         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
886         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
887         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
888         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
889         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
890         device_create_file(&new_client->dev, &dev_attr_alarms);
891         if (enable_pwm_interface) {
892                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
893                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
894                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
895                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
896                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
897                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
898         }
899
900         if (data->type == it8712) {
901                 data->vrm = vid_which_vrm();
902                 device_create_file_vrm(new_client);
903                 device_create_file_vid(new_client);
904         }
905
906         return 0;
907
908 ERROR3:
909         i2c_detach_client(new_client);
910 ERROR2:
911         kfree(data);
912 ERROR1:
913         if (is_isa)
914                 release_region(address, IT87_EXTENT);
915 ERROR0:
916         return err;
917 }
918
919 static int it87_detach_client(struct i2c_client *client)
920 {
921         struct it87_data *data = i2c_get_clientdata(client);
922         int err;
923
924         hwmon_device_unregister(data->class_dev);
925
926         if ((err = i2c_detach_client(client)))
927                 return err;
928
929         if(i2c_is_isa_client(client))
930                 release_region(client->addr, IT87_EXTENT);
931         kfree(data);
932
933         return 0;
934 }
935
936 /* The SMBus locks itself, but ISA access must be locked explicitly! 
937    We don't want to lock the whole ISA bus, so we lock each client
938    separately.
939    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
940    would slow down the IT87 access and should not be necessary. */
941 static int it87_read_value(struct i2c_client *client, u8 reg)
942 {
943         struct it87_data *data = i2c_get_clientdata(client);
944
945         int res;
946         if (i2c_is_isa_client(client)) {
947                 down(&data->lock);
948                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
949                 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
950                 up(&data->lock);
951                 return res;
952         } else
953                 return i2c_smbus_read_byte_data(client, reg);
954 }
955
956 /* The SMBus locks itself, but ISA access muse be locked explicitly! 
957    We don't want to lock the whole ISA bus, so we lock each client
958    separately.
959    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
960    would slow down the IT87 access and should not be necessary. */
961 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
962 {
963         struct it87_data *data = i2c_get_clientdata(client);
964
965         if (i2c_is_isa_client(client)) {
966                 down(&data->lock);
967                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
968                 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
969                 up(&data->lock);
970                 return 0;
971         } else
972                 return i2c_smbus_write_byte_data(client, reg, value);
973 }
974
975 /* Return 1 if and only if the PWM interface is safe to use */
976 static int it87_check_pwm(struct i2c_client *client)
977 {
978         /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
979          * and polarity set to active low is sign that this is the case so we
980          * disable pwm control to protect the user. */
981         int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
982         if ((tmp & 0x87) == 0) {
983                 if (fix_pwm_polarity) {
984                         /* The user asks us to attempt a chip reconfiguration.
985                          * This means switching to active high polarity and
986                          * inverting all fan speed values. */
987                         int i;
988                         u8 pwm[3];
989
990                         for (i = 0; i < 3; i++)
991                                 pwm[i] = it87_read_value(client,
992                                                          IT87_REG_PWM(i));
993
994                         /* If any fan is in automatic pwm mode, the polarity
995                          * might be correct, as suspicious as it seems, so we
996                          * better don't change anything (but still disable the
997                          * PWM interface). */
998                         if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
999                                 dev_info(&client->dev, "Reconfiguring PWM to "
1000                                          "active high polarity\n");
1001                                 it87_write_value(client, IT87_REG_FAN_CTL,
1002                                                  tmp | 0x87);
1003                                 for (i = 0; i < 3; i++)
1004                                         it87_write_value(client,
1005                                                          IT87_REG_PWM(i),
1006                                                          0x7f & ~pwm[i]);
1007                                 return 1;
1008                         }
1009
1010                         dev_info(&client->dev, "PWM configuration is "
1011                                  "too broken to be fixed\n");
1012                 }
1013
1014                 dev_info(&client->dev, "Detected broken BIOS "
1015                          "defaults, disabling PWM interface\n");
1016                 return 0;
1017         } else if (fix_pwm_polarity) {
1018                 dev_info(&client->dev, "PWM configuration looks "
1019                          "sane, won't touch\n");
1020         }
1021
1022         return 1;
1023 }
1024
1025 /* Called when we have found a new IT87. */
1026 static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1027 {
1028         int tmp, i;
1029
1030         /* initialize to sane defaults:
1031          * - if the chip is in manual pwm mode, this will be overwritten with
1032          *   the actual settings on the chip (so in this case, initialization
1033          *   is not needed)
1034          * - if in automatic or on/off mode, we could switch to manual mode,
1035          *   read the registers and set manual_pwm_ctl accordingly, but currently
1036          *   this is not implemented, so we initialize to something sane */
1037         for (i = 0; i < 3; i++) {
1038                 data->manual_pwm_ctl[i] = 0xff;
1039         }
1040
1041         /* Check if temperature channnels are reset manually or by some reason */
1042         tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1043         if ((tmp & 0x3f) == 0) {
1044                 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1045                 tmp = (tmp & 0xc0) | 0x2a;
1046                 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1047         }
1048         data->sensor = tmp;
1049
1050         /* Check if voltage monitors are reset manually or by some reason */
1051         tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1052         if ((tmp & 0xff) == 0) {
1053                 /* Enable all voltage monitors */
1054                 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1055         }
1056
1057         /* Check if tachometers are reset manually or by some reason */
1058         data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1059         if ((data->fan_main_ctrl & 0x70) == 0) {
1060                 /* Enable all fan tachometers */
1061                 data->fan_main_ctrl |= 0x70;
1062                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1063         }
1064
1065         /* Set current fan mode registers and the default settings for the
1066          * other mode registers */
1067         for (i = 0; i < 3; i++) {
1068                 if (data->fan_main_ctrl & (1 << i)) {
1069                         /* pwm mode */
1070                         tmp = it87_read_value(client, IT87_REG_PWM(i));
1071                         if (tmp & 0x80) {
1072                                 /* automatic pwm - not yet implemented, but
1073                                  * leave the settings made by the BIOS alone
1074                                  * until a change is requested via the sysfs
1075                                  * interface */
1076                         } else {
1077                                 /* manual pwm */
1078                                 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1079                         }
1080                 }
1081         }
1082
1083         /* Start monitoring */
1084         it87_write_value(client, IT87_REG_CONFIG,
1085                          (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1086                          | (update_vbat ? 0x41 : 0x01));
1087 }
1088
1089 static struct it87_data *it87_update_device(struct device *dev)
1090 {
1091         struct i2c_client *client = to_i2c_client(dev);
1092         struct it87_data *data = i2c_get_clientdata(client);
1093         int i;
1094
1095         down(&data->update_lock);
1096
1097         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1098             || !data->valid) {
1099
1100                 if (update_vbat) {
1101                         /* Cleared after each update, so reenable.  Value
1102                           returned by this read will be previous value */       
1103                         it87_write_value(client, IT87_REG_CONFIG,
1104                            it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1105                 }
1106                 for (i = 0; i <= 7; i++) {
1107                         data->in[i] =
1108                             it87_read_value(client, IT87_REG_VIN(i));
1109                         data->in_min[i] =
1110                             it87_read_value(client, IT87_REG_VIN_MIN(i));
1111                         data->in_max[i] =
1112                             it87_read_value(client, IT87_REG_VIN_MAX(i));
1113                 }
1114                 data->in[8] =
1115                     it87_read_value(client, IT87_REG_VIN(8));
1116                 /* Temperature sensor doesn't have limit registers, set
1117                    to min and max value */
1118                 data->in_min[8] = 0;
1119                 data->in_max[8] = 255;
1120
1121                 for (i = 0; i < 3; i++) {
1122                         data->fan[i] =
1123                             it87_read_value(client, IT87_REG_FAN(i));
1124                         data->fan_min[i] =
1125                             it87_read_value(client, IT87_REG_FAN_MIN(i));
1126                 }
1127                 for (i = 0; i < 3; i++) {
1128                         data->temp[i] =
1129                             it87_read_value(client, IT87_REG_TEMP(i));
1130                         data->temp_high[i] =
1131                             it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1132                         data->temp_low[i] =
1133                             it87_read_value(client, IT87_REG_TEMP_LOW(i));
1134                 }
1135
1136                 i = it87_read_value(client, IT87_REG_FAN_DIV);
1137                 data->fan_div[0] = i & 0x07;
1138                 data->fan_div[1] = (i >> 3) & 0x07;
1139                 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1140
1141                 data->alarms =
1142                         it87_read_value(client, IT87_REG_ALARM1) |
1143                         (it87_read_value(client, IT87_REG_ALARM2) << 8) |
1144                         (it87_read_value(client, IT87_REG_ALARM3) << 16);
1145                 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1146
1147                 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1148                 /* The 8705 does not have VID capability */
1149                 if (data->type == it8712) {
1150                         data->vid = it87_read_value(client, IT87_REG_VID);
1151                         data->vid &= 0x1f;
1152                 }
1153                 data->last_updated = jiffies;
1154                 data->valid = 1;
1155         }
1156
1157         up(&data->update_lock);
1158
1159         return data;
1160 }
1161
1162 static int __init sm_it87_init(void)
1163 {
1164         int res;
1165
1166         res = i2c_add_driver(&it87_driver);
1167         if (res)
1168                 return res;
1169
1170         if (!it87_find(&isa_address)) {
1171                 res = i2c_isa_add_driver(&it87_isa_driver);
1172                 if (res) {
1173                         i2c_del_driver(&it87_driver);
1174                         return res;
1175                 }
1176         }
1177
1178         return 0;
1179 }
1180
1181 static void __exit sm_it87_exit(void)
1182 {
1183         i2c_isa_del_driver(&it87_isa_driver);
1184         i2c_del_driver(&it87_driver);
1185 }
1186
1187
1188 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1189 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1190 module_param(update_vbat, bool, 0);
1191 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1192 module_param(fix_pwm_polarity, bool, 0);
1193 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1194 MODULE_LICENSE("GPL");
1195
1196 module_init(sm_it87_init);
1197 module_exit(sm_it87_exit);