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