Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * via686a.c - Part of lm_sensors, Linux kernel modules
0004  *         for hardware monitoring
0005  *
0006  * Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
0007  *                Kyösti Mälkki <kmalkki@cc.hut.fi>,
0008  *                Mark Studebaker <mdsxyz123@yahoo.com>,
0009  *                and Bob Dougherty <bobd@stanford.edu>
0010  *
0011  * (Some conversion-factor data were contributed by Jonathan Teh Soon Yew
0012  * <j.teh@iname.com> and Alex van Kaam <darkside@chello.nl>.)
0013  */
0014 
0015 /*
0016  * Supports the Via VT82C686A, VT82C686B south bridges.
0017  * Reports all as a 686A.
0018  * Warning - only supports a single device.
0019  */
0020 
0021 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0022 
0023 #include <linux/module.h>
0024 #include <linux/slab.h>
0025 #include <linux/pci.h>
0026 #include <linux/jiffies.h>
0027 #include <linux/platform_device.h>
0028 #include <linux/hwmon.h>
0029 #include <linux/hwmon-sysfs.h>
0030 #include <linux/err.h>
0031 #include <linux/init.h>
0032 #include <linux/mutex.h>
0033 #include <linux/sysfs.h>
0034 #include <linux/acpi.h>
0035 #include <linux/io.h>
0036 
0037 /*
0038  * If force_addr is set to anything different from 0, we forcibly enable
0039  * the device at the given address.
0040  */
0041 static unsigned short force_addr;
0042 module_param(force_addr, ushort, 0);
0043 MODULE_PARM_DESC(force_addr,
0044          "Initialize the base address of the sensors");
0045 
0046 static struct platform_device *pdev;
0047 
0048 /*
0049  * The Via 686a southbridge has a LM78-like chip integrated on the same IC.
0050  * This driver is a customized copy of lm78.c
0051  */
0052 
0053 /* Many VIA686A constants specified below */
0054 
0055 /* Length of ISA address segment */
0056 #define VIA686A_EXTENT      0x80
0057 #define VIA686A_BASE_REG    0x70
0058 #define VIA686A_ENABLE_REG  0x74
0059 
0060 /* The VIA686A registers */
0061 /* ins numbered 0-4 */
0062 #define VIA686A_REG_IN_MAX(nr)  (0x2b + ((nr) * 2))
0063 #define VIA686A_REG_IN_MIN(nr)  (0x2c + ((nr) * 2))
0064 #define VIA686A_REG_IN(nr)  (0x22 + (nr))
0065 
0066 /* fans numbered 1-2 */
0067 #define VIA686A_REG_FAN_MIN(nr) (0x3a + (nr))
0068 #define VIA686A_REG_FAN(nr) (0x28 + (nr))
0069 
0070 /* temps numbered 1-3 */
0071 static const u8 VIA686A_REG_TEMP[]  = { 0x20, 0x21, 0x1f };
0072 static const u8 VIA686A_REG_TEMP_OVER[] = { 0x39, 0x3d, 0x1d };
0073 static const u8 VIA686A_REG_TEMP_HYST[] = { 0x3a, 0x3e, 0x1e };
0074 /* bits 7-6 */
0075 #define VIA686A_REG_TEMP_LOW1   0x4b
0076 /* 2 = bits 5-4, 3 = bits 7-6 */
0077 #define VIA686A_REG_TEMP_LOW23  0x49
0078 
0079 #define VIA686A_REG_ALARM1  0x41
0080 #define VIA686A_REG_ALARM2  0x42
0081 #define VIA686A_REG_FANDIV  0x47
0082 #define VIA686A_REG_CONFIG  0x40
0083 /*
0084  * The following register sets temp interrupt mode (bits 1-0 for temp1,
0085  * 3-2 for temp2, 5-4 for temp3).  Modes are:
0086  * 00 interrupt stays as long as value is out-of-range
0087  * 01 interrupt is cleared once register is read (default)
0088  * 10 comparator mode- like 00, but ignores hysteresis
0089  * 11 same as 00
0090  */
0091 #define VIA686A_REG_TEMP_MODE       0x4b
0092 /* We'll just assume that you want to set all 3 simultaneously: */
0093 #define VIA686A_TEMP_MODE_MASK      0x3F
0094 #define VIA686A_TEMP_MODE_CONTINUOUS    0x00
0095 
0096 /*
0097  * Conversions. Limit checking is only done on the TO_REG
0098  * variants.
0099  *
0100  ******** VOLTAGE CONVERSIONS (Bob Dougherty) ********
0101  * From HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew):
0102  * voltagefactor[0]=1.25/2628; (2628/1.25=2102.4)   // Vccp
0103  * voltagefactor[1]=1.25/2628; (2628/1.25=2102.4)   // +2.5V
0104  * voltagefactor[2]=1.67/2628; (2628/1.67=1573.7)   // +3.3V
0105  * voltagefactor[3]=2.6/2628;  (2628/2.60=1010.8)   // +5V
0106  * voltagefactor[4]=6.3/2628;  (2628/6.30=417.14)   // +12V
0107  * in[i]=(data[i+2]*25.0+133)*voltagefactor[i];
0108  * That is:
0109  * volts = (25*regVal+133)*factor
0110  * regVal = (volts/factor-133)/25
0111  * (These conversions were contributed by Jonathan Teh Soon Yew
0112  * <j.teh@iname.com>)
0113  */
0114 static inline u8 IN_TO_REG(long val, int in_num)
0115 {
0116     /*
0117      * To avoid floating point, we multiply constants by 10 (100 for +12V).
0118      * Rounding is done (120500 is actually 133000 - 12500).
0119      * Remember that val is expressed in 0.001V/bit, which is why we divide
0120      * by an additional 10000 (100000 for +12V): 1000 for val and 10 (100)
0121      * for the constants.
0122      */
0123     if (in_num <= 1)
0124         return (u8) clamp_val((val * 21024 - 1205000) / 250000, 0, 255);
0125     else if (in_num == 2)
0126         return (u8) clamp_val((val * 15737 - 1205000) / 250000, 0, 255);
0127     else if (in_num == 3)
0128         return (u8) clamp_val((val * 10108 - 1205000) / 250000, 0, 255);
0129     else
0130         return (u8) clamp_val((val * 41714 - 12050000) / 2500000, 0,
0131                       255);
0132 }
0133 
0134 static inline long IN_FROM_REG(u8 val, int in_num)
0135 {
0136     /*
0137      * To avoid floating point, we multiply constants by 10 (100 for +12V).
0138      * We also multiply them by 1000 because we want 0.001V/bit for the
0139      * output value. Rounding is done.
0140      */
0141     if (in_num <= 1)
0142         return (long) ((250000 * val + 1330000 + 21024 / 2) / 21024);
0143     else if (in_num == 2)
0144         return (long) ((250000 * val + 1330000 + 15737 / 2) / 15737);
0145     else if (in_num == 3)
0146         return (long) ((250000 * val + 1330000 + 10108 / 2) / 10108);
0147     else
0148         return (long) ((2500000 * val + 13300000 + 41714 / 2) / 41714);
0149 }
0150 
0151 /********* FAN RPM CONVERSIONS ********/
0152 /*
0153  * Higher register values = slower fans (the fan's strobe gates a counter).
0154  * But this chip saturates back at 0, not at 255 like all the other chips.
0155  * So, 0 means 0 RPM
0156  */
0157 static inline u8 FAN_TO_REG(long rpm, int div)
0158 {
0159     if (rpm == 0)
0160         return 0;
0161     rpm = clamp_val(rpm, 1, 1000000);
0162     return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 255);
0163 }
0164 
0165 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (val) == 255 ? 0 : 1350000 / \
0166                 ((val) * (div)))
0167 
0168 /******** TEMP CONVERSIONS (Bob Dougherty) *********/
0169 /*
0170  * linear fits from HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew)
0171  *  if(temp<169)
0172  *      return double(temp)*0.427-32.08;
0173  *  else if(temp>=169 && temp<=202)
0174  *      return double(temp)*0.582-58.16;
0175  *  else
0176  *      return double(temp)*0.924-127.33;
0177  *
0178  * A fifth-order polynomial fits the unofficial data (provided by Alex van
0179  * Kaam <darkside@chello.nl>) a bit better.  It also give more reasonable
0180  * numbers on my machine (ie. they agree with what my BIOS tells me).
0181  * Here's the fifth-order fit to the 8-bit data:
0182  * temp = 1.625093e-10*val^5 - 1.001632e-07*val^4 + 2.457653e-05*val^3 -
0183  *  2.967619e-03*val^2 + 2.175144e-01*val - 7.090067e+0.
0184  *
0185  * (2000-10-25- RFD: thanks to Uwe Andersen <uandersen@mayah.com> for
0186  * finding my typos in this formula!)
0187  *
0188  * Alas, none of the elegant function-fit solutions will work because we
0189  * aren't allowed to use floating point in the kernel and doing it with
0190  * integers doesn't provide enough precision.  So we'll do boring old
0191  * look-up table stuff.  The unofficial data (see below) have effectively
0192  * 7-bit resolution (they are rounded to the nearest degree).  I'm assuming
0193  * that the transfer function of the device is monotonic and smooth, so a
0194  * smooth function fit to the data will allow us to get better precision.
0195  * I used the 5th-order poly fit described above and solved for
0196  * VIA register values 0-255.  I *10 before rounding, so we get tenth-degree
0197  * precision.  (I could have done all 1024 values for our 10-bit readings,
0198  * but the function is very linear in the useful range (0-80 deg C), so
0199  * we'll just use linear interpolation for 10-bit readings.)  So, temp_lut
0200  * is the temp at via register values 0-255:
0201  */
0202 static const s16 temp_lut[] = {
0203     -709, -688, -667, -646, -627, -607, -589, -570, -553, -536, -519,
0204     -503, -487, -471, -456, -442, -428, -414, -400, -387, -375,
0205     -362, -350, -339, -327, -316, -305, -295, -285, -275, -265,
0206     -255, -246, -237, -229, -220, -212, -204, -196, -188, -180,
0207     -173, -166, -159, -152, -145, -139, -132, -126, -120, -114,
0208     -108, -102, -96, -91, -85, -80, -74, -69, -64, -59, -54, -49,
0209     -44, -39, -34, -29, -25, -20, -15, -11, -6, -2, 3, 7, 12, 16,
0210     20, 25, 29, 33, 37, 42, 46, 50, 54, 59, 63, 67, 71, 75, 79, 84,
0211     88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138,
0212     142, 146, 151, 155, 159, 163, 168, 172, 176, 181, 185, 189,
0213     193, 198, 202, 206, 211, 215, 219, 224, 228, 232, 237, 241,
0214     245, 250, 254, 259, 263, 267, 272, 276, 281, 285, 290, 294,
0215     299, 303, 307, 312, 316, 321, 325, 330, 334, 339, 344, 348,
0216     353, 357, 362, 366, 371, 376, 380, 385, 390, 395, 399, 404,
0217     409, 414, 419, 423, 428, 433, 438, 443, 449, 454, 459, 464,
0218     469, 475, 480, 486, 491, 497, 502, 508, 514, 520, 526, 532,
0219     538, 544, 551, 557, 564, 571, 578, 584, 592, 599, 606, 614,
0220     621, 629, 637, 645, 654, 662, 671, 680, 689, 698, 708, 718,
0221     728, 738, 749, 759, 770, 782, 793, 805, 818, 830, 843, 856,
0222     870, 883, 898, 912, 927, 943, 958, 975, 991, 1008, 1026, 1044,
0223     1062, 1081, 1101, 1121, 1141, 1162, 1184, 1206, 1229, 1252,
0224     1276, 1301, 1326, 1352, 1378, 1406, 1434, 1462
0225 };
0226 
0227 /*
0228  * the original LUT values from Alex van Kaam <darkside@chello.nl>
0229  * (for via register values 12-240):
0230  * {-50,-49,-47,-45,-43,-41,-39,-38,-37,-35,-34,-33,-32,-31,
0231  * -30,-29,-28,-27,-26,-25,-24,-24,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15,
0232  * -15,-14,-14,-13,-12,-12,-11,-11,-10,-9,-9,-8,-8,-7,-7,-6,-6,-5,-5,-4,-4,-3,
0233  * -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,
0234  * 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,
0235  * 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,
0236  * 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,
0237  * 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,
0238  * 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,
0239  * 85,86,88,89,91,92,94,96,97,99,101,103,105,107,109,110};
0240  *
0241  *
0242  * Here's the reverse LUT.  I got it by doing a 6-th order poly fit (needed
0243  * an extra term for a good fit to these inverse data!) and then
0244  * solving for each temp value from -50 to 110 (the useable range for
0245  * this chip).  Here's the fit:
0246  * viaRegVal = -1.160370e-10*val^6 +3.193693e-08*val^5 - 1.464447e-06*val^4
0247  * - 2.525453e-04*val^3 + 1.424593e-02*val^2 + 2.148941e+00*val +7.275808e+01)
0248  * Note that n=161:
0249  */
0250 static const u8 via_lut[] = {
0251     12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22, 23,
0252     23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 39, 40,
0253     41, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 62, 64, 66,
0254     69, 71, 73, 75, 77, 79, 82, 84, 86, 88, 91, 93, 95, 98, 100,
0255     103, 105, 107, 110, 112, 115, 117, 119, 122, 124, 126, 129,
0256     131, 134, 136, 138, 140, 143, 145, 147, 150, 152, 154, 156,
0257     158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180,
0258     182, 183, 185, 187, 188, 190, 192, 193, 195, 196, 198, 199,
0259     200, 202, 203, 205, 206, 207, 208, 209, 210, 211, 212, 213,
0260     214, 215, 216, 217, 218, 219, 220, 221, 222, 222, 223, 224,
0261     225, 226, 226, 227, 228, 228, 229, 230, 230, 231, 232, 232,
0262     233, 233, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239,
0263     239, 240
0264 };
0265 
0266 /*
0267  * Converting temps to (8-bit) hyst and over registers
0268  * No interpolation here.
0269  * The +50 is because the temps start at -50
0270  */
0271 static inline u8 TEMP_TO_REG(long val)
0272 {
0273     return via_lut[val <= -50000 ? 0 : val >= 110000 ? 160 :
0274               (val < 0 ? val - 500 : val + 500) / 1000 + 50];
0275 }
0276 
0277 /* for 8-bit temperature hyst and over registers */
0278 #define TEMP_FROM_REG(val)  ((long)temp_lut[val] * 100)
0279 
0280 /* for 10-bit temperature readings */
0281 static inline long TEMP_FROM_REG10(u16 val)
0282 {
0283     u16 eight_bits = val >> 2;
0284     u16 two_bits = val & 3;
0285 
0286     /* no interpolation for these */
0287     if (two_bits == 0 || eight_bits == 255)
0288         return TEMP_FROM_REG(eight_bits);
0289 
0290     /* do some linear interpolation */
0291     return (temp_lut[eight_bits] * (4 - two_bits) +
0292         temp_lut[eight_bits + 1] * two_bits) * 25;
0293 }
0294 
0295 #define DIV_FROM_REG(val) (1 << (val))
0296 #define DIV_TO_REG(val) ((val) == 8 ? 3 : (val) == 4 ? 2 : (val) == 1 ? 0 : 1)
0297 
0298 /*
0299  * For each registered chip, we need to keep some data in memory.
0300  * The structure is dynamically allocated.
0301  */
0302 struct via686a_data {
0303     unsigned short addr;
0304     const char *name;
0305     struct device *hwmon_dev;
0306     struct mutex update_lock;
0307     bool valid;     /* true if following fields are valid */
0308     unsigned long last_updated; /* In jiffies */
0309 
0310     u8 in[5];       /* Register value */
0311     u8 in_max[5];       /* Register value */
0312     u8 in_min[5];       /* Register value */
0313     u8 fan[2];      /* Register value */
0314     u8 fan_min[2];      /* Register value */
0315     u16 temp[3];        /* Register value 10 bit */
0316     u8 temp_over[3];    /* Register value */
0317     u8 temp_hyst[3];    /* Register value */
0318     u8 fan_div[2];      /* Register encoding, shifted right */
0319     u16 alarms;     /* Register encoding, combined */
0320 };
0321 
0322 static struct pci_dev *s_bridge;    /* pointer to the (only) via686a */
0323 
0324 static int via686a_probe(struct platform_device *pdev);
0325 static int via686a_remove(struct platform_device *pdev);
0326 
0327 static inline int via686a_read_value(struct via686a_data *data, u8 reg)
0328 {
0329     return inb_p(data->addr + reg);
0330 }
0331 
0332 static inline void via686a_write_value(struct via686a_data *data, u8 reg,
0333                        u8 value)
0334 {
0335     outb_p(value, data->addr + reg);
0336 }
0337 
0338 static struct via686a_data *via686a_update_device(struct device *dev);
0339 static void via686a_init_device(struct via686a_data *data);
0340 
0341 /* following are the sysfs callback functions */
0342 
0343 /* 7 voltage sensors */
0344 static ssize_t in_show(struct device *dev, struct device_attribute *da,
0345                char *buf) {
0346     struct via686a_data *data = via686a_update_device(dev);
0347     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0348     int nr = attr->index;
0349     return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr));
0350 }
0351 
0352 static ssize_t in_min_show(struct device *dev, struct device_attribute *da,
0353                char *buf) {
0354     struct via686a_data *data = via686a_update_device(dev);
0355     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0356     int nr = attr->index;
0357     return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr));
0358 }
0359 
0360 static ssize_t in_max_show(struct device *dev, struct device_attribute *da,
0361                char *buf) {
0362     struct via686a_data *data = via686a_update_device(dev);
0363     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0364     int nr = attr->index;
0365     return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr));
0366 }
0367 
0368 static ssize_t in_min_store(struct device *dev, struct device_attribute *da,
0369                 const char *buf, size_t count) {
0370     struct via686a_data *data = dev_get_drvdata(dev);
0371     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0372     int nr = attr->index;
0373     unsigned long val;
0374     int err;
0375 
0376     err = kstrtoul(buf, 10, &val);
0377     if (err)
0378         return err;
0379 
0380     mutex_lock(&data->update_lock);
0381     data->in_min[nr] = IN_TO_REG(val, nr);
0382     via686a_write_value(data, VIA686A_REG_IN_MIN(nr),
0383             data->in_min[nr]);
0384     mutex_unlock(&data->update_lock);
0385     return count;
0386 }
0387 static ssize_t in_max_store(struct device *dev, struct device_attribute *da,
0388                 const char *buf, size_t count) {
0389     struct via686a_data *data = dev_get_drvdata(dev);
0390     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0391     int nr = attr->index;
0392     unsigned long val;
0393     int err;
0394 
0395     err = kstrtoul(buf, 10, &val);
0396     if (err)
0397         return err;
0398 
0399     mutex_lock(&data->update_lock);
0400     data->in_max[nr] = IN_TO_REG(val, nr);
0401     via686a_write_value(data, VIA686A_REG_IN_MAX(nr),
0402             data->in_max[nr]);
0403     mutex_unlock(&data->update_lock);
0404     return count;
0405 }
0406 
0407 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
0408 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0409 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0410 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
0411 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0412 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0413 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
0414 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0415 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0416 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
0417 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0418 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0419 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
0420 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0421 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0422 
0423 /* 3 temperatures */
0424 static ssize_t temp_show(struct device *dev, struct device_attribute *da,
0425              char *buf) {
0426     struct via686a_data *data = via686a_update_device(dev);
0427     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0428     int nr = attr->index;
0429     return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr]));
0430 }
0431 static ssize_t temp_over_show(struct device *dev, struct device_attribute *da,
0432                   char *buf) {
0433     struct via686a_data *data = via686a_update_device(dev);
0434     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0435     int nr = attr->index;
0436     return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr]));
0437 }
0438 static ssize_t temp_hyst_show(struct device *dev, struct device_attribute *da,
0439                   char *buf) {
0440     struct via686a_data *data = via686a_update_device(dev);
0441     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0442     int nr = attr->index;
0443     return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr]));
0444 }
0445 static ssize_t temp_over_store(struct device *dev,
0446                    struct device_attribute *da, const char *buf,
0447                    size_t count) {
0448     struct via686a_data *data = dev_get_drvdata(dev);
0449     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0450     int nr = attr->index;
0451     long val;
0452     int err;
0453 
0454     err = kstrtol(buf, 10, &val);
0455     if (err)
0456         return err;
0457 
0458     mutex_lock(&data->update_lock);
0459     data->temp_over[nr] = TEMP_TO_REG(val);
0460     via686a_write_value(data, VIA686A_REG_TEMP_OVER[nr],
0461                 data->temp_over[nr]);
0462     mutex_unlock(&data->update_lock);
0463     return count;
0464 }
0465 static ssize_t temp_hyst_store(struct device *dev,
0466                    struct device_attribute *da, const char *buf,
0467                    size_t count) {
0468     struct via686a_data *data = dev_get_drvdata(dev);
0469     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0470     int nr = attr->index;
0471     long val;
0472     int err;
0473 
0474     err = kstrtol(buf, 10, &val);
0475     if (err)
0476         return err;
0477 
0478     mutex_lock(&data->update_lock);
0479     data->temp_hyst[nr] = TEMP_TO_REG(val);
0480     via686a_write_value(data, VIA686A_REG_TEMP_HYST[nr],
0481                 data->temp_hyst[nr]);
0482     mutex_unlock(&data->update_lock);
0483     return count;
0484 }
0485 
0486 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0487 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_over, 0);
0488 static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, temp_hyst, 0);
0489 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0490 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_over, 1);
0491 static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_hyst, 1);
0492 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0493 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_over, 2);
0494 static SENSOR_DEVICE_ATTR_RW(temp3_max_hyst, temp_hyst, 2);
0495 
0496 /* 2 Fans */
0497 static ssize_t fan_show(struct device *dev, struct device_attribute *da,
0498             char *buf) {
0499     struct via686a_data *data = via686a_update_device(dev);
0500     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0501     int nr = attr->index;
0502     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
0503                 DIV_FROM_REG(data->fan_div[nr])));
0504 }
0505 static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,
0506                 char *buf) {
0507     struct via686a_data *data = via686a_update_device(dev);
0508     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0509     int nr = attr->index;
0510     return sprintf(buf, "%d\n",
0511         FAN_FROM_REG(data->fan_min[nr],
0512                  DIV_FROM_REG(data->fan_div[nr])));
0513 }
0514 static ssize_t fan_div_show(struct device *dev, struct device_attribute *da,
0515                 char *buf) {
0516     struct via686a_data *data = via686a_update_device(dev);
0517     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0518     int nr = attr->index;
0519     return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
0520 }
0521 static ssize_t fan_min_store(struct device *dev, struct device_attribute *da,
0522                  const char *buf, size_t count) {
0523     struct via686a_data *data = dev_get_drvdata(dev);
0524     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0525     int nr = attr->index;
0526     unsigned long val;
0527     int err;
0528 
0529     err = kstrtoul(buf, 10, &val);
0530     if (err)
0531         return err;
0532 
0533     mutex_lock(&data->update_lock);
0534     data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
0535     via686a_write_value(data, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
0536     mutex_unlock(&data->update_lock);
0537     return count;
0538 }
0539 static ssize_t fan_div_store(struct device *dev, struct device_attribute *da,
0540                  const char *buf, size_t count) {
0541     struct via686a_data *data = dev_get_drvdata(dev);
0542     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0543     int nr = attr->index;
0544     int old;
0545     unsigned long val;
0546     int err;
0547 
0548     err = kstrtoul(buf, 10, &val);
0549     if (err)
0550         return err;
0551 
0552     mutex_lock(&data->update_lock);
0553     old = via686a_read_value(data, VIA686A_REG_FANDIV);
0554     data->fan_div[nr] = DIV_TO_REG(val);
0555     old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
0556     via686a_write_value(data, VIA686A_REG_FANDIV, old);
0557     mutex_unlock(&data->update_lock);
0558     return count;
0559 }
0560 
0561 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
0562 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
0563 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
0564 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
0565 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
0566 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
0567 
0568 /* Alarms */
0569 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0570                char *buf)
0571 {
0572     struct via686a_data *data = via686a_update_device(dev);
0573     return sprintf(buf, "%u\n", data->alarms);
0574 }
0575 
0576 static DEVICE_ATTR_RO(alarms);
0577 
0578 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0579               char *buf)
0580 {
0581     int bitnr = to_sensor_dev_attr(attr)->index;
0582     struct via686a_data *data = via686a_update_device(dev);
0583     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0584 }
0585 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
0586 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
0587 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
0588 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
0589 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
0590 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
0591 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 11);
0592 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 15);
0593 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
0594 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
0595 
0596 static ssize_t name_show(struct device *dev, struct device_attribute
0597              *devattr, char *buf)
0598 {
0599     struct via686a_data *data = dev_get_drvdata(dev);
0600     return sprintf(buf, "%s\n", data->name);
0601 }
0602 static DEVICE_ATTR_RO(name);
0603 
0604 static struct attribute *via686a_attributes[] = {
0605     &sensor_dev_attr_in0_input.dev_attr.attr,
0606     &sensor_dev_attr_in1_input.dev_attr.attr,
0607     &sensor_dev_attr_in2_input.dev_attr.attr,
0608     &sensor_dev_attr_in3_input.dev_attr.attr,
0609     &sensor_dev_attr_in4_input.dev_attr.attr,
0610     &sensor_dev_attr_in0_min.dev_attr.attr,
0611     &sensor_dev_attr_in1_min.dev_attr.attr,
0612     &sensor_dev_attr_in2_min.dev_attr.attr,
0613     &sensor_dev_attr_in3_min.dev_attr.attr,
0614     &sensor_dev_attr_in4_min.dev_attr.attr,
0615     &sensor_dev_attr_in0_max.dev_attr.attr,
0616     &sensor_dev_attr_in1_max.dev_attr.attr,
0617     &sensor_dev_attr_in2_max.dev_attr.attr,
0618     &sensor_dev_attr_in3_max.dev_attr.attr,
0619     &sensor_dev_attr_in4_max.dev_attr.attr,
0620     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0621     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0622     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0623     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0624     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0625 
0626     &sensor_dev_attr_temp1_input.dev_attr.attr,
0627     &sensor_dev_attr_temp2_input.dev_attr.attr,
0628     &sensor_dev_attr_temp3_input.dev_attr.attr,
0629     &sensor_dev_attr_temp1_max.dev_attr.attr,
0630     &sensor_dev_attr_temp2_max.dev_attr.attr,
0631     &sensor_dev_attr_temp3_max.dev_attr.attr,
0632     &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
0633     &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
0634     &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
0635     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0636     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0637     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0638 
0639     &sensor_dev_attr_fan1_input.dev_attr.attr,
0640     &sensor_dev_attr_fan2_input.dev_attr.attr,
0641     &sensor_dev_attr_fan1_min.dev_attr.attr,
0642     &sensor_dev_attr_fan2_min.dev_attr.attr,
0643     &sensor_dev_attr_fan1_div.dev_attr.attr,
0644     &sensor_dev_attr_fan2_div.dev_attr.attr,
0645     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0646     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0647 
0648     &dev_attr_alarms.attr,
0649     &dev_attr_name.attr,
0650     NULL
0651 };
0652 
0653 static const struct attribute_group via686a_group = {
0654     .attrs = via686a_attributes,
0655 };
0656 
0657 static struct platform_driver via686a_driver = {
0658     .driver = {
0659         .name   = "via686a",
0660     },
0661     .probe      = via686a_probe,
0662     .remove     = via686a_remove,
0663 };
0664 
0665 /* This is called when the module is loaded */
0666 static int via686a_probe(struct platform_device *pdev)
0667 {
0668     struct via686a_data *data;
0669     struct resource *res;
0670     int err;
0671 
0672     /* Reserve the ISA region */
0673     res = platform_get_resource(pdev, IORESOURCE_IO, 0);
0674     if (!devm_request_region(&pdev->dev, res->start, VIA686A_EXTENT,
0675                  via686a_driver.driver.name)) {
0676         dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n",
0677             (unsigned long)res->start, (unsigned long)res->end);
0678         return -ENODEV;
0679     }
0680 
0681     data = devm_kzalloc(&pdev->dev, sizeof(struct via686a_data),
0682                 GFP_KERNEL);
0683     if (!data)
0684         return -ENOMEM;
0685 
0686     platform_set_drvdata(pdev, data);
0687     data->addr = res->start;
0688     data->name = "via686a";
0689     mutex_init(&data->update_lock);
0690 
0691     /* Initialize the VIA686A chip */
0692     via686a_init_device(data);
0693 
0694     /* Register sysfs hooks */
0695     err = sysfs_create_group(&pdev->dev.kobj, &via686a_group);
0696     if (err)
0697         return err;
0698 
0699     data->hwmon_dev = hwmon_device_register(&pdev->dev);
0700     if (IS_ERR(data->hwmon_dev)) {
0701         err = PTR_ERR(data->hwmon_dev);
0702         goto exit_remove_files;
0703     }
0704 
0705     return 0;
0706 
0707 exit_remove_files:
0708     sysfs_remove_group(&pdev->dev.kobj, &via686a_group);
0709     return err;
0710 }
0711 
0712 static int via686a_remove(struct platform_device *pdev)
0713 {
0714     struct via686a_data *data = platform_get_drvdata(pdev);
0715 
0716     hwmon_device_unregister(data->hwmon_dev);
0717     sysfs_remove_group(&pdev->dev.kobj, &via686a_group);
0718 
0719     return 0;
0720 }
0721 
0722 static void via686a_update_fan_div(struct via686a_data *data)
0723 {
0724     int reg = via686a_read_value(data, VIA686A_REG_FANDIV);
0725     data->fan_div[0] = (reg >> 4) & 0x03;
0726     data->fan_div[1] = reg >> 6;
0727 }
0728 
0729 static void via686a_init_device(struct via686a_data *data)
0730 {
0731     u8 reg;
0732 
0733     /* Start monitoring */
0734     reg = via686a_read_value(data, VIA686A_REG_CONFIG);
0735     via686a_write_value(data, VIA686A_REG_CONFIG, (reg | 0x01) & 0x7F);
0736 
0737     /* Configure temp interrupt mode for continuous-interrupt operation */
0738     reg = via686a_read_value(data, VIA686A_REG_TEMP_MODE);
0739     via686a_write_value(data, VIA686A_REG_TEMP_MODE,
0740                 (reg & ~VIA686A_TEMP_MODE_MASK)
0741                 | VIA686A_TEMP_MODE_CONTINUOUS);
0742 
0743     /* Pre-read fan clock divisor values */
0744     via686a_update_fan_div(data);
0745 }
0746 
0747 static struct via686a_data *via686a_update_device(struct device *dev)
0748 {
0749     struct via686a_data *data = dev_get_drvdata(dev);
0750     int i;
0751 
0752     mutex_lock(&data->update_lock);
0753 
0754     if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
0755         || !data->valid) {
0756         for (i = 0; i <= 4; i++) {
0757             data->in[i] =
0758                 via686a_read_value(data, VIA686A_REG_IN(i));
0759             data->in_min[i] = via686a_read_value(data,
0760                                  VIA686A_REG_IN_MIN
0761                                  (i));
0762             data->in_max[i] =
0763                 via686a_read_value(data, VIA686A_REG_IN_MAX(i));
0764         }
0765         for (i = 1; i <= 2; i++) {
0766             data->fan[i - 1] =
0767                 via686a_read_value(data, VIA686A_REG_FAN(i));
0768             data->fan_min[i - 1] = via686a_read_value(data,
0769                              VIA686A_REG_FAN_MIN(i));
0770         }
0771         for (i = 0; i <= 2; i++) {
0772             data->temp[i] = via686a_read_value(data,
0773                          VIA686A_REG_TEMP[i]) << 2;
0774             data->temp_over[i] =
0775                 via686a_read_value(data,
0776                            VIA686A_REG_TEMP_OVER[i]);
0777             data->temp_hyst[i] =
0778                 via686a_read_value(data,
0779                            VIA686A_REG_TEMP_HYST[i]);
0780         }
0781         /*
0782          * add in lower 2 bits
0783          * temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1
0784          * temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
0785          * temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
0786          */
0787         data->temp[0] |= (via686a_read_value(data,
0788                              VIA686A_REG_TEMP_LOW1)
0789                   & 0xc0) >> 6;
0790         data->temp[1] |=
0791             (via686a_read_value(data, VIA686A_REG_TEMP_LOW23) &
0792              0x30) >> 4;
0793         data->temp[2] |=
0794             (via686a_read_value(data, VIA686A_REG_TEMP_LOW23) &
0795              0xc0) >> 6;
0796 
0797         via686a_update_fan_div(data);
0798         data->alarms =
0799             via686a_read_value(data,
0800                        VIA686A_REG_ALARM1) |
0801             (via686a_read_value(data, VIA686A_REG_ALARM2) << 8);
0802         data->last_updated = jiffies;
0803         data->valid = true;
0804     }
0805 
0806     mutex_unlock(&data->update_lock);
0807 
0808     return data;
0809 }
0810 
0811 static const struct pci_device_id via686a_pci_ids[] = {
0812     { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4) },
0813     { }
0814 };
0815 MODULE_DEVICE_TABLE(pci, via686a_pci_ids);
0816 
0817 static int via686a_device_add(unsigned short address)
0818 {
0819     struct resource res = {
0820         .start  = address,
0821         .end    = address + VIA686A_EXTENT - 1,
0822         .name   = "via686a",
0823         .flags  = IORESOURCE_IO,
0824     };
0825     int err;
0826 
0827     err = acpi_check_resource_conflict(&res);
0828     if (err)
0829         goto exit;
0830 
0831     pdev = platform_device_alloc("via686a", address);
0832     if (!pdev) {
0833         err = -ENOMEM;
0834         pr_err("Device allocation failed\n");
0835         goto exit;
0836     }
0837 
0838     err = platform_device_add_resources(pdev, &res, 1);
0839     if (err) {
0840         pr_err("Device resource addition failed (%d)\n", err);
0841         goto exit_device_put;
0842     }
0843 
0844     err = platform_device_add(pdev);
0845     if (err) {
0846         pr_err("Device addition failed (%d)\n", err);
0847         goto exit_device_put;
0848     }
0849 
0850     return 0;
0851 
0852 exit_device_put:
0853     platform_device_put(pdev);
0854 exit:
0855     return err;
0856 }
0857 
0858 static int via686a_pci_probe(struct pci_dev *dev,
0859                        const struct pci_device_id *id)
0860 {
0861     u16 address, val;
0862 
0863     if (force_addr) {
0864         address = force_addr & ~(VIA686A_EXTENT - 1);
0865         dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", address);
0866         if (PCIBIOS_SUCCESSFUL !=
0867             pci_write_config_word(dev, VIA686A_BASE_REG, address | 1))
0868             return -ENODEV;
0869     }
0870     if (PCIBIOS_SUCCESSFUL !=
0871         pci_read_config_word(dev, VIA686A_BASE_REG, &val))
0872         return -ENODEV;
0873 
0874     address = val & ~(VIA686A_EXTENT - 1);
0875     if (address == 0) {
0876         dev_err(&dev->dev,
0877             "base address not set - upgrade BIOS or use force_addr=0xaddr\n");
0878         return -ENODEV;
0879     }
0880 
0881     if (PCIBIOS_SUCCESSFUL !=
0882         pci_read_config_word(dev, VIA686A_ENABLE_REG, &val))
0883         return -ENODEV;
0884     if (!(val & 0x0001)) {
0885         if (!force_addr) {
0886             dev_warn(&dev->dev,
0887                  "Sensors disabled, enable with force_addr=0x%x\n",
0888                  address);
0889             return -ENODEV;
0890         }
0891 
0892         dev_warn(&dev->dev, "Enabling sensors\n");
0893         if (PCIBIOS_SUCCESSFUL !=
0894             pci_write_config_word(dev, VIA686A_ENABLE_REG,
0895                       val | 0x0001))
0896             return -ENODEV;
0897     }
0898 
0899     if (platform_driver_register(&via686a_driver))
0900         goto exit;
0901 
0902     /* Sets global pdev as a side effect */
0903     if (via686a_device_add(address))
0904         goto exit_unregister;
0905 
0906     /*
0907      * Always return failure here.  This is to allow other drivers to bind
0908      * to this pci device.  We don't really want to have control over the
0909      * pci device, we only wanted to read as few register values from it.
0910      */
0911     s_bridge = pci_dev_get(dev);
0912     return -ENODEV;
0913 
0914 exit_unregister:
0915     platform_driver_unregister(&via686a_driver);
0916 exit:
0917     return -ENODEV;
0918 }
0919 
0920 static struct pci_driver via686a_pci_driver = {
0921     .name       = "via686a",
0922     .id_table   = via686a_pci_ids,
0923     .probe      = via686a_pci_probe,
0924 };
0925 
0926 static int __init sm_via686a_init(void)
0927 {
0928     return pci_register_driver(&via686a_pci_driver);
0929 }
0930 
0931 static void __exit sm_via686a_exit(void)
0932 {
0933     pci_unregister_driver(&via686a_pci_driver);
0934     if (s_bridge != NULL) {
0935         platform_device_unregister(pdev);
0936         platform_driver_unregister(&via686a_driver);
0937         pci_dev_put(s_bridge);
0938         s_bridge = NULL;
0939     }
0940 }
0941 
0942 MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
0943           "Mark Studebaker <mdsxyz123@yahoo.com> "
0944           "and Bob Dougherty <bobd@stanford.edu>");
0945 MODULE_DESCRIPTION("VIA 686A Sensor device");
0946 MODULE_LICENSE("GPL");
0947 
0948 module_init(sm_via686a_init);
0949 module_exit(sm_via686a_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!