git.oblomov.eu Git - linux-2.6/blob - 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;
  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 s16 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)      ((long)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         .driver = {
 576                 .name   = "via686a",
 577         },
 578         .attach_adapter = via686a_detect,
 579         .detach_client  = via686a_detach_client,
 580 };
 581
 582
 583 /* This is called when the module is loaded */
 584 static int via686a_detect(struct i2c_adapter *adapter)
 585 {
 586         struct i2c_client *new_client;
 587         struct via686a_data *data;
 588         int err = 0;
 589         const char client_name[] = "via686a";
 590         u16 val;
 591
 592         /* 8231 requires multiple of 256, we enforce that on 686 as well */
 593         if (force_addr) {
 594                 address = force_addr & 0xFF00;
 595                 dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n",
 596                          address);
 597                 if (PCIBIOS_SUCCESSFUL !=
 598                     pci_write_config_word(s_bridge, VIA686A_BASE_REG, address))
 599                         return -ENODEV;
 600         }
 601         if (PCIBIOS_SUCCESSFUL !=
 602             pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val))
 603                 return -ENODEV;
 604         if (!(val & 0x0001)) {
 605                 if (force_addr) {
 606                         dev_info(&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                 } else {
 612                         dev_warn(&adapter->dev, "sensors disabled - enable "
 613                                  "with force_addr=0x%x\n", address);
 614                         return -ENODEV;
 615                 }
 616         }
 617
 618         /* Reserve the ISA region */
 619         if (!request_region(address, VIA686A_EXTENT,
 620                             via686a_driver.driver.name)) {
 621                 dev_err(&adapter->dev, "region 0x%x already in use!\n",
 622                         address);
 623                 return -ENODEV;
 624         }
 625
 626         if (!(data = kzalloc(sizeof(struct via686a_data), GFP_KERNEL))) {
 627                 err = -ENOMEM;
 628                 goto exit_release;
 629         }
 630
 631         new_client = &data->client;
 632         i2c_set_clientdata(new_client, data);
 633         new_client->addr = address;
 634         new_client->adapter = adapter;
 635         new_client->driver = &via686a_driver;
 636         new_client->flags = 0;
 637
 638         /* Fill in the remaining client fields and put into the global list */
 639         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 640
 641         data->valid = 0;
 642         init_MUTEX(&data->update_lock);
 643         /* Tell the I2C layer a new client has arrived */
 644         if ((err = i2c_attach_client(new_client)))
 645                 goto exit_free;
 646
 647         /* Initialize the VIA686A chip */
 648         via686a_init_client(new_client);
 649
 650         /* Register sysfs hooks */
 651         data->class_dev = hwmon_device_register(&new_client->dev);
 652         if (IS_ERR(data->class_dev)) {
 653                 err = PTR_ERR(data->class_dev);
 654                 goto exit_detach;
 655         }
 656
 657         device_create_file(&new_client->dev, &dev_attr_in0_input);
 658         device_create_file(&new_client->dev, &dev_attr_in1_input);
 659         device_create_file(&new_client->dev, &dev_attr_in2_input);
 660         device_create_file(&new_client->dev, &dev_attr_in3_input);
 661         device_create_file(&new_client->dev, &dev_attr_in4_input);
 662         device_create_file(&new_client->dev, &dev_attr_in0_min);
 663         device_create_file(&new_client->dev, &dev_attr_in1_min);
 664         device_create_file(&new_client->dev, &dev_attr_in2_min);
 665         device_create_file(&new_client->dev, &dev_attr_in3_min);
 666         device_create_file(&new_client->dev, &dev_attr_in4_min);
 667         device_create_file(&new_client->dev, &dev_attr_in0_max);
 668         device_create_file(&new_client->dev, &dev_attr_in1_max);
 669         device_create_file(&new_client->dev, &dev_attr_in2_max);
 670         device_create_file(&new_client->dev, &dev_attr_in3_max);
 671         device_create_file(&new_client->dev, &dev_attr_in4_max);
 672         device_create_file(&new_client->dev, &dev_attr_temp1_input);
 673         device_create_file(&new_client->dev, &dev_attr_temp2_input);
 674         device_create_file(&new_client->dev, &dev_attr_temp3_input);
 675         device_create_file(&new_client->dev, &dev_attr_temp1_max);
 676         device_create_file(&new_client->dev, &dev_attr_temp2_max);
 677         device_create_file(&new_client->dev, &dev_attr_temp3_max);
 678         device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
 679         device_create_file(&new_client->dev, &dev_attr_temp2_max_hyst);
 680         device_create_file(&new_client->dev, &dev_attr_temp3_max_hyst);
 681         device_create_file(&new_client->dev, &dev_attr_fan1_input);
 682         device_create_file(&new_client->dev, &dev_attr_fan2_input);
 683         device_create_file(&new_client->dev, &dev_attr_fan1_min);
 684         device_create_file(&new_client->dev, &dev_attr_fan2_min);
 685         device_create_file(&new_client->dev, &dev_attr_fan1_div);
 686         device_create_file(&new_client->dev, &dev_attr_fan2_div);
 687         device_create_file(&new_client->dev, &dev_attr_alarms);
 688
 689         return 0;
 690
 691 exit_detach:
 692         i2c_detach_client(new_client);
 693 exit_free:
 694         kfree(data);
 695 exit_release:
 696         release_region(address, VIA686A_EXTENT);
 697         return err;
 698 }
 699
 700 static int via686a_detach_client(struct i2c_client *client)
 701 {
 702         struct via686a_data *data = i2c_get_clientdata(client);
 703         int err;
 704
 705         hwmon_device_unregister(data->class_dev);
 706
 707         if ((err = i2c_detach_client(client)))
 708                 return err;
 709
 710         release_region(client->addr, VIA686A_EXTENT);
 711         kfree(data);
 712
 713         return 0;
 714 }
 715
 716 static void via686a_init_client(struct i2c_client *client)
 717 {
 718         u8 reg;
 719
 720         /* Start monitoring */
 721         reg = via686a_read_value(client, VIA686A_REG_CONFIG);
 722         via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F);
 723
 724         /* Configure temp interrupt mode for continuous-interrupt operation */
 725         via686a_write_value(client, VIA686A_REG_TEMP_MODE,
 726                             via686a_read_value(client, VIA686A_REG_TEMP_MODE) &
 727                             !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS));
 728 }
 729
 730 static struct via686a_data *via686a_update_device(struct device *dev)
 731 {
 732         struct i2c_client *client = to_i2c_client(dev);
 733         struct via686a_data *data = i2c_get_clientdata(client);
 734         int i;
 735
 736         down(&data->update_lock);
 737
 738         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 739             || !data->valid) {
 740                 for (i = 0; i <= 4; i++) {
 741                         data->in[i] =
 742                             via686a_read_value(client, VIA686A_REG_IN(i));
 743                         data->in_min[i] = via686a_read_value(client,
 744                                                              VIA686A_REG_IN_MIN
 745                                                              (i));
 746                         data->in_max[i] =
 747                             via686a_read_value(client, VIA686A_REG_IN_MAX(i));
 748                 }
 749                 for (i = 1; i <= 2; i++) {
 750                         data->fan[i - 1] =
 751                             via686a_read_value(client, VIA686A_REG_FAN(i));
 752                         data->fan_min[i - 1] = via686a_read_value(client,
 753                                                      VIA686A_REG_FAN_MIN(i));
 754                 }
 755                 for (i = 0; i <= 2; i++) {
 756                         data->temp[i] = via686a_read_value(client,
 757                                                  VIA686A_REG_TEMP[i]) << 2;
 758                         data->temp_over[i] =
 759                             via686a_read_value(client,
 760                                                VIA686A_REG_TEMP_OVER[i]);
 761                         data->temp_hyst[i] =
 762                             via686a_read_value(client,
 763                                                VIA686A_REG_TEMP_HYST[i]);
 764                 }
 765                 /* add in lower 2 bits
 766                    temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1
 767                    temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
 768                    temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
 769                  */
 770                 data->temp[0] |= (via686a_read_value(client,
 771                                                      VIA686A_REG_TEMP_LOW1)
 772                                   & 0xc0) >> 6;
 773                 data->temp[1] |=
 774                     (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
 775                      0x30) >> 4;
 776                 data->temp[2] |=
 777                     (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
 778                      0xc0) >> 6;
 779
 780                 i = via686a_read_value(client, VIA686A_REG_FANDIV);
 781                 data->fan_div[0] = (i >> 4) & 0x03;
 782                 data->fan_div[1] = i >> 6;
 783                 data->alarms =
 784                     via686a_read_value(client,
 785                                        VIA686A_REG_ALARM1) |
 786                     (via686a_read_value(client, VIA686A_REG_ALARM2) << 8);
 787                 data->last_updated = jiffies;
 788                 data->valid = 1;
 789         }
 790
 791         up(&data->update_lock);
 792
 793         return data;
 794 }
 795
 796 static struct pci_device_id via686a_pci_ids[] = {
 797         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) },
 798         { 0, }
 799 };
 800
 801 MODULE_DEVICE_TABLE(pci, via686a_pci_ids);
 802
 803 static int __devinit via686a_pci_probe(struct pci_dev *dev,
 804                                        const struct pci_device_id *id)
 805 {
 806         u16 val;
 807
 808         if (PCIBIOS_SUCCESSFUL !=
 809             pci_read_config_word(dev, VIA686A_BASE_REG, &val))
 810                 return -ENODEV;
 811
 812         address = val & ~(VIA686A_EXTENT - 1);
 813         if (address == 0 && force_addr == 0) {
 814                 dev_err(&dev->dev, "base address not set - upgrade BIOS "
 815                         "or use force_addr=0xaddr\n");
 816                 return -ENODEV;
 817         }
 818
 819         s_bridge = pci_dev_get(dev);
 820         if (i2c_isa_add_driver(&via686a_driver)) {
 821                 pci_dev_put(s_bridge);
 822                 s_bridge = NULL;
 823         }
 824
 825         /* Always return failure here.  This is to allow other drivers to bind
 826          * to this pci device.  We don't really want to have control over the
 827          * pci device, we only wanted to read as few register values from it.
 828          */
 829         return -ENODEV;
 830 }
 831
 832 static struct pci_driver via686a_pci_driver = {
 833         .name           = "via686a",
 834         .id_table       = via686a_pci_ids,
 835         .probe          = via686a_pci_probe,
 836 };
 837
 838 static int __init sm_via686a_init(void)
 839 {
 840         return pci_register_driver(&via686a_pci_driver);
 841 }
 842
 843 static void __exit sm_via686a_exit(void)
 844 {
 845         pci_unregister_driver(&via686a_pci_driver);
 846         if (s_bridge != NULL) {
 847                 i2c_isa_del_driver(&via686a_driver);
 848                 pci_dev_put(s_bridge);
 849                 s_bridge = NULL;
 850         }
 851 }
 852
 853 MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
 854               "Mark Studebaker <mdsxyz123@yahoo.com> "
 855               "and Bob Dougherty <bobd@stanford.edu>");
 856 MODULE_DESCRIPTION("VIA 686A Sensor device");
 857 MODULE_LICENSE("GPL");
 858
 859 module_init(sm_via686a_init);
 860 module_exit(sm_via686a_exit);