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