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