drivers/i2c/chips/via686a.c

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