[PATCH] hwmon: hwmon vs i2c, second round (06/11)
[linux-3.10.git] / drivers / hwmon / via686a.c
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     Warning - only supports a single device.
31 */
32
33 #include <linux/module.h>
34 #include <linux/slab.h>
35 #include <linux/pci.h>
36 #include <linux/jiffies.h>
37 #include <linux/i2c.h>
38 #include <linux/i2c-isa.h>
39 #include <linux/hwmon.h>
40 #include <linux/err.h>
41 #include <linux/init.h>
42 #include <asm/io.h>
43
44
45 /* If force_addr is set to anything different from 0, we forcibly enable
46    the device at the given address. */
47 static unsigned short force_addr = 0;
48 module_param(force_addr, ushort, 0);
49 MODULE_PARM_DESC(force_addr,
50                  "Initialize the base address of the sensors");
51
52 /* Device address
53    Note that we can't determine the ISA address until we have initialized
54    our module */
55 static unsigned short address;
56
57 /*
58    The Via 686a southbridge has a LM78-like chip integrated on the same IC.
59    This driver is a customized copy of lm78.c
60 */
61
62 /* Many VIA686A constants specified below */
63
64 /* Length of ISA address segment */
65 #define VIA686A_EXTENT          0x80
66 #define VIA686A_BASE_REG        0x70
67 #define VIA686A_ENABLE_REG      0x74
68
69 /* The VIA686A registers */
70 /* ins numbered 0-4 */
71 #define VIA686A_REG_IN_MAX(nr)  (0x2b + ((nr) * 2))
72 #define VIA686A_REG_IN_MIN(nr)  (0x2c + ((nr) * 2))
73 #define VIA686A_REG_IN(nr)      (0x22 + (nr))
74
75 /* fans numbered 1-2 */
76 #define VIA686A_REG_FAN_MIN(nr) (0x3a + (nr))
77 #define VIA686A_REG_FAN(nr)     (0x28 + (nr))
78
79 /* temps numbered 1-3 */
80 static const u8 VIA686A_REG_TEMP[]      = { 0x20, 0x21, 0x1f };
81 static const u8 VIA686A_REG_TEMP_OVER[] = { 0x39, 0x3d, 0x1d };
82 static const u8 VIA686A_REG_TEMP_HYST[] = { 0x3a, 0x3e, 0x1e };
83 /* bits 7-6 */
84 #define VIA686A_REG_TEMP_LOW1   0x4b
85 /* 2 = bits 5-4, 3 = bits 7-6 */
86 #define VIA686A_REG_TEMP_LOW23  0x49
87
88 #define VIA686A_REG_ALARM1      0x41
89 #define VIA686A_REG_ALARM2      0x42
90 #define VIA686A_REG_FANDIV      0x47
91 #define VIA686A_REG_CONFIG      0x40
92 /* The following register sets temp interrupt mode (bits 1-0 for temp1,
93  3-2 for temp2, 5-4 for temp3).  Modes are:
94     00 interrupt stays as long as value is out-of-range
95     01 interrupt is cleared once register is read (default)
96     10 comparator mode- like 00, but ignores hysteresis
97     11 same as 00 */
98 #define VIA686A_REG_TEMP_MODE           0x4b
99 /* We'll just assume that you want to set all 3 simultaneously: */
100 #define VIA686A_TEMP_MODE_MASK          0x3F
101 #define VIA686A_TEMP_MODE_CONTINUOUS    0x00
102
103 /* Conversions. Limit checking is only done on the TO_REG
104    variants.
105
106 ********* VOLTAGE CONVERSIONS (Bob Dougherty) ********
107  From HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew):
108  voltagefactor[0]=1.25/2628; (2628/1.25=2102.4)   // Vccp
109  voltagefactor[1]=1.25/2628; (2628/1.25=2102.4)   // +2.5V
110  voltagefactor[2]=1.67/2628; (2628/1.67=1573.7)   // +3.3V
111  voltagefactor[3]=2.6/2628;  (2628/2.60=1010.8)   // +5V
112  voltagefactor[4]=6.3/2628;  (2628/6.30=417.14)   // +12V
113  in[i]=(data[i+2]*25.0+133)*voltagefactor[i];
114  That is:
115  volts = (25*regVal+133)*factor
116  regVal = (volts/factor-133)/25
117  (These conversions were contributed by Jonathan Teh Soon Yew
118  <j.teh@iname.com>) */
119 static inline u8 IN_TO_REG(long val, int inNum)
120 {
121         /* To avoid floating point, we multiply constants by 10 (100 for +12V).
122            Rounding is done (120500 is actually 133000 - 12500).
123            Remember that val is expressed in 0.001V/bit, which is why we divide
124            by an additional 10000 (100000 for +12V): 1000 for val and 10 (100)
125            for the constants. */
126         if (inNum <= 1)
127                 return (u8)
128                     SENSORS_LIMIT((val * 21024 - 1205000) / 250000, 0, 255);
129         else if (inNum == 2)
130                 return (u8)
131                     SENSORS_LIMIT((val * 15737 - 1205000) / 250000, 0, 255);
132         else if (inNum == 3)
133                 return (u8)
134                     SENSORS_LIMIT((val * 10108 - 1205000) / 250000, 0, 255);
135         else
136                 return (u8)
137                     SENSORS_LIMIT((val * 41714 - 12050000) / 2500000, 0, 255);
138 }
139
140 static inline long IN_FROM_REG(u8 val, int inNum)
141 {
142         /* To avoid floating point, we multiply constants by 10 (100 for +12V).
143            We also multiply them by 1000 because we want 0.001V/bit for the
144            output value. Rounding is done. */
145         if (inNum <= 1)
146                 return (long) ((250000 * val + 1330000 + 21024 / 2) / 21024);
147         else if (inNum == 2)
148                 return (long) ((250000 * val + 1330000 + 15737 / 2) / 15737);
149         else if (inNum == 3)
150                 return (long) ((250000 * val + 1330000 + 10108 / 2) / 10108);
151         else
152                 return (long) ((2500000 * val + 13300000 + 41714 / 2) / 41714);
153 }
154
155 /********* FAN RPM CONVERSIONS ********/
156 /* Higher register values = slower fans (the fan's strobe gates a counter).
157  But this chip saturates back at 0, not at 255 like all the other chips.
158  So, 0 means 0 RPM */
159 static inline u8 FAN_TO_REG(long rpm, int div)
160 {
161         if (rpm == 0)
162                 return 0;
163         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
164         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 255);
165 }
166
167 #define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1350000/((val)*(div)))
168
169 /******** TEMP CONVERSIONS (Bob Dougherty) *********/
170 /* linear fits from HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew)
171       if(temp<169)
172               return double(temp)*0.427-32.08;
173       else if(temp>=169 && temp<=202)
174               return double(temp)*0.582-58.16;
175       else
176               return double(temp)*0.924-127.33;
177
178  A fifth-order polynomial fits the unofficial data (provided by Alex van
179  Kaam <darkside@chello.nl>) a bit better.  It also give more reasonable
180  numbers on my machine (ie. they agree with what my BIOS tells me).
181  Here's the fifth-order fit to the 8-bit data:
182  temp = 1.625093e-10*val^5 - 1.001632e-07*val^4 + 2.457653e-05*val^3 -
183         2.967619e-03*val^2 + 2.175144e-01*val - 7.090067e+0.
184
185  (2000-10-25- RFD: thanks to Uwe Andersen <uandersen@mayah.com> for
186  finding my typos in this formula!)
187
188  Alas, none of the elegant function-fit solutions will work because we
189  aren't allowed to use floating point in the kernel and doing it with
190  integers doesn't provide enough precision.  So we'll do boring old
191  look-up table stuff.  The unofficial data (see below) have effectively
192  7-bit resolution (they are rounded to the nearest degree).  I'm assuming
193  that the transfer function of the device is monotonic and smooth, so a
194  smooth function fit to the data will allow us to get better precision.
195  I used the 5th-order poly fit described above and solved for
196  VIA register values 0-255.  I *10 before rounding, so we get tenth-degree
197  precision.  (I could have done all 1024 values for our 10-bit readings,
198  but the function is very linear in the useful range (0-80 deg C), so
199  we'll just use linear interpolation for 10-bit readings.)  So, tempLUT
200  is the temp at via register values 0-255: */
201 static const long tempLUT[] =
202 { -709, -688, -667, -646, -627, -607, -589, -570, -553, -536, -519,
203         -503, -487, -471, -456, -442, -428, -414, -400, -387, -375,
204         -362, -350, -339, -327, -316, -305, -295, -285, -275, -265,
205         -255, -246, -237, -229, -220, -212, -204, -196, -188, -180,
206         -173, -166, -159, -152, -145, -139, -132, -126, -120, -114,
207         -108, -102, -96, -91, -85, -80, -74, -69, -64, -59, -54, -49,
208         -44, -39, -34, -29, -25, -20, -15, -11, -6, -2, 3, 7, 12, 16,
209         20, 25, 29, 33, 37, 42, 46, 50, 54, 59, 63, 67, 71, 75, 79, 84,
210         88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138,
211         142, 146, 151, 155, 159, 163, 168, 172, 176, 181, 185, 189,
212         193, 198, 202, 206, 211, 215, 219, 224, 228, 232, 237, 241,
213         245, 250, 254, 259, 263, 267, 272, 276, 281, 285, 290, 294,
214         299, 303, 307, 312, 316, 321, 325, 330, 334, 339, 344, 348,
215         353, 357, 362, 366, 371, 376, 380, 385, 390, 395, 399, 404,
216         409, 414, 419, 423, 428, 433, 438, 443, 449, 454, 459, 464,
217         469, 475, 480, 486, 491, 497, 502, 508, 514, 520, 526, 532,
218         538, 544, 551, 557, 564, 571, 578, 584, 592, 599, 606, 614,
219         621, 629, 637, 645, 654, 662, 671, 680, 689, 698, 708, 718,
220         728, 738, 749, 759, 770, 782, 793, 805, 818, 830, 843, 856,
221         870, 883, 898, 912, 927, 943, 958, 975, 991, 1008, 1026, 1044,
222         1062, 1081, 1101, 1121, 1141, 1162, 1184, 1206, 1229, 1252,
223         1276, 1301, 1326, 1352, 1378, 1406, 1434, 1462
224 };
225
226 /* the original LUT values from Alex van Kaam <darkside@chello.nl>
227    (for via register values 12-240):
228 {-50,-49,-47,-45,-43,-41,-39,-38,-37,-35,-34,-33,-32,-31,
229 -30,-29,-28,-27,-26,-25,-24,-24,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15,
230 -15,-14,-14,-13,-12,-12,-11,-11,-10,-9,-9,-8,-8,-7,-7,-6,-6,-5,-5,-4,-4,-3,
231 -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,
232 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,
233 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,
234 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,
235 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,
236 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,
237 85,86,88,89,91,92,94,96,97,99,101,103,105,107,109,110};
238
239
240  Here's the reverse LUT.  I got it by doing a 6-th order poly fit (needed
241  an extra term for a good fit to these inverse data!) and then
242  solving for each temp value from -50 to 110 (the useable range for
243  this chip).  Here's the fit:
244  viaRegVal = -1.160370e-10*val^6 +3.193693e-08*val^5 - 1.464447e-06*val^4
245  - 2.525453e-04*val^3 + 1.424593e-02*val^2 + 2.148941e+00*val +7.275808e+01)
246  Note that n=161: */
247 static const u8 viaLUT[] =
248 { 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22, 23,
249         23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 39, 40,
250         41, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 62, 64, 66,
251         69, 71, 73, 75, 77, 79, 82, 84, 86, 88, 91, 93, 95, 98, 100,
252         103, 105, 107, 110, 112, 115, 117, 119, 122, 124, 126, 129,
253         131, 134, 136, 138, 140, 143, 145, 147, 150, 152, 154, 156,
254         158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180,
255         182, 183, 185, 187, 188, 190, 192, 193, 195, 196, 198, 199,
256         200, 202, 203, 205, 206, 207, 208, 209, 210, 211, 212, 213,
257         214, 215, 216, 217, 218, 219, 220, 221, 222, 222, 223, 224,
258         225, 226, 226, 227, 228, 228, 229, 230, 230, 231, 232, 232,
259         233, 233, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239,
260         239, 240
261 };
262
263 /* Converting temps to (8-bit) hyst and over registers
264    No interpolation here.
265    The +50 is because the temps start at -50 */
266 static inline u8 TEMP_TO_REG(long val)
267 {
268         return viaLUT[val <= -50000 ? 0 : val >= 110000 ? 160 :
269                       (val < 0 ? val - 500 : val + 500) / 1000 + 50];
270 }
271
272 /* for 8-bit temperature hyst and over registers */
273 #define TEMP_FROM_REG(val) (tempLUT[(val)] * 100)
274
275 /* for 10-bit temperature readings */
276 static inline long TEMP_FROM_REG10(u16 val)
277 {
278         u16 eightBits = val >> 2;
279         u16 twoBits = val & 3;
280
281         /* no interpolation for these */
282         if (twoBits == 0 || eightBits == 255)
283                 return TEMP_FROM_REG(eightBits);
284
285         /* do some linear interpolation */
286         return (tempLUT[eightBits] * (4 - twoBits) +
287                 tempLUT[eightBits + 1] * twoBits) * 25;
288 }
289
290 #define DIV_FROM_REG(val) (1 << (val))
291 #define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
292
293 /* For the VIA686A, we need to keep some data in memory.
294    The structure is dynamically allocated, at the same time when a new
295    via686a client is allocated. */
296 struct via686a_data {
297         struct i2c_client client;
298         struct class_device *class_dev;
299         struct semaphore update_lock;
300         char valid;             /* !=0 if following fields are valid */
301         unsigned long last_updated;     /* In jiffies */
302
303         u8 in[5];               /* Register value */
304         u8 in_max[5];           /* Register value */
305         u8 in_min[5];           /* Register value */
306         u8 fan[2];              /* Register value */
307         u8 fan_min[2];          /* Register value */
308         u16 temp[3];            /* Register value 10 bit */
309         u8 temp_over[3];        /* Register value */
310         u8 temp_hyst[3];        /* Register value */
311         u8 fan_div[2];          /* Register encoding, shifted right */
312         u16 alarms;             /* Register encoding, combined */
313 };
314
315 static struct pci_dev *s_bridge;        /* pointer to the (only) via686a */
316
317 static int via686a_detect(struct i2c_adapter *adapter);
318 static int via686a_detach_client(struct i2c_client *client);
319
320 static inline int via686a_read_value(struct i2c_client *client, u8 reg)
321 {
322         return (inb_p(client->addr + reg));
323 }
324
325 static inline void via686a_write_value(struct i2c_client *client, u8 reg,
326                                        u8 value)
327 {
328         outb_p(value, client->addr + reg);
329 }
330
331 static struct via686a_data *via686a_update_device(struct device *dev);
332 static void via686a_init_client(struct i2c_client *client);
333
334 /* following are the sysfs callback functions */
335
336 /* 7 voltage sensors */
337 static ssize_t show_in(struct device *dev, char *buf, int nr) {
338         struct via686a_data *data = via686a_update_device(dev);
339         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr));
340 }
341
342 static ssize_t show_in_min(struct device *dev, char *buf, int nr) {
343         struct via686a_data *data = via686a_update_device(dev);
344         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr));
345 }
346
347 static ssize_t show_in_max(struct device *dev, char *buf, int nr) {
348         struct via686a_data *data = via686a_update_device(dev);
349         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr));
350 }
351
352 static ssize_t set_in_min(struct device *dev, const char *buf,
353                 size_t count, int nr) {
354         struct i2c_client *client = to_i2c_client(dev);
355         struct via686a_data *data = i2c_get_clientdata(client);
356         unsigned long val = simple_strtoul(buf, NULL, 10);
357
358         down(&data->update_lock);
359         data->in_min[nr] = IN_TO_REG(val, nr);
360         via686a_write_value(client, VIA686A_REG_IN_MIN(nr),
361                         data->in_min[nr]);
362         up(&data->update_lock);
363         return count;
364 }
365 static ssize_t set_in_max(struct device *dev, const char *buf,
366                 size_t count, int nr) {
367         struct i2c_client *client = to_i2c_client(dev);
368         struct via686a_data *data = i2c_get_clientdata(client);
369         unsigned long val = simple_strtoul(buf, NULL, 10);
370
371         down(&data->update_lock);
372         data->in_max[nr] = IN_TO_REG(val, nr);
373         via686a_write_value(client, VIA686A_REG_IN_MAX(nr),
374                         data->in_max[nr]);
375         up(&data->update_lock);
376         return count;
377 }
378 #define show_in_offset(offset)                                  \
379 static ssize_t                                                  \
380         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
381 {                                                               \
382         return show_in(dev, buf, offset);                       \
383 }                                                               \
384 static ssize_t                                                  \
385         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)    \
386 {                                                               \
387         return show_in_min(dev, buf, offset);           \
388 }                                                               \
389 static ssize_t                                                  \
390         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)    \
391 {                                                               \
392         return show_in_max(dev, buf, offset);           \
393 }                                                               \
394 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr,         \
395                 const char *buf, size_t count)                  \
396 {                                                               \
397         return set_in_min(dev, buf, count, offset);             \
398 }                                                               \
399 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
400                         const char *buf, size_t count)          \
401 {                                                               \
402         return set_in_max(dev, buf, count, offset);             \
403 }                                                               \
404 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in##offset, NULL);\
405 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
406                 show_in##offset##_min, set_in##offset##_min);   \
407 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
408                 show_in##offset##_max, set_in##offset##_max);
409
410 show_in_offset(0);
411 show_in_offset(1);
412 show_in_offset(2);
413 show_in_offset(3);
414 show_in_offset(4);
415
416 /* 3 temperatures */
417 static ssize_t show_temp(struct device *dev, char *buf, int nr) {
418         struct via686a_data *data = via686a_update_device(dev);
419         return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr]));
420 }
421 static ssize_t show_temp_over(struct device *dev, char *buf, int nr) {
422         struct via686a_data *data = via686a_update_device(dev);
423         return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr]));
424 }
425 static ssize_t show_temp_hyst(struct device *dev, char *buf, int nr) {
426         struct via686a_data *data = via686a_update_device(dev);
427         return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr]));
428 }
429 static ssize_t set_temp_over(struct device *dev, const char *buf,
430                 size_t count, int nr) {
431         struct i2c_client *client = to_i2c_client(dev);
432         struct via686a_data *data = i2c_get_clientdata(client);
433         int val = simple_strtol(buf, NULL, 10);
434
435         down(&data->update_lock);
436         data->temp_over[nr] = TEMP_TO_REG(val);
437         via686a_write_value(client, VIA686A_REG_TEMP_OVER[nr],
438                             data->temp_over[nr]);
439         up(&data->update_lock);
440         return count;
441 }
442 static ssize_t set_temp_hyst(struct device *dev, const char *buf,
443                 size_t count, int nr) {
444         struct i2c_client *client = to_i2c_client(dev);
445         struct via686a_data *data = i2c_get_clientdata(client);
446         int val = simple_strtol(buf, NULL, 10);
447
448         down(&data->update_lock);
449         data->temp_hyst[nr] = TEMP_TO_REG(val);
450         via686a_write_value(client, VIA686A_REG_TEMP_HYST[nr],
451                             data->temp_hyst[nr]);
452         up(&data->update_lock);
453         return count;
454 }
455 #define show_temp_offset(offset)                                        \
456 static ssize_t show_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf)        \
457 {                                                                       \
458         return show_temp(dev, buf, offset - 1);                         \
459 }                                                                       \
460 static ssize_t                                                          \
461 show_temp_##offset##_over (struct device *dev, struct device_attribute *attr, char *buf)                \
462 {                                                                       \
463         return show_temp_over(dev, buf, offset - 1);                    \
464 }                                                                       \
465 static ssize_t                                                          \
466 show_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr, char *buf)                \
467 {                                                                       \
468         return show_temp_hyst(dev, buf, offset - 1);                    \
469 }                                                                       \
470 static ssize_t set_temp_##offset##_over (struct device *dev, struct device_attribute *attr,             \
471                 const char *buf, size_t count)                          \
472 {                                                                       \
473         return set_temp_over(dev, buf, count, offset - 1);              \
474 }                                                                       \
475 static ssize_t set_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr,             \
476                 const char *buf, size_t count)                          \
477 {                                                                       \
478         return set_temp_hyst(dev, buf, count, offset - 1);              \
479 }                                                                       \
480 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_##offset, NULL);\
481 static DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,               \
482                 show_temp_##offset##_over, set_temp_##offset##_over);   \
483 static DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,          \
484                 show_temp_##offset##_hyst, set_temp_##offset##_hyst);
485
486 show_temp_offset(1);
487 show_temp_offset(2);
488 show_temp_offset(3);
489
490 /* 2 Fans */
491 static ssize_t show_fan(struct device *dev, char *buf, int nr) {
492         struct via686a_data *data = via686a_update_device(dev);
493         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
494                                 DIV_FROM_REG(data->fan_div[nr])) );
495 }
496 static ssize_t show_fan_min(struct device *dev, char *buf, int nr) {
497         struct via686a_data *data = via686a_update_device(dev);
498         return sprintf(buf, "%d\n",
499                 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])) );
500 }
501 static ssize_t show_fan_div(struct device *dev, char *buf, int nr) {
502         struct via686a_data *data = via686a_update_device(dev);
503         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
504 }
505 static ssize_t set_fan_min(struct device *dev, const char *buf,
506                 size_t count, int nr) {
507         struct i2c_client *client = to_i2c_client(dev);
508         struct via686a_data *data = i2c_get_clientdata(client);
509         int val = simple_strtol(buf, NULL, 10);
510
511         down(&data->update_lock);
512         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
513         via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
514         up(&data->update_lock);
515         return count;
516 }
517 static ssize_t set_fan_div(struct device *dev, const char *buf,
518                 size_t count, int nr) {
519         struct i2c_client *client = to_i2c_client(dev);
520         struct via686a_data *data = i2c_get_clientdata(client);
521         int val = simple_strtol(buf, NULL, 10);
522         int old;
523
524         down(&data->update_lock);
525         old = via686a_read_value(client, VIA686A_REG_FANDIV);
526         data->fan_div[nr] = DIV_TO_REG(val);
527         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
528         via686a_write_value(client, VIA686A_REG_FANDIV, old);
529         up(&data->update_lock);
530         return count;
531 }
532
533 #define show_fan_offset(offset)                                         \
534 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
535 {                                                                       \
536         return show_fan(dev, buf, offset - 1);                          \
537 }                                                                       \
538 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
539 {                                                                       \
540         return show_fan_min(dev, buf, offset - 1);                      \
541 }                                                                       \
542 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)   \
543 {                                                                       \
544         return show_fan_div(dev, buf, offset - 1);                      \
545 }                                                                       \
546 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
547         const char *buf, size_t count)                                  \
548 {                                                                       \
549         return set_fan_min(dev, buf, count, offset - 1);                \
550 }                                                                       \
551 static ssize_t set_fan_##offset##_div (struct device *dev, struct device_attribute *attr,               \
552                 const char *buf, size_t count)                          \
553 {                                                                       \
554         return set_fan_div(dev, buf, count, offset - 1);                \
555 }                                                                       \
556 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
557 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
558                 show_fan_##offset##_min, set_fan_##offset##_min);       \
559 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,                \
560                 show_fan_##offset##_div, set_fan_##offset##_div);
561
562 show_fan_offset(1);
563 show_fan_offset(2);
564
565 /* Alarms */
566 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) {
567         struct via686a_data *data = via686a_update_device(dev);
568         return sprintf(buf, "%u\n", data->alarms);
569 }
570 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
571
572 /* The driver. I choose to use type i2c_driver, as at is identical to both
573    smbus_driver and isa_driver, and clients could be of either kind */
574 static struct i2c_driver via686a_driver = {
575         .owner          = THIS_MODULE,
576         .name           = "via686a",
577         .attach_adapter = via686a_detect,
578         .detach_client  = via686a_detach_client,
579 };
580
581
582 /* This is called when the module is loaded */
583 static int via686a_detect(struct i2c_adapter *adapter)
584 {
585         struct i2c_client *new_client;
586         struct via686a_data *data;
587         int err = 0;
588         const char client_name[] = "via686a";
589         u16 val;
590
591         /* 8231 requires multiple of 256, we enforce that on 686 as well */
592         if (force_addr)
593                 address = force_addr & 0xFF00;
594
595         if (force_addr) {
596                 dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n",
597                          address);
598                 if (PCIBIOS_SUCCESSFUL !=
599                     pci_write_config_word(s_bridge, VIA686A_BASE_REG, address))
600                         return -ENODEV;
601         }
602         if (PCIBIOS_SUCCESSFUL !=
603             pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val))
604                 return -ENODEV;
605         if (!(val & 0x0001)) {
606                 dev_warn(&adapter->dev, "enabling sensors\n");
607                 if (PCIBIOS_SUCCESSFUL !=
608                     pci_write_config_word(s_bridge, VIA686A_ENABLE_REG,
609                                           val | 0x0001))
610                         return -ENODEV;
611         }
612
613         /* Reserve the ISA region */
614         if (!request_region(address, VIA686A_EXTENT, via686a_driver.name)) {
615                 dev_err(&adapter->dev, "region 0x%x already in use!\n",
616                         address);
617                 return -ENODEV;
618         }
619
620         if (!(data = kmalloc(sizeof(struct via686a_data), GFP_KERNEL))) {
621                 err = -ENOMEM;
622                 goto exit_release;
623         }
624         memset(data, 0, sizeof(struct via686a_data));
625
626         new_client = &data->client;
627         i2c_set_clientdata(new_client, data);
628         new_client->addr = address;
629         new_client->adapter = adapter;
630         new_client->driver = &via686a_driver;
631         new_client->flags = 0;
632
633         /* Fill in the remaining client fields and put into the global list */
634         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
635
636         data->valid = 0;
637         init_MUTEX(&data->update_lock);
638         /* Tell the I2C layer a new client has arrived */
639         if ((err = i2c_attach_client(new_client)))
640                 goto exit_free;
641
642         /* Initialize the VIA686A chip */
643         via686a_init_client(new_client);
644
645         /* Register sysfs hooks */
646         data->class_dev = hwmon_device_register(&new_client->dev);
647         if (IS_ERR(data->class_dev)) {
648                 err = PTR_ERR(data->class_dev);
649                 goto exit_detach;
650         }
651
652         device_create_file(&new_client->dev, &dev_attr_in0_input);
653         device_create_file(&new_client->dev, &dev_attr_in1_input);
654         device_create_file(&new_client->dev, &dev_attr_in2_input);
655         device_create_file(&new_client->dev, &dev_attr_in3_input);
656         device_create_file(&new_client->dev, &dev_attr_in4_input);
657         device_create_file(&new_client->dev, &dev_attr_in0_min);
658         device_create_file(&new_client->dev, &dev_attr_in1_min);
659         device_create_file(&new_client->dev, &dev_attr_in2_min);
660         device_create_file(&new_client->dev, &dev_attr_in3_min);
661         device_create_file(&new_client->dev, &dev_attr_in4_min);
662         device_create_file(&new_client->dev, &dev_attr_in0_max);
663         device_create_file(&new_client->dev, &dev_attr_in1_max);
664         device_create_file(&new_client->dev, &dev_attr_in2_max);
665         device_create_file(&new_client->dev, &dev_attr_in3_max);
666         device_create_file(&new_client->dev, &dev_attr_in4_max);
667         device_create_file(&new_client->dev, &dev_attr_temp1_input);
668         device_create_file(&new_client->dev, &dev_attr_temp2_input);
669         device_create_file(&new_client->dev, &dev_attr_temp3_input);
670         device_create_file(&new_client->dev, &dev_attr_temp1_max);
671         device_create_file(&new_client->dev, &dev_attr_temp2_max);
672         device_create_file(&new_client->dev, &dev_attr_temp3_max);
673         device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
674         device_create_file(&new_client->dev, &dev_attr_temp2_max_hyst);
675         device_create_file(&new_client->dev, &dev_attr_temp3_max_hyst);
676         device_create_file(&new_client->dev, &dev_attr_fan1_input);
677         device_create_file(&new_client->dev, &dev_attr_fan2_input);
678         device_create_file(&new_client->dev, &dev_attr_fan1_min);
679         device_create_file(&new_client->dev, &dev_attr_fan2_min);
680         device_create_file(&new_client->dev, &dev_attr_fan1_div);
681         device_create_file(&new_client->dev, &dev_attr_fan2_div);
682         device_create_file(&new_client->dev, &dev_attr_alarms);
683
684         return 0;
685
686 exit_detach:
687         i2c_detach_client(new_client);
688 exit_free:
689         kfree(data);
690 exit_release:
691         release_region(address, VIA686A_EXTENT);
692         return err;
693 }
694
695 static int via686a_detach_client(struct i2c_client *client)
696 {
697         struct via686a_data *data = i2c_get_clientdata(client);
698         int err;
699
700         hwmon_device_unregister(data->class_dev);
701
702         if ((err = i2c_detach_client(client)))
703                 return err;
704
705         release_region(client->addr, VIA686A_EXTENT);
706         kfree(data);
707
708         return 0;
709 }
710
711 /* Called when we have found a new VIA686A. Set limits, etc. */
712 static void via686a_init_client(struct i2c_client *client)
713 {
714         u8 reg;
715
716         /* Start monitoring */
717         reg = via686a_read_value(client, VIA686A_REG_CONFIG);
718         via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F);
719
720         /* Configure temp interrupt mode for continuous-interrupt operation */
721         via686a_write_value(client, VIA686A_REG_TEMP_MODE,
722                             via686a_read_value(client, VIA686A_REG_TEMP_MODE) &
723                             !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS));
724 }
725
726 static struct via686a_data *via686a_update_device(struct device *dev)
727 {
728         struct i2c_client *client = to_i2c_client(dev);
729         struct via686a_data *data = i2c_get_clientdata(client);
730         int i;
731
732         down(&data->update_lock);
733
734         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
735             || !data->valid) {
736                 for (i = 0; i <= 4; i++) {
737                         data->in[i] =
738                             via686a_read_value(client, VIA686A_REG_IN(i));
739                         data->in_min[i] = via686a_read_value(client,
740                                                              VIA686A_REG_IN_MIN
741                                                              (i));
742                         data->in_max[i] =
743                             via686a_read_value(client, VIA686A_REG_IN_MAX(i));
744                 }
745                 for (i = 1; i <= 2; i++) {
746                         data->fan[i - 1] =
747                             via686a_read_value(client, VIA686A_REG_FAN(i));
748                         data->fan_min[i - 1] = via686a_read_value(client,
749                                                      VIA686A_REG_FAN_MIN(i));
750                 }
751                 for (i = 0; i <= 2; i++) {
752                         data->temp[i] = via686a_read_value(client,
753                                                  VIA686A_REG_TEMP[i]) << 2;
754                         data->temp_over[i] =
755                             via686a_read_value(client,
756                                                VIA686A_REG_TEMP_OVER[i]);
757                         data->temp_hyst[i] =
758                             via686a_read_value(client,
759                                                VIA686A_REG_TEMP_HYST[i]);
760                 }
761                 /* add in lower 2 bits
762                    temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1
763                    temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
764                    temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
765                  */
766                 data->temp[0] |= (via686a_read_value(client,
767                                                      VIA686A_REG_TEMP_LOW1)
768                                   & 0xc0) >> 6;
769                 data->temp[1] |=
770                     (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
771                      0x30) >> 4;
772                 data->temp[2] |=
773                     (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
774                      0xc0) >> 6;
775
776                 i = via686a_read_value(client, VIA686A_REG_FANDIV);
777                 data->fan_div[0] = (i >> 4) & 0x03;
778                 data->fan_div[1] = i >> 6;
779                 data->alarms =
780                     via686a_read_value(client,
781                                        VIA686A_REG_ALARM1) |
782                     (via686a_read_value(client, VIA686A_REG_ALARM2) << 8);
783                 data->last_updated = jiffies;
784                 data->valid = 1;
785         }
786
787         up(&data->update_lock);
788
789         return data;
790 }
791
792 static struct pci_device_id via686a_pci_ids[] = {
793         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) },
794         { 0, }
795 };
796
797 MODULE_DEVICE_TABLE(pci, via686a_pci_ids);
798
799 static int __devinit via686a_pci_probe(struct pci_dev *dev,
800                                        const struct pci_device_id *id)
801 {
802         u16 val;
803
804         if (PCIBIOS_SUCCESSFUL !=
805             pci_read_config_word(dev, VIA686A_BASE_REG, &val))
806                 return -ENODEV;
807
808         address = val & ~(VIA686A_EXTENT - 1);
809         if (address == 0 && force_addr == 0) {
810                 dev_err(&dev->dev, "base address not set - upgrade BIOS "
811                         "or use force_addr=0xaddr\n");
812                 return -ENODEV;
813         }
814
815         if (!address) {
816                 dev_err(&dev->dev, "No Via 686A sensors found.\n");
817                 return -ENODEV;
818         }
819
820         s_bridge = pci_dev_get(dev);
821         if (i2c_isa_add_driver(&via686a_driver)) {
822                 pci_dev_put(s_bridge);
823                 s_bridge = NULL;
824         }
825
826         /* Always return failure here.  This is to allow other drivers to bind
827          * to this pci device.  We don't really want to have control over the
828          * pci device, we only wanted to read as few register values from it.
829          */
830         return -ENODEV;
831 }
832
833 static struct pci_driver via686a_pci_driver = {
834         .name           = "via686a",
835         .id_table       = via686a_pci_ids,
836         .probe          = via686a_pci_probe,
837 };
838
839 static int __init sm_via686a_init(void)
840 {
841         return pci_register_driver(&via686a_pci_driver);
842 }
843
844 static void __exit sm_via686a_exit(void)
845 {
846         pci_unregister_driver(&via686a_pci_driver);
847         if (s_bridge != NULL) {
848                 i2c_isa_del_driver(&via686a_driver);
849                 pci_dev_put(s_bridge);
850                 s_bridge = NULL;
851         }
852 }
853
854 MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
855               "Mark Studebaker <mdsxyz123@yahoo.com> "
856               "and Bob Dougherty <bobd@stanford.edu>");
857 MODULE_DESCRIPTION("VIA 686A Sensor device");
858 MODULE_LICENSE("GPL");
859
860 module_init(sm_via686a_init);
861 module_exit(sm_via686a_exit);