drivers/hwmon/via686a.c

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