drivers/hwmon/via686a.c

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