Subversion Repositories shark

Rev

Rev 420 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
420 giacomo 1
/*
2
    via686a.c - Part of lm_sensors, Linux kernel modules
3
                for hardware monitoring
4
 
5
    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
6
                        Kyösti Mälkki <kmalkki@cc.hut.fi>,
7
                        Mark Studebaker <mdsxyz123@yahoo.com>,
8
                        and Bob Dougherty <bobd@stanford.edu>
9
    (Some conversion-factor data were contributed by Jonathan Teh Soon Yew
10
    <j.teh@iname.com> and Alex van Kaam <darkside@chello.nl>.)
11
 
12
    This program is free software; you can redistribute it and/or modify
13
    it under the terms of the GNU General Public License as published by
14
    the Free Software Foundation; either version 2 of the License, or
15
    (at your option) any later version.
16
 
17
    This program is distributed in the hope that it will be useful,
18
    but WITHOUT ANY WARRANTY; without even the implied warranty of
19
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
    GNU General Public License for more details.
21
 
22
    You should have received a copy of the GNU General Public License
23
    along with this program; if not, write to the Free Software
24
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
*/
26
 
27
/*
28
    Supports the Via VT82C686A, VT82C686B south bridges.
29
    Reports all as a 686A.
30
    See doc/chips/via686a for details.
31
    Warning - only supports a single device.
32
*/
33
 
34
#include <linux/module.h>
35
#include <linux/slab.h>
36
#include <linux/pci.h>
37
#include <linux/delay.h>
38
#include <linux/i2c.h>
39
#include <linux/i2c-sensor.h>
40
#include <linux/init.h>
41
#include <asm/io.h>
42
 
43
 
44
/* If force_addr is set to anything different from 0, we forcibly enable
45
   the device at the given address. */
46
static int force_addr = 0;
47
MODULE_PARM(force_addr, "i");
48
MODULE_PARM_DESC(force_addr,
49
                 "Initialize the base address of the sensors");
50
 
51
/* Addresses to scan.
52
   Note that we can't determine the ISA address until we have initialized
53
   our module */
54
static unsigned short normal_i2c[] = { I2C_CLIENT_END };
55
static unsigned short normal_i2c_range[] = { I2C_CLIENT_END };
56
static unsigned int normal_isa[] = { 0x0000, I2C_CLIENT_ISA_END };
57
static unsigned int normal_isa_range[] = { I2C_CLIENT_ISA_END };
58
 
59
/* Insmod parameters */
60
SENSORS_INSMOD_1(via686a);
61
 
62
/*
63
   The Via 686a southbridge has a LM78-like chip integrated on the same IC.
64
   This driver is a customized copy of lm78.c
65
*/
66
 
67
/* Many VIA686A constants specified below */
68
 
69
/* Length of ISA address segment */
70
#define VIA686A_EXTENT 0x80
71
#define VIA686A_BASE_REG 0x70
72
#define VIA686A_ENABLE_REG 0x74
73
 
74
/* The VIA686A registers */
75
/* ins numbered 0-4 */
76
#define VIA686A_REG_IN_MAX(nr) (0x2b + ((nr) * 2))
77
#define VIA686A_REG_IN_MIN(nr) (0x2c + ((nr) * 2))
78
#define VIA686A_REG_IN(nr)     (0x22 + (nr))
79
 
80
/* fans numbered 1-2 */
81
#define VIA686A_REG_FAN_MIN(nr) (0x3a + (nr))
82
#define VIA686A_REG_FAN(nr)     (0x28 + (nr))
83
 
84
/* the following values are as speced by VIA: */
85
static const u8 regtemp[] = { 0x20, 0x21, 0x1f };
86
static const u8 regover[] = { 0x39, 0x3d, 0x1d };
87
static const u8 reghyst[] = { 0x3a, 0x3e, 0x1e };
88
 
89
/* temps numbered 1-3 */
90
#define VIA686A_REG_TEMP(nr)            (regtemp[nr])
91
#define VIA686A_REG_TEMP_OVER(nr)       (regover[nr])
92
#define VIA686A_REG_TEMP_HYST(nr)       (reghyst[nr])
93
#define VIA686A_REG_TEMP_LOW1   0x4b    // bits 7-6
94
#define VIA686A_REG_TEMP_LOW23  0x49    // 2 = bits 5-4, 3 = bits 7-6
95
 
96
#define VIA686A_REG_ALARM1 0x41
97
#define VIA686A_REG_ALARM2 0x42
98
#define VIA686A_REG_FANDIV 0x47
99
#define VIA686A_REG_CONFIG 0x40
100
/* The following register sets temp interrupt mode (bits 1-0 for temp1,
101
 3-2 for temp2, 5-4 for temp3).  Modes are:
102
    00 interrupt stays as long as value is out-of-range
103
    01 interrupt is cleared once register is read (default)
104
    10 comparator mode- like 00, but ignores hysteresis
105
    11 same as 00 */
106
#define VIA686A_REG_TEMP_MODE 0x4b
107
/* We'll just assume that you want to set all 3 simultaneously: */
108
#define VIA686A_TEMP_MODE_MASK 0x3F
109
#define VIA686A_TEMP_MODE_CONTINUOUS (0x00)
110
 
111
/* Conversions. Rounding and limit checking is only done on the TO_REG
112
   variants.
113
 
114
********* VOLTAGE CONVERSIONS (Bob Dougherty) ********
115
 From HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew):
116
 voltagefactor[0]=1.25/2628; (2628/1.25=2102.4)   // Vccp
117
 voltagefactor[1]=1.25/2628; (2628/1.25=2102.4)   // +2.5V
118
 voltagefactor[2]=1.67/2628; (2628/1.67=1573.7)   // +3.3V
119
 voltagefactor[3]=2.6/2628;  (2628/2.60=1010.8)   // +5V
120
 voltagefactor[4]=6.3/2628;  (2628/6.30=417.14)   // +12V
121
 in[i]=(data[i+2]*25.0+133)*voltagefactor[i];
122
 That is:
123
 volts = (25*regVal+133)*factor
124
 regVal = (volts/factor-133)/25
125
 (These conversions were contributed by Jonathan Teh Soon Yew
126
 <j.teh@iname.com>)
127
 
128
 These get us close, but they don't completely agree with what my BIOS
129
 says- they are all a bit low.  But, it all we have to go on... */
130
static inline u8 IN_TO_REG(long val, int inNum)
131
{
132
        /* to avoid floating point, we multiply everything by 100.
133
         val is guaranteed to be positive, so we can achieve the effect of
134
         rounding by (...*10+5)/10.  Note that the *10 is hidden in the
135
         /250 (which should really be /2500).
136
         At the end, we need to /100 because we *100 everything and we need
137
         to /10 because of the rounding thing, so we /1000.   */
138
        if (inNum <= 1)
139
                return (u8)
140
                    SENSORS_LIMIT(((val * 210240 - 13300) / 250 + 5) / 1000,
141
                                  0, 255);
142
        else if (inNum == 2)
143
                return (u8)
144
                    SENSORS_LIMIT(((val * 157370 - 13300) / 250 + 5) / 1000,
145
                                  0, 255);
146
        else if (inNum == 3)
147
                return (u8)
148
                    SENSORS_LIMIT(((val * 101080 - 13300) / 250 + 5) / 1000,
149
                                  0, 255);
150
        else
151
                return (u8) SENSORS_LIMIT(((val * 41714 - 13300) / 250 + 5)
152
                                          / 1000, 0, 255);
153
}
154
 
155
static inline long IN_FROM_REG(u8 val, int inNum)
156
{
157
        /* to avoid floating point, we multiply everything by 100.
158
         val is guaranteed to be positive, so we can achieve the effect of
159
         rounding by adding 0.5.  Or, to avoid fp math, we do (...*10+5)/10.
160
         We need to scale with *100 anyway, so no need to /100 at the end. */
161
        if (inNum <= 1)
162
                return (long) (((250000 * val + 13300) / 210240 * 10 + 5) /10);
163
        else if (inNum == 2)
164
                return (long) (((250000 * val + 13300) / 157370 * 10 + 5) /10);
165
        else if (inNum == 3)
166
                return (long) (((250000 * val + 13300) / 101080 * 10 + 5) /10);
167
        else
168
                return (long) (((250000 * val + 13300) / 41714 * 10 + 5) /10);
169
}
170
 
171
/********* FAN RPM CONVERSIONS ********/
172
/* Higher register values = slower fans (the fan's strobe gates a counter).
173
 But this chip saturates back at 0, not at 255 like all the other chips.
174
 So, 0 means 0 RPM */
175
static inline u8 FAN_TO_REG(long rpm, int div)
176
{
177
        if (rpm == 0)
178
                return 0;
179
        rpm = SENSORS_LIMIT(rpm, 1, 1000000);
180
        return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 255);
181
}
182
 
183
#define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1350000/((val)*(div)))
184
 
185
/******** TEMP CONVERSIONS (Bob Dougherty) *********/
186
/* linear fits from HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew)
187
      if(temp<169)
188
              return double(temp)*0.427-32.08;
189
      else if(temp>=169 && temp<=202)
190
              return double(temp)*0.582-58.16;
191
      else
192
              return double(temp)*0.924-127.33;
193
 
194
 A fifth-order polynomial fits the unofficial data (provided by Alex van
195
 Kaam <darkside@chello.nl>) a bit better.  It also give more reasonable
196
 numbers on my machine (ie. they agree with what my BIOS tells me).  
197
 Here's the fifth-order fit to the 8-bit data:
198
 temp = 1.625093e-10*val^5 - 1.001632e-07*val^4 + 2.457653e-05*val^3 -
199
        2.967619e-03*val^2 + 2.175144e-01*val - 7.090067e+0.
200
 
201
 (2000-10-25- RFD: thanks to Uwe Andersen <uandersen@mayah.com> for
202
 finding my typos in this formula!)
203
 
204
 Alas, none of the elegant function-fit solutions will work because we
205
 aren't allowed to use floating point in the kernel and doing it with
206
 integers doesn't rpovide enough precision.  So we'll do boring old
207
 look-up table stuff.  The unofficial data (see below) have effectively
208
 7-bit resolution (they are rounded to the nearest degree).  I'm assuming
209
 that the transfer function of the device is monotonic and smooth, so a
210
 smooth function fit to the data will allow us to get better precision.  
211
 I used the 5th-order poly fit described above and solved for
212
 VIA register values 0-255.  I *10 before rounding, so we get tenth-degree
213
 precision.  (I could have done all 1024 values for our 10-bit readings,
214
 but the function is very linear in the useful range (0-80 deg C), so
215
 we'll just use linear interpolation for 10-bit readings.)  So, tempLUT
216
 is the temp at via register values 0-255: */
217
static const long tempLUT[] =
218
    { -709, -688, -667, -646, -627, -607, -589, -570, -553, -536, -519,
219
            -503, -487, -471, -456, -442, -428, -414, -400, -387, -375,
220
            -362, -350, -339, -327, -316, -305, -295, -285, -275, -265,
221
            -255, -246, -237, -229, -220, -212, -204, -196, -188, -180,
222
            -173, -166, -159, -152, -145, -139, -132, -126, -120, -114,
223
            -108, -102, -96, -91, -85, -80, -74, -69, -64, -59, -54, -49,
224
            -44, -39, -34, -29, -25, -20, -15, -11, -6, -2, 3, 7, 12, 16,
225
            20, 25, 29, 33, 37, 42, 46, 50, 54, 59, 63, 67, 71, 75, 79, 84,
226
            88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138,
227
            142, 146, 151, 155, 159, 163, 168, 172, 176, 181, 185, 189,
228
            193, 198, 202, 206, 211, 215, 219, 224, 228, 232, 237, 241,
229
            245, 250, 254, 259, 263, 267, 272, 276, 281, 285, 290, 294,
230
            299, 303, 307, 312, 316, 321, 325, 330, 334, 339, 344, 348,
231
            353, 357, 362, 366, 371, 376, 380, 385, 390, 395, 399, 404,
232
            409, 414, 419, 423, 428, 433, 438, 443, 449, 454, 459, 464,
233
            469, 475, 480, 486, 491, 497, 502, 508, 514, 520, 526, 532,
234
            538, 544, 551, 557, 564, 571, 578, 584, 592, 599, 606, 614,
235
            621, 629, 637, 645, 654, 662, 671, 680, 689, 698, 708, 718,
236
            728, 738, 749, 759, 770, 782, 793, 805, 818, 830, 843, 856,
237
            870, 883, 898, 912, 927, 943, 958, 975, 991, 1008, 1026, 1044,
238
            1062, 1081, 1101, 1121, 1141, 1162, 1184, 1206, 1229, 1252,
239
            1276, 1301, 1326, 1352, 1378, 1406, 1434, 1462
240
};
241
 
242
/* the original LUT values from Alex van Kaam <darkside@chello.nl>
243
   (for via register values 12-240):
244
{-50,-49,-47,-45,-43,-41,-39,-38,-37,-35,-34,-33,-32,-31,
245
-30,-29,-28,-27,-26,-25,-24,-24,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15,
246
-15,-14,-14,-13,-12,-12,-11,-11,-10,-9,-9,-8,-8,-7,-7,-6,-6,-5,-5,-4,-4,-3,
247
-3,-2,-2,-1,-1,0,0,1,1,1,3,3,3,4,4,4,5,5,5,6,6,7,7,8,8,9,9,9,10,10,11,11,12,
248
12,12,13,13,13,14,14,15,15,16,16,16,17,17,18,18,19,19,20,20,21,21,21,22,22,
249
22,23,23,24,24,25,25,26,26,26,27,27,27,28,28,29,29,30,30,30,31,31,32,32,33,
250
33,34,34,35,35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,43,43,44,44,45,
251
45,46,46,47,48,48,49,49,50,51,51,52,52,53,53,54,55,55,56,57,57,58,59,59,60,
252
61,62,62,63,64,65,66,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,83,84,
253
85,86,88,89,91,92,94,96,97,99,101,103,105,107,109,110};
254
 
255
 
256
 Here's the reverse LUT.  I got it by doing a 6-th order poly fit (needed
257
 an extra term for a good fit to these inverse data!) and then
258
 solving for each temp value from -50 to 110 (the useable range for
259
 this chip).  Here's the fit:
260
 viaRegVal = -1.160370e-10*val^6 +3.193693e-08*val^5 - 1.464447e-06*val^4
261
 - 2.525453e-04*val^3 + 1.424593e-02*val^2 + 2.148941e+00*val +7.275808e+01)
262
 Note that n=161: */
263
static const u8 viaLUT[] =
264
    { 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22, 23,
265
            23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 39, 40,
266
            41, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 62, 64, 66,
267
            69, 71, 73, 75, 77, 79, 82, 84, 86, 88, 91, 93, 95, 98, 100,
268
            103, 105, 107, 110, 112, 115, 117, 119, 122, 124, 126, 129,
269
            131, 134, 136, 138, 140, 143, 145, 147, 150, 152, 154, 156,
270
            158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180,
271
            182, 183, 185, 187, 188, 190, 192, 193, 195, 196, 198, 199,
272
            200, 202, 203, 205, 206, 207, 208, 209, 210, 211, 212, 213,
273
            214, 215, 216, 217, 218, 219, 220, 221, 222, 222, 223, 224,
274
            225, 226, 226, 227, 228, 228, 229, 230, 230, 231, 232, 232,
275
            233, 233, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239,
276
            239, 240
277
};
278
 
279
/* Converting temps to (8-bit) hyst and over registers
280
 No interpolation here.  Just check the limits and go.
281
 The +5 effectively rounds off properly and the +50 is because
282
 the temps start at -50 */
283
static inline u8 TEMP_TO_REG(long val)
284
{
285
        return (u8)
286
            SENSORS_LIMIT(viaLUT[((val <= -500) ? 0 : (val >= 1100) ? 160 :
287
                                  ((val + 5) / 10 + 50))], 0, 255);
288
}
289
 
290
/* for 8-bit temperature hyst and over registers
291
 The temp values are already *10, so we don't need to do that.
292
 But we _will_ round these off to the nearest degree with (...*10+5)/10 */
293
#define TEMP_FROM_REG(val) ((tempLUT[(val)]*10+5)/10)
294
 
295
/* for 10-bit temperature readings
296
 You might _think_ this is too long to inline, but's it's really only
297
 called once... */
298
static inline long TEMP_FROM_REG10(u16 val)
299
{
300
        /* the temp values are already *10, so we don't need to do that. */
301
        long temp;
302
        u16 eightBits = val >> 2;
303
        u16 twoBits = val & 3;
304
 
305
        /* handle the extremes first (they won't interpolate well! ;-) */
306
        if (val == 0)
307
                return (long) tempLUT[0];
308
        if (val == 1023)
309
                return (long) tempLUT[255];
310
 
311
        if (twoBits == 0)
312
                return (long) tempLUT[eightBits];
313
        else {
314
                /* do some interpolation by multipying the lower and upper
315
                 bounds by 25, 50 or 75, then /100. */
316
                temp = ((25 * (4 - twoBits)) * tempLUT[eightBits]
317
                        + (25 * twoBits) * tempLUT[eightBits + 1]);
318
                /* increase the magnitude by 50 to achieve rounding. */
319
                if (temp > 0)
320
                        temp += 50;
321
                else
322
                        temp -= 50;
323
                return (temp / 100);
324
        }
325
}
326
 
327
#define ALARMS_FROM_REG(val) (val)
328
 
329
#define DIV_FROM_REG(val) (1 << (val))
330
#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
331
 
332
/* Initial limits */
333
#define VIA686A_INIT_IN_0 200
334
#define VIA686A_INIT_IN_1 250
335
#define VIA686A_INIT_IN_2 330
336
#define VIA686A_INIT_IN_3 500
337
#define VIA686A_INIT_IN_4 1200
338
 
339
#define VIA686A_INIT_IN_PERCENTAGE 10
340
 
341
#define VIA686A_INIT_IN_MIN_0 (VIA686A_INIT_IN_0 - VIA686A_INIT_IN_0 \
342
        * VIA686A_INIT_IN_PERCENTAGE / 100)
343
#define VIA686A_INIT_IN_MAX_0 (VIA686A_INIT_IN_0 + VIA686A_INIT_IN_0 \
344
        * VIA686A_INIT_IN_PERCENTAGE / 100)
345
#define VIA686A_INIT_IN_MIN_1 (VIA686A_INIT_IN_1 - VIA686A_INIT_IN_1 \
346
        * VIA686A_INIT_IN_PERCENTAGE / 100)
347
#define VIA686A_INIT_IN_MAX_1 (VIA686A_INIT_IN_1 + VIA686A_INIT_IN_1 \
348
        * VIA686A_INIT_IN_PERCENTAGE / 100)
349
#define VIA686A_INIT_IN_MIN_2 (VIA686A_INIT_IN_2 - VIA686A_INIT_IN_2 \
350
        * VIA686A_INIT_IN_PERCENTAGE / 100)
351
#define VIA686A_INIT_IN_MAX_2 (VIA686A_INIT_IN_2 + VIA686A_INIT_IN_2 \
352
        * VIA686A_INIT_IN_PERCENTAGE / 100)
353
#define VIA686A_INIT_IN_MIN_3 (VIA686A_INIT_IN_3 - VIA686A_INIT_IN_3 \
354
        * VIA686A_INIT_IN_PERCENTAGE / 100)
355
#define VIA686A_INIT_IN_MAX_3 (VIA686A_INIT_IN_3 + VIA686A_INIT_IN_3 \
356
        * VIA686A_INIT_IN_PERCENTAGE / 100)
357
#define VIA686A_INIT_IN_MIN_4 (VIA686A_INIT_IN_4 - VIA686A_INIT_IN_4 \
358
        * VIA686A_INIT_IN_PERCENTAGE / 100)
359
#define VIA686A_INIT_IN_MAX_4 (VIA686A_INIT_IN_4 + VIA686A_INIT_IN_4 \
360
        * VIA686A_INIT_IN_PERCENTAGE / 100)
361
 
362
#define VIA686A_INIT_FAN_MIN    3000
363
 
364
#define VIA686A_INIT_TEMP_OVER 600
365
#define VIA686A_INIT_TEMP_HYST 500
366
 
367
/* For the VIA686A, we need to keep some data in memory. That
368
   data is pointed to by via686a_list[NR]->data. The structure itself is
369
   dynamically allocated, at the same time when a new via686a client is
370
   allocated. */
371
struct via686a_data {
372
        int sysctl_id;
373
 
374
        struct semaphore update_lock;
375
        char valid;             /* !=0 if following fields are valid */
376
        unsigned long last_updated;     /* In jiffies */
377
 
378
        u8 in[5];               /* Register value */
379
        u8 in_max[5];           /* Register value */
380
        u8 in_min[5];           /* Register value */
381
        u8 fan[2];              /* Register value */
382
        u8 fan_min[2];          /* Register value */
383
        u16 temp[3];            /* Register value 10 bit */
384
        u8 temp_over[3];        /* Register value */
385
        u8 temp_hyst[3];        /* Register value */
386
        u8 fan_div[2];          /* Register encoding, shifted right */
387
        u16 alarms;             /* Register encoding, combined */
388
};
389
 
390
static struct pci_dev *s_bridge;        /* pointer to the (only) via686a */
391
 
392
static int via686a_attach_adapter(struct i2c_adapter *adapter);
393
static int via686a_detect(struct i2c_adapter *adapter, int address, int kind);
394
static int via686a_detach_client(struct i2c_client *client);
395
 
396
static inline int via686a_read_value(struct i2c_client *client, u8 reg)
397
{
398
        return (inb_p(client->addr + reg));
399
}
400
 
401
static inline void via686a_write_value(struct i2c_client *client, u8 reg,
402
                                       u8 value)
403
{
404
        outb_p(value, client->addr + reg);
405
}
406
 
407
static void via686a_update_client(struct i2c_client *client);
408
static void via686a_init_client(struct i2c_client *client);
409
 
410
/* following are the sysfs callback functions */
411
 
412
/* 7 voltage sensors */
413
static ssize_t show_in(struct device *dev, char *buf, int nr) {
414
        struct i2c_client *client = to_i2c_client(dev);
415
        struct via686a_data *data = i2c_get_clientdata(client);
416
        via686a_update_client(client);
417
        return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr)*10 );
418
}
419
 
420
static ssize_t show_in_min(struct device *dev, char *buf, int nr) {
421
        struct i2c_client *client = to_i2c_client(dev);
422
        struct via686a_data *data = i2c_get_clientdata(client);
423
        via686a_update_client(client);
424
        return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr)*10 );
425
}
426
 
427
static ssize_t show_in_max(struct device *dev, char *buf, int nr) {
428
        struct i2c_client *client = to_i2c_client(dev);
429
        struct via686a_data *data = i2c_get_clientdata(client);
430
        via686a_update_client(client);
431
        return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr)*10 );
432
}
433
 
434
static ssize_t set_in_min(struct device *dev, const char *buf,
435
                size_t count, int nr) {
436
        struct i2c_client *client = to_i2c_client(dev);
437
        struct via686a_data *data = i2c_get_clientdata(client);
438
        unsigned long val = simple_strtoul(buf, NULL, 10)/10;
439
        data->in_min[nr] = IN_TO_REG(val,nr);
440
        via686a_write_value(client, VIA686A_REG_IN_MIN(nr),
441
                        data->in_min[nr]);
442
        return count;
443
}
444
static ssize_t set_in_max(struct device *dev, const char *buf,
445
                size_t count, int nr) {
446
        struct i2c_client *client = to_i2c_client(dev);
447
        struct via686a_data *data = i2c_get_clientdata(client);
448
        unsigned long val = simple_strtoul(buf, NULL, 10)/10;
449
        data->in_max[nr] = IN_TO_REG(val,nr);
450
        via686a_write_value(client, VIA686A_REG_IN_MAX(nr),
451
                        data->in_max[nr]);
452
        return count;
453
}
454
#define show_in_offset(offset)                                  \
455
static ssize_t                                                  \
456
        show_in##offset (struct device *dev, char *buf)         \
457
{                                                               \
458
        return show_in(dev, buf, 0x##offset);                   \
459
}                                                               \
460
static ssize_t                                                  \
461
        show_in##offset##_min (struct device *dev, char *buf)   \
462
{                                                               \
463
        return show_in_min(dev, buf, 0x##offset);               \
464
}                                                               \
465
static ssize_t                                                  \
466
        show_in##offset##_max (struct device *dev, char *buf)   \
467
{                                                               \
468
        return show_in_max(dev, buf, 0x##offset);               \
469
}                                                               \
470
static ssize_t set_in##offset##_min (struct device *dev,        \
471
                const char *buf, size_t count)                  \
472
{                                                               \
473
        return set_in_min(dev, buf, count, 0x##offset);         \
474
}                                                               \
475
static ssize_t set_in##offset##_max (struct device *dev,        \
476
                        const char *buf, size_t count)          \
477
{                                                               \
478
        return set_in_max(dev, buf, count, 0x##offset);         \
479
}                                                               \
480
static DEVICE_ATTR(in_input##offset, S_IRUGO, show_in##offset, NULL)    \
481
static DEVICE_ATTR(in_min##offset, S_IRUGO | S_IWUSR,           \
482
                show_in##offset##_min, set_in##offset##_min)    \
483
static DEVICE_ATTR(in_max##offset, S_IRUGO | S_IWUSR,           \
484
                show_in##offset##_max, set_in##offset##_max)
485
 
486
show_in_offset(0);
487
show_in_offset(1);
488
show_in_offset(2);
489
show_in_offset(3);
490
show_in_offset(4);
491
 
492
/* 3 temperatures */
493
static ssize_t show_temp(struct device *dev, char *buf, int nr) {
494
        struct i2c_client *client = to_i2c_client(dev);
495
        struct via686a_data *data = i2c_get_clientdata(client);
496
        via686a_update_client(client);
497
        return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr])*100 );
498
}
499
/* more like overshoot temperature */
500
static ssize_t show_temp_max(struct device *dev, char *buf, int nr) {
501
        struct i2c_client *client = to_i2c_client(dev);
502
        struct via686a_data *data = i2c_get_clientdata(client);
503
        via686a_update_client(client);
504
        return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr])*100);
505
}
506
/* more like hysteresis temperature */
507
static ssize_t show_temp_min(struct device *dev, char *buf, int nr) {
508
        struct i2c_client *client = to_i2c_client(dev);
509
        struct via686a_data *data = i2c_get_clientdata(client);
510
        via686a_update_client(client);
511
        return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr])*100);
512
}
513
static ssize_t set_temp_max(struct device *dev, const char *buf,
514
                size_t count, int nr) {
515
        struct i2c_client *client = to_i2c_client(dev);
516
        struct via686a_data *data = i2c_get_clientdata(client);
517
        int val = simple_strtol(buf, NULL, 10)/100;
518
        data->temp_over[nr] = TEMP_TO_REG(val);
519
        via686a_write_value(client, VIA686A_REG_TEMP_OVER(nr), data->temp_over[nr]);
520
        return count;
521
}
522
static ssize_t set_temp_min(struct device *dev, const char *buf,
523
                size_t count, int nr) {
524
        struct i2c_client *client = to_i2c_client(dev);
525
        struct via686a_data *data = i2c_get_clientdata(client);
526
        int val = simple_strtol(buf, NULL, 10)/100;
527
        data->temp_hyst[nr] = TEMP_TO_REG(val);
528
        via686a_write_value(client, VIA686A_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
529
        return count;
530
}
531
#define show_temp_offset(offset)                                        \
532
static ssize_t show_temp_##offset (struct device *dev, char *buf)       \
533
{                                                                       \
534
        return show_temp(dev, buf, 0x##offset - 1);                     \
535
}                                                                       \
536
static ssize_t                                                          \
537
show_temp_##offset##_max (struct device *dev, char *buf)                \
538
{                                                                       \
539
        return show_temp_max(dev, buf, 0x##offset - 1);                 \
540
}                                                                       \
541
static ssize_t                                                          \
542
show_temp_##offset##_min (struct device *dev, char *buf)                \
543
{                                                                       \
544
        return show_temp_min(dev, buf, 0x##offset - 1);                 \
545
}                                                                       \
546
static ssize_t set_temp_##offset##_max (struct device *dev,             \
547
                const char *buf, size_t count)                          \
548
{                                                                       \
549
        return set_temp_max(dev, buf, count, 0x##offset - 1);           \
550
}                                                                       \
551
static ssize_t set_temp_##offset##_min (struct device *dev,             \
552
                const char *buf, size_t count)                          \
553
{                                                                       \
554
        return set_temp_min(dev, buf, count, 0x##offset - 1);           \
555
}                                                                       \
556
static DEVICE_ATTR(temp_input##offset, S_IRUGO, show_temp_##offset, NULL) \
557
static DEVICE_ATTR(temp_max##offset, S_IRUGO | S_IWUSR,                 \
558
                show_temp_##offset##_max, set_temp_##offset##_max)      \
559
static DEVICE_ATTR(temp_min##offset, S_IRUGO | S_IWUSR,                 \
560
                show_temp_##offset##_min, set_temp_##offset##_min)      
561
 
562
show_temp_offset(1);
563
show_temp_offset(2);
564
show_temp_offset(3);
565
 
566
/* 2 Fans */
567
static ssize_t show_fan(struct device *dev, char *buf, int nr) {
568
        struct i2c_client *client = to_i2c_client(dev);
569
        struct via686a_data *data = i2c_get_clientdata(client);
570
        via686a_update_client(client);
571
        return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
572
                                DIV_FROM_REG(data->fan_div[nr])) );
573
}
574
static ssize_t show_fan_min(struct device *dev, char *buf, int nr) {
575
        struct i2c_client *client = to_i2c_client(dev);
576
        struct via686a_data *data = i2c_get_clientdata(client);
577
        via686a_update_client(client);
578
        return sprintf(buf,"%d\n",
579
                FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])) );
580
}
581
static ssize_t show_fan_div(struct device *dev, char *buf, int nr) {
582
        struct i2c_client *client = to_i2c_client(dev);
583
        struct via686a_data *data = i2c_get_clientdata(client);
584
        via686a_update_client(client);
585
        return sprintf(buf,"%d\n", DIV_FROM_REG(data->fan_div[nr]) );
586
}
587
static ssize_t set_fan_min(struct device *dev, const char *buf,
588
                size_t count, int nr) {
589
        struct i2c_client *client = to_i2c_client(dev);
590
        struct via686a_data *data = i2c_get_clientdata(client);
591
        int val = simple_strtol(buf, NULL, 10);
592
        data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
593
        via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
594
        return count;
595
}
596
static ssize_t set_fan_div(struct device *dev, const char *buf,
597
                size_t count, int nr) {
598
        struct i2c_client *client = to_i2c_client(dev);
599
        struct via686a_data *data = i2c_get_clientdata(client);
600
        int val = simple_strtol(buf, NULL, 10);
601
        int old = via686a_read_value(client, VIA686A_REG_FANDIV);
602
        data->fan_div[nr] = DIV_TO_REG(val);
603
        old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
604
        via686a_write_value(client, VIA686A_REG_FANDIV, old);
605
        return count;
606
}
607
 
608
#define show_fan_offset(offset)                                         \
609
static ssize_t show_fan_##offset (struct device *dev, char *buf)        \
610
{                                                                       \
611
        return show_fan(dev, buf, 0x##offset - 1);                      \
612
}                                                                       \
613
static ssize_t show_fan_##offset##_min (struct device *dev, char *buf)  \
614
{                                                                       \
615
        return show_fan_min(dev, buf, 0x##offset - 1);                  \
616
}                                                                       \
617
static ssize_t show_fan_##offset##_div (struct device *dev, char *buf)  \
618
{                                                                       \
619
        return show_fan_div(dev, buf, 0x##offset - 1);                  \
620
}                                                                       \
621
static ssize_t set_fan_##offset##_min (struct device *dev,              \
622
        const char *buf, size_t count)                                  \
623
{                                                                       \
624
        return set_fan_min(dev, buf, count, 0x##offset - 1);            \
625
}                                                                       \
626
static ssize_t set_fan_##offset##_div (struct device *dev,              \
627
                const char *buf, size_t count)                          \
628
{                                                                       \
629
        return set_fan_div(dev, buf, count, 0x##offset - 1);            \
630
}                                                                       \
631
static DEVICE_ATTR(fan_input##offset, S_IRUGO, show_fan_##offset, NULL) \
632
static DEVICE_ATTR(fan_min##offset, S_IRUGO | S_IWUSR,                  \
633
                show_fan_##offset##_min, set_fan_##offset##_min)        \
634
static DEVICE_ATTR(fan_div##offset, S_IRUGO | S_IWUSR,                  \
635
                show_fan_##offset##_div, set_fan_##offset##_div)
636
 
637
show_fan_offset(1);
638
show_fan_offset(2);
639
 
640
/* Alarm */
641
static ssize_t show_alarm(struct device *dev, char *buf) {
642
        struct i2c_client *client = to_i2c_client(dev);
643
        struct via686a_data *data = i2c_get_clientdata(client);
644
        via686a_update_client(client);
645
        return sprintf(buf,"%d\n", ALARMS_FROM_REG(data->alarms));
646
}
647
static DEVICE_ATTR(alarm, S_IRUGO | S_IWUSR, show_alarm, NULL);
648
 
649
/* The driver. I choose to use type i2c_driver, as at is identical to both
650
   smbus_driver and isa_driver, and clients could be of either kind */
651
static struct i2c_driver via686a_driver = {
652
        .owner          = THIS_MODULE,
653
        .name           = "VIA686A",
654
        .id             = I2C_DRIVERID_VIA686A,
655
        .flags          = I2C_DF_NOTIFY,
656
        .attach_adapter = via686a_attach_adapter,
657
        .detach_client  = via686a_detach_client,
658
};
659
 
660
 
661
/* This is called when the module is loaded */
662
static int via686a_attach_adapter(struct i2c_adapter *adapter)
663
{
664
        if (!(adapter->class & I2C_ADAP_CLASS_SMBUS))
665
                return 0;
666
        return i2c_detect(adapter, &addr_data, via686a_detect);
667
}
668
 
669
static int via686a_detect(struct i2c_adapter *adapter, int address, int kind)
670
{
671
        struct i2c_client *new_client;
672
        struct via686a_data *data;
673
        int err = 0;
674
        const char client_name[] = "via686a";
675
        u16 val;
676
 
677
        /* Make sure we are probing the ISA bus!!  */
678
        if (!i2c_is_isa_adapter(adapter)) {
679
                dev_err(&adapter->dev,
680
                "via686a_detect called for an I2C bus adapter?!?\n");
681
                return 0;
682
        }
683
 
684
        /* 8231 requires multiple of 256, we enforce that on 686 as well */
685
        if(force_addr)
686
                address = force_addr & 0xFF00;
687
 
688
        if(force_addr) {
689
                dev_warn(&adapter->dev,"forcing ISA address 0x%04X\n", address);
690
                if (PCIBIOS_SUCCESSFUL !=
691
                    pci_write_config_word(s_bridge, VIA686A_BASE_REG, address))
692
                        return -ENODEV;
693
        }
694
        if (PCIBIOS_SUCCESSFUL !=
695
            pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val))
696
                return -ENODEV;
697
        if (!(val & 0x0001)) {
698
                dev_warn(&adapter->dev,"enabling sensors\n");
699
                if (PCIBIOS_SUCCESSFUL !=
700
                    pci_write_config_word(s_bridge, VIA686A_ENABLE_REG,
701
                                      val | 0x0001))
702
                        return -ENODEV;
703
        }
704
 
705
        /* Reserve the ISA region */
706
        if (!request_region(address, VIA686A_EXTENT, "via686a-sensor")) {
707
                dev_err(&adapter->dev,"region 0x%x already in use!\n",
708
                       address);
709
                return -ENODEV;
710
        }
711
 
712
        if (!(new_client = kmalloc(sizeof(struct i2c_client) +
713
                                   sizeof(struct via686a_data),
714
                                   GFP_KERNEL))) {
715
                err = -ENOMEM;
716
                goto ERROR0;
717
        }
718
 
719
        memset(new_client,0x00, sizeof(struct i2c_client) +
720
                                sizeof(struct via686a_data));
721
        data = (struct via686a_data *) (new_client + 1);
722
        i2c_set_clientdata(new_client, data);
723
        new_client->addr = address;
724
        new_client->adapter = adapter;
725
        new_client->driver = &via686a_driver;
726
        new_client->flags = 0;
727
        new_client->dev.parent = &adapter->dev;
728
 
729
        /* Fill in the remaining client fields and put into the global list */
730
        snprintf(new_client->name, I2C_NAME_SIZE, client_name);
731
 
732
        data->valid = 0;
733
        init_MUTEX(&data->update_lock);
734
        /* Tell the I2C layer a new client has arrived */
735
        if ((err = i2c_attach_client(new_client)))
736
                goto ERROR3;
737
 
738
        /* Initialize the VIA686A chip */
739
        via686a_init_client(new_client);
740
 
741
        /* Register sysfs hooks */
742
        device_create_file(&new_client->dev, &dev_attr_in_input0);
743
        device_create_file(&new_client->dev, &dev_attr_in_input1);
744
        device_create_file(&new_client->dev, &dev_attr_in_input2);
745
        device_create_file(&new_client->dev, &dev_attr_in_input3);
746
        device_create_file(&new_client->dev, &dev_attr_in_input4);
747
        device_create_file(&new_client->dev, &dev_attr_in_min0);
748
        device_create_file(&new_client->dev, &dev_attr_in_min1);
749
        device_create_file(&new_client->dev, &dev_attr_in_min2);
750
        device_create_file(&new_client->dev, &dev_attr_in_min3);
751
        device_create_file(&new_client->dev, &dev_attr_in_min4);
752
        device_create_file(&new_client->dev, &dev_attr_in_max0);
753
        device_create_file(&new_client->dev, &dev_attr_in_max1);
754
        device_create_file(&new_client->dev, &dev_attr_in_max2);
755
        device_create_file(&new_client->dev, &dev_attr_in_max3);
756
        device_create_file(&new_client->dev, &dev_attr_in_max4);
757
        device_create_file(&new_client->dev, &dev_attr_temp_input1);
758
        device_create_file(&new_client->dev, &dev_attr_temp_input2);
759
        device_create_file(&new_client->dev, &dev_attr_temp_input3);
760
        device_create_file(&new_client->dev, &dev_attr_temp_max1);
761
        device_create_file(&new_client->dev, &dev_attr_temp_max2);
762
        device_create_file(&new_client->dev, &dev_attr_temp_max3);
763
        device_create_file(&new_client->dev, &dev_attr_temp_min1);
764
        device_create_file(&new_client->dev, &dev_attr_temp_min2);
765
        device_create_file(&new_client->dev, &dev_attr_temp_min3);
766
        device_create_file(&new_client->dev, &dev_attr_fan_input1);
767
        device_create_file(&new_client->dev, &dev_attr_fan_input2);
768
        device_create_file(&new_client->dev, &dev_attr_fan_min1);
769
        device_create_file(&new_client->dev, &dev_attr_fan_min2);
770
        device_create_file(&new_client->dev, &dev_attr_fan_div1);
771
        device_create_file(&new_client->dev, &dev_attr_fan_div2);
772
        device_create_file(&new_client->dev, &dev_attr_alarm);
773
 
774
        return 0;
775
 
776
      ERROR3:
777
        release_region(address, VIA686A_EXTENT);
778
        kfree(new_client);
779
      ERROR0:
780
        return err;
781
}
782
 
783
static int via686a_detach_client(struct i2c_client *client)
784
{
785
        int err;
786
 
787
        if ((err = i2c_detach_client(client))) {
788
                dev_err(&client->dev,
789
                "Client deregistration failed, client not detached.\n");
790
                return err;
791
        }
792
 
793
        release_region(client->addr, VIA686A_EXTENT);
794
        kfree(client);
795
 
796
        return 0;
797
}
798
 
799
/* Called when we have found a new VIA686A. Set limits, etc. */
800
static void via686a_init_client(struct i2c_client *client)
801
{
802
        int i;
803
 
804
        /* Reset the device */
805
        via686a_write_value(client, VIA686A_REG_CONFIG, 0x80);
806
 
807
        /* Have to wait for reset to complete or else the following
808
           initializations won't work reliably. The delay was arrived at
809
           empirically, the datasheet doesn't tell you.
810
           Waiting for the reset bit to clear doesn't work, it
811
           clears in about 2-4 udelays and that isn't nearly enough. */
812
        udelay(50);
813
 
814
        via686a_write_value(client, VIA686A_REG_IN_MIN(0),
815
                            IN_TO_REG(VIA686A_INIT_IN_MIN_0, 0));
816
        via686a_write_value(client, VIA686A_REG_IN_MAX(0),
817
                            IN_TO_REG(VIA686A_INIT_IN_MAX_0, 0));
818
        via686a_write_value(client, VIA686A_REG_IN_MIN(1),
819
                            IN_TO_REG(VIA686A_INIT_IN_MIN_1, 1));
820
        via686a_write_value(client, VIA686A_REG_IN_MAX(1),
821
                            IN_TO_REG(VIA686A_INIT_IN_MAX_1, 1));
822
        via686a_write_value(client, VIA686A_REG_IN_MIN(2),
823
                            IN_TO_REG(VIA686A_INIT_IN_MIN_2, 2));
824
        via686a_write_value(client, VIA686A_REG_IN_MAX(2),
825
                            IN_TO_REG(VIA686A_INIT_IN_MAX_2, 2));
826
        via686a_write_value(client, VIA686A_REG_IN_MIN(3),
827
                            IN_TO_REG(VIA686A_INIT_IN_MIN_3, 3));
828
        via686a_write_value(client, VIA686A_REG_IN_MAX(3),
829
                            IN_TO_REG(VIA686A_INIT_IN_MAX_3, 3));
830
        via686a_write_value(client, VIA686A_REG_IN_MIN(4),
831
                            IN_TO_REG(VIA686A_INIT_IN_MIN_4, 4));
832
        via686a_write_value(client, VIA686A_REG_IN_MAX(4),
833
                            IN_TO_REG(VIA686A_INIT_IN_MAX_4, 4));
834
        via686a_write_value(client, VIA686A_REG_FAN_MIN(1),
835
                            FAN_TO_REG(VIA686A_INIT_FAN_MIN, 2));
836
        via686a_write_value(client, VIA686A_REG_FAN_MIN(2),
837
                            FAN_TO_REG(VIA686A_INIT_FAN_MIN, 2));
838
        for (i = 0; i <= 2; i++) {
839
                via686a_write_value(client, VIA686A_REG_TEMP_OVER(i),
840
                                    TEMP_TO_REG(VIA686A_INIT_TEMP_OVER));
841
                via686a_write_value(client, VIA686A_REG_TEMP_HYST(i),
842
                                    TEMP_TO_REG(VIA686A_INIT_TEMP_HYST));
843
        }
844
 
845
        /* Start monitoring */
846
        via686a_write_value(client, VIA686A_REG_CONFIG, 0x01);
847
 
848
        /* Cofigure temp interrupt mode for continuous-interrupt operation */
849
        via686a_write_value(client, VIA686A_REG_TEMP_MODE,
850
                            via686a_read_value(client, VIA686A_REG_TEMP_MODE) &
851
                            !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS));
852
}
853
 
854
static void via686a_update_client(struct i2c_client *client)
855
{
856
        struct via686a_data *data = i2c_get_clientdata(client);
857
        int i;
858
 
859
        down(&data->update_lock);
860
 
861
       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
862
           (jiffies < data->last_updated) || !data->valid) {
863
 
864
                for (i = 0; i <= 4; i++) {
865
                        data->in[i] =
866
                            via686a_read_value(client, VIA686A_REG_IN(i));
867
                        data->in_min[i] = via686a_read_value(client,
868
                                                             VIA686A_REG_IN_MIN
869
                                                             (i));
870
                        data->in_max[i] =
871
                            via686a_read_value(client, VIA686A_REG_IN_MAX(i));
872
                }
873
                for (i = 1; i <= 2; i++) {
874
                        data->fan[i - 1] =
875
                            via686a_read_value(client, VIA686A_REG_FAN(i));
876
                        data->fan_min[i - 1] = via686a_read_value(client,
877
                                                     VIA686A_REG_FAN_MIN(i));
878
                }
879
                for (i = 0; i <= 2; i++) {
880
                        data->temp[i] = via686a_read_value(client,
881
                                                 VIA686A_REG_TEMP(i)) << 2;
882
                        data->temp_over[i] =
883
                            via686a_read_value(client,
884
                                               VIA686A_REG_TEMP_OVER(i));
885
                        data->temp_hyst[i] =
886
                            via686a_read_value(client,
887
                                               VIA686A_REG_TEMP_HYST(i));
888
                }
889
                /* add in lower 2 bits
890
                   temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1
891
                   temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
892
                   temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
893
                 */
894
                data->temp[0] |= (via686a_read_value(client,
895
                                                     VIA686A_REG_TEMP_LOW1)
896
                                  & 0xc0) >> 6;
897
                data->temp[1] |=
898
                    (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
899
                     0x30) >> 4;
900
                data->temp[2] |=
901
                    (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
902
                     0xc0) >> 6;
903
 
904
                i = via686a_read_value(client, VIA686A_REG_FANDIV);
905
                data->fan_div[0] = (i >> 4) & 0x03;
906
                data->fan_div[1] = i >> 6;
907
                data->alarms =
908
                    via686a_read_value(client,
909
                                       VIA686A_REG_ALARM1) |
910
                    (via686a_read_value(client, VIA686A_REG_ALARM2) << 8);
911
                data->last_updated = jiffies;
912
                data->valid = 1;
913
        }
914
 
915
        up(&data->update_lock);
916
}
917
 
918
static struct pci_device_id via686a_pci_ids[] = {
919
       {
920
               .vendor          = PCI_VENDOR_ID_VIA,
921
               .device          = PCI_DEVICE_ID_VIA_82C686_4,
922
               .subvendor       = PCI_ANY_ID,
923
               .subdevice       = PCI_ANY_ID,
924
       },
925
       { 0, }
926
};
927
 
928
static int __devinit via686a_pci_probe(struct pci_dev *dev,
929
                                      const struct pci_device_id *id)
930
{
931
       u16 val;
932
       int addr = 0;
933
 
934
       if (PCIBIOS_SUCCESSFUL !=
935
           pci_read_config_word(dev, VIA686A_BASE_REG, &val))
936
               return -ENODEV;
937
 
938
       addr = val & ~(VIA686A_EXTENT - 1);
939
       if (addr == 0 && force_addr == 0) {
940
               dev_err(&dev->dev,"base address not set - upgrade BIOS or use force_addr=0xaddr\n");
941
               return -ENODEV;
942
       }
943
       if (force_addr)
944
               addr = force_addr;      /* so detect will get called */
945
 
946
       if (!addr) {
947
               dev_err(&dev->dev,"No Via 686A sensors found.\n");
948
               return -ENODEV;
949
       }
950
       normal_isa[0] = addr;
951
       s_bridge = dev;
952
       return i2c_add_driver(&via686a_driver);
953
}
954
 
955
static void __devexit via686a_pci_remove(struct pci_dev *dev)
956
{
957
       i2c_del_driver(&via686a_driver);
958
}
959
 
960
static struct pci_driver via686a_pci_driver = {
961
       .name            = "via686a",
962
       .id_table        = via686a_pci_ids,
963
       .probe           = via686a_pci_probe,
964
       .remove          = __devexit_p(via686a_pci_remove),
965
};
966
 
967
static int __init sm_via686a_init(void)
968
{
969
       return pci_module_init(&via686a_pci_driver);
970
}
971
 
972
static void __exit sm_via686a_exit(void)
973
{
974
       pci_unregister_driver(&via686a_pci_driver);
975
}
976
 
977
MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
978
              "Mark Studebaker <mdsxyz123@yahoo.com> "
979
             "and Bob Dougherty <bobd@stanford.edu>");
980
MODULE_DESCRIPTION("VIA 686A Sensor device");
981
MODULE_LICENSE("GPL");
982
 
983
module_init(sm_via686a_init);
984
module_exit(sm_via686a_exit);