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 /* bits 7-6 */
  91 #define VIA686A_REG_TEMP_LOW1   0x4b
  92 /* 2 = bits 5-4, 3 = bits 7-6 */
  93 #define VIA686A_REG_TEMP_LOW23  0x49
  94
  95 #define VIA686A_REG_ALARM1      0x41
  96 #define VIA686A_REG_ALARM2      0x42
  97 #define VIA686A_REG_FANDIV      0x47
  98 #define VIA686A_REG_CONFIG      0x40
  99 /* The following register sets temp interrupt mode (bits 1-0 for temp1,
 100  3-2 for temp2, 5-4 for temp3).  Modes are:
 101     00 interrupt stays as long as value is out-of-range
 102     01 interrupt is cleared once register is read (default)
 103     10 comparator mode- like 00, but ignores hysteresis
 104     11 same as 00 */
 105 #define VIA686A_REG_TEMP_MODE           0x4b
 106 /* We'll just assume that you want to set all 3 simultaneously: */
 107 #define VIA686A_TEMP_MODE_MASK          0x3F
 108 #define VIA686A_TEMP_MODE_CONTINUOUS    0x00
 109
 110 /* Conversions. Limit checking is only done on the TO_REG
 111    variants.
 112
 113 ********* VOLTAGE CONVERSIONS (Bob Dougherty) ********
 114  From HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew):
 115  voltagefactor[0]=1.25/2628; (2628/1.25=2102.4)   // Vccp
 116  voltagefactor[1]=1.25/2628; (2628/1.25=2102.4)   // +2.5V
 117  voltagefactor[2]=1.67/2628; (2628/1.67=1573.7)   // +3.3V
 118  voltagefactor[3]=2.6/2628;  (2628/2.60=1010.8)   // +5V
 119  voltagefactor[4]=6.3/2628;  (2628/6.30=417.14)   // +12V
 120  in[i]=(data[i+2]*25.0+133)*voltagefactor[i];
 121  That is:
 122  volts = (25*regVal+133)*factor
 123  regVal = (volts/factor-133)/25
 124  (These conversions were contributed by Jonathan Teh Soon Yew
 125  <j.teh@iname.com>) */
 126 static inline u8 IN_TO_REG(long val, int inNum)
 127 {
 128         /* To avoid floating point, we multiply constants by 10 (100 for +12V).
 129            Rounding is done (120500 is actually 133000 - 12500).
 130            Remember that val is expressed in 0.001V/bit, which is why we divide
 131            by an additional 10000 (100000 for +12V): 1000 for val and 10 (100)
 132            for the constants. */
 133         if (inNum <= 1)
 134                 return (u8)
 135                     SENSORS_LIMIT((val * 21024 - 1205000) / 250000, 0, 255);
 136         else if (inNum == 2)
 137                 return (u8)
 138                     SENSORS_LIMIT((val * 15737 - 1205000) / 250000, 0, 255);
 139         else if (inNum == 3)
 140                 return (u8)
 141                     SENSORS_LIMIT((val * 10108 - 1205000) / 250000, 0, 255);
 142         else
 143                 return (u8)
 144                     SENSORS_LIMIT((val * 41714 - 12050000) / 2500000, 0, 255);
 145 }
 146
 147 static inline long IN_FROM_REG(u8 val, int inNum)
 148 {
 149         /* To avoid floating point, we multiply constants by 10 (100 for +12V).
 150            We also multiply them by 1000 because we want 0.001V/bit for the
 151            output value. Rounding is done. */
 152         if (inNum <= 1)
 153                 return (long) ((250000 * val + 1330000 + 21024 / 2) / 21024);
 154         else if (inNum == 2)
 155                 return (long) ((250000 * val + 1330000 + 15737 / 2) / 15737);
 156         else if (inNum == 3)
 157                 return (long) ((250000 * val + 1330000 + 10108 / 2) / 10108);
 158         else
 159                 return (long) ((2500000 * val + 13300000 + 41714 / 2) / 41714);
 160 }
 161
 162 /********* FAN RPM CONVERSIONS ********/
 163 /* Higher register values = slower fans (the fan's strobe gates a counter).
 164  But this chip saturates back at 0, not at 255 like all the other chips.
 165  So, 0 means 0 RPM */
 166 static inline u8 FAN_TO_REG(long rpm, int div)
 167 {
 168         if (rpm == 0)
 169                 return 0;
 170         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 171         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 255);
 172 }
 173
 174 #define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1350000/((val)*(div)))
 175
 176 /******** TEMP CONVERSIONS (Bob Dougherty) *********/
 177 /* linear fits from HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew)
 178       if(temp<169)
 179               return double(temp)*0.427-32.08;
 180       else if(temp>=169 && temp<=202)
 181               return double(temp)*0.582-58.16;
 182       else
 183               return double(temp)*0.924-127.33;
 184
 185  A fifth-order polynomial fits the unofficial data (provided by Alex van
 186  Kaam <darkside@chello.nl>) a bit better.  It also give more reasonable
 187  numbers on my machine (ie. they agree with what my BIOS tells me).
 188  Here's the fifth-order fit to the 8-bit data:
 189  temp = 1.625093e-10*val^5 - 1.001632e-07*val^4 + 2.457653e-05*val^3 -
 190         2.967619e-03*val^2 + 2.175144e-01*val - 7.090067e+0.
 191
 192  (2000-10-25- RFD: thanks to Uwe Andersen <uandersen@mayah.com> for
 193  finding my typos in this formula!)
 194
 195  Alas, none of the elegant function-fit solutions will work because we
 196  aren't allowed to use floating point in the kernel and doing it with
 197  integers doesn't provide enough precision.  So we'll do boring old
 198  look-up table stuff.  The unofficial data (see below) have effectively
 199  7-bit resolution (they are rounded to the nearest degree).  I'm assuming
 200  that the transfer function of the device is monotonic and smooth, so a
 201  smooth function fit to the data will allow us to get better precision.
 202  I used the 5th-order poly fit described above and solved for
 203  VIA register values 0-255.  I *10 before rounding, so we get tenth-degree
 204  precision.  (I could have done all 1024 values for our 10-bit readings,
 205  but the function is very linear in the useful range (0-80 deg C), so
 206  we'll just use linear interpolation for 10-bit readings.)  So, tempLUT
 207  is the temp at via register values 0-255: */
 208 static const long tempLUT[] =
 209 { -709, -688, -667, -646, -627, -607, -589, -570, -553, -536, -519,
 210         -503, -487, -471, -456, -442, -428, -414, -400, -387, -375,
 211         -362, -350, -339, -327, -316, -305, -295, -285, -275, -265,
 212         -255, -246, -237, -229, -220, -212, -204, -196, -188, -180,
 213         -173, -166, -159, -152, -145, -139, -132, -126, -120, -114,
 214         -108, -102, -96, -91, -85, -80, -74, -69, -64, -59, -54, -49,
 215         -44, -39, -34, -29, -25, -20, -15, -11, -6, -2, 3, 7, 12, 16,
 216         20, 25, 29, 33, 37, 42, 46, 50, 54, 59, 63, 67, 71, 75, 79, 84,
 217         88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138,
 218         142, 146, 151, 155, 159, 163, 168, 172, 176, 181, 185, 189,
 219         193, 198, 202, 206, 211, 215, 219, 224, 228, 232, 237, 241,
 220         245, 250, 254, 259, 263, 267, 272, 276, 281, 285, 290, 294,
 221         299, 303, 307, 312, 316, 321, 325, 330, 334, 339, 344, 348,
 222         353, 357, 362, 366, 371, 376, 380, 385, 390, 395, 399, 404,
 223         409, 414, 419, 423, 428, 433, 438, 443, 449, 454, 459, 464,
 224         469, 475, 480, 486, 491, 497, 502, 508, 514, 520, 526, 532,
 225         538, 544, 551, 557, 564, 571, 578, 584, 592, 599, 606, 614,
 226         621, 629, 637, 645, 654, 662, 671, 680, 689, 698, 708, 718,
 227         728, 738, 749, 759, 770, 782, 793, 805, 818, 830, 843, 856,
 228         870, 883, 898, 912, 927, 943, 958, 975, 991, 1008, 1026, 1044,
 229         1062, 1081, 1101, 1121, 1141, 1162, 1184, 1206, 1229, 1252,
 230         1276, 1301, 1326, 1352, 1378, 1406, 1434, 1462
 231 };
 232
 233 /* the original LUT values from Alex van Kaam <darkside@chello.nl>
 234    (for via register values 12-240):
 235 {-50,-49,-47,-45,-43,-41,-39,-38,-37,-35,-34,-33,-32,-31,
 236 -30,-29,-28,-27,-26,-25,-24,-24,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15,
 237 -15,-14,-14,-13,-12,-12,-11,-11,-10,-9,-9,-8,-8,-7,-7,-6,-6,-5,-5,-4,-4,-3,
 238 -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,
 239 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,
 240 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,
 241 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,
 242 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,
 243 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,
 244 85,86,88,89,91,92,94,96,97,99,101,103,105,107,109,110};
 245
 246
 247  Here's the reverse LUT.  I got it by doing a 6-th order poly fit (needed
 248  an extra term for a good fit to these inverse data!) and then
 249  solving for each temp value from -50 to 110 (the useable range for
 250  this chip).  Here's the fit:
 251  viaRegVal = -1.160370e-10*val^6 +3.193693e-08*val^5 - 1.464447e-06*val^4
 252  - 2.525453e-04*val^3 + 1.424593e-02*val^2 + 2.148941e+00*val +7.275808e+01)
 253  Note that n=161: */
 254 static const u8 viaLUT[] =
 255 { 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22, 23,
 256         23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 39, 40,
 257         41, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 62, 64, 66,
 258         69, 71, 73, 75, 77, 79, 82, 84, 86, 88, 91, 93, 95, 98, 100,
 259         103, 105, 107, 110, 112, 115, 117, 119, 122, 124, 126, 129,
 260         131, 134, 136, 138, 140, 143, 145, 147, 150, 152, 154, 156,
 261         158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180,
 262         182, 183, 185, 187, 188, 190, 192, 193, 195, 196, 198, 199,
 263         200, 202, 203, 205, 206, 207, 208, 209, 210, 211, 212, 213,
 264         214, 215, 216, 217, 218, 219, 220, 221, 222, 222, 223, 224,
 265         225, 226, 226, 227, 228, 228, 229, 230, 230, 231, 232, 232,
 266         233, 233, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239,
 267         239, 240
 268 };
 269
 270 /* Converting temps to (8-bit) hyst and over registers
 271    No interpolation here.
 272    The +50 is because the temps start at -50 */
 273 static inline u8 TEMP_TO_REG(long val)
 274 {
 275         return viaLUT[val <= -50000 ? 0 : val >= 110000 ? 160 :
 276                       (val < 0 ? val - 500 : val + 500) / 1000 + 50];
 277 }
 278
 279 /* for 8-bit temperature hyst and over registers */
 280 #define TEMP_FROM_REG(val) (tempLUT[(val)] * 100)
 281
 282 /* for 10-bit temperature readings */
 283 static inline long TEMP_FROM_REG10(u16 val)
 284 {
 285         u16 eightBits = val >> 2;
 286         u16 twoBits = val & 3;
 287
 288         /* no interpolation for these */
 289         if (twoBits == 0 || eightBits == 255)
 290                 return TEMP_FROM_REG(eightBits);
 291
 292         /* do some linear interpolation */
 293         return (tempLUT[eightBits] * (4 - twoBits) +
 294                 tempLUT[eightBits + 1] * twoBits) * 25;
 295 }
 296
 297 #define DIV_FROM_REG(val) (1 << (val))
 298 #define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
 299
 300 /* For the VIA686A, we need to keep some data in memory.
 301    The structure is dynamically allocated, at the same time when a new
 302    via686a client is allocated. */
 303 struct via686a_data {
 304         struct i2c_client client;
 305         struct semaphore update_lock;
 306         char valid;             /* !=0 if following fields are valid */
 307         unsigned long last_updated;     /* In jiffies */
 308
 309         u8 in[5];               /* Register value */
 310         u8 in_max[5];           /* Register value */
 311         u8 in_min[5];           /* Register value */
 312         u8 fan[2];              /* Register value */
 313         u8 fan_min[2];          /* Register value */
 314         u16 temp[3];            /* Register value 10 bit */
 315         u8 temp_over[3];        /* Register value */
 316         u8 temp_hyst[3];        /* Register value */
 317         u8 fan_div[2];          /* Register encoding, shifted right */
 318         u16 alarms;             /* Register encoding, combined */
 319 };
 320
 321 static struct pci_dev *s_bridge;        /* pointer to the (only) via686a */
 322
 323 static int via686a_attach_adapter(struct i2c_adapter *adapter);
 324 static int via686a_detect(struct i2c_adapter *adapter, int address, int kind);
 325 static int via686a_detach_client(struct i2c_client *client);
 326
 327 static inline int via686a_read_value(struct i2c_client *client, u8 reg)
 328 {
 329         return (inb_p(client->addr + reg));
 330 }
 331
 332 static inline void via686a_write_value(struct i2c_client *client, u8 reg,
 333                                        u8 value)
 334 {
 335         outb_p(value, client->addr + reg);
 336 }
 337
 338 static struct via686a_data *via686a_update_device(struct device *dev);
 339 static void via686a_init_client(struct i2c_client *client);
 340
 341 /* following are the sysfs callback functions */
 342
 343 /* 7 voltage sensors */
 344 static ssize_t show_in(struct device *dev, char *buf, int nr) {
 345         struct via686a_data *data = via686a_update_device(dev);
 346         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr));
 347 }
 348
 349 static ssize_t show_in_min(struct device *dev, char *buf, int nr) {
 350         struct via686a_data *data = via686a_update_device(dev);
 351         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr));
 352 }
 353
 354 static ssize_t show_in_max(struct device *dev, char *buf, int nr) {
 355         struct via686a_data *data = via686a_update_device(dev);
 356         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr));
 357 }
 358
 359 static ssize_t set_in_min(struct device *dev, const char *buf,
 360                 size_t count, int nr) {
 361         struct i2c_client *client = to_i2c_client(dev);
 362         struct via686a_data *data = i2c_get_clientdata(client);
 363         unsigned long val = simple_strtoul(buf, NULL, 10);
 364
 365         down(&data->update_lock);
 366         data->in_min[nr] = IN_TO_REG(val, nr);
 367         via686a_write_value(client, VIA686A_REG_IN_MIN(nr),
 368                         data->in_min[nr]);
 369         up(&data->update_lock);
 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
 378         down(&data->update_lock);
 379         data->in_max[nr] = IN_TO_REG(val, nr);
 380         via686a_write_value(client, VIA686A_REG_IN_MAX(nr),
 381                         data->in_max[nr]);
 382         up(&data->update_lock);
 383         return count;
 384 }
 385 #define show_in_offset(offset)                                  \
 386 static ssize_t                                                  \
 387         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
 388 {                                                               \
 389         return show_in(dev, buf, offset);                       \
 390 }                                                               \
 391 static ssize_t                                                  \
 392         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)    \
 393 {                                                               \
 394         return show_in_min(dev, buf, offset);           \
 395 }                                                               \
 396 static ssize_t                                                  \
 397         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)    \
 398 {                                                               \
 399         return show_in_max(dev, buf, offset);           \
 400 }                                                               \
 401 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr,         \
 402                 const char *buf, size_t count)                  \
 403 {                                                               \
 404         return set_in_min(dev, buf, count, offset);             \
 405 }                                                               \
 406 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
 407                         const char *buf, size_t count)          \
 408 {                                                               \
 409         return set_in_max(dev, buf, count, offset);             \
 410 }                                                               \
 411 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in##offset, NULL);\
 412 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
 413                 show_in##offset##_min, set_in##offset##_min);   \
 414 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
 415                 show_in##offset##_max, set_in##offset##_max);
 416
 417 show_in_offset(0);
 418 show_in_offset(1);
 419 show_in_offset(2);
 420 show_in_offset(3);
 421 show_in_offset(4);
 422
 423 /* 3 temperatures */
 424 static ssize_t show_temp(struct device *dev, char *buf, int nr) {
 425         struct via686a_data *data = via686a_update_device(dev);
 426         return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr]));
 427 }
 428 static ssize_t show_temp_over(struct device *dev, char *buf, int nr) {
 429         struct via686a_data *data = via686a_update_device(dev);
 430         return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr]));
 431 }
 432 static ssize_t show_temp_hyst(struct device *dev, char *buf, int nr) {
 433         struct via686a_data *data = via686a_update_device(dev);
 434         return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr]));
 435 }
 436 static ssize_t set_temp_over(struct device *dev, const char *buf,
 437                 size_t count, int nr) {
 438         struct i2c_client *client = to_i2c_client(dev);
 439         struct via686a_data *data = i2c_get_clientdata(client);
 440         int val = simple_strtol(buf, NULL, 10);
 441
 442         down(&data->update_lock);
 443         data->temp_over[nr] = TEMP_TO_REG(val);
 444         via686a_write_value(client, VIA686A_REG_TEMP_OVER(nr), data->temp_over[nr]);
 445         up(&data->update_lock);
 446         return count;
 447 }
 448 static ssize_t set_temp_hyst(struct device *dev, const char *buf,
 449                 size_t count, int nr) {
 450         struct i2c_client *client = to_i2c_client(dev);
 451         struct via686a_data *data = i2c_get_clientdata(client);
 452         int val = simple_strtol(buf, NULL, 10);
 453
 454         down(&data->update_lock);
 455         data->temp_hyst[nr] = TEMP_TO_REG(val);
 456         via686a_write_value(client, VIA686A_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
 457         up(&data->update_lock);
 458         return count;
 459 }
 460 #define show_temp_offset(offset)                                        \
 461 static ssize_t show_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf)        \
 462 {                                                                       \
 463         return show_temp(dev, buf, offset - 1);                         \
 464 }                                                                       \
 465 static ssize_t                                                          \
 466 show_temp_##offset##_over (struct device *dev, struct device_attribute *attr, char *buf)                \
 467 {                                                                       \
 468         return show_temp_over(dev, buf, offset - 1);                    \
 469 }                                                                       \
 470 static ssize_t                                                          \
 471 show_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr, char *buf)                \
 472 {                                                                       \
 473         return show_temp_hyst(dev, buf, offset - 1);                    \
 474 }                                                                       \
 475 static ssize_t set_temp_##offset##_over (struct device *dev, struct device_attribute *attr,             \
 476                 const char *buf, size_t count)                          \
 477 {                                                                       \
 478         return set_temp_over(dev, buf, count, offset - 1);              \
 479 }                                                                       \
 480 static ssize_t set_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr,             \
 481                 const char *buf, size_t count)                          \
 482 {                                                                       \
 483         return set_temp_hyst(dev, buf, count, offset - 1);              \
 484 }                                                                       \
 485 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_##offset, NULL);\
 486 static DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,               \
 487                 show_temp_##offset##_over, set_temp_##offset##_over);   \
 488 static DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,          \
 489                 show_temp_##offset##_hyst, set_temp_##offset##_hyst);
 490
 491 show_temp_offset(1);
 492 show_temp_offset(2);
 493 show_temp_offset(3);
 494
 495 /* 2 Fans */
 496 static ssize_t show_fan(struct device *dev, char *buf, int nr) {
 497         struct via686a_data *data = via686a_update_device(dev);
 498         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 499                                 DIV_FROM_REG(data->fan_div[nr])) );
 500 }
 501 static ssize_t show_fan_min(struct device *dev, char *buf, int nr) {
 502         struct via686a_data *data = via686a_update_device(dev);
 503         return sprintf(buf, "%d\n",
 504                 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])) );
 505 }
 506 static ssize_t show_fan_div(struct device *dev, char *buf, int nr) {
 507         struct via686a_data *data = via686a_update_device(dev);
 508         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
 509 }
 510 static ssize_t set_fan_min(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
 516         down(&data->update_lock);
 517         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 518         via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
 519         up(&data->update_lock);
 520         return count;
 521 }
 522 static ssize_t set_fan_div(struct device *dev, const char *buf,
 523                 size_t count, int nr) {
 524         struct i2c_client *client = to_i2c_client(dev);
 525         struct via686a_data *data = i2c_get_clientdata(client);
 526         int val = simple_strtol(buf, NULL, 10);
 527         int old;
 528
 529         down(&data->update_lock);
 530         old = via686a_read_value(client, VIA686A_REG_FANDIV);
 531         data->fan_div[nr] = DIV_TO_REG(val);
 532         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
 533         via686a_write_value(client, VIA686A_REG_FANDIV, old);
 534         up(&data->update_lock);
 535         return count;
 536 }
 537
 538 #define show_fan_offset(offset)                                         \
 539 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 540 {                                                                       \
 541         return show_fan(dev, buf, offset - 1);                          \
 542 }                                                                       \
 543 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
 544 {                                                                       \
 545         return show_fan_min(dev, buf, offset - 1);                      \
 546 }                                                                       \
 547 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)   \
 548 {                                                                       \
 549         return show_fan_div(dev, buf, offset - 1);                      \
 550 }                                                                       \
 551 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
 552         const char *buf, size_t count)                                  \
 553 {                                                                       \
 554         return set_fan_min(dev, buf, count, offset - 1);                \
 555 }                                                                       \
 556 static ssize_t set_fan_##offset##_div (struct device *dev, struct device_attribute *attr,               \
 557                 const char *buf, size_t count)                          \
 558 {                                                                       \
 559         return set_fan_div(dev, buf, count, offset - 1);                \
 560 }                                                                       \
 561 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
 562 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
 563                 show_fan_##offset##_min, set_fan_##offset##_min);       \
 564 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,                \
 565                 show_fan_##offset##_div, set_fan_##offset##_div);
 566
 567 show_fan_offset(1);
 568 show_fan_offset(2);
 569
 570 /* Alarms */
 571 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) {
 572         struct via686a_data *data = via686a_update_device(dev);
 573         return sprintf(buf, "%u\n", data->alarms);
 574 }
 575 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 576
 577 /* The driver. I choose to use type i2c_driver, as at is identical to both
 578    smbus_driver and isa_driver, and clients could be of either kind */
 579 static struct i2c_driver via686a_driver = {
 580         .owner          = THIS_MODULE,
 581         .name           = "via686a",
 582         .id             = I2C_DRIVERID_VIA686A,
 583         .flags          = I2C_DF_NOTIFY,
 584         .attach_adapter = via686a_attach_adapter,
 585         .detach_client  = via686a_detach_client,
 586 };
 587
 588
 589 /* This is called when the module is loaded */
 590 static int via686a_attach_adapter(struct i2c_adapter *adapter)
 591 {
 592         if (!(adapter->class & I2C_CLASS_HWMON))
 593                 return 0;
 594         return i2c_detect(adapter, &addr_data, via686a_detect);
 595 }
 596
 597 static int via686a_detect(struct i2c_adapter *adapter, int address, int kind)
 598 {
 599         struct i2c_client *new_client;
 600         struct via686a_data *data;
 601         int err = 0;
 602         const char client_name[] = "via686a";
 603         u16 val;
 604
 605         /* Make sure we are probing the ISA bus!!  */
 606         if (!i2c_is_isa_adapter(adapter)) {
 607                 dev_err(&adapter->dev,
 608                 "via686a_detect called for an I2C bus adapter?!?\n");
 609                 return 0;
 610         }
 611
 612         /* 8231 requires multiple of 256, we enforce that on 686 as well */
 613         if (force_addr)
 614                 address = force_addr & 0xFF00;
 615
 616         if (force_addr) {
 617                 dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n",
 618                          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 "
 825                         "or use force_addr=0xaddr\n");
 826                 return -ENODEV;
 827         }
 828         if (force_addr)
 829                 addr = force_addr;      /* so detect will get called */
 830
 831         if (!addr) {
 832                 dev_err(&dev->dev, "No Via 686A sensors found.\n");
 833                 return -ENODEV;
 834         }
 835         normal_isa[0] = addr;
 836
 837         s_bridge = pci_dev_get(dev);
 838         if (i2c_add_driver(&via686a_driver)) {
 839                 pci_dev_put(s_bridge);
 840                 s_bridge = NULL;
 841         }
 842
 843         /* Always return failure here.  This is to allow other drivers to bind
 844          * to this pci device.  We don't really want to have control over the
 845          * pci device, we only wanted to read as few register values from it.
 846          */
 847         return -ENODEV;
 848 }
 849
 850 static struct pci_driver via686a_pci_driver = {
 851         .name           = "via686a",
 852         .id_table       = via686a_pci_ids,
 853         .probe          = via686a_pci_probe,
 854 };
 855
 856 static int __init sm_via686a_init(void)
 857 {
 858         return pci_register_driver(&via686a_pci_driver);
 859 }
 860
 861 static void __exit sm_via686a_exit(void)
 862 {
 863         pci_unregister_driver(&via686a_pci_driver);
 864         if (s_bridge != NULL) {
 865                 i2c_del_driver(&via686a_driver);
 866                 pci_dev_put(s_bridge);
 867                 s_bridge = NULL;
 868         }
 869 }
 870
 871 MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
 872               "Mark Studebaker <mdsxyz123@yahoo.com> "
 873               "and Bob Dougherty <bobd@stanford.edu>");
 874 MODULE_DESCRIPTION("VIA 686A Sensor device");
 875 MODULE_LICENSE("GPL");
 876
 877 module_init(sm_via686a_init);
 878 module_exit(sm_via686a_exit);