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 <linux/mutex.h> 43 #include <linux/sysfs.h> 44 #include <asm/io.h> 45 46 47 /* If force_addr is set to anything different from 0, we forcibly enable 48 the device at the given address. */ 49 static unsigned short force_addr; 50 module_param(force_addr, ushort, 0); 51 MODULE_PARM_DESC(force_addr, 52 "Initialize the base address of the sensors"); 53 54 /* Device address 55 Note that we can't determine the ISA address until we have initialized 56 our module */ 57 static unsigned short address; 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 s16 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) ((long)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 each registered chip, we need to keep some data in memory. 296 The structure is dynamically allocated. */ 297 struct via686a_data { 298 struct i2c_client client; 299 struct class_device *class_dev; 300 struct mutex 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_detect(struct i2c_adapter *adapter); 319 static int via686a_detach_client(struct i2c_client *client); 320 321 static inline int via686a_read_value(struct i2c_client *client, u8 reg) 322 { 323 return (inb_p(client->addr + reg)); 324 } 325 326 static inline void via686a_write_value(struct i2c_client *client, u8 reg, 327 u8 value) 328 { 329 outb_p(value, client->addr + reg); 330 } 331 332 static struct via686a_data *via686a_update_device(struct device *dev); 333 static void via686a_init_client(struct i2c_client *client); 334 335 /* following are the sysfs callback functions */ 336 337 /* 7 voltage sensors */ 338 static ssize_t show_in(struct device *dev, char *buf, int nr) { 339 struct via686a_data *data = via686a_update_device(dev); 340 return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr)); 341 } 342 343 static ssize_t show_in_min(struct device *dev, char *buf, int nr) { 344 struct via686a_data *data = via686a_update_device(dev); 345 return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr)); 346 } 347 348 static ssize_t show_in_max(struct device *dev, char *buf, int nr) { 349 struct via686a_data *data = via686a_update_device(dev); 350 return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr)); 351 } 352 353 static ssize_t set_in_min(struct device *dev, const char *buf, 354 size_t count, int nr) { 355 struct i2c_client *client = to_i2c_client(dev); 356 struct via686a_data *data = i2c_get_clientdata(client); 357 unsigned long val = simple_strtoul(buf, NULL, 10); 358 359 mutex_lock(&data->update_lock); 360 data->in_min[nr] = IN_TO_REG(val, nr); 361 via686a_write_value(client, VIA686A_REG_IN_MIN(nr), 362 data->in_min[nr]); 363 mutex_unlock(&data->update_lock); 364 return count; 365 } 366 static ssize_t set_in_max(struct device *dev, const char *buf, 367 size_t count, int nr) { 368 struct i2c_client *client = to_i2c_client(dev); 369 struct via686a_data *data = i2c_get_clientdata(client); 370 unsigned long val = simple_strtoul(buf, NULL, 10); 371 372 mutex_lock(&data->update_lock); 373 data->in_max[nr] = IN_TO_REG(val, nr); 374 via686a_write_value(client, VIA686A_REG_IN_MAX(nr), 375 data->in_max[nr]); 376 mutex_unlock(&data->update_lock); 377 return count; 378 } 379 #define show_in_offset(offset) \ 380 static ssize_t \ 381 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 382 { \ 383 return show_in(dev, buf, offset); \ 384 } \ 385 static ssize_t \ 386 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 387 { \ 388 return show_in_min(dev, buf, offset); \ 389 } \ 390 static ssize_t \ 391 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \ 392 { \ 393 return show_in_max(dev, buf, offset); \ 394 } \ 395 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \ 396 const char *buf, size_t count) \ 397 { \ 398 return set_in_min(dev, buf, count, offset); \ 399 } \ 400 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \ 401 const char *buf, size_t count) \ 402 { \ 403 return set_in_max(dev, buf, count, offset); \ 404 } \ 405 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in##offset, NULL);\ 406 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 407 show_in##offset##_min, set_in##offset##_min); \ 408 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 409 show_in##offset##_max, set_in##offset##_max); 410 411 show_in_offset(0); 412 show_in_offset(1); 413 show_in_offset(2); 414 show_in_offset(3); 415 show_in_offset(4); 416 417 /* 3 temperatures */ 418 static ssize_t show_temp(struct device *dev, char *buf, int nr) { 419 struct via686a_data *data = via686a_update_device(dev); 420 return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr])); 421 } 422 static ssize_t show_temp_over(struct device *dev, char *buf, int nr) { 423 struct via686a_data *data = via686a_update_device(dev); 424 return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr])); 425 } 426 static ssize_t show_temp_hyst(struct device *dev, char *buf, int nr) { 427 struct via686a_data *data = via686a_update_device(dev); 428 return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr])); 429 } 430 static ssize_t set_temp_over(struct device *dev, const char *buf, 431 size_t count, int nr) { 432 struct i2c_client *client = to_i2c_client(dev); 433 struct via686a_data *data = i2c_get_clientdata(client); 434 int val = simple_strtol(buf, NULL, 10); 435 436 mutex_lock(&data->update_lock); 437 data->temp_over[nr] = TEMP_TO_REG(val); 438 via686a_write_value(client, VIA686A_REG_TEMP_OVER[nr], 439 data->temp_over[nr]); 440 mutex_unlock(&data->update_lock); 441 return count; 442 } 443 static ssize_t set_temp_hyst(struct device *dev, const char *buf, 444 size_t count, int nr) { 445 struct i2c_client *client = to_i2c_client(dev); 446 struct via686a_data *data = i2c_get_clientdata(client); 447 int val = simple_strtol(buf, NULL, 10); 448 449 mutex_lock(&data->update_lock); 450 data->temp_hyst[nr] = TEMP_TO_REG(val); 451 via686a_write_value(client, VIA686A_REG_TEMP_HYST[nr], 452 data->temp_hyst[nr]); 453 mutex_unlock(&data->update_lock); 454 return count; 455 } 456 #define show_temp_offset(offset) \ 457 static ssize_t show_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 458 { \ 459 return show_temp(dev, buf, offset - 1); \ 460 } \ 461 static ssize_t \ 462 show_temp_##offset##_over (struct device *dev, struct device_attribute *attr, char *buf) \ 463 { \ 464 return show_temp_over(dev, buf, offset - 1); \ 465 } \ 466 static ssize_t \ 467 show_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr, char *buf) \ 468 { \ 469 return show_temp_hyst(dev, buf, offset - 1); \ 470 } \ 471 static ssize_t set_temp_##offset##_over (struct device *dev, struct device_attribute *attr, \ 472 const char *buf, size_t count) \ 473 { \ 474 return set_temp_over(dev, buf, count, offset - 1); \ 475 } \ 476 static ssize_t set_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr, \ 477 const char *buf, size_t count) \ 478 { \ 479 return set_temp_hyst(dev, buf, count, offset - 1); \ 480 } \ 481 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_##offset, NULL);\ 482 static DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 483 show_temp_##offset##_over, set_temp_##offset##_over); \ 484 static DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \ 485 show_temp_##offset##_hyst, set_temp_##offset##_hyst); 486 487 show_temp_offset(1); 488 show_temp_offset(2); 489 show_temp_offset(3); 490 491 /* 2 Fans */ 492 static ssize_t show_fan(struct device *dev, char *buf, int nr) { 493 struct via686a_data *data = via686a_update_device(dev); 494 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 495 DIV_FROM_REG(data->fan_div[nr])) ); 496 } 497 static ssize_t show_fan_min(struct device *dev, char *buf, int nr) { 498 struct via686a_data *data = via686a_update_device(dev); 499 return sprintf(buf, "%d\n", 500 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])) ); 501 } 502 static ssize_t show_fan_div(struct device *dev, char *buf, int nr) { 503 struct via686a_data *data = via686a_update_device(dev); 504 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) ); 505 } 506 static ssize_t set_fan_min(struct device *dev, const char *buf, 507 size_t count, int nr) { 508 struct i2c_client *client = to_i2c_client(dev); 509 struct via686a_data *data = i2c_get_clientdata(client); 510 int val = simple_strtol(buf, NULL, 10); 511 512 mutex_lock(&data->update_lock); 513 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 514 via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]); 515 mutex_unlock(&data->update_lock); 516 return count; 517 } 518 static ssize_t set_fan_div(struct device *dev, const char *buf, 519 size_t count, int nr) { 520 struct i2c_client *client = to_i2c_client(dev); 521 struct via686a_data *data = i2c_get_clientdata(client); 522 int val = simple_strtol(buf, NULL, 10); 523 int old; 524 525 mutex_lock(&data->update_lock); 526 old = via686a_read_value(client, VIA686A_REG_FANDIV); 527 data->fan_div[nr] = DIV_TO_REG(val); 528 old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4); 529 via686a_write_value(client, VIA686A_REG_FANDIV, old); 530 mutex_unlock(&data->update_lock); 531 return count; 532 } 533 534 #define show_fan_offset(offset) \ 535 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \ 536 { \ 537 return show_fan(dev, buf, offset - 1); \ 538 } \ 539 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \ 540 { \ 541 return show_fan_min(dev, buf, offset - 1); \ 542 } \ 543 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \ 544 { \ 545 return show_fan_div(dev, buf, offset - 1); \ 546 } \ 547 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \ 548 const char *buf, size_t count) \ 549 { \ 550 return set_fan_min(dev, buf, count, offset - 1); \ 551 } \ 552 static ssize_t set_fan_##offset##_div (struct device *dev, struct device_attribute *attr, \ 553 const char *buf, size_t count) \ 554 { \ 555 return set_fan_div(dev, buf, count, offset - 1); \ 556 } \ 557 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\ 558 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 559 show_fan_##offset##_min, set_fan_##offset##_min); \ 560 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 561 show_fan_##offset##_div, set_fan_##offset##_div); 562 563 show_fan_offset(1); 564 show_fan_offset(2); 565 566 /* Alarms */ 567 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) { 568 struct via686a_data *data = via686a_update_device(dev); 569 return sprintf(buf, "%u\n", data->alarms); 570 } 571 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 572 573 static struct attribute *via686a_attributes[] = { 574 &dev_attr_in0_input.attr, 575 &dev_attr_in1_input.attr, 576 &dev_attr_in2_input.attr, 577 &dev_attr_in3_input.attr, 578 &dev_attr_in4_input.attr, 579 &dev_attr_in0_min.attr, 580 &dev_attr_in1_min.attr, 581 &dev_attr_in2_min.attr, 582 &dev_attr_in3_min.attr, 583 &dev_attr_in4_min.attr, 584 &dev_attr_in0_max.attr, 585 &dev_attr_in1_max.attr, 586 &dev_attr_in2_max.attr, 587 &dev_attr_in3_max.attr, 588 &dev_attr_in4_max.attr, 589 590 &dev_attr_temp1_input.attr, 591 &dev_attr_temp2_input.attr, 592 &dev_attr_temp3_input.attr, 593 &dev_attr_temp1_max.attr, 594 &dev_attr_temp2_max.attr, 595 &dev_attr_temp3_max.attr, 596 &dev_attr_temp1_max_hyst.attr, 597 &dev_attr_temp2_max_hyst.attr, 598 &dev_attr_temp3_max_hyst.attr, 599 600 &dev_attr_fan1_input.attr, 601 &dev_attr_fan2_input.attr, 602 &dev_attr_fan1_min.attr, 603 &dev_attr_fan2_min.attr, 604 &dev_attr_fan1_div.attr, 605 &dev_attr_fan2_div.attr, 606 607 &dev_attr_alarms.attr, 608 NULL 609 }; 610 611 static const struct attribute_group via686a_group = { 612 .attrs = via686a_attributes, 613 }; 614 615 /* The driver. I choose to use type i2c_driver, as at is identical to both 616 smbus_driver and isa_driver, and clients could be of either kind */ 617 static struct i2c_driver via686a_driver = { 618 .driver = { 619 .owner = THIS_MODULE, 620 .name = "via686a", 621 }, 622 .attach_adapter = via686a_detect, 623 .detach_client = via686a_detach_client, 624 }; 625 626 627 /* This is called when the module is loaded */ 628 static int via686a_detect(struct i2c_adapter *adapter) 629 { 630 struct i2c_client *new_client; 631 struct via686a_data *data; 632 int err = 0; 633 const char client_name[] = "via686a"; 634 u16 val; 635 636 /* 8231 requires multiple of 256, we enforce that on 686 as well */ 637 if (force_addr) { 638 address = force_addr & 0xFF00; 639 dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n", 640 address); 641 if (PCIBIOS_SUCCESSFUL != 642 pci_write_config_word(s_bridge, VIA686A_BASE_REG, address)) 643 return -ENODEV; 644 } 645 if (PCIBIOS_SUCCESSFUL != 646 pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val)) 647 return -ENODEV; 648 if (!(val & 0x0001)) { 649 if (force_addr) { 650 dev_info(&adapter->dev, "enabling sensors\n"); 651 if (PCIBIOS_SUCCESSFUL != 652 pci_write_config_word(s_bridge, VIA686A_ENABLE_REG, 653 val | 0x0001)) 654 return -ENODEV; 655 } else { 656 dev_warn(&adapter->dev, "sensors disabled - enable " 657 "with force_addr=0x%x\n", address); 658 return -ENODEV; 659 } 660 } 661 662 /* Reserve the ISA region */ 663 if (!request_region(address, VIA686A_EXTENT, 664 via686a_driver.driver.name)) { 665 dev_err(&adapter->dev, "region 0x%x already in use!\n", 666 address); 667 return -ENODEV; 668 } 669 670 if (!(data = kzalloc(sizeof(struct via686a_data), GFP_KERNEL))) { 671 err = -ENOMEM; 672 goto exit_release; 673 } 674 675 new_client = &data->client; 676 i2c_set_clientdata(new_client, data); 677 new_client->addr = address; 678 new_client->adapter = adapter; 679 new_client->driver = &via686a_driver; 680 new_client->flags = 0; 681 682 /* Fill in the remaining client fields and put into the global list */ 683 strlcpy(new_client->name, client_name, I2C_NAME_SIZE); 684 685 data->valid = 0; 686 mutex_init(&data->update_lock); 687 /* Tell the I2C layer a new client has arrived */ 688 if ((err = i2c_attach_client(new_client))) 689 goto exit_free; 690 691 /* Initialize the VIA686A chip */ 692 via686a_init_client(new_client); 693 694 /* Register sysfs hooks */ 695 if ((err = sysfs_create_group(&new_client->dev.kobj, &via686a_group))) 696 goto exit_detach; 697 698 data->class_dev = hwmon_device_register(&new_client->dev); 699 if (IS_ERR(data->class_dev)) { 700 err = PTR_ERR(data->class_dev); 701 goto exit_remove_files; 702 } 703 704 return 0; 705 706 exit_remove_files: 707 sysfs_remove_group(&new_client->dev.kobj, &via686a_group); 708 exit_detach: 709 i2c_detach_client(new_client); 710 exit_free: 711 kfree(data); 712 exit_release: 713 release_region(address, VIA686A_EXTENT); 714 return err; 715 } 716 717 static int via686a_detach_client(struct i2c_client *client) 718 { 719 struct via686a_data *data = i2c_get_clientdata(client); 720 int err; 721 722 hwmon_device_unregister(data->class_dev); 723 sysfs_remove_group(&client->dev.kobj, &via686a_group); 724 725 if ((err = i2c_detach_client(client))) 726 return err; 727 728 release_region(client->addr, VIA686A_EXTENT); 729 kfree(data); 730 731 return 0; 732 } 733 734 static void via686a_init_client(struct i2c_client *client) 735 { 736 u8 reg; 737 738 /* Start monitoring */ 739 reg = via686a_read_value(client, VIA686A_REG_CONFIG); 740 via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F); 741 742 /* Configure temp interrupt mode for continuous-interrupt operation */ 743 via686a_write_value(client, VIA686A_REG_TEMP_MODE, 744 via686a_read_value(client, VIA686A_REG_TEMP_MODE) & 745 !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS)); 746 } 747 748 static struct via686a_data *via686a_update_device(struct device *dev) 749 { 750 struct i2c_client *client = to_i2c_client(dev); 751 struct via686a_data *data = i2c_get_clientdata(client); 752 int i; 753 754 mutex_lock(&data->update_lock); 755 756 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 757 || !data->valid) { 758 for (i = 0; i <= 4; i++) { 759 data->in[i] = 760 via686a_read_value(client, VIA686A_REG_IN(i)); 761 data->in_min[i] = via686a_read_value(client, 762 VIA686A_REG_IN_MIN 763 (i)); 764 data->in_max[i] = 765 via686a_read_value(client, VIA686A_REG_IN_MAX(i)); 766 } 767 for (i = 1; i <= 2; i++) { 768 data->fan[i - 1] = 769 via686a_read_value(client, VIA686A_REG_FAN(i)); 770 data->fan_min[i - 1] = via686a_read_value(client, 771 VIA686A_REG_FAN_MIN(i)); 772 } 773 for (i = 0; i <= 2; i++) { 774 data->temp[i] = via686a_read_value(client, 775 VIA686A_REG_TEMP[i]) << 2; 776 data->temp_over[i] = 777 via686a_read_value(client, 778 VIA686A_REG_TEMP_OVER[i]); 779 data->temp_hyst[i] = 780 via686a_read_value(client, 781 VIA686A_REG_TEMP_HYST[i]); 782 } 783 /* add in lower 2 bits 784 temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1 785 temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23 786 temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23 787 */ 788 data->temp[0] |= (via686a_read_value(client, 789 VIA686A_REG_TEMP_LOW1) 790 & 0xc0) >> 6; 791 data->temp[1] |= 792 (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) & 793 0x30) >> 4; 794 data->temp[2] |= 795 (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) & 796 0xc0) >> 6; 797 798 i = via686a_read_value(client, VIA686A_REG_FANDIV); 799 data->fan_div[0] = (i >> 4) & 0x03; 800 data->fan_div[1] = i >> 6; 801 data->alarms = 802 via686a_read_value(client, 803 VIA686A_REG_ALARM1) | 804 (via686a_read_value(client, VIA686A_REG_ALARM2) << 8); 805 data->last_updated = jiffies; 806 data->valid = 1; 807 } 808 809 mutex_unlock(&data->update_lock); 810 811 return data; 812 } 813 814 static struct pci_device_id via686a_pci_ids[] = { 815 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) }, 816 { 0, } 817 }; 818 819 MODULE_DEVICE_TABLE(pci, via686a_pci_ids); 820 821 static int __devinit via686a_pci_probe(struct pci_dev *dev, 822 const struct pci_device_id *id) 823 { 824 u16 val; 825 826 if (PCIBIOS_SUCCESSFUL != 827 pci_read_config_word(dev, VIA686A_BASE_REG, &val)) 828 return -ENODEV; 829 830 address = val & ~(VIA686A_EXTENT - 1); 831 if (address == 0 && force_addr == 0) { 832 dev_err(&dev->dev, "base address not set - upgrade BIOS " 833 "or use force_addr=0xaddr\n"); 834 return -ENODEV; 835 } 836 837 s_bridge = pci_dev_get(dev); 838 if (i2c_isa_add_driver(&via686a_driver)) { 839 pci_dev_put(s_bridge); 840 s_bridge = NULL; 841 } 842 843 /* Always return failure here. This is to allow other drivers to bind 844 * to this pci device. We don't really want to have control over the 845 * pci device, we only wanted to read as few register values from it. 846 */ 847 return -ENODEV; 848 } 849 850 static struct pci_driver via686a_pci_driver = { 851 .name = "via686a", 852 .id_table = via686a_pci_ids, 853 .probe = via686a_pci_probe, 854 }; 855 856 static int __init sm_via686a_init(void) 857 { 858 return pci_register_driver(&via686a_pci_driver); 859 } 860 861 static void __exit sm_via686a_exit(void) 862 { 863 pci_unregister_driver(&via686a_pci_driver); 864 if (s_bridge != NULL) { 865 i2c_isa_del_driver(&via686a_driver); 866 pci_dev_put(s_bridge); 867 s_bridge = NULL; 868 } 869 } 870 871 MODULE_AUTHOR("Ky�sti M�lkki <kmalkki@cc.hut.fi>, " 872 "Mark Studebaker <mdsxyz123@yahoo.com> " 873 "and Bob Dougherty <bobd@stanford.edu>"); 874 MODULE_DESCRIPTION("VIA 686A Sensor device"); 875 MODULE_LICENSE("GPL"); 876 877 module_init(sm_via686a_init); 878 module_exit(sm_via686a_exit); 879