root/lm-sensors/trunk/kernel/chips/w83781d.c @ 3071

Revision 3071, 65.4 KB (checked in by khali, 9 years ago)

Drop the W83697HF support from the w83781d driver. It is better
supported by the super-I/O w83627hf driver. Patch from Grant Coady.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2    w83781d.c - Part of lm_sensors, Linux kernel modules for hardware
3                monitoring
4    Copyright (c) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
5    Philip Edelbrock <phil@netroedge.com>,
6    and Mark Studebaker <mdsxyz123@yahoo.com>
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21*/
22
23/*
24    Supports following chips:
25
26    Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
27    as99127f    7       3       0       3       0x31    0x12c3  yes     no
28    as99127f rev.2 (type name = as99127f)       0x31    0x5ca3  yes     no
29    w83627hf    9       3       2       3       0x21    0x5ca3  yes     yes(LPC)
30    w83781d     7       3       0       3       0x10-1  0x5ca3  yes     yes
31    w83782d     9       3       2-4     3       0x30    0x5ca3  yes     yes
32    w83783s     5-6     3       2       1-2     0x40    0x5ca3  yes     no
33    w83791d     10      5       5       3       0x71    0x5ca3  yes     no
34
35*/
36
37#include <linux/module.h>
38#include <linux/slab.h>
39#include <linux/ioport.h>
40#include <linux/i2c.h>
41#include <linux/i2c-proc.h>
42#include <linux/init.h>
43#include <asm/io.h>
44#include "version.h"
45#include "sensors_vid.h"
46#include "lm75.h"
47
48/* RT Table support #defined so we can take it out if it gets bothersome */
49#define W83781D_RT 1
50
51/* Addresses to scan */
52static unsigned short normal_i2c[] = { SENSORS_I2C_END };
53static unsigned short normal_i2c_range[] = { 0x20, 0x2f, SENSORS_I2C_END };
54static unsigned int normal_isa[] = { 0x0290, SENSORS_ISA_END };
55static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
56
57/* Insmod parameters */
58SENSORS_INSMOD_6(w83781d, w83782d, w83783s, w83627hf, as99127f, w83791d);
59SENSORS_MODULE_PARM(force_subclients, "List of subclient addresses: " \
60                      "{bus, clientaddr, subclientaddr1, subclientaddr2}");
61
62static int init = 1;
63MODULE_PARM(init, "i");
64MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
65
66/* Constants specified below */
67
68/* Length of ISA address segment */
69#define W83781D_EXTENT 8
70
71/* Where are the ISA address/data registers relative to the base address */
72#define W83781D_ADDR_REG_OFFSET 5
73#define W83781D_DATA_REG_OFFSET 6
74
75/* The W83781D registers */
76/* The W83782D registers for nr=7,8 are in bank 5 */
77#define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
78                                           (0x554 + (((nr) - 7) * 2)))
79#define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
80                                           (0x555 + (((nr) - 7) * 2)))
81#define W83781D_REG_IN(nr)     ((nr < 7) ? (0x20 + (nr)) : \
82                                           (0x550 + (nr) - 7))
83
84#define W83791D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
85                                           (0xb4 + (((nr) - 7) * 2)))
86#define W83791D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
87                                           (0xb5 + (((nr) - 7) * 2)))
88#define W83791D_REG_IN(nr)     ((nr < 7) ? (0x20 + (nr)) : \
89                                           (0xb0 + (nr) - 7))
90
91#define W83781D_REG_FAN_MIN(nr) ((nr < 4) ? (0x3a + (nr)) : \
92                                            (0xba + (nr) - 4))
93#define W83781D_REG_FAN(nr)     ((nr < 4) ? (0x27 + (nr)) : \
94                                            (0xbc + (nr) - 4))
95
96#define W83781D_REG_TEMP2 0x0150
97#define W83781D_REG_TEMP3 0x0250
98#define W83781D_REG_TEMP2_HYST 0x153
99#define W83781D_REG_TEMP3_HYST 0x253
100#define W83781D_REG_TEMP2_CONFIG 0x152
101#define W83781D_REG_TEMP3_CONFIG 0x252
102#define W83781D_REG_TEMP2_OVER 0x155
103#define W83781D_REG_TEMP3_OVER 0x255
104
105#define W83781D_REG_TEMP 0x27
106#define W83781D_REG_TEMP_OVER 0x39
107#define W83781D_REG_TEMP_HYST 0x3A
108#define W83781D_REG_BANK 0x4E
109
110#define W83781D_REG_CONFIG 0x40
111#define W83781D_REG_ALARM1 0x41
112#define W83781D_REG_ALARM2 0x42
113#define W83781D_REG_ALARM3 0x450        /* not on W83781D */
114
115#define W83781D_REG_IRQ 0x4C
116#define W83781D_REG_BEEP_CONFIG 0x4D
117#define W83781D_REG_BEEP_INTS1 0x56
118#define W83781D_REG_BEEP_INTS2 0x57
119#define W83781D_REG_BEEP_INTS3 0x453    /* not on W83781D */
120
121#define W83781D_REG_VID_FANDIV 0x47
122
123#define W83781D_REG_CHIPID 0x49
124#define W83781D_REG_WCHIPID 0x58
125#define W83781D_REG_CHIPMAN 0x4F
126#define W83781D_REG_PIN 0x4B
127
128/* 782D/783S only */
129#define W83781D_REG_VBAT 0x5D
130
131/* PWM 782D (1-4) and 783S (1-2) only */
132#define W83781D_REG_PWM1 0x5B   /* 782d and 783s/627hf datasheets disagree */
133                                /* on which is which; */
134#define W83781D_REG_PWM2 0x5A   /* We follow the 782d convention here, */
135                                /* However 782d is probably wrong. */
136#define W83781D_REG_PWM3 0x5E
137#define W83781D_REG_PWM4 0x5F
138#define W83781D_REG_PWMCLK12 0x5C
139#define W83781D_REG_PWMCLK34 0x45C
140
141#define W83791D_REG_PWM1 0x81
142#define W83791D_REG_PWM2 0x83
143#define W83791D_REG_PWM3 0x94
144
145#define W83627HF_REG_PWM1 0x01
146#define W83627HF_REG_PWM2 0x03
147#define W83627HF_REG_PWMCLK1 0x00
148#define W83627HF_REG_PWMCLK2 0x02
149
150static const u8 regpwm[] = { W83781D_REG_PWM1, W83781D_REG_PWM2,
151        W83781D_REG_PWM3, W83781D_REG_PWM4
152};
153
154static const u8 regpwm_w83791d[] = { W83791D_REG_PWM1, W83791D_REG_PWM2,
155                                   W83791D_REG_PWM3
156};
157       
158#define W83781D_REG_PWM(type, nr) (((type) == w83791d) ? \
159                                         regpwm_w83791d[(nr) - 1] : \
160                                         regpwm[(nr) - 1])
161
162#define W83781D_REG_I2C_ADDR 0x48
163#define W83781D_REG_I2C_SUBADDR 0x4A
164
165/* The following are undocumented in the data sheets however we
166   received the information in an email from Winbond tech support */
167/* Sensor selection - not on 781d */
168#define W83781D_REG_SCFG1 0x5D
169static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
170#define W83781D_REG_SCFG2 0x59
171static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
172#define W83781D_DEFAULT_BETA 3435
173
174/* RT Table registers */
175#define W83781D_REG_RT_IDX 0x50
176#define W83781D_REG_RT_VAL 0x51
177
178/* Conversions. Rounding and limit checking is only done on the TO_REG
179   variants. Note that you should be a bit careful with which arguments
180   these macros are called: arguments may be evaluated more than once.
181   Fixing this is just not worth it. */
182#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
183#define IN_FROM_REG(val) (((val) * 16 + 5) / 10)
184
185static inline u8 FAN_TO_REG(long rpm, int div)
186{
187        if (rpm == 0)
188                return 255;
189        rpm = SENSORS_LIMIT(rpm, 1, 1000000);
190        return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
191                             254);
192}
193
194#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
195
196#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
197                                                 ((val)+5)/10),0,255))
198#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
199
200#define ALARMS_FROM_REG(val) (val)
201#define PWM_FROM_REG(val) (val)
202#define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
203#define BEEPS_FROM_REG(val,type) ((type)==as99127f?(val)^0x7FFF:(val))
204#define BEEPS_TO_REG(val,type) ((type)==as99127f?(~(val))&0x7FFF:(val)&0xffffff)
205
206#define BEEP_ENABLE_TO_REG(val)   ((val)?1:0)
207#define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
208
209#define DIV_FROM_REG(val) (1 << (val))
210
211static inline u8 DIV_TO_REG(long val, enum chips type)
212{
213        int i;
214        val = SENSORS_LIMIT(val, 1,
215                ((type == w83781d || type == as99127f) ? 8 : 128)) >> 1;
216        for (i = 0; i < 7; i++) {
217                if (val == 0)
218                        break;
219                val >>= 1;
220        }
221        return ((u8) i);
222}
223
224/* There are some complications in a module like this. First off, W83781D chips
225   may be both present on the SMBus and the ISA bus, and we have to handle
226   those cases separately at some places. Second, there might be several
227   W83781D chips available (well, actually, that is probably never done; but
228   it is a clean illustration of how to handle a case like that). Finally,
229   a specific chip may be attached to *both* ISA and SMBus, and we would
230   not like to detect it double. Fortunately, in the case of the W83781D at
231   least, a register tells us what SMBus address we are on, so that helps
232   a bit - except if there could be more than one SMBus. Groan. No solution
233   for this yet. */
234
235/* This module may seem overly long and complicated. In fact, it is not so
236   bad. Quite a lot of bookkeeping is done. A real driver can often cut
237   some corners. */
238
239/* For each registered W83781D, we need to keep some data in memory. That
240   data is pointed to by w83781d_list[NR]->data. The structure itself is
241   dynamically allocated, at the same time when a new w83781d client is
242   allocated. */
243struct w83781d_data {
244        struct i2c_client client;
245        struct semaphore lock;
246        int sysctl_id;
247        enum chips type;
248
249        struct semaphore update_lock;
250        char valid;             /* !=0 if following fields are valid */
251        unsigned long last_updated;     /* In jiffies */
252
253        struct i2c_client *lm75;        /* for secondary I2C addresses */
254        /* pointer to array of 2 subclients */
255
256        u8 in[10];              /* Register value - 8 & 9 for 782D and 791D only 10 for 791D */
257        u8 in_max[10];          /* Register value - 8 & 9 for 782D and 791D only 10 for 791D */
258        u8 in_min[10];          /* Register value - 8 & 9 for 782D and 791D only 10 for 791D */
259        u8 fan[5];              /* Register value - 4 & 5 for 791D only */
260        u8 fan_min[5];          /* Register value - 4 & 5 for 791D only */
261        u8 temp;
262        u8 temp_over;           /* Register value */
263        u8 temp_hyst;           /* Register value */
264        u16 temp_add[2];        /* Register value */
265        u16 temp_add_over[2];   /* Register value */
266        u16 temp_add_hyst[2];   /* Register value */
267        u8 fan_div[3];          /* Register encoding, shifted right */
268        u8 vid;                 /* Register encoding, combined */
269        u32 alarms;             /* Register encoding, combined */
270        u32 beeps;              /* Register encoding, combined */
271        u8 beep_enable;         /* Boolean */
272        u8 pwm[4];              /* Register value */
273        u8 pwmenable[4];        /* bool */
274        u16 sens[3];            /* 782D/783S only.
275                                   1 = pentium diode; 2 = 3904 diode;
276                                   3000-5000 = thermistor beta.
277                                   Default = 3435.
278                                   Other Betas unimplemented */
279#ifdef W83781D_RT
280        u8 rt[3][32];           /* Register value */
281#endif
282        u8 vrm;
283};
284
285
286static int w83781d_attach_adapter(struct i2c_adapter *adapter);
287static int w83781d_detect(struct i2c_adapter *adapter, int address,
288                          unsigned short flags, int kind);
289static int w83781d_detach_client(struct i2c_client *client);
290
291static int w83781d_read_value(struct i2c_client *client, u16 register);
292static int w83781d_write_value(struct i2c_client *client, u16 register,
293                               u16 value);
294static void w83781d_update_client(struct i2c_client *client);
295static void w83781d_init_client(struct i2c_client *client);
296
297
298static void w83781d_in(struct i2c_client *client, int operation,
299                       int ctl_name, int *nrels_mag, long *results);
300static void w83781d_fan(struct i2c_client *client, int operation,
301                        int ctl_name, int *nrels_mag, long *results);
302static void w83781d_temp(struct i2c_client *client, int operation,
303                         int ctl_name, int *nrels_mag, long *results);
304static void w83781d_temp_add(struct i2c_client *client, int operation,
305                             int ctl_name, int *nrels_mag, long *results);
306static void w83781d_vid(struct i2c_client *client, int operation,
307                        int ctl_name, int *nrels_mag, long *results);
308static void w83781d_vrm(struct i2c_client *client, int operation,
309                        int ctl_name, int *nrels_mag, long *results);
310static void w83781d_alarms(struct i2c_client *client, int operation,
311                           int ctl_name, int *nrels_mag, long *results);
312static void w83781d_beep(struct i2c_client *client, int operation,
313                         int ctl_name, int *nrels_mag, long *results);
314static void w83781d_fan_div(struct i2c_client *client, int operation,
315                            int ctl_name, int *nrels_mag, long *results);
316static void w83781d_pwm(struct i2c_client *client, int operation,
317                        int ctl_name, int *nrels_mag, long *results);
318static void w83781d_sens(struct i2c_client *client, int operation,
319                         int ctl_name, int *nrels_mag, long *results);
320#ifdef W83781D_RT
321static void w83781d_rt(struct i2c_client *client, int operation,
322                       int ctl_name, int *nrels_mag, long *results);
323#endif
324
325static struct i2c_driver w83781d_driver = {
326        .name           = "W83781D sensor driver",
327        .id             = I2C_DRIVERID_W83781D,
328        .flags          = I2C_DF_NOTIFY,
329        .attach_adapter = w83781d_attach_adapter,
330        .detach_client  = w83781d_detach_client,
331};
332
333/* The /proc/sys entries */
334/* -- SENSORS SYSCTL START -- */
335
336#define W83781D_SYSCTL_IN0 1000 /* Volts * 100 */
337#define W83781D_SYSCTL_IN1 1001
338#define W83781D_SYSCTL_IN2 1002
339#define W83781D_SYSCTL_IN3 1003
340#define W83781D_SYSCTL_IN4 1004
341#define W83781D_SYSCTL_IN5 1005
342#define W83781D_SYSCTL_IN6 1006
343#define W83781D_SYSCTL_IN7 1007
344#define W83781D_SYSCTL_IN8 1008
345#define W83781D_SYSCTL_IN9 1009
346#define W83781D_SYSCTL_FAN1 1101        /* Rotations/min */
347#define W83781D_SYSCTL_FAN2 1102
348#define W83781D_SYSCTL_FAN3 1103
349#define W83781D_SYSCTL_FAN4 1104
350#define W83781D_SYSCTL_FAN5 1105
351
352#define W83781D_SYSCTL_TEMP1 1200       /* Degrees Celsius * 10 */
353#define W83781D_SYSCTL_TEMP2 1201       /* Degrees Celsius * 10 */
354#define W83781D_SYSCTL_TEMP3 1202       /* Degrees Celsius * 10 */
355#define W83781D_SYSCTL_VID 1300         /* Volts * 1000 */
356#define W83781D_SYSCTL_VRM 1301
357#define W83781D_SYSCTL_PWM1 1401
358#define W83781D_SYSCTL_PWM2 1402
359#define W83781D_SYSCTL_PWM3 1403
360#define W83781D_SYSCTL_PWM4 1404
361#define W83781D_SYSCTL_SENS1 1501       /* 1, 2, or Beta (3000-5000) */
362#define W83781D_SYSCTL_SENS2 1502
363#define W83781D_SYSCTL_SENS3 1503
364#define W83781D_SYSCTL_RT1   1601       /* 32-entry table */
365#define W83781D_SYSCTL_RT2   1602       /* 32-entry table */
366#define W83781D_SYSCTL_RT3   1603       /* 32-entry table */
367#define W83781D_SYSCTL_FAN_DIV 2000     /* 1, 2, 4 or 8 */
368#define W83781D_SYSCTL_ALARMS 2001      /* bitvector */
369#define W83781D_SYSCTL_BEEP 2002        /* bitvector */
370
371#define W83781D_ALARM_IN0 0x0001
372#define W83781D_ALARM_IN1 0x0002
373#define W83781D_ALARM_IN2 0x0004
374#define W83781D_ALARM_IN3 0x0008
375#define W83781D_ALARM_IN4 0x0100
376#define W83781D_ALARM_IN5 0x0200
377#define W83781D_ALARM_IN6 0x0400
378#define W83782D_ALARM_IN7 0x10000
379#define W83782D_ALARM_IN8 0x20000
380#define W83781D_ALARM_FAN1 0x0040
381#define W83781D_ALARM_FAN2 0x0080
382#define W83781D_ALARM_FAN3 0x0800
383#define W83781D_ALARM_TEMP1 0x0010
384#define W83781D_ALARM_TEMP23 0x0020     /* 781D only */
385#define W83781D_ALARM_TEMP2 0x0020      /* 782D/783S */
386#define W83781D_ALARM_TEMP3 0x2000      /* 782D only */
387#define W83781D_ALARM_CHAS 0x1000
388
389/* -- SENSORS SYSCTL END -- */
390
391/* These files are created for each detected chip. This is just a template;
392   though at first sight, you might think we could use a statically
393   allocated list, we need some way to get back to the parent - which
394   is done through one of the 'extra' fields which are initialized
395   when a new copy is allocated. */
396
397/* just a guess - no datasheet */
398static ctl_table as99127f_dir_table_template[] = {
399        {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
400         &i2c_sysctl_real, NULL, &w83781d_in},
401        {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
402         &i2c_sysctl_real, NULL, &w83781d_in},
403        {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
404         &i2c_sysctl_real, NULL, &w83781d_in},
405        {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
406         &i2c_sysctl_real, NULL, &w83781d_in},
407        {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
408         &i2c_sysctl_real, NULL, &w83781d_in},
409        {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
410         &i2c_sysctl_real, NULL, &w83781d_in},
411        {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
412         &i2c_sysctl_real, NULL, &w83781d_in},
413        {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
414         &i2c_sysctl_real, NULL, &w83781d_fan},
415        {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
416         &i2c_sysctl_real, NULL, &w83781d_fan},
417        {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
418         &i2c_sysctl_real, NULL, &w83781d_fan},
419        {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
420         &i2c_sysctl_real, NULL, &w83781d_temp},
421        {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
422         &i2c_sysctl_real, NULL, &w83781d_temp_add},
423        {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
424         &i2c_sysctl_real, NULL, &w83781d_temp_add},
425        {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
426         &i2c_sysctl_real, NULL, &w83781d_vid},
427        {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
428         &i2c_sysctl_real, NULL, &w83781d_vrm},
429        {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
430         &i2c_sysctl_real, NULL, &w83781d_fan_div},
431        {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
432         &i2c_sysctl_real, NULL, &w83781d_alarms},
433        {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
434         &i2c_sysctl_real, NULL, &w83781d_beep},
435        {0}
436};
437
438static ctl_table w83781d_dir_table_template[] = {
439        {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
440         &i2c_sysctl_real, NULL, &w83781d_in},
441        {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
442         &i2c_sysctl_real, NULL, &w83781d_in},
443        {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
444         &i2c_sysctl_real, NULL, &w83781d_in},
445        {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
446         &i2c_sysctl_real, NULL, &w83781d_in},
447        {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
448         &i2c_sysctl_real, NULL, &w83781d_in},
449        {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
450         &i2c_sysctl_real, NULL, &w83781d_in},
451        {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
452         &i2c_sysctl_real, NULL, &w83781d_in},
453        {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
454         &i2c_sysctl_real, NULL, &w83781d_fan},
455        {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
456         &i2c_sysctl_real, NULL, &w83781d_fan},
457        {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
458         &i2c_sysctl_real, NULL, &w83781d_fan},
459        {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
460         &i2c_sysctl_real, NULL, &w83781d_temp},
461        {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
462         &i2c_sysctl_real, NULL, &w83781d_temp_add},
463        {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
464         &i2c_sysctl_real, NULL, &w83781d_temp_add},
465        {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
466         &i2c_sysctl_real, NULL, &w83781d_vid},
467        {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
468         &i2c_sysctl_real, NULL, &w83781d_vrm},
469        {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
470         &i2c_sysctl_real, NULL, &w83781d_fan_div},
471        {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
472         &i2c_sysctl_real, NULL, &w83781d_alarms},
473        {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
474         &i2c_sysctl_real, NULL, &w83781d_beep},
475#ifdef W83781D_RT
476        {W83781D_SYSCTL_RT1, "rt1", NULL, 0, 0644, NULL, &i2c_proc_real,
477         &i2c_sysctl_real, NULL, &w83781d_rt},
478        {W83781D_SYSCTL_RT2, "rt2", NULL, 0, 0644, NULL, &i2c_proc_real,
479         &i2c_sysctl_real, NULL, &w83781d_rt},
480        {W83781D_SYSCTL_RT3, "rt3", NULL, 0, 0644, NULL, &i2c_proc_real,
481         &i2c_sysctl_real, NULL, &w83781d_rt},
482#endif
483        {0}
484};
485
486/* without pwm3-4 */
487static ctl_table w83782d_isa_dir_table_template[] = {
488        {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
489         &i2c_sysctl_real, NULL, &w83781d_in},
490        {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
491         &i2c_sysctl_real, NULL, &w83781d_in},
492        {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
493         &i2c_sysctl_real, NULL, &w83781d_in},
494        {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
495         &i2c_sysctl_real, NULL, &w83781d_in},
496        {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
497         &i2c_sysctl_real, NULL, &w83781d_in},
498        {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
499         &i2c_sysctl_real, NULL, &w83781d_in},
500        {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
501         &i2c_sysctl_real, NULL, &w83781d_in},
502        {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
503         &i2c_sysctl_real, NULL, &w83781d_in},
504        {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
505         &i2c_sysctl_real, NULL, &w83781d_in},
506        {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
507         &i2c_sysctl_real, NULL, &w83781d_fan},
508        {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
509         &i2c_sysctl_real, NULL, &w83781d_fan},
510        {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
511         &i2c_sysctl_real, NULL, &w83781d_fan},
512        {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
513         &i2c_sysctl_real, NULL, &w83781d_temp},
514        {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
515         &i2c_sysctl_real, NULL, &w83781d_temp_add},
516        {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
517         &i2c_sysctl_real, NULL, &w83781d_temp_add},
518        {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
519         &i2c_sysctl_real, NULL, &w83781d_vid},
520        {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
521         &i2c_sysctl_real, NULL, &w83781d_vrm},
522        {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
523         &i2c_sysctl_real, NULL, &w83781d_fan_div},
524        {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
525         &i2c_sysctl_real, NULL, &w83781d_alarms},
526        {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
527         &i2c_sysctl_real, NULL, &w83781d_beep},
528        {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
529         &i2c_sysctl_real, NULL, &w83781d_pwm},
530        {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
531         &i2c_sysctl_real, NULL, &w83781d_pwm},
532        {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
533         &i2c_sysctl_real, NULL, &w83781d_sens},
534        {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
535         &i2c_sysctl_real, NULL, &w83781d_sens},
536        {W83781D_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
537         &i2c_sysctl_real, NULL, &w83781d_sens},
538        {0}
539};
540
541/* with pwm3-4 */
542static ctl_table w83782d_i2c_dir_table_template[] = {
543        {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
544         &i2c_sysctl_real, NULL, &w83781d_in},
545        {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
546         &i2c_sysctl_real, NULL, &w83781d_in},
547        {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
548         &i2c_sysctl_real, NULL, &w83781d_in},
549        {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
550         &i2c_sysctl_real, NULL, &w83781d_in},
551        {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
552         &i2c_sysctl_real, NULL, &w83781d_in},
553        {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
554         &i2c_sysctl_real, NULL, &w83781d_in},
555        {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
556         &i2c_sysctl_real, NULL, &w83781d_in},
557        {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
558         &i2c_sysctl_real, NULL, &w83781d_in},
559        {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
560         &i2c_sysctl_real, NULL, &w83781d_in},
561        {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
562         &i2c_sysctl_real, NULL, &w83781d_fan},
563        {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
564         &i2c_sysctl_real, NULL, &w83781d_fan},
565        {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
566         &i2c_sysctl_real, NULL, &w83781d_fan},
567        {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
568         &i2c_sysctl_real, NULL, &w83781d_temp},
569        {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
570         &i2c_sysctl_real, NULL, &w83781d_temp_add},
571        {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
572         &i2c_sysctl_real, NULL, &w83781d_temp_add},
573        {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
574         &i2c_sysctl_real, NULL, &w83781d_vid},
575        {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
576         &i2c_sysctl_real, NULL, &w83781d_vrm},
577        {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
578         &i2c_sysctl_real, NULL, &w83781d_fan_div},
579        {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
580         &i2c_sysctl_real, NULL, &w83781d_alarms},
581        {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
582         &i2c_sysctl_real, NULL, &w83781d_beep},
583        {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
584         &i2c_sysctl_real, NULL, &w83781d_pwm},
585        {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
586         &i2c_sysctl_real, NULL, &w83781d_pwm},
587        {W83781D_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
588         &i2c_sysctl_real, NULL, &w83781d_pwm},
589        {W83781D_SYSCTL_PWM4, "pwm4", NULL, 0, 0644, NULL, &i2c_proc_real,
590         &i2c_sysctl_real, NULL, &w83781d_pwm},
591        {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
592         &i2c_sysctl_real, NULL, &w83781d_sens},
593        {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
594         &i2c_sysctl_real, NULL, &w83781d_sens},
595        {W83781D_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
596         &i2c_sysctl_real, NULL, &w83781d_sens},
597        {0}
598};
599
600/* w83791D has 10 voltages 5 fans and 3 temps.  2 of the temps are on other
601 devices. */
602static ctl_table w83791d_dir_table_template[] = {
603        {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
604         &i2c_sysctl_real, NULL, &w83781d_in},
605        {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
606         &i2c_sysctl_real, NULL, &w83781d_in},
607        {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
608         &i2c_sysctl_real, NULL, &w83781d_in},
609        {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
610         &i2c_sysctl_real, NULL, &w83781d_in},
611        {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
612         &i2c_sysctl_real, NULL, &w83781d_in},
613        {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
614         &i2c_sysctl_real, NULL, &w83781d_in},
615        {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
616         &i2c_sysctl_real, NULL, &w83781d_in},
617        {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
618         &i2c_sysctl_real, NULL, &w83781d_in},
619        {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
620         &i2c_sysctl_real, NULL, &w83781d_in},
621        {W83781D_SYSCTL_IN9, "in9", NULL, 0, 0644, NULL, &i2c_proc_real,
622         &i2c_sysctl_real, NULL, &w83781d_in},
623        {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
624         &i2c_sysctl_real, NULL, &w83781d_fan},
625        {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
626         &i2c_sysctl_real, NULL, &w83781d_fan},
627        {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
628         &i2c_sysctl_real, NULL, &w83781d_fan},
629        {W83781D_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
630         &i2c_sysctl_real, NULL, &w83781d_fan},
631        {W83781D_SYSCTL_FAN5, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
632         &i2c_sysctl_real, NULL, &w83781d_fan},
633        {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
634         &i2c_sysctl_real, NULL, &w83781d_temp},
635        {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
636         &i2c_sysctl_real, NULL, &w83781d_temp_add},
637        {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
638         &i2c_sysctl_real, NULL, &w83781d_temp_add},
639        {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
640         &i2c_sysctl_real, NULL, &w83781d_vid},
641        {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
642         &i2c_sysctl_real, NULL, &w83781d_fan_div},
643        {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
644         &i2c_sysctl_real, NULL, &w83781d_alarms},
645        {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
646         &i2c_sysctl_real, NULL, &w83781d_beep},
647        {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
648         &i2c_sysctl_real, NULL, &w83781d_pwm},
649        {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
650         &i2c_sysctl_real, NULL, &w83781d_pwm},
651        {W83781D_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
652         &i2c_sysctl_real, NULL, &w83781d_pwm},
653        {W83781D_SYSCTL_PWM4, "pwm4", NULL, 0, 0644, NULL, &i2c_proc_real,
654         &i2c_sysctl_real, NULL, &w83781d_pwm},
655        {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
656         &i2c_sysctl_real, NULL, &w83781d_vrm},
657        {0}
658};
659
660static ctl_table w83783s_dir_table_template[] = {
661        {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
662         &i2c_sysctl_real, NULL, &w83781d_in},
663        /* no in1 to maintain compatibility with 781d and 782d. */
664        {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
665         &i2c_sysctl_real, NULL, &w83781d_in},
666        {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
667         &i2c_sysctl_real, NULL, &w83781d_in},
668        {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
669         &i2c_sysctl_real, NULL, &w83781d_in},
670        {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
671         &i2c_sysctl_real, NULL, &w83781d_in},
672        {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
673         &i2c_sysctl_real, NULL, &w83781d_in},
674        {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
675         &i2c_sysctl_real, NULL, &w83781d_fan},
676        {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
677         &i2c_sysctl_real, NULL, &w83781d_fan},
678        {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
679         &i2c_sysctl_real, NULL, &w83781d_fan},
680        {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
681         &i2c_sysctl_real, NULL, &w83781d_temp},
682        {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
683         &i2c_sysctl_real, NULL, &w83781d_temp_add},
684        {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
685         &i2c_sysctl_real, NULL, &w83781d_vid},
686        {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
687         &i2c_sysctl_real, NULL, &w83781d_vrm},
688        {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
689         &i2c_sysctl_real, NULL, &w83781d_fan_div},
690        {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
691         &i2c_sysctl_real, NULL, &w83781d_alarms},
692        {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
693         &i2c_sysctl_real, NULL, &w83781d_beep},
694        {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
695         &i2c_sysctl_real, NULL, &w83781d_pwm},
696        {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
697         &i2c_sysctl_real, NULL, &w83781d_pwm},
698        {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
699         &i2c_sysctl_real, NULL, &w83781d_sens},
700        {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
701         &i2c_sysctl_real, NULL, &w83781d_sens},
702        {0}
703};
704
705
706/* This function is called when:
707     * w83781d_driver is inserted (when this module is loaded), for each
708       available adapter
709     * when a new adapter is inserted (and w83781d_driver is still present) */
710static int w83781d_attach_adapter(struct i2c_adapter *adapter)
711{
712        return i2c_detect(adapter, &addr_data, w83781d_detect);
713}
714
715static int w83781d_detect(struct i2c_adapter *adapter, int address,
716                  unsigned short flags, int kind)
717{
718        int i, val1 = 0, val2, id;
719        struct i2c_client *new_client;
720        struct w83781d_data *data;
721        int err = 0;
722        const char *type_name = "";
723        const char *client_name = "";
724        int is_isa = i2c_is_isa_adapter(adapter);
725        enum vendor { winbond, asus } vendid;
726
727        if (!is_isa
728            && !i2c_check_functionality(adapter,
729                                        I2C_FUNC_SMBUS_BYTE_DATA)) goto
730                    ERROR0;
731
732       if (is_isa) {
733               if (!request_region(address, W83781D_EXTENT, "w83781d"))
734                       goto ERROR0;
735               release_region(address, W83781D_EXTENT);
736       }
737
738        /* Probe whether there is anything available on this address. Already
739           done for SMBus clients */
740        if (kind < 0) {
741                if (is_isa) {
742
743#define REALLY_SLOW_IO
744                        /* We need the timeouts for at least some LM78-like chips. But only
745                           if we read 'undefined' registers. */
746                        i = inb_p(address + 1);
747                        if (inb_p(address + 2) != i)
748                                goto ERROR0;
749                        if (inb_p(address + 3) != i)
750                                goto ERROR0;
751                        if (inb_p(address + 7) != i)
752                                goto ERROR0;
753#undef REALLY_SLOW_IO
754
755                        /* Let's just hope nothing breaks here */
756                        i = inb_p(address + 5) & 0x7f;
757                        outb_p(~i & 0x7f, address + 5);
758                        if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
759                                outb_p(i, address + 5);
760                                return 0;
761                        }
762                }
763        }
764
765        /* OK. For now, we presume we have a valid client. We now create the
766           client structure, even though we cannot fill it completely yet.
767           But it allows us to access w83781d_{read,write}_value. */
768
769        if (!(data = kmalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
770                err = -ENOMEM;
771                goto ERROR0;
772        }
773
774        new_client = &data->client;
775        new_client->addr = address;
776        init_MUTEX(&data->lock);
777        new_client->data = data;
778        new_client->adapter = adapter;
779        new_client->driver = &w83781d_driver;
780        new_client->flags = 0;
781
782        /* Now, we do the remaining detection. */
783
784        /* The w8378?d may be stuck in some other bank than bank 0. This may
785           make reading other information impossible. Specify a force=... or
786           force_*=... parameter, and the Winbond will be reset to the right
787           bank. */
788        if (kind < 0) {
789                if (w83781d_read_value(new_client, W83781D_REG_CONFIG) &
790                    0x80)
791                        goto ERROR1;
792
793                val1 = w83781d_read_value(new_client, W83781D_REG_BANK);
794                val2 = w83781d_read_value(new_client, W83781D_REG_CHIPMAN);
795                /* Check for Winbond or Asus ID if in bank 0 */
796                if ((!(val1 & 0x07)) &&
797                    (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
798                     || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12))))
799                        goto ERROR1;
800
801                /* If Winbond SMBus, check address at 0x48.
802                   Asus doesn't support, except for the as99127f rev.2 */
803                if ((!is_isa) && (((!(val1 & 0x80)) && (val2 == 0xa3)) ||
804                                  ((val1 & 0x80) && (val2 == 0x5c)))) {
805                        if (w83781d_read_value
806                            (new_client, W83781D_REG_I2C_ADDR) != address)
807                                goto ERROR1;
808                }
809        }
810
811        /* We have either had a force parameter, or we have already detected the
812           Winbond. Put it now into bank 0 and Vendor ID High Byte */
813        w83781d_write_value(new_client, W83781D_REG_BANK,
814                            (w83781d_read_value(new_client,
815                                                W83781D_REG_BANK) & 0x78) |
816                            0x80);
817
818        /* Determine the chip type. */
819        if (kind <= 0) {
820                /* get vendor ID */
821                val2 = w83781d_read_value(new_client, W83781D_REG_CHIPMAN);
822                if (val2 == 0x5c)
823                        vendid = winbond;
824                else if (val2 == 0x12)
825                        vendid = asus;
826                else
827                        goto ERROR1;
828
829                val1 =
830                    w83781d_read_value(new_client, W83781D_REG_WCHIPID);
831                if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
832                        kind = w83781d;
833                else if (val1 == 0x30 && vendid == winbond)
834                        kind = w83782d;
835                else if (val1 == 0x40 && vendid == winbond && !is_isa && address == 0x2d)
836                        kind = w83783s;
837                else if (val1 == 0x21 && vendid == winbond)
838                        kind = w83627hf;
839                else if (val1 == 0x71 && vendid == winbond && address >= 0x2c)
840                        kind = w83791d;
841                else if (val1 == 0x31 && !is_isa && address >= 0x28)
842                        kind = as99127f;
843                else {
844                        if (kind == 0)
845                                printk(KERN_WARNING "w83781d.o: Ignoring "
846                                       "'force' parameter for unknown chip "
847                                       "at adapter %d, address 0x%02x\n",
848                                       i2c_adapter_id(adapter), address);
849                        goto ERROR1;
850                }
851        }
852
853        if (kind == w83781d) {
854                type_name = "w83781d";
855                client_name = "W83781D chip";
856        } else if (kind == w83782d) {
857                type_name = "w83782d";
858                client_name = "W83782D chip";
859        } else if (kind == w83783s) {
860                type_name = "w83783s";
861                client_name = "W83783S chip";
862        } else if (kind == w83627hf) {
863                type_name = "w83627hf";
864                client_name = "W83627HF chip";
865        } else if (kind == as99127f) {
866                type_name = "as99127f";
867                client_name = "AS99127F chip";
868        } else if (kind == w83791d) {
869                type_name = "w83791d";
870                client_name = "W83791D chip";
871        } else {
872#ifdef DEBUG
873                printk(KERN_ERR "w83781d.o: Internal error: unknown kind (%d)?!?",
874                       kind);
875#endif
876                err = -ENODEV;
877                goto ERROR1;
878        }
879
880        /* Reserve the ISA region */
881        if (is_isa)
882                request_region(address, W83781D_EXTENT, type_name);
883
884        /* Fill in the remaining client fields and put it into the global list */
885        strcpy(new_client->name, client_name);
886        data->type = kind;
887        data->valid = 0;
888        init_MUTEX(&data->update_lock);
889
890        /* Tell the I2C layer a new client has arrived */
891        if ((err = i2c_attach_client(new_client)))
892                goto ERROR3;
893
894        /* attach secondary i2c lm75-like clients */
895        if (!is_isa) {
896                if (!(data->lm75 = kmalloc(2 * sizeof(struct i2c_client),
897                                           GFP_KERNEL))) {
898                        err = -ENOMEM;
899                        goto ERROR4;
900                }
901                id = i2c_adapter_id(adapter);
902                if(force_subclients[0] == id && force_subclients[1] == address) {
903                        for(i = 2; i <= 3; i++) {
904                                if(force_subclients[i] < 0x48 ||
905                                   force_subclients[i] > 0x4f) {
906                                        printk(KERN_ERR "w83781d.o: Invalid subclient address %d; must be 0x48-0x4f\n",
907                                                force_subclients[i]);
908                                        goto ERROR5;
909                                }
910                        }
911                        w83781d_write_value(new_client,
912                                            W83781D_REG_I2C_SUBADDR,
913                                            (force_subclients[2] & 0x07) |
914                                            ((force_subclients[3] & 0x07) <<4));
915                        data->lm75[0].addr = force_subclients[2];
916                } else {
917                        val1 = w83781d_read_value(new_client,
918                                                  W83781D_REG_I2C_SUBADDR);
919                        data->lm75[0].addr = 0x48 + (val1 & 0x07);
920                }
921                if (kind != w83783s) {
922                        if(force_subclients[0] == id &&
923                           force_subclients[1] == address) {
924                                data->lm75[1].addr = force_subclients[3];
925                        } else {
926                                data->lm75[1].addr = 0x48 + ((val1 >> 4) & 0x07);
927                        }
928                        if(data->lm75[0].addr == data->lm75[1].addr) {
929                                printk(KERN_ERR "w83781d.o: Duplicate addresses 0x%x for subclients.\n",
930                                        data->lm75[0].addr);
931                                goto ERROR5;
932                        }
933                }
934                if (kind == w83781d)
935                        client_name = "W83781D subclient";
936                else if (kind == w83782d)
937                        client_name = "W83782D subclient";
938                else if (kind == w83783s)
939                        client_name = "W83783S subclient";
940                else if (kind == w83627hf)
941                        client_name = "W83627HF subclient";
942                else if (kind == as99127f)
943                        client_name = "AS99127F subclient";
944                else if (kind == w83791d)
945                        client_name = "W83791D subclient";
946
947
948                for (i = 0; i <= 1; i++) {
949                        data->lm75[i].data = NULL;      /* store all data in w83781d */
950                        data->lm75[i].adapter = adapter;
951                        data->lm75[i].driver = &w83781d_driver;
952                        data->lm75[i].flags = 0;
953                        strcpy(data->lm75[i].name, client_name);
954                        if ((err = i2c_attach_client(&(data->lm75[i])))) {
955                                printk(KERN_ERR "w83781d.o: Subclient %d registration at address 0x%x failed.\n",
956                                       i, data->lm75[i].addr);
957                                if (i == 1)
958                                        goto ERROR6;
959                                goto ERROR5;
960                        }
961                        if (kind == w83783s)
962                                break;
963                }
964        } else {
965                data->lm75 = NULL;
966        }
967
968        /* Register a new directory entry with module sensors */
969        if ((i = i2c_register_entry(new_client,
970                                        type_name,
971                                        (kind == as99127f) ?
972                                           as99127f_dir_table_template :
973                                        (kind == w83781d) ?
974                                           w83781d_dir_table_template :
975                                        (kind == w83783s) ?
976                                           w83783s_dir_table_template :
977                                        (kind == w83791d ) ?
978                                            w83791d_dir_table_template :
979                                        (is_isa || kind == w83627hf) ?
980                                           w83782d_isa_dir_table_template :
981                                           w83782d_i2c_dir_table_template,
982                                        THIS_MODULE)) < 0) {
983                err = i;
984                goto ERROR7;
985        }
986        data->sysctl_id = i;
987
988        /* Only PWM2 can be disabled */
989        for(i = 0; i < 4; i++)
990                data->pwmenable[i] = 1;
991
992        /* Initialize the chip */
993        w83781d_init_client(new_client);
994        return 0;
995
996/* OK, this is not exactly good programming practice, usually. But it is
997   very code-efficient in this case. */
998
999      ERROR7:
1000        if (!is_isa)
1001                i2c_detach_client(&
1002                                  (((struct
1003                                     w83781d_data *) (new_client->data))->
1004                                   lm75[1]));
1005      ERROR6:
1006        if (!is_isa)
1007                i2c_detach_client(&
1008                                  (((struct
1009                                     w83781d_data *) (new_client->data))->
1010                                   lm75[0]));
1011      ERROR5:
1012        if (!is_isa)
1013                kfree(((struct w83781d_data *) (new_client->data))->lm75);
1014      ERROR4:
1015        i2c_detach_client(new_client);
1016      ERROR3:
1017        if (is_isa)
1018                release_region(address, W83781D_EXTENT);
1019      ERROR1:
1020        kfree(data);
1021      ERROR0:
1022        return err;
1023}
1024
1025static int w83781d_detach_client(struct i2c_client *client)
1026{
1027        int err;
1028        struct w83781d_data *data = client->data;
1029
1030        i2c_deregister_entry(data->sysctl_id);
1031
1032        if ((err = i2c_detach_client(client))) {
1033                printk
1034                    (KERN_ERR "w83781d.o: Client deregistration failed, client not detached.\n");
1035                return err;
1036        }
1037
1038        if(i2c_is_isa_client(client)) {
1039                release_region(client->addr, W83781D_EXTENT);
1040        } else {
1041                i2c_detach_client(&(data->lm75[0]));
1042                if (data->type != w83783s)
1043                        i2c_detach_client(&(data->lm75[1]));
1044                kfree(data->lm75);
1045        }
1046        kfree(data);
1047
1048        return 0;
1049}
1050
1051/* The SMBus locks itself, usually, but nothing may access the Winbond between
1052   bank switches. ISA access must always be locked explicitly!
1053   We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1054   would slow down the W83781D access and should not be necessary.
1055   There are some ugly typecasts here, but the good news is - they should
1056   nowhere else be necessary! */
1057static int w83781d_read_value(struct i2c_client *client, u16 reg)
1058{
1059        int res, word_sized, bank;
1060        struct i2c_client *cl;
1061
1062        down(&(((struct w83781d_data *) (client->data))->lock));
1063        if (i2c_is_isa_client(client)) {
1064                word_sized = (((reg & 0xff00) == 0x100)
1065                              || ((reg & 0xff00) == 0x200))
1066                    && (((reg & 0x00ff) == 0x50)
1067                        || ((reg & 0x00ff) == 0x53)
1068                        || ((reg & 0x00ff) == 0x55));
1069                if (reg & 0xff00) {
1070                        outb_p(W83781D_REG_BANK,
1071                               client->addr + W83781D_ADDR_REG_OFFSET);
1072                        outb_p(reg >> 8,
1073                               client->addr + W83781D_DATA_REG_OFFSET);
1074                }
1075                outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1076                res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1077                if (word_sized) {
1078                        outb_p((reg & 0xff) + 1,
1079                               client->addr + W83781D_ADDR_REG_OFFSET);
1080                        res =
1081                            (res << 8) + inb_p(client->addr +
1082                                               W83781D_DATA_REG_OFFSET);
1083                }
1084                if (reg & 0xff00) {
1085                        outb_p(W83781D_REG_BANK,
1086                               client->addr + W83781D_ADDR_REG_OFFSET);
1087                        outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1088                }
1089        } else {
1090                bank = (reg >> 8) & 0x0f;
1091                if (bank > 2)
1092                        /* switch banks */
1093                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1094                                                  bank);
1095                if (bank == 0 || bank > 2) {
1096                        res = i2c_smbus_read_byte_data(client, reg & 0xff);
1097                } else {
1098                        /* switch to subclient */
1099                        cl =
1100                            &(((struct w83781d_data *) (client->data))->
1101                              lm75[bank - 1]);
1102                        /* convert from ISA to LM75 I2C addresses */
1103                        switch (reg & 0xff) {
1104                        case 0x50: /* TEMP */
1105                                res = swab16(i2c_smbus_read_word_data(cl, 0));
1106                                break;
1107                        case 0x52: /* CONFIG */
1108                                res = i2c_smbus_read_byte_data(cl, 1);
1109                                break;
1110                        case 0x53: /* HYST */
1111                                res = swab16(i2c_smbus_read_word_data(cl, 2));
1112                                break;
1113                        case 0x55: /* OVER */
1114                        default:
1115                                res = swab16(i2c_smbus_read_word_data(cl, 3));
1116                                break;
1117                        }
1118                }
1119                if (bank > 2)
1120                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1121                                                  0);
1122        }
1123        up(&(((struct w83781d_data *) (client->data))->lock));
1124        return res;
1125}
1126
1127static int w83781d_write_value(struct i2c_client *client, u16 reg, u16 value)
1128{
1129        int word_sized, bank;
1130        struct i2c_client *cl;
1131
1132        down(&(((struct w83781d_data *) (client->data))->lock));
1133        if (i2c_is_isa_client(client)) {
1134                word_sized = (((reg & 0xff00) == 0x100)
1135                              || ((reg & 0xff00) == 0x200))
1136                    && (((reg & 0x00ff) == 0x53)
1137                        || ((reg & 0x00ff) == 0x55));
1138                if (reg & 0xff00) {
1139                        outb_p(W83781D_REG_BANK,
1140                               client->addr + W83781D_ADDR_REG_OFFSET);
1141                        outb_p(reg >> 8,
1142                               client->addr + W83781D_DATA_REG_OFFSET);
1143                }
1144                outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1145                if (word_sized) {
1146                        outb_p(value >> 8,
1147                               client->addr + W83781D_DATA_REG_OFFSET);
1148                        outb_p((reg & 0xff) + 1,
1149                               client->addr + W83781D_ADDR_REG_OFFSET);
1150                }
1151                outb_p(value & 0xff,
1152                       client->addr + W83781D_DATA_REG_OFFSET);
1153                if (reg & 0xff00) {
1154                        outb_p(W83781D_REG_BANK,
1155                               client->addr + W83781D_ADDR_REG_OFFSET);
1156                        outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1157                }
1158        } else {
1159                bank = (reg >> 8) & 0x0f;
1160                if (bank > 2)
1161                        /* switch banks */
1162                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1163                                                  bank);
1164                if (bank == 0 || bank > 2) {
1165                        i2c_smbus_write_byte_data(client, reg & 0xff,
1166                                                  value & 0xff);
1167                } else {
1168                        /* switch to subclient */
1169                        cl = &(((struct w83781d_data *) (client->data))->
1170                              lm75[bank - 1]);
1171                        /* convert from ISA to LM75 I2C addresses */
1172                        switch (reg & 0xff) {
1173                        case 0x52: /* CONFIG */
1174                                i2c_smbus_write_byte_data(cl, 1, value & 0xff);
1175                                break;
1176                        case 0x53: /* HYST */
1177                                i2c_smbus_write_word_data(cl, 2, swab16(value));
1178                                break;
1179                        case 0x55: /* OVER */
1180                                i2c_smbus_write_word_data(cl, 3, swab16(value));
1181                                break;
1182                        }
1183                }
1184                if (bank > 2)
1185                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1186                                                  0);
1187        }
1188        up(&(((struct w83781d_data *) (client->data))->lock));
1189        return 0;
1190}
1191
1192/* Called when we have found a new W83781D. It should set limits, etc. */
1193static void w83781d_init_client(struct i2c_client *client)
1194{
1195        struct w83781d_data *data = client->data;
1196        int i, p;
1197        int type = data->type;
1198        u8 tmp;
1199
1200        if(init && type != as99127f) { /* this resets registers we don't have
1201                                          documentation for on the as99127f */
1202                /* save these registers */
1203                i = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
1204                p = w83781d_read_value(client, W83781D_REG_PWMCLK12);
1205                /* Reset all except Watchdog values and last conversion values
1206                   This sets fan-divs to 2, among others */
1207                w83781d_write_value(client, W83781D_REG_CONFIG, 0x80);
1208                /* Restore the registers and disable power-on abnormal beep.
1209                   This saves FAN 1/2/3 input/output values set by BIOS. */
1210                w83781d_write_value(client, W83781D_REG_BEEP_CONFIG, i | 0x80);
1211                w83781d_write_value(client, W83781D_REG_PWMCLK12, p);
1212                /* Disable master beep-enable (reset turns it on).
1213                   Individual beeps should be reset to off but for some reason
1214                   disabling this bit helps some people not get beeped */
1215                w83781d_write_value(client, W83781D_REG_BEEP_INTS2, 0);
1216        }
1217
1218        data->vrm = (type == w83791d) ? 90 : 82;
1219
1220        if ((type != w83781d) && (type != as99127f)) {
1221                tmp = w83781d_read_value(client, W83781D_REG_SCFG1);
1222                for (i = 1; i <= 3; i++) {
1223                        if (!(tmp & BIT_SCFG1[i - 1])) {
1224                                data->sens[i - 1] = W83781D_DEFAULT_BETA;
1225                        } else {
1226                                if (w83781d_read_value
1227                                    (client,
1228                                     W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1229                                        data->sens[i - 1] = 1;
1230                                else
1231                                        data->sens[i - 1] = 2;
1232                        }
1233                        if (type == w83783s && i == 2)
1234                                break;
1235                }
1236        }
1237#ifdef W83781D_RT
1238/*
1239   Fill up the RT Tables.
1240   We assume that they are 32 bytes long, in order for temp 1-3.
1241   Data sheet documentation is sparse.
1242   We also assume that it is only for the 781D although I suspect
1243   that the others support it as well....
1244*/
1245
1246        if (init && type == w83781d) {
1247                u16 k = 0;
1248/*
1249    Auto-indexing doesn't seem to work...
1250    w83781d_write_value(client,W83781D_REG_RT_IDX,0);
1251*/
1252                for (i = 0; i < 3; i++) {
1253                        int j;
1254                        for (j = 0; j < 32; j++) {
1255                                w83781d_write_value(client,
1256                                                    W83781D_REG_RT_IDX,
1257                                                    k++);
1258                                data->rt[i][j] =
1259                                    w83781d_read_value(client,
1260                                                       W83781D_REG_RT_VAL);
1261                        }
1262                }
1263        }
1264#endif                          /* W83781D_RT */
1265
1266        if (init && type != as99127f) {
1267                w83781d_write_value(client, W83781D_REG_TEMP2_CONFIG, 0x00);
1268                if (type != w83783s) {
1269                        w83781d_write_value(client, W83781D_REG_TEMP3_CONFIG,
1270                                            0x00);
1271                }
1272                if (type != w83781d) {
1273                        /* enable comparator mode for temp2 and temp3 so
1274                           alarm indication will work correctly */
1275                        i = w83781d_read_value(client, W83781D_REG_IRQ);
1276                        if (!(i & 0x40))
1277                                w83781d_write_value(client, W83781D_REG_IRQ,
1278                                                    i | 0x40);
1279                }
1280        }
1281
1282        /* Start monitoring */
1283        w83781d_write_value(client, W83781D_REG_CONFIG,
1284                            (w83781d_read_value(client,
1285                                                W83781D_REG_CONFIG) & 0xf7)
1286                            | 0x01);
1287}
1288
1289static void w83781d_update_client(struct i2c_client *client)
1290{
1291       struct w83781d_data *data = client->data;
1292       int i;
1293
1294       down(&data->update_lock);
1295
1296       if (time_after(jiffies - data->last_updated, HZ + HZ / 2) ||
1297           time_before(jiffies, data->last_updated) || !data->valid) {
1298               pr_debug(KERN_DEBUG "Starting device update\n");
1299
1300               for (i = 0; i <= 9; i++) {
1301                       if ((data->type == w83783s)
1302                           && (i == 1))
1303                               continue;       /* 783S has no in1 */
1304                       if (data->type == w83791d) {
1305                                data->in[i] =
1306                                        w83781d_read_value(client, W83791D_REG_IN(i));
1307                                data->in_min[i] =
1308                                        w83781d_read_value(client,
1309                                                           W83791D_REG_IN_MIN(i));
1310                                data->in_max[i] =
1311                                        w83781d_read_value(client,
1312                                                           W83791D_REG_IN_MAX(i));
1313                       } else {
1314                       data->in[i] =
1315                           w83781d_read_value(client, W83781D_REG_IN(i));
1316                       data->in_min[i] =
1317                           w83781d_read_value(client,
1318                                              W83781D_REG_IN_MIN(i));
1319                       data->in_max[i] =
1320                           w83781d_read_value(client,
1321                                              W83781D_REG_IN_MAX(i));
1322                       }
1323                       if ((data->type != w83782d)
1324                           && (data->type != w83627hf) && (i == 6)
1325                           && (data->type != w83791d))
1326                               break;
1327
1328                       if (data->type != w83791d && i == 8) 
1329                         break;
1330               }
1331               for (i = 1; i <= 5; i++) {
1332                       data->fan[i - 1] =
1333                           w83781d_read_value(client, W83781D_REG_FAN(i));
1334                       data->fan_min[i - 1] =
1335                           w83781d_read_value(client,
1336                                              W83781D_REG_FAN_MIN(i));
1337                       if (data->type != w83791d && i == 3) break;
1338               }
1339               if (data->type != w83781d && data->type != as99127f) {
1340                       for (i = 1; i <= 4; i++) {
1341                               data->pwm[i - 1] =
1342                                   w83781d_read_value(client,
1343                                             W83781D_REG_PWM(data->type, i));
1344                               if (((data->type == w83783s)
1345                                    || (data->type == w83627hf)
1346                                    || ((data->type == w83782d)
1347                                       && i2c_is_isa_client(client)))
1348                                   && i == 2)
1349                                       break;
1350                       }
1351                        /* Only PWM2 can be disabled */
1352                        data->pwmenable[1] = (w83781d_read_value(client,
1353                                              W83781D_REG_PWMCLK12) & 0x08) >> 3;
1354               }
1355
1356               data->temp = w83781d_read_value(client, W83781D_REG_TEMP);
1357               data->temp_over =
1358                   w83781d_read_value(client, W83781D_REG_TEMP_OVER);
1359               data->temp_hyst =
1360                   w83781d_read_value(client, W83781D_REG_TEMP_HYST);
1361               data->temp_add[0] =
1362                   w83781d_read_value(client, W83781D_REG_TEMP2);
1363               data->temp_add_over[0] =
1364                   w83781d_read_value(client, W83781D_REG_TEMP2_OVER);
1365               data->temp_add_hyst[0] =
1366                   w83781d_read_value(client, W83781D_REG_TEMP2_HYST);
1367               if (data->type != w83783s) {
1368                       data->temp_add[1] =
1369                           w83781d_read_value(client, W83781D_REG_TEMP3);
1370                       data->temp_add_over[1] =
1371                           w83781d_read_value(client, W83781D_REG_TEMP3_OVER);
1372                       data->temp_add_hyst[1] =
1373                           w83781d_read_value(client, W83781D_REG_TEMP3_HYST);
1374               }
1375               i = w83781d_read_value(client, W83781D_REG_VID_FANDIV);
1376               data->vid = i & 0x0f;
1377               data->vid |= (w83781d_read_value(client,
1378                                       W83781D_REG_CHIPID) & 0x01) << 4;
1379               data->fan_div[0] = (i >> 4) & 0x03;
1380               data->fan_div[1] = (i >> 6) & 0x03;
1381               data->fan_div[2] = (w83781d_read_value(client,
1382                                       W83781D_REG_PIN) >> 6) & 0x03;
1383               if ((data->type != w83781d) && (data->type != as99127f)) {
1384                       i = w83781d_read_value(client, W83781D_REG_VBAT);
1385                       data->fan_div[0] |= (i >> 3) & 0x04;
1386                       data->fan_div[1] |= (i >> 4) & 0x04;
1387                       data->fan_div[2] |= (i >> 5) & 0x04;
1388               }
1389               data->alarms =
1390                   w83781d_read_value(client,
1391                                      W83781D_REG_ALARM1) +
1392                   (w83781d_read_value(client, W83781D_REG_ALARM2) << 8);
1393               if ((data->type == w83782d) || (data->type == w83627hf)) {
1394                       data->alarms |=
1395                           w83781d_read_value(client,
1396                                              W83781D_REG_ALARM3) << 16;
1397               }
1398               i = w83781d_read_value(client, W83781D_REG_BEEP_INTS2);
1399               data->beep_enable = i >> 7;
1400               data->beeps = ((i & 0x7f) << 8) +
1401                   w83781d_read_value(client, W83781D_REG_BEEP_INTS1);
1402               if ((data->type != w83781d) && (data->type != as99127f)
1403                   && (data->type != w83791d)) {
1404                       data->beeps |=
1405                           w83781d_read_value(client,
1406                                              W83781D_REG_BEEP_INTS3) << 16;
1407               }
1408               data->last_updated = jiffies;
1409               data->valid = 1;
1410       }
1411
1412        up(&data->update_lock);
1413}
1414
1415
1416/* The next few functions are the call-back functions of the /proc/sys and
1417   sysctl files. Which function is used is defined in the ctl_table in
1418   the extra1 field.
1419   Each function must return the magnitude (power of 10 to divide the date
1420   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
1421   put a maximum of *nrels elements in results reflecting the data of this
1422   file, and set *nrels to the number it actually put in it, if operation==
1423   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
1424   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
1425   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
1426   large enough (by checking the incoming value of *nrels). This is not very
1427   good practice, but as long as you put less than about 5 values in results,
1428   you can assume it is large enough. */
1429static void w83781d_in(struct i2c_client *client, int operation, int ctl_name,
1430               int *nrels_mag, long *results)
1431{
1432        struct w83781d_data *data = client->data;
1433        int nr = ctl_name - W83781D_SYSCTL_IN0;
1434
1435        if (operation == SENSORS_PROC_REAL_INFO)
1436                *nrels_mag = 2;
1437        else if (operation == SENSORS_PROC_REAL_READ) {
1438                w83781d_update_client(client);
1439                results[0] = IN_FROM_REG(data->in_min[nr]);
1440                results[1] = IN_FROM_REG(data->in_max[nr]);
1441                results[2] = IN_FROM_REG(data->in[nr]);
1442                *nrels_mag = 3;
1443        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1444                if (*nrels_mag >= 1) {
1445                        data->in_min[nr] = IN_TO_REG(results[0]);
1446                        w83781d_write_value(client, W83781D_REG_IN_MIN(nr),
1447                                            data->in_min[nr]);
1448                }
1449                if (*nrels_mag >= 2) {
1450                        data->in_max[nr] = IN_TO_REG(results[1]);
1451                        w83781d_write_value(client, W83781D_REG_IN_MAX(nr),
1452                                            data->in_max[nr]);
1453                }
1454        }
1455}
1456
1457void w83781d_fan(struct i2c_client *client, int operation, int ctl_name,
1458                 int *nrels_mag, long *results)
1459{
1460        struct w83781d_data *data = client->data;
1461        int nr = ctl_name - W83781D_SYSCTL_FAN1 + 1;
1462
1463        if (operation == SENSORS_PROC_REAL_INFO)
1464                *nrels_mag = 0;
1465        else if (operation == SENSORS_PROC_REAL_READ) {
1466                w83781d_update_client(client);
1467                results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
1468                                  DIV_FROM_REG(data->fan_div[nr - 1]));
1469                results[1] = FAN_FROM_REG(data->fan[nr - 1],
1470                                  DIV_FROM_REG(data->fan_div[nr - 1]));
1471                *nrels_mag = 2;
1472        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1473                if (*nrels_mag >= 1) {
1474                        data->fan_min[nr - 1] =
1475                             FAN_TO_REG(results[0],
1476                                    DIV_FROM_REG(data->fan_div[nr-1]));
1477                        w83781d_write_value(client,
1478                                            W83781D_REG_FAN_MIN(nr),
1479                                            data->fan_min[nr - 1]);
1480                }
1481        }
1482}
1483
1484void w83781d_temp(struct i2c_client *client, int operation, int ctl_name,
1485                  int *nrels_mag, long *results)
1486{
1487        struct w83781d_data *data = client->data;
1488        if (operation == SENSORS_PROC_REAL_INFO)
1489                *nrels_mag = 1;
1490        else if (operation == SENSORS_PROC_REAL_READ) {
1491                w83781d_update_client(client);
1492                results[0] = TEMP_FROM_REG(data->temp_over);
1493                results[1] = TEMP_FROM_REG(data->temp_hyst);
1494                results[2] = TEMP_FROM_REG(data->temp);
1495                *nrels_mag = 3;
1496        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1497                if (*nrels_mag >= 1) {
1498                        data->temp_over = TEMP_TO_REG(results[0]);
1499                        w83781d_write_value(client, W83781D_REG_TEMP_OVER,
1500                                            data->temp_over);
1501                }
1502                if (*nrels_mag >= 2) {
1503                        data->temp_hyst = TEMP_TO_REG(results[1]);
1504                        w83781d_write_value(client, W83781D_REG_TEMP_HYST,
1505                                            data->temp_hyst);
1506                }
1507        }
1508}
1509
1510void w83781d_temp_add(struct i2c_client *client, int operation,
1511                      int ctl_name, int *nrels_mag, long *results)
1512{
1513        struct w83781d_data *data = client->data;
1514        int nr = ctl_name - W83781D_SYSCTL_TEMP2;
1515
1516        if (operation == SENSORS_PROC_REAL_INFO)
1517                *nrels_mag = 1;
1518        else if (operation == SENSORS_PROC_REAL_READ) {
1519                w83781d_update_client(client);
1520                results[0] = LM75_TEMP_FROM_REG(data->temp_add_over[nr]);
1521                results[1] = LM75_TEMP_FROM_REG(data->temp_add_hyst[nr]);
1522                results[2] = LM75_TEMP_FROM_REG(data->temp_add[nr]);
1523                *nrels_mag = 3;
1524        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1525                if (*nrels_mag >= 1) {
1526                        data->temp_add_over[nr] =
1527                            LM75_TEMP_TO_REG(results[0]);
1528                        w83781d_write_value(client,
1529                                            nr ? W83781D_REG_TEMP3_OVER :
1530                                            W83781D_REG_TEMP2_OVER,
1531                                            data->temp_add_over[nr]);
1532                }
1533                if (*nrels_mag >= 2) {
1534                        data->temp_add_hyst[nr] =
1535                            LM75_TEMP_TO_REG(results[1]);
1536                        w83781d_write_value(client,
1537                                            nr ? W83781D_REG_TEMP3_HYST :
1538                                            W83781D_REG_TEMP2_HYST,
1539                                            data->temp_add_hyst[nr]);
1540                }
1541        }
1542}
1543
1544
1545void w83781d_vid(struct i2c_client *client, int operation, int ctl_name,
1546                 int *nrels_mag, long *results)
1547{
1548        struct w83781d_data *data = client->data;
1549        if (operation == SENSORS_PROC_REAL_INFO)
1550                *nrels_mag = 3;
1551        else if (operation == SENSORS_PROC_REAL_READ) {
1552                w83781d_update_client(client);
1553                results[0] = vid_from_reg(data->vid, data->vrm);
1554                *nrels_mag = 1;
1555        }
1556}
1557
1558void w83781d_vrm(struct i2c_client *client, int operation, int ctl_name,
1559                 int *nrels_mag, long *results)
1560{
1561        struct w83781d_data *data = client->data;
1562        if (operation == SENSORS_PROC_REAL_INFO)
1563                *nrels_mag = 1;
1564        else if (operation == SENSORS_PROC_REAL_READ) {
1565                results[0] = data->vrm;
1566                *nrels_mag = 1;
1567        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1568                if (*nrels_mag >= 1)
1569                        data->vrm = results[0];
1570        }
1571}
1572
1573void w83781d_alarms(struct i2c_client *client, int operation, int ctl_name,
1574                    int *nrels_mag, long *results)
1575{
1576        struct w83781d_data *data = client->data;
1577        if (operation == SENSORS_PROC_REAL_INFO)
1578                *nrels_mag = 0;
1579        else if (operation == SENSORS_PROC_REAL_READ) {
1580                w83781d_update_client(client);
1581                results[0] = ALARMS_FROM_REG(data->alarms);
1582                *nrels_mag = 1;
1583        }
1584}
1585
1586void w83781d_beep(struct i2c_client *client, int operation, int ctl_name,
1587                  int *nrels_mag, long *results)
1588{
1589        struct w83781d_data *data = client->data;
1590        int val;
1591
1592        if (operation == SENSORS_PROC_REAL_INFO)
1593                *nrels_mag = 0;
1594        else if (operation == SENSORS_PROC_REAL_READ) {
1595                w83781d_update_client(client);
1596                results[0] = BEEP_ENABLE_FROM_REG(data->beep_enable);
1597                results[1] = BEEPS_FROM_REG(data->beeps, data->type);
1598                *nrels_mag = 2;
1599        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1600                if (*nrels_mag >= 2) {
1601                        data->beeps = BEEPS_TO_REG(results[1], data->type);
1602                        w83781d_write_value(client, W83781D_REG_BEEP_INTS1,
1603                                            data->beeps & 0xff);
1604                        if ((data->type != w83781d) &&
1605                            (data->type != as99127f)) {
1606                                w83781d_write_value(client,
1607                                                    W83781D_REG_BEEP_INTS3,
1608                                                    ((data-> beeps) >> 16) &
1609                                                      0xff);
1610                        }
1611                        val = (data->beeps >> 8) & 0x7f;
1612                } else if (*nrels_mag >= 1)
1613                        val =
1614                            w83781d_read_value(client,
1615                                               W83781D_REG_BEEP_INTS2) &
1616                            0x7f;
1617                if (*nrels_mag >= 1) {
1618                        data->beep_enable = BEEP_ENABLE_TO_REG(results[0]);
1619                        w83781d_write_value(client, W83781D_REG_BEEP_INTS2,
1620                                            val | data->beep_enable << 7);
1621                }
1622        }
1623}
1624
1625void w83781d_fan_div(struct i2c_client *client, int operation,
1626                     int ctl_name, int *nrels_mag, long *results)
1627{
1628        struct w83781d_data *data = client->data;
1629        int old, old2, old3 = 0;
1630
1631        if (operation == SENSORS_PROC_REAL_INFO)
1632                *nrels_mag = 0;
1633        else if (operation == SENSORS_PROC_REAL_READ) {
1634                w83781d_update_client(client);
1635                results[0] = DIV_FROM_REG(data->fan_div[0]);
1636                results[1] = DIV_FROM_REG(data->fan_div[1]);
1637                results[2] = DIV_FROM_REG(data->fan_div[2]);
1638                *nrels_mag = 3;
1639        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1640                old = w83781d_read_value(client, W83781D_REG_VID_FANDIV);
1641                /* w83781d and as99127f don't have extended divisor bits */
1642                if ((data->type != w83781d) && data->type != as99127f) {
1643                        old3 =
1644                            w83781d_read_value(client, W83781D_REG_VBAT);
1645                }
1646                if (*nrels_mag >= 3) {
1647                        data->fan_div[2] =
1648                            DIV_TO_REG(results[2], data->type);
1649                        old2 = w83781d_read_value(client, W83781D_REG_PIN);
1650                        old2 =
1651                            (old2 & 0x3f) | ((data->fan_div[2] & 0x03) << 6);
1652                        w83781d_write_value(client, W83781D_REG_PIN, old2);
1653                        if ((data->type != w83781d) &&
1654                            (data->type != as99127f)) {
1655                                old3 =
1656                                    (old3 & 0x7f) |
1657                                    ((data->fan_div[2] & 0x04) << 5);
1658                        }
1659                }
1660                if (*nrels_mag >= 2) {
1661                        data->fan_div[1] =
1662                            DIV_TO_REG(results[1], data->type);
1663                        old =
1664                            (old & 0x3f) | ((data->fan_div[1] & 0x03) << 6);
1665                        if ((data->type != w83781d) &&
1666                            (data->type != as99127f)) {
1667                                old3 =
1668                                    (old3 & 0xbf) |
1669                                    ((data->fan_div[1] & 0x04) << 4);
1670                        }
1671                }
1672                if (*nrels_mag >= 1) {
1673                        data->fan_div[0] =
1674                            DIV_TO_REG(results[0], data->type);
1675                        old =
1676                            (old & 0xcf) | ((data->fan_div[0] & 0x03) << 4);
1677                        w83781d_write_value(client, W83781D_REG_VID_FANDIV,
1678                                            old);
1679                        if ((data->type != w83781d) &&
1680                            (data->type != as99127f)) {
1681                                old3 =
1682                                    (old3 & 0xdf) |
1683                                    ((data->fan_div[0] & 0x04) << 3);
1684                                w83781d_write_value(client,
1685                                                    W83781D_REG_VBAT,
1686                                                    old3);
1687                        }
1688                }
1689        }
1690}
1691
1692void w83781d_pwm(struct i2c_client *client, int operation, int ctl_name,
1693                 int *nrels_mag, long *results)
1694{
1695        struct w83781d_data *data = client->data;
1696        int nr = 1 + ctl_name - W83781D_SYSCTL_PWM1;
1697        int j, k;
1698
1699        if (operation == SENSORS_PROC_REAL_INFO)
1700                *nrels_mag = 0;
1701        else if (operation == SENSORS_PROC_REAL_READ) {
1702                w83781d_update_client(client);
1703                results[0] = PWM_FROM_REG(data->pwm[nr - 1]);
1704                results[1] = data->pwmenable[nr - 1];
1705                *nrels_mag = 2;
1706        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1707                if (*nrels_mag >= 1) {
1708                        data->pwm[nr - 1] = PWM_TO_REG(results[0]);
1709                        w83781d_write_value(client,
1710                                            W83781D_REG_PWM(data->type, nr),
1711                                            data->pwm[nr - 1]);
1712                }
1713                /* only PWM2 can be enabled/disabled */
1714                if (*nrels_mag >= 2 && nr == 2) {
1715                        j = w83781d_read_value(client, W83781D_REG_PWMCLK12);
1716                        k = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
1717                        if(results[1]) {
1718                                if(!(j & 0x08))
1719                                        w83781d_write_value(client,
1720                                             W83781D_REG_PWMCLK12, j | 0x08);
1721                                if(k & 0x10)
1722                                        w83781d_write_value(client,
1723                                             W83781D_REG_BEEP_CONFIG, k & 0xef);
1724                                data->pwmenable[1] = 1;
1725                        } else {
1726                                if(j & 0x08)
1727                                        w83781d_write_value(client,
1728                                             W83781D_REG_PWMCLK12, j & 0xf7);
1729                                if(!(k & 0x10))
1730                                        w83781d_write_value(client,
1731                                             W83781D_REG_BEEP_CONFIG, j | 0x10);
1732                                data->pwmenable[1] = 0;
1733                        }
1734                }
1735        }
1736}
1737
1738void w83781d_sens(struct i2c_client *client, int operation, int ctl_name,
1739                  int *nrels_mag, long *results)
1740{
1741        struct w83781d_data *data = client->data;
1742        int nr = 1 + ctl_name - W83781D_SYSCTL_SENS1;
1743        u8 tmp;
1744
1745        if (operation == SENSORS_PROC_REAL_INFO)
1746                *nrels_mag = 0;
1747        else if (operation == SENSORS_PROC_REAL_READ) {
1748                results[0] = data->sens[nr - 1];
1749                *nrels_mag = 1;
1750        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1751                if (*nrels_mag >= 1) {
1752                        switch (results[0]) {
1753                        case 1: /* PII/Celeron diode */
1754                                tmp = w83781d_read_value(client,
1755                                                       W83781D_REG_SCFG1);
1756                                w83781d_write_value(client,
1757                                                    W83781D_REG_SCFG1,
1758                                                    tmp | BIT_SCFG1[nr -
1759                                                                    1]);
1760                                tmp = w83781d_read_value(client,
1761                                                       W83781D_REG_SCFG2);
1762                                w83781d_write_value(client,
1763                                                    W83781D_REG_SCFG2,
1764                                                    tmp | BIT_SCFG2[nr -
1765                                                                    1]);
1766                                data->sens[nr - 1] = results[0];
1767                                break;
1768                        case 2: /* 3904 */
1769                                tmp = w83781d_read_value(client,
1770                                                       W83781D_REG_SCFG1);
1771                                w83781d_write_value(client,
1772                                                    W83781D_REG_SCFG1,
1773                                                    tmp | BIT_SCFG1[nr -
1774                                                                    1]);
1775                                tmp = w83781d_read_value(client,
1776                                                       W83781D_REG_SCFG2);
1777                                w83781d_write_value(client,
1778                                                    W83781D_REG_SCFG2,
1779                                                    tmp & ~BIT_SCFG2[nr -
1780                                                                     1]);
1781                                data->sens[nr - 1] = results[0];
1782                                break;
1783                        case W83781D_DEFAULT_BETA:      /* thermistor */
1784                                tmp = w83781d_read_value(client,
1785                                                       W83781D_REG_SCFG1);
1786                                w83781d_write_value(client,
1787                                                    W83781D_REG_SCFG1,
1788                                                    tmp & ~BIT_SCFG1[nr -
1789                                                                     1]);
1790                                data->sens[nr - 1] = results[0];
1791                                break;
1792                        default:
1793                                printk
1794                                    (KERN_ERR "w83781d.o: Invalid sensor type %ld; must be 1, 2, or %d\n",
1795                                     results[0], W83781D_DEFAULT_BETA);
1796                                break;
1797                        }
1798                }
1799        }
1800}
1801
1802#ifdef W83781D_RT
1803static void w83781d_rt(struct i2c_client *client, int operation, int ctl_name,
1804               int *nrels_mag, long *results)
1805{
1806        struct w83781d_data *data = client->data;
1807        int nr = 1 + ctl_name - W83781D_SYSCTL_RT1;
1808        int i;
1809
1810        if (operation == SENSORS_PROC_REAL_INFO)
1811                *nrels_mag = 0;
1812        else if (operation == SENSORS_PROC_REAL_READ) {
1813                for (i = 0; i < 32; i++) {
1814                        results[i] = data->rt[nr - 1][i];
1815                }
1816                *nrels_mag = 32;
1817        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1818                if (*nrels_mag > 32)
1819                        *nrels_mag = 32;
1820                for (i = 0; i < *nrels_mag; i++) {
1821                        /* fixme: no bounds checking 0-255 */
1822                        data->rt[nr - 1][i] = results[i];
1823                        w83781d_write_value(client, W83781D_REG_RT_IDX, i);
1824                        w83781d_write_value(client, W83781D_REG_RT_VAL,
1825                                            data->rt[nr - 1][i]);
1826                }
1827        }
1828}
1829#endif
1830
1831static int __init sm_w83781d_init(void)
1832{
1833        printk(KERN_INFO "w83781d.o version %s (%s)\n", LM_VERSION, LM_DATE);
1834        return i2c_add_driver(&w83781d_driver);
1835}
1836
1837static void __exit sm_w83781d_exit(void)
1838{
1839        i2c_del_driver(&w83781d_driver);
1840}
1841
1842
1843
1844MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1845              "Philip Edelbrock <phil@netroedge.com>, "
1846              "and Mark Studebaker <mdsxyz123@yahoo.com>");
1847MODULE_DESCRIPTION("W83781D driver");
1848MODULE_LICENSE("GPL");
1849
1850module_init(sm_w83781d_init);
1851module_exit(sm_w83781d_exit);
Note: See TracBrowser for help on using the browser.