root/lm-sensors/trunk/kernel/chips/it87.c @ 3044

Revision 3044, 35.2 KB (checked in by khali, 9 years ago)

Tag device find functions init, as they are called from init
functions.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
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 & SMBus
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/*
35    michael.hufer@gmx.de Michael Hufer 09/07/03
36    Modified configure (enable/disable) chip reset at module load time.
37    Added ability to read and set fan pwm registers and the smart
38    guardian (sg) features of the chip.
39*/
40
41#include <linux/module.h>
42#include <linux/slab.h>
43#include <linux/ioport.h>
44#include <linux/i2c.h>
45#include <linux/i2c-proc.h>
46#include <linux/init.h>
47#include <asm/io.h>
48#include "version.h"
49
50MODULE_LICENSE("GPL");
51
52/* Addresses to scan */
53static unsigned short normal_i2c[] = { SENSORS_I2C_END };
54static unsigned short normal_i2c_range[] = { 0x28, 0x2f, SENSORS_I2C_END };
55static unsigned int normal_isa[] = { 0x0290, SENSORS_ISA_END };
56static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
57
58/* Insmod parameters */
59SENSORS_INSMOD_2(it87, it8712);
60
61
62#define REG     0x2e    /* The register to read/write */
63#define DEV     0x07    /* Register: Logical device select */
64#define VAL     0x2f    /* The value to read/write */
65#define PME     0x04    /* The device with the fan registers in it */
66#define DEVID   0x20    /* Register: Device ID */
67#define DEVREV  0x22    /* Register: Device Revision */
68
69static inline int
70superio_inb(int reg)
71{
72        outb(reg, REG);
73        return inb(VAL);
74}
75
76static int superio_inw(int reg)
77{
78        int val;
79        outb(reg++, REG);
80        val = inb(VAL) << 8;
81        outb(reg, REG);
82        val |= inb(VAL);
83        return val;
84}
85
86static inline void
87superio_select(void)
88{
89        outb(DEV, REG);
90        outb(PME, VAL);
91}
92
93static inline void
94superio_enter(void)
95{
96        outb(0x87, REG);
97        outb(0x01, REG);
98        outb(0x55, REG);
99        outb(0x55, REG);
100}
101
102static inline void
103superio_exit(void)
104{
105        outb(0x02, REG);
106        outb(0x02, VAL);
107}
108
109#define IT87_DEVID_MATCH(id) ((id) == 0x8712 || (id) == 0x8705)
110
111#define IT87_ACT_REG  0x30
112#define IT87_BASE_REG 0x60
113
114/* Update battery voltage after every reading if true */
115static int update_vbat = 0;
116
117/* Reset the registers on init */
118static int reset = 0;
119
120/* Many IT87 constants specified below */
121
122/* Length of ISA address segment */
123#define IT87_EXTENT 8
124
125/* Where are the ISA address/data registers relative to the base address */
126#define IT87_ADDR_REG_OFFSET 5
127#define IT87_DATA_REG_OFFSET 6
128
129/*----- The IT87 registers -----*/
130
131#define IT87_REG_CONFIG        0x00
132
133#define IT87_REG_ALARM1        0x01
134#define IT87_REG_ALARM2        0x02
135#define IT87_REG_ALARM3        0x03
136
137#define IT87_REG_VID           0x0a
138#define IT87_REG_FAN_DIV       0x0b
139
140#define IT87_REG_FAN(nr)       (0x0c + (nr))
141#define IT87_REG_FAN_MIN(nr)   (0x0f + (nr))
142#define IT87_REG_FAN_CTRL      0x13
143
144/* pwm and smart guardian registers */
145
146#define IT87_REG_FAN_ONOFF     0x14
147#define IT87_REG_PWM(nr)       (0x14 + (nr))
148#define IT87_REG_SG_TL_OFF(nr) (0x58 + (nr)*8)
149#define IT87_REG_SG_TL_LOW(nr) (0x59 + (nr)*8)
150#define IT87_REG_SG_TL_MED(nr) (0x5a + (nr)*8)
151#define IT87_REG_SG_TL_HI(nr)  (0x5b + (nr)*8)
152#define IT87_REG_SG_TL_OVR(nr) (0x5c + (nr)*8)
153#define IT87_REG_SG_PWM_LOW(nr) (0x5d + (nr)*8)
154#define IT87_REG_SG_PWM_MED(nr) (0x5e + (nr)*8)
155#define IT87_REG_SG_PWM_HI(nr)  (0x5f + (nr)*8)
156
157/* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
158
159#define IT87_REG_VIN(nr)       (0x20 + (nr))
160#define IT87_REG_TEMP(nr)      (0x28 + (nr))
161
162#define IT87_REG_VIN_MAX(nr)   (0x30 + (nr) * 2)
163#define IT87_REG_VIN_MIN(nr)   (0x31 + (nr) * 2)
164#define IT87_REG_TEMP_HIGH(nr) (0x3e + (nr) * 2)
165#define IT87_REG_TEMP_LOW(nr)  (0x3f + (nr) * 2)
166
167#define IT87_REG_I2C_ADDR      0x48
168
169#define IT87_REG_VIN_ENABLE    0x50
170#define IT87_REG_TEMP_ENABLE   0x51
171
172#define IT87_REG_CHIPID        0x58
173#define IT87_REG_CHIPID2       0x5b /* IT8712F only */
174
175/* sensor pin types */
176#define UNUSED          0
177#define THERMISTOR      2
178#define PIIDIODE        3
179
180/* Conversions. Limit checking is only done on the TO_REG
181   variants. Note that you should be a bit careful with which arguments
182   these macros are called: arguments may be evaluated more than once.
183   Fixing this is just not worth it. */
184#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
185#define IN_FROM_REG(val) (((val) *  16 + 5) / 10)
186
187static inline u8 FAN_TO_REG(long rpm, int div)
188{
189        if (rpm == 0)
190                return 255;
191        rpm = SENSORS_LIMIT(rpm, 1, 1000000);
192        return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
193                             254);
194}
195
196#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
197
198#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
199                                                 ((val)+5)/10),-127,127))
200#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
201
202#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
203                           205-(val)*5)
204#define ALARMS_FROM_REG(val) (val)
205
206extern inline u8 DIV_TO_REG(long val)
207{
208        u8 i;
209        for( i = 0; i <= 7; i++ )
210        {
211                if( val>>i == 1 )
212                        return i;
213        }
214        return 1;
215}
216#define DIV_FROM_REG(val) (1 << (val))
217
218/* For each registered IT87, we need to keep some data in memory. That
219   data is pointed to by it87_list[NR]->data. The structure itself is
220   dynamically allocated, at the same time when a new it87 client is
221   allocated. */
222struct it87_data {
223        struct i2c_client client;
224        struct semaphore lock;
225        int sysctl_id;
226        enum chips type;
227
228        struct semaphore update_lock;
229        char valid;             /* !=0 if following fields are valid */
230        unsigned long last_updated;     /* In jiffies */
231
232        u8 in[9];               /* Register value */
233        u8 in_max[9];           /* Register value */
234        u8 in_min[9];           /* Register value */
235        u8 fan[3];              /* Register value */
236        u8 fan_min[3];          /* Register value */
237        u8 temp[3];             /* Register value */
238        u8 temp_high[3];        /* Register value */
239        u8 temp_low[3];         /* Register value */
240        u8 fan_div[3];          /* Register encoding, shifted right */
241        u8 vid;                 /* Register encoding, combined */
242        u32 alarms;             /* Register encoding, combined */
243        u8 pwm[3];              /* Register value */
244        u8 fan_ctl[2];          /* Register encoding */
245        u8 sg_tl[3][5];         /* Register value */
246        u8 sg_pwm[3][3];        /* Register value */
247        u8 sens[3];             /* 2 = Thermistor,
248                                   3 = PII/Celeron diode */
249};
250
251
252static int it87_attach_adapter(struct i2c_adapter *adapter);
253static int it87_detect(struct i2c_adapter *adapter, int address,
254                       unsigned short flags, int kind);
255static int it87_detach_client(struct i2c_client *client);
256
257static int it87_read_value(struct i2c_client *client, u8 register);
258static int it87_write_value(struct i2c_client *client, u8 register,
259                            u8 value);
260static void it87_update_client(struct i2c_client *client);
261static void it87_init_client(struct i2c_client *client);
262
263
264static void it87_in(struct i2c_client *client, int operation, int ctl_name,
265                    int *nrels_mag, long *results);
266static void it87_fan(struct i2c_client *client, int operation,
267                     int ctl_name, int *nrels_mag, long *results);
268static void it87_temp(struct i2c_client *client, int operation,
269                      int ctl_name, int *nrels_mag, long *results);
270static void it87_vid(struct i2c_client *client, int operation,
271                     int ctl_name, int *nrels_mag, long *results);
272static void it87_alarms(struct i2c_client *client, int operation,
273                            int ctl_name, int *nrels_mag, long *results);
274static void it87_fan_div(struct i2c_client *client, int operation,
275                         int ctl_name, int *nrels_mag, long *results);
276static void it87_fan_ctl(struct i2c_client *client, int operation,
277                         int ctl_name, int *nrels_mag, long *results);
278static void it87_pwm(struct i2c_client *client, int operation,
279                         int ctl_name, int *nrels_mag, long *results);
280static void it87_sgpwm(struct i2c_client *client, int operation,
281                         int ctl_name, int *nrels_mag, long *results);
282static void it87_sgtl(struct i2c_client *client, int operation,
283                         int ctl_name, int *nrels_mag, long *results);
284static void it87_sens(struct i2c_client *client, int operation,
285                         int ctl_name, int *nrels_mag, long *results);
286
287static struct i2c_driver it87_driver = {
288        .name           = "IT87xx sensor driver",
289        .id             = I2C_DRIVERID_IT87,
290        .flags          = I2C_DF_NOTIFY,
291        .attach_adapter = it87_attach_adapter,
292        .detach_client  = it87_detach_client,
293};
294
295/* The /proc/sys entries */
296
297/* -- SENSORS SYSCTL START -- */
298#define IT87_SYSCTL_IN0 1000    /* Volts * 100 */
299#define IT87_SYSCTL_IN1 1001
300#define IT87_SYSCTL_IN2 1002
301#define IT87_SYSCTL_IN3 1003
302#define IT87_SYSCTL_IN4 1004
303#define IT87_SYSCTL_IN5 1005
304#define IT87_SYSCTL_IN6 1006
305#define IT87_SYSCTL_IN7 1007
306#define IT87_SYSCTL_IN8 1008
307#define IT87_SYSCTL_FAN1 1101   /* Rotations/min */
308#define IT87_SYSCTL_FAN2 1102
309#define IT87_SYSCTL_FAN3 1103
310#define IT87_SYSCTL_TEMP1 1200  /* Degrees Celsius * 10 */
311#define IT87_SYSCTL_TEMP2 1201  /* Degrees Celsius * 10 */
312#define IT87_SYSCTL_TEMP3 1202  /* Degrees Celsius * 10 */
313#define IT87_SYSCTL_VID 1300    /* Volts * 100 */
314#define IT87_SYSCTL_FAN_DIV 2000        /* 1, 2, 4 or 8 */
315#define IT87_SYSCTL_ALARMS 2004    /* bitvector */
316
317#define IT87_SYSCTL_PWM1 1401
318#define IT87_SYSCTL_PWM2 1402
319#define IT87_SYSCTL_PWM3 1403
320#define IT87_SYSCTL_FAN_CTL  1501
321#define IT87_SYSCTL_FAN_ON_OFF  1502
322#define IT87_SYSCTL_SENS1 1601  /* 1, 2, or Beta (3000-5000) */
323#define IT87_SYSCTL_SENS2 1602
324#define IT87_SYSCTL_SENS3 1603
325
326#define IT87_ALARM_IN0 0x000100
327#define IT87_ALARM_IN1 0x000200
328#define IT87_ALARM_IN2 0x000400
329#define IT87_ALARM_IN3 0x000800
330#define IT87_ALARM_IN4 0x001000
331#define IT87_ALARM_IN5 0x002000
332#define IT87_ALARM_IN6 0x004000
333#define IT87_ALARM_IN7 0x008000
334#define IT87_ALARM_FAN1 0x0001
335#define IT87_ALARM_FAN2 0x0002
336#define IT87_ALARM_FAN3 0x0004
337#define IT87_ALARM_TEMP1 0x00010000
338#define IT87_ALARM_TEMP2 0x00020000
339#define IT87_ALARM_TEMP3 0x00040000
340
341/* -- SENSORS SYSCTL END -- */
342
343/* These files are created for each detected IT87. This is just a template;
344   though at first sight, you might think we could use a statically
345   allocated list, we need some way to get back to the parent - which
346   is done through one of the 'extra' fields which are initialized
347   when a new copy is allocated. */
348static ctl_table it87_dir_table_template[] = {
349        {IT87_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
350         &i2c_sysctl_real, NULL, &it87_in},
351        {IT87_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
352         &i2c_sysctl_real, NULL, &it87_in},
353        {IT87_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
354         &i2c_sysctl_real, NULL, &it87_in},
355        {IT87_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
356         &i2c_sysctl_real, NULL, &it87_in},
357        {IT87_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
358         &i2c_sysctl_real, NULL, &it87_in},
359        {IT87_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
360         &i2c_sysctl_real, NULL, &it87_in},
361        {IT87_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
362         &i2c_sysctl_real, NULL, &it87_in},
363        {IT87_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
364         &i2c_sysctl_real, NULL, &it87_in},
365        {IT87_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
366         &i2c_sysctl_real, NULL, &it87_in},
367        {IT87_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
368         &i2c_sysctl_real, NULL, &it87_fan},
369        {IT87_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
370         &i2c_sysctl_real, NULL, &it87_fan},
371        {IT87_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
372         &i2c_sysctl_real, NULL, &it87_fan},
373        {IT87_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
374         &i2c_sysctl_real, NULL, &it87_temp},
375        {IT87_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
376         &i2c_sysctl_real, NULL, &it87_temp},
377        {IT87_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
378         &i2c_sysctl_real, NULL, &it87_temp},
379        {IT87_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
380         &i2c_sysctl_real, NULL, &it87_vid},
381        {IT87_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
382         &i2c_sysctl_real, NULL, &it87_fan_div},
383        {IT87_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
384         &i2c_sysctl_real, NULL, &it87_alarms},
385        {IT87_SYSCTL_FAN_CTL, "fan_ctl", NULL, 0, 0644, NULL, &i2c_proc_real,
386         &i2c_sysctl_real, NULL, &it87_fan_ctl},
387        {IT87_SYSCTL_FAN_ON_OFF, "fan_on_off", NULL, 0, 0644, NULL, &i2c_proc_real,
388         &i2c_sysctl_real, NULL, &it87_fan_ctl},
389        {IT87_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
390         &i2c_sysctl_real, NULL, &it87_pwm},
391        {IT87_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
392         &i2c_sysctl_real, NULL, &it87_pwm},
393        {IT87_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
394         &i2c_sysctl_real, NULL, &it87_pwm},
395        {IT87_SYSCTL_PWM1, "sg_pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
396         &i2c_sysctl_real, NULL, &it87_sgpwm},
397        {IT87_SYSCTL_PWM2, "sg_pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
398         &i2c_sysctl_real, NULL, &it87_sgpwm},
399        {IT87_SYSCTL_PWM3, "sg_pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
400         &i2c_sysctl_real, NULL, &it87_sgpwm},
401        {IT87_SYSCTL_PWM1, "sg_tl1", NULL, 0, 0644, NULL, &i2c_proc_real,
402         &i2c_sysctl_real, NULL, &it87_sgtl},
403        {IT87_SYSCTL_PWM2, "sg_tl2", NULL, 0, 0644, NULL, &i2c_proc_real,
404         &i2c_sysctl_real, NULL, &it87_sgtl},
405        {IT87_SYSCTL_PWM3, "sg_tl3", NULL, 0, 0644, NULL, &i2c_proc_real,
406         &i2c_sysctl_real, NULL, &it87_sgtl},
407        {IT87_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
408         &i2c_sysctl_real, NULL, &it87_sens},
409        {IT87_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
410         &i2c_sysctl_real, NULL, &it87_sens},
411        {IT87_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
412         &i2c_sysctl_real, NULL, &it87_sens},
413        {0}
414};
415
416
417/* This function is called when:
418     * it87_driver is inserted (when this module is loaded), for each
419       available adapter
420     * when a new adapter is inserted (and it87_driver is still present) */
421static int it87_attach_adapter(struct i2c_adapter *adapter)
422{
423        return i2c_detect(adapter, &addr_data, it87_detect);
424}
425
426static int __init it87_find(int *address)
427{
428        int err = -ENODEV;
429        u16 devid;
430
431        superio_enter();
432        devid = superio_inw(DEVID);
433        if (!IT87_DEVID_MATCH(devid))
434                goto exit;
435
436        superio_select();
437        if (!(superio_inb(IT87_ACT_REG)) & 0x01) {
438                printk(KERN_INFO "it87: Device not activated, skipping\n");
439                goto exit;
440        }
441
442        *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
443        if (*address == 0) {
444                printk(KERN_INFO "it87: Base address not set, skipping\n");
445                goto exit;
446        }
447
448        err = 0;
449        printk(KERN_INFO "it87: Found IT%04xF chip at 0x%x, revision %d\n",
450               devid, *address, superio_inb(DEVREV) & 0x0f);
451
452exit:
453        superio_exit();
454        return err;
455}
456
457/* This function is called by i2c_detect */
458int it87_detect(struct i2c_adapter *adapter, int address,
459                unsigned short flags, int kind)
460{
461        int i;
462        struct i2c_client *new_client;
463        struct it87_data *data;
464        int err = 0;
465        const char *type_name = "";
466        const char *client_name = "";
467        int is_isa = i2c_is_isa_adapter(adapter);
468
469        if (!is_isa
470         && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
471                return 0;
472
473        if (is_isa
474         && check_region(address, IT87_EXTENT))
475                return 0;
476
477        /* Probe whether there is anything available on this address. Already
478           done for SMBus clients */
479        if (is_isa && kind < 0) {
480#define REALLY_SLOW_IO
481                /* We need the timeouts for at least some IT87-like chips.
482                   But only if we read 'undefined' registers. */
483                i = inb_p(address + 1);
484                if (inb_p(address + 2) != i
485                 || inb_p(address + 3) != i
486                 || inb_p(address + 7) != i)
487                        return 0;
488#undef REALLY_SLOW_IO
489
490                /* Let's just hope nothing breaks here */
491                i = inb_p(address + 5) & 0x7f;
492                outb_p(~i & 0x7f, address + 5);
493                if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
494                        outb_p(i, address + 5);
495                        return 0;
496                }
497        }
498
499        /* OK. For now, we presume we have a valid client. We now create the
500           client structure, even though we cannot fill it completely yet.
501           But it allows us to access it87_{read,write}_value. */
502
503        if (!(data = kmalloc(sizeof(struct it87_data), GFP_KERNEL))) {
504                err = -ENOMEM;
505                goto ERROR0;
506        }
507
508        new_client = &data->client;
509        if (is_isa)
510                init_MUTEX(&data->lock);
511        new_client->addr = address;
512        new_client->data = data;
513        new_client->adapter = adapter;
514        new_client->driver = &it87_driver;
515        new_client->flags = 0;
516
517        /* Now, we do the remaining detection. */
518
519        if (kind < 0) {
520                if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
521                 || (!is_isa
522                  && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address))
523                        goto ERROR1;
524        }
525
526        /* Determine the chip type. */
527        if (kind <= 0) {
528                i = it87_read_value(new_client, IT87_REG_CHIPID);
529                if (i == 0x90) {
530                        kind = it87;
531                        i = it87_read_value(new_client, IT87_REG_CHIPID2);
532                        if (i == 0x12)
533                                kind = it8712;
534                }
535                else {
536                        if (kind == 0)
537                                printk
538                                    ("it87.o: Ignoring 'force' parameter for unknown chip at "
539                                     "adapter %d, address 0x%02x\n",
540                                     i2c_adapter_id(adapter), address);
541                        goto ERROR1;
542                }
543        }
544
545        if (kind == it87) {
546                type_name = "it87";
547                client_name = "IT87 chip";
548        } else if (kind == it8712) {
549                type_name = "it8712";
550                client_name = "IT8712 chip";
551        } else {
552#ifdef DEBUG
553                printk("it87.o: Internal error: unknown kind (%d)?!?",
554                       kind);
555#endif
556                goto ERROR1;
557        }
558
559        /* Reserve the ISA region */
560        if (is_isa)
561                request_region(address, IT87_EXTENT, type_name);
562
563        /* Fill in the remaining client fields and put it into the global list */
564        strcpy(new_client->name, client_name);
565        data->type = kind;
566        data->valid = 0;
567        init_MUTEX(&data->update_lock);
568
569        /* The IT8705F doesn't have VID capability */
570        data->vid = 0x1f;
571
572        /* Tell the I2C layer a new client has arrived */
573        if ((err = i2c_attach_client(new_client)))
574                goto ERROR3;
575
576        /* Register a new directory entry with module sensors */
577        if ((i = i2c_register_entry(new_client,
578                                    type_name,
579                                    it87_dir_table_template,
580                                    THIS_MODULE)) < 0) {
581                err = i;
582                goto ERROR4;
583        }
584        data->sysctl_id = i;
585
586        /* Initialize the IT87 chip */
587        it87_init_client(new_client);
588        return 0;
589
590/* OK, this is not exactly good programming practice, usually. But it is
591   very code-efficient in this case. */
592
593      ERROR4:
594        i2c_detach_client(new_client);
595      ERROR3:
596        if (is_isa)
597                release_region(address, IT87_EXTENT);
598      ERROR1:
599        kfree(data);
600      ERROR0:
601        return err;
602}
603
604static int it87_detach_client(struct i2c_client *client)
605{
606        int err;
607
608        i2c_deregister_entry(((struct it87_data *) (client->data))->
609                                sysctl_id);
610
611        if ((err = i2c_detach_client(client))) {
612                printk
613                    ("it87.o: Client deregistration failed, client not detached.\n");
614                return err;
615        }
616
617        if(i2c_is_isa_client(client))
618                release_region(client->addr, IT87_EXTENT);
619        kfree(client->data);
620
621        return 0;
622}
623
624/* The SMBus locks itself, but ISA access must be locked explicitly!
625   We don't want to lock the whole ISA bus, so we lock each client
626   separately.
627   We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
628   would slow down the IT87 access and should not be necessary.
629   There are some ugly typecasts here, but the good new is - they should
630   nowhere else be necessary! */
631static int it87_read_value(struct i2c_client *client, u8 reg)
632{
633        int res;
634        if (i2c_is_isa_client(client)) {
635                down(&(((struct it87_data *) (client->data))->lock));
636                outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
637                res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
638                up(&(((struct it87_data *) (client->data))->lock));
639                return res;
640        } else
641                return i2c_smbus_read_byte_data(client, reg);
642}
643
644/* The SMBus locks itself, but ISA access muse be locked explicitly!
645   We don't want to lock the whole ISA bus, so we lock each client
646   separately.
647   We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
648   would slow down the IT87 access and should not be necessary.
649   There are some ugly typecasts here, but the good new is - they should
650   nowhere else be necessary! */
651static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
652{
653        if (i2c_is_isa_client(client)) {
654                down(&(((struct it87_data *) (client->data))->lock));
655                outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
656                outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
657                up(&(((struct it87_data *) (client->data))->lock));
658                return 0;
659        } else
660                return i2c_smbus_write_byte_data(client, reg, value);
661}
662
663/* Called when we have found a new IT87. */
664static void it87_init_client(struct i2c_client *client)
665{
666        int tmp;
667
668        if (reset) {
669                /* Reset all except Watchdog values and last conversion values
670                   This sets fan-divs to 2, among others */
671                it87_write_value(client, IT87_REG_CONFIG, 0x80);
672        }
673
674        /* Check if temperature channnels are reset manually or by some reason */
675        tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
676        if ((tmp & 0x3f) == 0) {
677                /* Temp1,Temp3=thermistor; Temp2=thermal diode */
678                tmp = (tmp & 0xc0) | 0x2a;
679                it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
680        }
681
682        /* Check if voltage monitors are reset manually or by some reason */
683        tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
684        if ((tmp & 0xff) == 0) {
685                /* Enable all voltage monitors */
686                it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
687        }
688
689        /* Check if tachometers are reset manually or by some reason */
690        tmp = it87_read_value(client, IT87_REG_FAN_CTRL);
691        if ((tmp & 0x70) == 0) {
692                /* Enable all fan tachometers */
693                tmp = (tmp & 0x8f) | 0x70;
694                it87_write_value(client, IT87_REG_FAN_CTRL, tmp);
695        }
696
697        /* Start monitoring */
698        it87_write_value(client, IT87_REG_CONFIG,
699                         (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
700                         | (update_vbat ? 0x41 : 0x01));
701}
702
703static void it87_update_client(struct i2c_client *client)
704{
705        struct it87_data *data = client->data;
706        int i, tmp, tmp2;
707
708        down(&data->update_lock);
709
710        if ((jiffies - data->last_updated > HZ + HZ / 2) ||
711            (jiffies < data->last_updated) || !data->valid) {
712
713                if (update_vbat) {
714        /* Cleared after each update, so reenable.  Value
715           returned by this read will be previous value */
716                        it87_write_value(client, IT87_REG_CONFIG,
717                           it87_read_value(client, IT87_REG_CONFIG) | 0x40);
718                }
719                for (i = 0; i <= 7; i++) {
720                        data->in[i] =
721                            it87_read_value(client, IT87_REG_VIN(i));
722                        data->in_min[i] =
723                            it87_read_value(client, IT87_REG_VIN_MIN(i));
724                        data->in_max[i] =
725                            it87_read_value(client, IT87_REG_VIN_MAX(i));
726                }
727                data->in[8] =
728                    it87_read_value(client, IT87_REG_VIN(8));
729                /* VBAT sensor doesn't have limit registers, set
730                   to min and max value */
731                data->in_min[8] = 0;
732                data->in_max[8] = 255;
733               
734                for (i = 1; i <= 3; i++) {
735                        data->fan[i - 1] =
736                            it87_read_value(client, IT87_REG_FAN(i));
737                        data->fan_min[i - 1] =
738                            it87_read_value(client, IT87_REG_FAN_MIN(i));
739                }
740                for (i = 1; i <= 3; i++) {
741                        data->temp[i - 1] =
742                            it87_read_value(client, IT87_REG_TEMP(i));
743                        data->temp_high[i - 1] =
744                            it87_read_value(client, IT87_REG_TEMP_HIGH(i));
745                        data->temp_low[i - 1] =
746                            it87_read_value(client, IT87_REG_TEMP_LOW(i));
747                }
748
749                if (data->type == it8712) {
750                        data->vid = it87_read_value(client, IT87_REG_VID);
751                        data->vid &= 0x1f;
752                }
753
754                i = it87_read_value(client, IT87_REG_FAN_DIV);
755                data->fan_div[0] = i & 0x07;
756                data->fan_div[1] = (i >> 3) & 0x07;
757                data->fan_div[2] = ( (i&0x40)==0x40 ? 3 : 1 );
758
759                for( i = 1; i <= 3; i++ ) {
760                        data->pwm[i-1] = it87_read_value(client, IT87_REG_PWM(i));
761                        data->sg_tl[i-1][0] = it87_read_value(client, IT87_REG_SG_TL_OFF(i));
762                        data->sg_tl[i-1][1] = it87_read_value(client, IT87_REG_SG_TL_LOW(i));
763                        data->sg_tl[i-1][2] = it87_read_value(client, IT87_REG_SG_TL_MED(i));
764                        data->sg_tl[i-1][3] = it87_read_value(client, IT87_REG_SG_TL_HI(i));
765                        data->sg_tl[i-1][4] = it87_read_value(client, IT87_REG_SG_TL_OVR(i));
766                        data->sg_pwm[i-1][0] = it87_read_value(client, IT87_REG_SG_PWM_LOW(i));
767                        data->sg_pwm[i-1][1] = it87_read_value(client, IT87_REG_SG_PWM_MED(i));
768                        data->sg_pwm[i-1][2] = it87_read_value(client, IT87_REG_SG_PWM_HI(i));
769                }
770                data->alarms =
771                        it87_read_value(client, IT87_REG_ALARM1) |
772                        (it87_read_value(client, IT87_REG_ALARM2) << 8) |
773                        (it87_read_value(client, IT87_REG_ALARM3) << 16);
774                data->fan_ctl[0] = it87_read_value(client, IT87_REG_FAN_CTRL);
775                data->fan_ctl[1] = it87_read_value(client, IT87_REG_FAN_ONOFF);
776
777                tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
778                for(i = 0; i < 3; i++) {
779                        tmp2 = (tmp >> i) & 0x09;
780                        if(tmp2 == 0x01)
781                                data->sens[i] = PIIDIODE;
782                        else if(tmp2 == 0x08)
783                                data->sens[i] = THERMISTOR;
784                        else
785                                data->sens[i] = UNUSED;
786                }
787
788                data->last_updated = jiffies;
789                data->valid = 1;
790        }
791
792        up(&data->update_lock);
793}
794
795
796/* The next few functions are the call-back functions of the /proc/sys and
797   sysctl files. Which function is used is defined in the ctl_table in
798   the extra1 field.
799    - Each function must return the magnitude (power of 10 to divide the
800      data with) if it is called with operation==SENSORS_PROC_REAL_INFO.
801    - It must put a maximum of *nrels elements in results reflecting the
802      data of this file, and set *nrels to the number it actually put
803      in it, if operation==SENSORS_PROC_REAL_READ.
804    - Finally, it must get upto *nrels elements from results and write them
805      to the chip, if operations==SENSORS_PROC_REAL_WRITE.
806   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
807   large enough (by checking the incoming value of *nrels). This is not very
808   good practice, but as long as you put less than about 5 values in results,
809   you can assume it is large enough. */
810void it87_in(struct i2c_client *client, int operation, int ctl_name,
811             int *nrels_mag, long *results)
812{
813        struct it87_data *data = client->data;
814        int nr = ctl_name - IT87_SYSCTL_IN0;
815
816        if (operation == SENSORS_PROC_REAL_INFO)
817                *nrels_mag = 2;
818        else if (operation == SENSORS_PROC_REAL_READ) {
819                it87_update_client(client);
820                results[0] = IN_FROM_REG(data->in_min[nr]);
821                results[1] = IN_FROM_REG(data->in_max[nr]);
822                results[2] = IN_FROM_REG(data->in[nr]);
823                *nrels_mag = 3;
824        } else if (operation == SENSORS_PROC_REAL_WRITE) {
825                if (*nrels_mag >= 1) {
826                        data->in_min[nr] = IN_TO_REG(results[0]);
827                        it87_write_value(client, IT87_REG_VIN_MIN(nr),
828                                         data->in_min[nr]);
829                }
830                if (*nrels_mag >= 2) {
831                        data->in_max[nr] = IN_TO_REG(results[1]);
832                        it87_write_value(client, IT87_REG_VIN_MAX(nr),
833                                         data->in_max[nr]);
834                }
835        }
836}
837
838void it87_fan(struct i2c_client *client, int operation, int ctl_name,
839              int *nrels_mag, long *results)
840{
841        struct it87_data *data = client->data;
842        int nr = ctl_name - IT87_SYSCTL_FAN1 + 1;
843
844        if (operation == SENSORS_PROC_REAL_INFO)
845                *nrels_mag = 0;
846        else if (operation == SENSORS_PROC_REAL_READ) {
847                it87_update_client(client);
848                results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
849                                          DIV_FROM_REG(data->fan_div[nr - 1]));
850                results[1] = FAN_FROM_REG(data->fan[nr - 1],
851                                 DIV_FROM_REG(data->fan_div[nr - 1]));
852                *nrels_mag = 2;
853        } else if (operation == SENSORS_PROC_REAL_WRITE) {
854                if (*nrels_mag >= 1) {
855                        data->fan_min[nr - 1] = FAN_TO_REG(results[0],
856                                                           DIV_FROM_REG(data->fan_div[nr - 1]));
857                        it87_write_value(client, IT87_REG_FAN_MIN(nr),
858                                         data->fan_min[nr - 1]);
859                }
860        }
861}
862
863
864void it87_temp(struct i2c_client *client, int operation, int ctl_name,
865               int *nrels_mag, long *results)
866{
867        struct it87_data *data = client->data;
868        int nr = ctl_name - IT87_SYSCTL_TEMP1 + 1;
869        if (operation == SENSORS_PROC_REAL_INFO)
870                *nrels_mag = 1;
871        else if (operation == SENSORS_PROC_REAL_READ) {
872                it87_update_client(client);
873                results[0] = TEMP_FROM_REG(data->temp_high[nr - 1]);
874                results[1] = TEMP_FROM_REG(data->temp_low[nr - 1]);
875                results[2] = TEMP_FROM_REG(data->temp[nr - 1]);
876                *nrels_mag = 3;
877        } else if (operation == SENSORS_PROC_REAL_WRITE) {
878                if (*nrels_mag >= 1) {
879                        data->temp_high[nr - 1] = TEMP_TO_REG(results[0]);
880                        it87_write_value(client, IT87_REG_TEMP_HIGH(nr),
881                                         data->temp_high[nr - 1]);
882                }
883                if (*nrels_mag >= 2) {
884                        data->temp_low[nr - 1] = TEMP_TO_REG(results[1]);
885                        it87_write_value(client, IT87_REG_TEMP_LOW(nr),
886                                         data->temp_low[nr - 1]);
887                }
888        }
889}
890
891void it87_pwm(struct i2c_client *client, int operation, int ctl_name,
892               int *nrels_mag, long *results)
893{
894        struct it87_data *data = client->data;
895        int nr = ctl_name - IT87_SYSCTL_PWM1 + 1;
896        if (operation == SENSORS_PROC_REAL_INFO)
897                *nrels_mag = 0;
898        else if (operation == SENSORS_PROC_REAL_READ) {
899                it87_update_client(client);
900                results[0] = data->pwm[nr - 1];
901                *nrels_mag = 1;
902        } else if (operation == SENSORS_PROC_REAL_WRITE) {
903                if (*nrels_mag >= 1) {
904                        data->pwm[nr - 1] = results[0];
905                        it87_write_value(client, IT87_REG_PWM(nr), data->pwm[nr - 1]);
906                }
907        }
908}
909
910void it87_sgpwm(struct i2c_client *client, int operation, int ctl_name,
911               int *nrels_mag, long *results)
912{
913        struct it87_data *data = client->data;
914        int nr = ctl_name - IT87_SYSCTL_PWM1 + 1;
915        if (operation == SENSORS_PROC_REAL_INFO)
916                *nrels_mag = 0;
917        else if (operation == SENSORS_PROC_REAL_READ) {
918                it87_update_client(client);
919                results[0] = data->sg_pwm[nr - 1][0];
920                results[1] = data->sg_pwm[nr - 1][1];
921                results[2] = data->sg_pwm[nr - 1][2];
922                *nrels_mag = 3;
923        } else if (operation == SENSORS_PROC_REAL_WRITE) {
924                if (*nrels_mag >= 1) {
925                        data->sg_pwm[nr - 1][0] = results[0];
926                        it87_write_value(client, IT87_REG_SG_PWM_LOW(nr), data->sg_pwm[nr - 1][0]);
927                }
928                if (*nrels_mag >= 2) {
929                        data->sg_pwm[nr - 1][1] = results[1];
930                        it87_write_value(client, IT87_REG_SG_PWM_MED(nr), data->sg_pwm[nr - 1][1]);
931                }
932                if (*nrels_mag >= 3) {
933                        data->sg_pwm[nr - 1][2] = results[2];
934                        it87_write_value(client, IT87_REG_SG_PWM_HI(nr), data->sg_pwm[nr - 1][2]);
935                }
936        }
937}
938
939void it87_sgtl(struct i2c_client *client, int operation, int ctl_name,
940               int *nrels_mag, long *results)
941{
942        struct it87_data *data = client->data;
943        int nr = ctl_name - IT87_SYSCTL_PWM1 + 1;
944        if (operation == SENSORS_PROC_REAL_INFO)
945                *nrels_mag = 1;
946        else if (operation == SENSORS_PROC_REAL_READ) {
947                it87_update_client(client);
948                results[0] = TEMP_FROM_REG(data->sg_tl[nr - 1][0]);
949                results[1] = TEMP_FROM_REG(data->sg_tl[nr - 1][1]);
950                results[2] = TEMP_FROM_REG(data->sg_tl[nr - 1][2]);
951                results[3] = TEMP_FROM_REG(data->sg_tl[nr - 1][3]);
952                results[4] = TEMP_FROM_REG(data->sg_tl[nr - 1][4]);
953                *nrels_mag = 5;
954        } else if (operation == SENSORS_PROC_REAL_WRITE) {
955                if (*nrels_mag >= 1) {
956                        data->sg_tl[nr - 1][0] = TEMP_TO_REG(results[0]);
957                        it87_write_value(client, IT87_REG_SG_TL_OFF(nr), data->sg_tl[nr - 1][0]);
958                }
959                if (*nrels_mag >= 2) {
960                        data->sg_tl[nr - 1][1] = TEMP_TO_REG(results[1]);
961                        it87_write_value(client, IT87_REG_SG_TL_LOW(nr), data->sg_tl[nr - 1][1]);
962                }
963                if (*nrels_mag >= 3) {
964                        data->sg_tl[nr - 1][2] = TEMP_TO_REG(results[2]);
965                        it87_write_value(client, IT87_REG_SG_TL_MED(nr), data->sg_tl[nr - 1][2]);
966                }
967                if (*nrels_mag >= 4) {
968                        data->sg_tl[nr - 1][3] = TEMP_TO_REG(results[3]);
969                        it87_write_value(client, IT87_REG_SG_TL_HI(nr), data->sg_tl[nr - 1][3]);
970                }
971                if (*nrels_mag >= 5) {
972                        data->sg_tl[nr - 1][4] = TEMP_TO_REG(results[4]);
973                        it87_write_value(client, IT87_REG_SG_TL_OVR(nr), data->sg_tl[nr - 1][4]);
974                }
975        }
976}
977
978void it87_vid(struct i2c_client *client, int operation, int ctl_name,
979              int *nrels_mag, long *results)
980{
981        struct it87_data *data = client->data;
982        if (operation == SENSORS_PROC_REAL_INFO)
983                *nrels_mag = 2;
984        else if (operation == SENSORS_PROC_REAL_READ) {
985                it87_update_client(client);
986                results[0] = VID_FROM_REG(data->vid);
987                *nrels_mag = 1;
988        }
989}
990
991void it87_alarms(struct i2c_client *client, int operation,
992                     int ctl_name, int *nrels_mag, long *results)
993{
994        struct it87_data *data = client->data;
995        if (operation == SENSORS_PROC_REAL_INFO)
996                *nrels_mag = 0;
997        else if (operation == SENSORS_PROC_REAL_READ) {
998                it87_update_client(client);
999                results[0] = ALARMS_FROM_REG(data->alarms);
1000                *nrels_mag = 1;
1001        }
1002}
1003
1004void it87_fan_div(struct i2c_client *client, int operation, int ctl_name,
1005                  int *nrels_mag, long *results)
1006{
1007        struct it87_data *data = client->data;
1008        int old;
1009
1010        if (operation == SENSORS_PROC_REAL_INFO)
1011                *nrels_mag = 0;
1012        else if (operation == SENSORS_PROC_REAL_READ) {
1013                it87_update_client(client);
1014                results[0] = DIV_FROM_REG(data->fan_div[0]);
1015                results[1] = DIV_FROM_REG(data->fan_div[1]);
1016                results[2] = DIV_FROM_REG(data->fan_div[2]);;
1017                *nrels_mag = 3;
1018        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1019                old = it87_read_value(client, IT87_REG_FAN_DIV);
1020                if (*nrels_mag >= 3) {
1021                        data->fan_div[2] = DIV_TO_REG(results[2]);
1022                        if( data->fan[2]!=3 ) {
1023                                data->fan_div[2] = 1;
1024                                old = (old & 0xbf);
1025                        } else {
1026                                old = (old | 0x40);
1027                        }
1028                }
1029                if (*nrels_mag >= 2) {
1030                        data->fan_div[1] = DIV_TO_REG(results[1]);
1031                        old = (old & 0xc3) | (data->fan_div[1] << 3);
1032                }
1033                if (*nrels_mag >= 1) {
1034                        data->fan_div[0] = DIV_TO_REG(results[0]);
1035                        old = (old & 0xf8) | data->fan_div[0];
1036                        it87_write_value(client, IT87_REG_FAN_DIV, old);
1037                }
1038        }
1039}
1040
1041void it87_fan_ctl(struct i2c_client *client, int operation, int ctl_name,
1042               int *nrels_mag, long *results)
1043{
1044        struct it87_data *data = client->data;
1045        int index = ctl_name - IT87_SYSCTL_FAN_CTL;
1046        if (operation == SENSORS_PROC_REAL_INFO)
1047                *nrels_mag = 0;
1048        else if (operation == SENSORS_PROC_REAL_READ) {
1049                it87_update_client(client);
1050                results[0] = data->fan_ctl[index];
1051                *nrels_mag = 1;
1052        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1053                if (*nrels_mag >= 1) {
1054                        data->fan_ctl[index] = results[0];
1055                        if( index == 0 )
1056                                it87_write_value(client, IT87_REG_FAN_CTRL, data->fan_ctl[index] );
1057                        else
1058                                it87_write_value(client, IT87_REG_FAN_ONOFF, data->fan_ctl[index] );
1059                }
1060        }
1061}
1062
1063void it87_sens(struct i2c_client *client, int operation, int ctl_name,
1064                  int *nrels_mag, long *results)
1065{
1066        struct it87_data *data = client->data;
1067        int nr = 1 + ctl_name - IT87_SYSCTL_SENS1;
1068        u8 tmp, val1, val2;
1069
1070        if (operation == SENSORS_PROC_REAL_INFO)
1071                *nrels_mag = 0;
1072        else if (operation == SENSORS_PROC_REAL_READ) {
1073                results[0] = data->sens[nr - 1];
1074                *nrels_mag = 1;
1075        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1076                if (*nrels_mag >= 1) {
1077                        val1 = 0x01 << (nr - 1);
1078                        val2 = 0x08 << (nr - 1);
1079                        tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1080                        switch (results[0]) {
1081                        case PIIDIODE:
1082                                tmp &= ~ val2;
1083                                tmp |= val1;
1084                                break;
1085                        case THERMISTOR:
1086                                tmp &= ~ val1;
1087                                tmp |= val2;
1088                                break;
1089                        case UNUSED:
1090                                tmp &= ~ val1;
1091                                tmp &= ~ val2;
1092                                break;
1093                        default:
1094                                printk(KERN_ERR "it87.o: Invalid sensor type %ld; "
1095                                       "must be 0 (unused), 2 (thermistor) "
1096                                       "or 3 (diode)\n", results[0]);
1097                                return;
1098                        }
1099                        it87_write_value(client,
1100                                         IT87_REG_TEMP_ENABLE, tmp);
1101                        data->sens[nr - 1] = results[0];
1102                }
1103        }
1104}
1105
1106static int __init sm_it87_init(void)
1107{
1108        int addr;
1109
1110        printk("it87.o version %s (%s)\n", LM_VERSION, LM_DATE);
1111        if (!it87_find(&addr)) {
1112                normal_isa[0] = addr;
1113        }
1114        return i2c_add_driver(&it87_driver);
1115}
1116
1117static void __exit sm_it87_exit(void)
1118{
1119        i2c_del_driver(&it87_driver);
1120}
1121
1122
1123
1124MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1125MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1126MODULE_PARM(update_vbat, "i");
1127MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1128MODULE_PARM(reset, "i");
1129MODULE_PARM_DESC(reset, "Reset the chip's registers, default no");
1130
1131module_init(sm_it87_init);
1132module_exit(sm_it87_exit);
Note: See TracBrowser for help on using the browser.