linux/drivers/hwmon/via686a.c
<<
>>
Prefs
   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 */
  55static unsigned short force_addr;
  56module_param(force_addr, ushort, 0);
  57MODULE_PARM_DESC(force_addr,
  58                 "Initialize the base address of the sensors");
  59
  60static 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 */
  85static const u8 VIA686A_REG_TEMP[]      = { 0x20, 0x21, 0x1f };
  86static const u8 VIA686A_REG_TEMP_OVER[] = { 0x39, 0x3d, 0x1d };
  87static 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 */
 128static 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
 151static 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 */
 174static 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 */
 219static 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 */
 267static 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 */
 288static 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 */
 298static 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 */
 319struct 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
 339static struct pci_dev *s_bridge;        /* pointer to the (only) via686a */
 340
 341static int via686a_probe(struct platform_device *pdev);
 342static int via686a_remove(struct platform_device *pdev);
 343
 344static inline int via686a_read_value(struct via686a_data *data, u8 reg)
 345{
 346        return inb_p(data->addr + reg);
 347}
 348
 349static inline void via686a_write_value(struct via686a_data *data, u8 reg,
 350                                       u8 value)
 351{
 352        outb_p(value, data->addr + reg);
 353}
 354
 355static struct via686a_data *via686a_update_device(struct device *dev);
 356static void via686a_init_device(struct via686a_data *data);
 357
 358/* following are the sysfs callback functions */
 359
 360/* 7 voltage sensors */
 361static 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
 369static 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
 377static 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
 385static 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}
 404static 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)                                  \
 424static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 425                show_in, NULL, offset);                         \
 426static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 427                show_in_min, set_in_min, offset);               \
 428static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 429                show_in_max, set_in_max, offset);
 430
 431show_in_offset(0);
 432show_in_offset(1);
 433show_in_offset(2);
 434show_in_offset(3);
 435show_in_offset(4);
 436
 437/* 3 temperatures */
 438static 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}
 445static 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}
 452static 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}
 459static 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}
 478static 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)                                        \
 498static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
 499                show_temp, NULL, offset - 1);                           \
 500static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
 501                show_temp_over, set_temp_over, offset - 1);             \
 502static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,   \
 503                show_temp_hyst, set_temp_hyst, offset - 1);
 504
 505show_temp_offset(1);
 506show_temp_offset(2);
 507show_temp_offset(3);
 508
 509/* 2 Fans */
 510static 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}
 518static 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}
 527static 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}
 534static 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}
 552static 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)                                         \
 575static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
 576                show_fan, NULL, offset - 1);                            \
 577static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
 578                show_fan_min, set_fan_min, offset - 1);                 \
 579static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
 580                show_fan_div, set_fan_div, offset - 1);
 581
 582show_fan_offset(1);
 583show_fan_offset(2);
 584
 585/* Alarms */
 586static 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
 593static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 594
 595static 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}
 602static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 603static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 604static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 605static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 606static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 607static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 608static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 11);
 609static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 15);
 610static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 611static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 612
 613static 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}
 619static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 620
 621static 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
 670static const struct attribute_group via686a_group = {
 671        .attrs = via686a_attributes,
 672};
 673
 674static 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 */
 685static 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
 726exit_remove_files:
 727        sysfs_remove_group(&pdev->dev.kobj, &via686a_group);
 728        return err;
 729}
 730
 731static 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
 741static 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
 748static 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
 766static 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
 830static DEFINE_PCI_DEVICE_TABLE(via686a_pci_ids) = {
 831        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) },
 832        { }
 833};
 834MODULE_DEVICE_TABLE(pci, via686a_pci_ids);
 835
 836static 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
 871exit_device_put:
 872        platform_device_put(pdev);
 873exit:
 874        return err;
 875}
 876
 877static 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
 932exit_unregister:
 933        platform_driver_unregister(&via686a_driver);
 934exit:
 935        return -ENODEV;
 936}
 937
 938static struct pci_driver via686a_pci_driver = {
 939        .name           = "via686a",
 940        .id_table       = via686a_pci_ids,
 941        .probe          = via686a_pci_probe,
 942};
 943
 944static int __init sm_via686a_init(void)
 945{
 946        return pci_register_driver(&via686a_pci_driver);
 947}
 948
 949static 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
 960MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
 961              "Mark Studebaker <mdsxyz123@yahoo.com> "
 962              "and Bob Dougherty <bobd@stanford.edu>");
 963MODULE_DESCRIPTION("VIA 686A Sensor device");
 964MODULE_LICENSE("GPL");
 965
 966module_init(sm_via686a_init);
 967module_exit(sm_via686a_exit);
 968
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.