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