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