drivers/i2c/chips/via686a.c

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