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