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