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 | S_IWUSR, 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         new_client->dev.parent = &adapter->dev;
 655
 656         /* Fill in the remaining client fields and put into the global list */
 657         snprintf(new_client->name, I2C_NAME_SIZE, client_name);
 658
 659         data->valid = 0;
 660         init_MUTEX(&data->update_lock);
 661         /* Tell the I2C layer a new client has arrived */
 662         if ((err = i2c_attach_client(new_client)))
 663                 goto ERROR3;
 664
 665         /* Initialize the VIA686A chip */
 666         via686a_init_client(new_client);
 667
 668         /* Register sysfs hooks */
 669         device_create_file(&new_client->dev, &dev_attr_in0_input);
 670         device_create_file(&new_client->dev, &dev_attr_in1_input);
 671         device_create_file(&new_client->dev, &dev_attr_in2_input);
 672         device_create_file(&new_client->dev, &dev_attr_in3_input);
 673         device_create_file(&new_client->dev, &dev_attr_in4_input);
 674         device_create_file(&new_client->dev, &dev_attr_in0_min);
 675         device_create_file(&new_client->dev, &dev_attr_in1_min);
 676         device_create_file(&new_client->dev, &dev_attr_in2_min);
 677         device_create_file(&new_client->dev, &dev_attr_in3_min);
 678         device_create_file(&new_client->dev, &dev_attr_in4_min);
 679         device_create_file(&new_client->dev, &dev_attr_in0_max);
 680         device_create_file(&new_client->dev, &dev_attr_in1_max);
 681         device_create_file(&new_client->dev, &dev_attr_in2_max);
 682         device_create_file(&new_client->dev, &dev_attr_in3_max);
 683         device_create_file(&new_client->dev, &dev_attr_in4_max);
 684         device_create_file(&new_client->dev, &dev_attr_temp1_input);
 685         device_create_file(&new_client->dev, &dev_attr_temp2_input);
 686         device_create_file(&new_client->dev, &dev_attr_temp3_input);
 687         device_create_file(&new_client->dev, &dev_attr_temp1_max);
 688         device_create_file(&new_client->dev, &dev_attr_temp2_max);
 689         device_create_file(&new_client->dev, &dev_attr_temp3_max);
 690         device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
 691         device_create_file(&new_client->dev, &dev_attr_temp2_max_hyst);
 692         device_create_file(&new_client->dev, &dev_attr_temp3_max_hyst);
 693         device_create_file(&new_client->dev, &dev_attr_fan1_input);
 694         device_create_file(&new_client->dev, &dev_attr_fan2_input);
 695         device_create_file(&new_client->dev, &dev_attr_fan1_min);
 696         device_create_file(&new_client->dev, &dev_attr_fan2_min);
 697         device_create_file(&new_client->dev, &dev_attr_fan1_div);
 698         device_create_file(&new_client->dev, &dev_attr_fan2_div);
 699         device_create_file(&new_client->dev, &dev_attr_alarms);
 700
 701         return 0;
 702
 703       ERROR3:
 704         kfree(data);
 705       ERROR0:
 706         release_region(address, VIA686A_EXTENT);
 707         return err;
 708 }
 709
 710 static int via686a_detach_client(struct i2c_client *client)
 711 {
 712         int err;
 713
 714         if ((err = i2c_detach_client(client))) {
 715                 dev_err(&client->dev,
 716                 "Client deregistration failed, client not detached.\n");
 717                 return err;
 718         }
 719
 720         release_region(client->addr, VIA686A_EXTENT);
 721         kfree(i2c_get_clientdata(client));
 722
 723         return 0;
 724 }
 725
 726 /* Called when we have found a new VIA686A. Set limits, etc. */
 727 static void via686a_init_client(struct i2c_client *client)
 728 {
 729         u8 reg;
 730
 731         /* Start monitoring */
 732         reg = via686a_read_value(client, VIA686A_REG_CONFIG);
 733         via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F);
 734
 735         /* Configure temp interrupt mode for continuous-interrupt operation */
 736         via686a_write_value(client, VIA686A_REG_TEMP_MODE,
 737                             via686a_read_value(client, VIA686A_REG_TEMP_MODE) &
 738                             !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS));
 739 }
 740
 741 static struct via686a_data *via686a_update_device(struct device *dev)
 742 {
 743         struct i2c_client *client = to_i2c_client(dev);
 744         struct via686a_data *data = i2c_get_clientdata(client);
 745         int i;
 746
 747         down(&data->update_lock);
 748
 749         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 750             || !data->valid) {
 751                 for (i = 0; i <= 4; i++) {
 752                         data->in[i] =
 753                             via686a_read_value(client, VIA686A_REG_IN(i));
 754                         data->in_min[i] = via686a_read_value(client,
 755                                                              VIA686A_REG_IN_MIN
 756                                                              (i));
 757                         data->in_max[i] =
 758                             via686a_read_value(client, VIA686A_REG_IN_MAX(i));
 759                 }
 760                 for (i = 1; i <= 2; i++) {
 761                         data->fan[i - 1] =
 762                             via686a_read_value(client, VIA686A_REG_FAN(i));
 763                         data->fan_min[i - 1] = via686a_read_value(client,
 764                                                      VIA686A_REG_FAN_MIN(i));
 765                 }
 766                 for (i = 0; i <= 2; i++) {
 767                         data->temp[i] = via686a_read_value(client,
 768                                                  VIA686A_REG_TEMP(i)) << 2;
 769                         data->temp_over[i] =
 770                             via686a_read_value(client,
 771                                                VIA686A_REG_TEMP_OVER(i));
 772                         data->temp_hyst[i] =
 773                             via686a_read_value(client,
 774                                                VIA686A_REG_TEMP_HYST(i));
 775                 }
 776                 /* add in lower 2 bits
 777                    temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1
 778                    temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
 779                    temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
 780                  */
 781                 data->temp[0] |= (via686a_read_value(client,
 782                                                      VIA686A_REG_TEMP_LOW1)
 783                                   & 0xc0) >> 6;
 784                 data->temp[1] |=
 785                     (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
 786                      0x30) >> 4;
 787                 data->temp[2] |=
 788                     (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
 789                      0xc0) >> 6;
 790
 791                 i = via686a_read_value(client, VIA686A_REG_FANDIV);
 792                 data->fan_div[0] = (i >> 4) & 0x03;
 793                 data->fan_div[1] = i >> 6;
 794                 data->alarms =
 795                     via686a_read_value(client,
 796                                        VIA686A_REG_ALARM1) |
 797                     (via686a_read_value(client, VIA686A_REG_ALARM2) << 8);
 798                 data->last_updated = jiffies;
 799                 data->valid = 1;
 800         }
 801
 802         up(&data->update_lock);
 803
 804         return data;
 805 }
 806
 807 static struct pci_device_id via686a_pci_ids[] = {
 808        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) },
 809        { 0, }
 810 };
 811
 812 MODULE_DEVICE_TABLE(pci, via686a_pci_ids);
 813
 814 static int __devinit via686a_pci_probe(struct pci_dev *dev,
 815                                       const struct pci_device_id *id)
 816 {
 817        u16 val;
 818        int addr = 0;
 819
 820        if (PCIBIOS_SUCCESSFUL !=
 821            pci_read_config_word(dev, VIA686A_BASE_REG, &val))
 822                return -ENODEV;
 823
 824        addr = val & ~(VIA686A_EXTENT - 1);
 825        if (addr == 0 && force_addr == 0) {
 826                dev_err(&dev->dev,"base address not set - upgrade BIOS or use force_addr=0xaddr\n");
 827                return -ENODEV;
 828        }
 829        if (force_addr)
 830                addr = force_addr;      /* so detect will get called */
 831
 832        if (!addr) {
 833                dev_err(&dev->dev,"No Via 686A sensors found.\n");
 834                return -ENODEV;
 835        }
 836        normal_isa[0] = addr;
 837
 838         s_bridge = pci_dev_get(dev);
 839         if (i2c_add_driver(&via686a_driver)) {
 840                 pci_dev_put(s_bridge);
 841                 s_bridge = NULL;
 842         }
 843
 844         /* Always return failure here.  This is to allow other drivers to bind
 845          * to this pci device.  We don't really want to have control over the
 846          * pci device, we only wanted to read as few register values from it.
 847          */
 848         return -ENODEV;
 849 }
 850
 851 static struct pci_driver via686a_pci_driver = {
 852        .name            = "via686a",
 853        .id_table        = via686a_pci_ids,
 854        .probe           = via686a_pci_probe,
 855 };
 856
 857 static int __init sm_via686a_init(void)
 858 {
 859        return pci_register_driver(&via686a_pci_driver);
 860 }
 861
 862 static void __exit sm_via686a_exit(void)
 863 {
 864         pci_unregister_driver(&via686a_pci_driver);
 865         if (s_bridge != NULL) {
 866                 i2c_del_driver(&via686a_driver);
 867                 pci_dev_put(s_bridge);
 868                 s_bridge = NULL;
 869         }
 870 }
 871
 872 MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
 873               "Mark Studebaker <mdsxyz123@yahoo.com> "
 874              "and Bob Dougherty <bobd@stanford.edu>");
 875 MODULE_DESCRIPTION("VIA 686A Sensor device");
 876 MODULE_LICENSE("GPL");
 877
 878 module_init(sm_via686a_init);
 879 module_exit(sm_via686a_exit);