git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/via686a.c

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