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