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