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