d7a9401600bb968ec3f81435734b2f0f618a4284
[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[] = { 0x2d, I2C_CLIENT_END };
49 static unsigned short isa_address;
50
51 /* Insmod parameters */
52 I2C_CLIENT_INSMOD_2(it87, it8712);
53
54 #define REG     0x2e    /* The register to read/write */
55 #define DEV     0x07    /* Register: Logical device select */
56 #define VAL     0x2f    /* The value to read/write */
57 #define PME     0x04    /* The device with the fan registers in it */
58 #define DEVID   0x20    /* Register: Device ID */
59 #define DEVREV  0x22    /* Register: Device Revision */
60
61 static inline int
62 superio_inb(int reg)
63 {
64         outb(reg, REG);
65         return inb(VAL);
66 }
67
68 static int superio_inw(int reg)
69 {
70         int val;
71         outb(reg++, REG);
72         val = inb(VAL) << 8;
73         outb(reg, REG);
74         val |= inb(VAL);
75         return val;
76 }
77
78 static inline void
79 superio_select(void)
80 {
81         outb(DEV, REG);
82         outb(PME, VAL);
83 }
84
85 static inline void
86 superio_enter(void)
87 {
88         outb(0x87, REG);
89         outb(0x01, REG);
90         outb(0x55, REG);
91         outb(0x55, REG);
92 }
93
94 static inline void
95 superio_exit(void)
96 {
97         outb(0x02, REG);
98         outb(0x02, VAL);
99 }
100
101 #define IT8712F_DEVID 0x8712
102 #define IT8705F_DEVID 0x8705
103 #define IT87_ACT_REG  0x30
104 #define IT87_BASE_REG 0x60
105
106 /* Update battery voltage after every reading if true */
107 static int update_vbat;
108
109 /* Not all BIOSes properly configure the PWM registers */
110 static int fix_pwm_polarity;
111
112 /* Chip Type */
113
114 static u16 chip_type;
115
116 /* Many IT87 constants specified below */
117
118 /* Length of ISA address segment */
119 #define IT87_EXTENT 8
120
121 /* Where are the ISA address/data registers relative to the base address */
122 #define IT87_ADDR_REG_OFFSET 5
123 #define IT87_DATA_REG_OFFSET 6
124
125 /*----- The IT87 registers -----*/
126
127 #define IT87_REG_CONFIG        0x00
128
129 #define IT87_REG_ALARM1        0x01
130 #define IT87_REG_ALARM2        0x02
131 #define IT87_REG_ALARM3        0x03
132
133 #define IT87_REG_VID           0x0a
134 #define IT87_REG_FAN_DIV       0x0b
135
136 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
137
138 #define IT87_REG_FAN(nr)       (0x0d + (nr))
139 #define IT87_REG_FAN_MIN(nr)   (0x10 + (nr))
140 #define IT87_REG_FAN_MAIN_CTRL 0x13
141 #define IT87_REG_FAN_CTL       0x14
142 #define IT87_REG_PWM(nr)       (0x15 + (nr))
143
144 #define IT87_REG_VIN(nr)       (0x20 + (nr))
145 #define IT87_REG_TEMP(nr)      (0x29 + (nr))
146
147 #define IT87_REG_VIN_MAX(nr)   (0x30 + (nr) * 2)
148 #define IT87_REG_VIN_MIN(nr)   (0x31 + (nr) * 2)
149 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
150 #define IT87_REG_TEMP_LOW(nr)  (0x41 + (nr) * 2)
151
152 #define IT87_REG_I2C_ADDR      0x48
153
154 #define IT87_REG_VIN_ENABLE    0x50
155 #define IT87_REG_TEMP_ENABLE   0x51
156
157 #define IT87_REG_CHIPID        0x58
158
159 #define IN_TO_REG(val)  (SENSORS_LIMIT((((val) + 8)/16),0,255))
160 #define IN_FROM_REG(val) ((val) * 16)
161
162 static inline u8 FAN_TO_REG(long rpm, int div)
163 {
164         if (rpm == 0)
165                 return 255;
166         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
167         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
168                              254);
169 }
170
171 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
172
173 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
174                                         ((val)+500)/1000),-128,127))
175 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
176
177 #define PWM_TO_REG(val)   ((val) >> 1)
178 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
179
180 static int DIV_TO_REG(int val)
181 {
182         int answer = 0;
183         while ((val >>= 1) != 0)
184                 answer++;
185         return answer;
186 }
187 #define DIV_FROM_REG(val) (1 << (val))
188
189
190 /* For each registered IT87, we need to keep some data in memory. That
191    data is pointed to by it87_list[NR]->data. The structure itself is
192    dynamically allocated, at the same time when a new it87 client is
193    allocated. */
194 struct it87_data {
195         struct i2c_client client;
196         struct class_device *class_dev;
197         struct semaphore lock;
198         enum chips type;
199
200         struct semaphore update_lock;
201         char valid;             /* !=0 if following fields are valid */
202         unsigned long last_updated;     /* In jiffies */
203
204         u8 in[9];               /* Register value */
205         u8 in_max[9];           /* Register value */
206         u8 in_min[9];           /* Register value */
207         u8 fan[3];              /* Register value */
208         u8 fan_min[3];          /* Register value */
209         u8 temp[3];             /* Register value */
210         u8 temp_high[3];        /* Register value */
211         u8 temp_low[3];         /* Register value */
212         u8 sensor;              /* Register value */
213         u8 fan_div[3];          /* Register encoding, shifted right */
214         u8 vid;                 /* Register encoding, combined */
215         u8 vrm;
216         u32 alarms;             /* Register encoding, combined */
217         u8 fan_main_ctrl;       /* Register value */
218         u8 manual_pwm_ctl[3];   /* manual PWM value set by user */
219 };
220
221
222 static int it87_attach_adapter(struct i2c_adapter *adapter);
223 static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
224 static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
225 static int it87_detach_client(struct i2c_client *client);
226
227 static int it87_read_value(struct i2c_client *client, u8 register);
228 static int it87_write_value(struct i2c_client *client, u8 register,
229                         u8 value);
230 static struct it87_data *it87_update_device(struct device *dev);
231 static int it87_check_pwm(struct i2c_client *client);
232 static void it87_init_client(struct i2c_client *client, struct it87_data *data);
233
234
235 static struct i2c_driver it87_driver = {
236         .driver = {
237                 .name   = "it87",
238         },
239         .id             = I2C_DRIVERID_IT87,
240         .attach_adapter = it87_attach_adapter,
241         .detach_client  = it87_detach_client,
242 };
243
244 static struct i2c_driver it87_isa_driver = {
245         .driver = {
246                 .name   = "it87-isa",
247         },
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, "%u\n", 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,
765                                     it87_isa_driver.driver.name))
766                         goto ERROR0;
767
768         /* For now, we presume we have a valid client. We create the
769            client structure, even though we cannot fill it completely yet.
770            But it allows us to access it87_{read,write}_value. */
771
772         if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
773                 err = -ENOMEM;
774                 goto ERROR1;
775         }
776
777         new_client = &data->client;
778         if (is_isa)
779                 init_MUTEX(&data->lock);
780         i2c_set_clientdata(new_client, data);
781         new_client->addr = address;
782         new_client->adapter = adapter;
783         new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
784         new_client->flags = 0;
785
786         /* Now, we do the remaining detection. */
787
788         if (kind < 0) {
789                 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
790                   || (!is_isa
791                    && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
792                         err = -ENODEV;
793                         goto ERROR2;
794                 }
795         }
796
797         /* Determine the chip type. */
798         if (kind <= 0) {
799                 i = it87_read_value(new_client, IT87_REG_CHIPID);
800                 if (i == 0x90) {
801                         kind = it87;
802                         if ((is_isa) && (chip_type == IT8712F_DEVID))
803                                 kind = it8712;
804                 }
805                 else {
806                         if (kind == 0)
807                                 dev_info(&adapter->dev, 
808                                         "Ignoring 'force' parameter for unknown chip at "
809                                         "adapter %d, address 0x%02x\n",
810                                         i2c_adapter_id(adapter), address);
811                         err = -ENODEV;
812                         goto ERROR2;
813                 }
814         }
815
816         if (kind == it87) {
817                 name = "it87";
818         } else if (kind == it8712) {
819                 name = "it8712";
820         }
821
822         /* Fill in the remaining client fields and put it into the global list */
823         strlcpy(new_client->name, name, I2C_NAME_SIZE);
824         data->type = kind;
825         data->valid = 0;
826         init_MUTEX(&data->update_lock);
827
828         /* Tell the I2C layer a new client has arrived */
829         if ((err = i2c_attach_client(new_client)))
830                 goto ERROR2;
831
832         if (!is_isa)
833                 dev_info(&new_client->dev, "The I2C interface to IT87xxF "
834                          "hardware monitoring chips is deprecated. Please "
835                          "report if you still rely on it.\n");
836
837         /* Check PWM configuration */
838         enable_pwm_interface = it87_check_pwm(new_client);
839
840         /* Initialize the IT87 chip */
841         it87_init_client(new_client, data);
842
843         /* Register sysfs hooks */
844         data->class_dev = hwmon_device_register(&new_client->dev);
845         if (IS_ERR(data->class_dev)) {
846                 err = PTR_ERR(data->class_dev);
847                 goto ERROR3;
848         }
849
850         device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
851         device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
852         device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
853         device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
854         device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
855         device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
856         device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
857         device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
858         device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
859         device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
860         device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
861         device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
862         device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
863         device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
864         device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
865         device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
866         device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
867         device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
868         device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
869         device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
870         device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
871         device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
872         device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
873         device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
874         device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
875         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
876         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
877         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
878         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
879         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
880         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
881         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
882         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
883         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
884         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
885         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
886         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
887         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
888         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
889         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
890         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
891         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
892         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
893         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
894         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
895         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
896         device_create_file(&new_client->dev, &dev_attr_alarms);
897         if (enable_pwm_interface) {
898                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
899                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
900                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
901                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
902                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
903                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
904         }
905
906         if (data->type == it8712) {
907                 data->vrm = vid_which_vrm();
908                 device_create_file_vrm(new_client);
909                 device_create_file_vid(new_client);
910         }
911
912         return 0;
913
914 ERROR3:
915         i2c_detach_client(new_client);
916 ERROR2:
917         kfree(data);
918 ERROR1:
919         if (is_isa)
920                 release_region(address, IT87_EXTENT);
921 ERROR0:
922         return err;
923 }
924
925 static int it87_detach_client(struct i2c_client *client)
926 {
927         struct it87_data *data = i2c_get_clientdata(client);
928         int err;
929
930         hwmon_device_unregister(data->class_dev);
931
932         if ((err = i2c_detach_client(client)))
933                 return err;
934
935         if(i2c_is_isa_client(client))
936                 release_region(client->addr, IT87_EXTENT);
937         kfree(data);
938
939         return 0;
940 }
941
942 /* The SMBus locks itself, but ISA access must be locked explicitly! 
943    We don't want to lock the whole ISA bus, so we lock each client
944    separately.
945    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
946    would slow down the IT87 access and should not be necessary. */
947 static int it87_read_value(struct i2c_client *client, u8 reg)
948 {
949         struct it87_data *data = i2c_get_clientdata(client);
950
951         int res;
952         if (i2c_is_isa_client(client)) {
953                 down(&data->lock);
954                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
955                 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
956                 up(&data->lock);
957                 return res;
958         } else
959                 return i2c_smbus_read_byte_data(client, reg);
960 }
961
962 /* The SMBus locks itself, but ISA access muse be locked explicitly! 
963    We don't want to lock the whole ISA bus, so we lock each client
964    separately.
965    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
966    would slow down the IT87 access and should not be necessary. */
967 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
968 {
969         struct it87_data *data = i2c_get_clientdata(client);
970
971         if (i2c_is_isa_client(client)) {
972                 down(&data->lock);
973                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
974                 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
975                 up(&data->lock);
976                 return 0;
977         } else
978                 return i2c_smbus_write_byte_data(client, reg, value);
979 }
980
981 /* Return 1 if and only if the PWM interface is safe to use */
982 static int it87_check_pwm(struct i2c_client *client)
983 {
984         /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
985          * and polarity set to active low is sign that this is the case so we
986          * disable pwm control to protect the user. */
987         int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
988         if ((tmp & 0x87) == 0) {
989                 if (fix_pwm_polarity) {
990                         /* The user asks us to attempt a chip reconfiguration.
991                          * This means switching to active high polarity and
992                          * inverting all fan speed values. */
993                         int i;
994                         u8 pwm[3];
995
996                         for (i = 0; i < 3; i++)
997                                 pwm[i] = it87_read_value(client,
998                                                          IT87_REG_PWM(i));
999
1000                         /* If any fan is in automatic pwm mode, the polarity
1001                          * might be correct, as suspicious as it seems, so we
1002                          * better don't change anything (but still disable the
1003                          * PWM interface). */
1004                         if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1005                                 dev_info(&client->dev, "Reconfiguring PWM to "
1006                                          "active high polarity\n");
1007                                 it87_write_value(client, IT87_REG_FAN_CTL,
1008                                                  tmp | 0x87);
1009                                 for (i = 0; i < 3; i++)
1010                                         it87_write_value(client,
1011                                                          IT87_REG_PWM(i),
1012                                                          0x7f & ~pwm[i]);
1013                                 return 1;
1014                         }
1015
1016                         dev_info(&client->dev, "PWM configuration is "
1017                                  "too broken to be fixed\n");
1018                 }
1019
1020                 dev_info(&client->dev, "Detected broken BIOS "
1021                          "defaults, disabling PWM interface\n");
1022                 return 0;
1023         } else if (fix_pwm_polarity) {
1024                 dev_info(&client->dev, "PWM configuration looks "
1025                          "sane, won't touch\n");
1026         }
1027
1028         return 1;
1029 }
1030
1031 /* Called when we have found a new IT87. */
1032 static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1033 {
1034         int tmp, i;
1035
1036         /* initialize to sane defaults:
1037          * - if the chip is in manual pwm mode, this will be overwritten with
1038          *   the actual settings on the chip (so in this case, initialization
1039          *   is not needed)
1040          * - if in automatic or on/off mode, we could switch to manual mode,
1041          *   read the registers and set manual_pwm_ctl accordingly, but currently
1042          *   this is not implemented, so we initialize to something sane */
1043         for (i = 0; i < 3; i++) {
1044                 data->manual_pwm_ctl[i] = 0xff;
1045         }
1046
1047         /* Check if temperature channnels are reset manually or by some reason */
1048         tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1049         if ((tmp & 0x3f) == 0) {
1050                 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1051                 tmp = (tmp & 0xc0) | 0x2a;
1052                 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1053         }
1054         data->sensor = tmp;
1055
1056         /* Check if voltage monitors are reset manually or by some reason */
1057         tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1058         if ((tmp & 0xff) == 0) {
1059                 /* Enable all voltage monitors */
1060                 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1061         }
1062
1063         /* Check if tachometers are reset manually or by some reason */
1064         data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1065         if ((data->fan_main_ctrl & 0x70) == 0) {
1066                 /* Enable all fan tachometers */
1067                 data->fan_main_ctrl |= 0x70;
1068                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1069         }
1070
1071         /* Set current fan mode registers and the default settings for the
1072          * other mode registers */
1073         for (i = 0; i < 3; i++) {
1074                 if (data->fan_main_ctrl & (1 << i)) {
1075                         /* pwm mode */
1076                         tmp = it87_read_value(client, IT87_REG_PWM(i));
1077                         if (tmp & 0x80) {
1078                                 /* automatic pwm - not yet implemented, but
1079                                  * leave the settings made by the BIOS alone
1080                                  * until a change is requested via the sysfs
1081                                  * interface */
1082                         } else {
1083                                 /* manual pwm */
1084                                 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1085                         }
1086                 }
1087         }
1088
1089         /* Start monitoring */
1090         it87_write_value(client, IT87_REG_CONFIG,
1091                          (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1092                          | (update_vbat ? 0x41 : 0x01));
1093 }
1094
1095 static struct it87_data *it87_update_device(struct device *dev)
1096 {
1097         struct i2c_client *client = to_i2c_client(dev);
1098         struct it87_data *data = i2c_get_clientdata(client);
1099         int i;
1100
1101         down(&data->update_lock);
1102
1103         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1104             || !data->valid) {
1105
1106                 if (update_vbat) {
1107                         /* Cleared after each update, so reenable.  Value
1108                           returned by this read will be previous value */       
1109                         it87_write_value(client, IT87_REG_CONFIG,
1110                            it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1111                 }
1112                 for (i = 0; i <= 7; i++) {
1113                         data->in[i] =
1114                             it87_read_value(client, IT87_REG_VIN(i));
1115                         data->in_min[i] =
1116                             it87_read_value(client, IT87_REG_VIN_MIN(i));
1117                         data->in_max[i] =
1118                             it87_read_value(client, IT87_REG_VIN_MAX(i));
1119                 }
1120                 data->in[8] =
1121                     it87_read_value(client, IT87_REG_VIN(8));
1122                 /* Temperature sensor doesn't have limit registers, set
1123                    to min and max value */
1124                 data->in_min[8] = 0;
1125                 data->in_max[8] = 255;
1126
1127                 for (i = 0; i < 3; i++) {
1128                         data->fan[i] =
1129                             it87_read_value(client, IT87_REG_FAN(i));
1130                         data->fan_min[i] =
1131                             it87_read_value(client, IT87_REG_FAN_MIN(i));
1132                 }
1133                 for (i = 0; i < 3; i++) {
1134                         data->temp[i] =
1135                             it87_read_value(client, IT87_REG_TEMP(i));
1136                         data->temp_high[i] =
1137                             it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1138                         data->temp_low[i] =
1139                             it87_read_value(client, IT87_REG_TEMP_LOW(i));
1140                 }
1141
1142                 i = it87_read_value(client, IT87_REG_FAN_DIV);
1143                 data->fan_div[0] = i & 0x07;
1144                 data->fan_div[1] = (i >> 3) & 0x07;
1145                 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1146
1147                 data->alarms =
1148                         it87_read_value(client, IT87_REG_ALARM1) |
1149                         (it87_read_value(client, IT87_REG_ALARM2) << 8) |
1150                         (it87_read_value(client, IT87_REG_ALARM3) << 16);
1151                 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1152
1153                 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1154                 /* The 8705 does not have VID capability */
1155                 if (data->type == it8712) {
1156                         data->vid = it87_read_value(client, IT87_REG_VID);
1157                         data->vid &= 0x1f;
1158                 }
1159                 data->last_updated = jiffies;
1160                 data->valid = 1;
1161         }
1162
1163         up(&data->update_lock);
1164
1165         return data;
1166 }
1167
1168 static int __init sm_it87_init(void)
1169 {
1170         int res;
1171
1172         res = i2c_add_driver(&it87_driver);
1173         if (res)
1174                 return res;
1175
1176         if (!it87_find(&isa_address)) {
1177                 res = i2c_isa_add_driver(&it87_isa_driver);
1178                 if (res) {
1179                         i2c_del_driver(&it87_driver);
1180                         return res;
1181                 }
1182         }
1183
1184         return 0;
1185 }
1186
1187 static void __exit sm_it87_exit(void)
1188 {
1189         if (isa_address)
1190                 i2c_isa_del_driver(&it87_isa_driver);
1191         i2c_del_driver(&it87_driver);
1192 }
1193
1194
1195 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1196 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1197 module_param(update_vbat, bool, 0);
1198 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1199 module_param(fix_pwm_polarity, bool, 0);
1200 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1201 MODULE_LICENSE("GPL");
1202
1203 module_init(sm_it87_init);
1204 module_exit(sm_it87_exit);