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