Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * vt8231.c - Part of lm_sensors, Linux kernel modules
0004  *        for hardware monitoring
0005  *
0006  * Copyright (c) 2005 Roger Lucas <vt8231@hiddenengine.co.uk>
0007  * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
0008  *            Aaron M. Marsh <amarsh@sdf.lonestar.org>
0009  */
0010 
0011 /*
0012  * Supports VIA VT8231 South Bridge embedded sensors
0013  */
0014 
0015 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0016 
0017 #include <linux/module.h>
0018 #include <linux/init.h>
0019 #include <linux/slab.h>
0020 #include <linux/pci.h>
0021 #include <linux/jiffies.h>
0022 #include <linux/platform_device.h>
0023 #include <linux/hwmon.h>
0024 #include <linux/hwmon-sysfs.h>
0025 #include <linux/hwmon-vid.h>
0026 #include <linux/err.h>
0027 #include <linux/mutex.h>
0028 #include <linux/acpi.h>
0029 #include <linux/io.h>
0030 
0031 static int force_addr;
0032 module_param(force_addr, int, 0);
0033 MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors");
0034 
0035 static struct platform_device *pdev;
0036 
0037 #define VT8231_EXTENT 0x80
0038 #define VT8231_BASE_REG 0x70
0039 #define VT8231_ENABLE_REG 0x74
0040 
0041 /*
0042  * The VT8231 registers
0043  *
0044  * The reset value for the input channel configuration is used (Reg 0x4A=0x07)
0045  * which sets the selected inputs marked with '*' below if multiple options are
0046  * possible:
0047  *
0048  *          Voltage Mode      Temperature Mode
0049  *  Sensor        Linux Id        Linux Id        VIA Id
0050  *  --------      --------        --------        ------
0051  *  CPU Diode   N/A     temp1       0
0052  *  UIC1        in0     temp2 *     1
0053  *  UIC2        in1 *       temp3       2
0054  *  UIC3        in2 *       temp4       3
0055  *  UIC4        in3 *       temp5       4
0056  *  UIC5        in4 *       temp6       5
0057  *  3.3V        in5     N/A
0058  *
0059  * Note that the BIOS may set the configuration register to a different value
0060  * to match the motherboard configuration.
0061  */
0062 
0063 /* fans numbered 0-1 */
0064 #define VT8231_REG_FAN_MIN(nr)  (0x3b + (nr))
0065 #define VT8231_REG_FAN(nr)  (0x29 + (nr))
0066 
0067 /* Voltage inputs numbered 0-5 */
0068 
0069 static const u8 regvolt[]    = { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26 };
0070 static const u8 regvoltmax[] = { 0x3d, 0x2b, 0x2d, 0x2f, 0x31, 0x33 };
0071 static const u8 regvoltmin[] = { 0x3e, 0x2c, 0x2e, 0x30, 0x32, 0x34 };
0072 
0073 /*
0074  * Temperatures are numbered 1-6 according to the Linux kernel specification.
0075  *
0076  * In the VIA datasheet, however, the temperatures are numbered from zero.
0077  * Since it is important that this driver can easily be compared to the VIA
0078  * datasheet, we will use the VIA numbering within this driver and map the
0079  * kernel sysfs device name to the VIA number in the sysfs callback.
0080  */
0081 
0082 #define VT8231_REG_TEMP_LOW01   0x49
0083 #define VT8231_REG_TEMP_LOW25   0x4d
0084 
0085 static const u8 regtemp[]    = { 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25 };
0086 static const u8 regtempmax[] = { 0x39, 0x3d, 0x2b, 0x2d, 0x2f, 0x31 };
0087 static const u8 regtempmin[] = { 0x3a, 0x3e, 0x2c, 0x2e, 0x30, 0x32 };
0088 
0089 #define TEMP_FROM_REG(reg)      (((253 * 4 - (reg)) * 550 + 105) / 210)
0090 #define TEMP_MAXMIN_FROM_REG(reg)   (((253 - (reg)) * 2200 + 105) / 210)
0091 #define TEMP_MAXMIN_TO_REG(val)     (253 - ((val) * 210 + 1100) / 2200)
0092 
0093 #define VT8231_REG_CONFIG 0x40
0094 #define VT8231_REG_ALARM1 0x41
0095 #define VT8231_REG_ALARM2 0x42
0096 #define VT8231_REG_FANDIV 0x47
0097 #define VT8231_REG_UCH_CONFIG 0x4a
0098 #define VT8231_REG_TEMP1_CONFIG 0x4b
0099 #define VT8231_REG_TEMP2_CONFIG 0x4c
0100 
0101 /*
0102  * temps 0-5 as numbered in VIA datasheet - see later for mapping to Linux
0103  * numbering
0104  */
0105 #define ISTEMP(i, ch_config) ((i) == 0 ? 1 : \
0106                   ((ch_config) >> ((i)+1)) & 0x01)
0107 /* voltages 0-5 */
0108 #define ISVOLT(i, ch_config) ((i) == 5 ? 1 : \
0109                   !(((ch_config) >> ((i)+2)) & 0x01))
0110 
0111 #define DIV_FROM_REG(val) (1 << (val))
0112 
0113 /*
0114  * NB  The values returned here are NOT temperatures.  The calibration curves
0115  *     for the thermistor curves are board-specific and must go in the
0116  *     sensors.conf file.  Temperature sensors are actually ten bits, but the
0117  *     VIA datasheet only considers the 8 MSBs obtained from the regtemp[]
0118  *     register.  The temperature value returned should have a magnitude of 3,
0119  *     so we use the VIA scaling as the "true" scaling and use the remaining 2
0120  *     LSBs as fractional precision.
0121  *
0122  *     All the on-chip hardware temperature comparisons for the alarms are only
0123  *     8-bits wide, and compare against the 8 MSBs of the temperature.  The bits
0124  *     in the registers VT8231_REG_TEMP_LOW01 and VT8231_REG_TEMP_LOW25 are
0125  *     ignored.
0126  */
0127 
0128 /*
0129  ****** FAN RPM CONVERSIONS ********
0130  * This chip saturates back at 0, not at 255 like many the other chips.
0131  * So, 0 means 0 RPM
0132  */
0133 static inline u8 FAN_TO_REG(long rpm, int div)
0134 {
0135     if (rpm <= 0 || rpm > 1310720)
0136         return 0;
0137     return clamp_val(1310720 / (rpm * div), 1, 255);
0138 }
0139 
0140 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div)))
0141 
0142 struct vt8231_data {
0143     unsigned short addr;
0144     const char *name;
0145 
0146     struct mutex update_lock;
0147     struct device *hwmon_dev;
0148     bool valid;     /* true if following fields are valid */
0149     unsigned long last_updated; /* In jiffies */
0150 
0151     u8 in[6];       /* Register value */
0152     u8 in_max[6];       /* Register value */
0153     u8 in_min[6];       /* Register value */
0154     u16 temp[6];        /* Register value 10 bit, right aligned */
0155     u8 temp_max[6];     /* Register value */
0156     u8 temp_min[6];     /* Register value */
0157     u8 fan[2];      /* Register value */
0158     u8 fan_min[2];      /* Register value */
0159     u8 fan_div[2];      /* Register encoding, shifted right */
0160     u16 alarms;     /* Register encoding */
0161     u8 uch_config;
0162 };
0163 
0164 static struct pci_dev *s_bridge;
0165 static int vt8231_probe(struct platform_device *pdev);
0166 static int vt8231_remove(struct platform_device *pdev);
0167 static struct vt8231_data *vt8231_update_device(struct device *dev);
0168 static void vt8231_init_device(struct vt8231_data *data);
0169 
0170 static inline int vt8231_read_value(struct vt8231_data *data, u8 reg)
0171 {
0172     return inb_p(data->addr + reg);
0173 }
0174 
0175 static inline void vt8231_write_value(struct vt8231_data *data, u8 reg,
0176                     u8 value)
0177 {
0178     outb_p(value, data->addr + reg);
0179 }
0180 
0181 /* following are the sysfs callback functions */
0182 static ssize_t in_show(struct device *dev, struct device_attribute *attr,
0183                char *buf)
0184 {
0185     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0186     int nr = sensor_attr->index;
0187     struct vt8231_data *data = vt8231_update_device(dev);
0188 
0189     return sprintf(buf, "%d\n", ((data->in[nr] - 3) * 10000) / 958);
0190 }
0191 
0192 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
0193                char *buf)
0194 {
0195     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0196     int nr = sensor_attr->index;
0197     struct vt8231_data *data = vt8231_update_device(dev);
0198 
0199     return sprintf(buf, "%d\n", ((data->in_min[nr] - 3) * 10000) / 958);
0200 }
0201 
0202 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
0203                char *buf)
0204 {
0205     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0206     int nr = sensor_attr->index;
0207     struct vt8231_data *data = vt8231_update_device(dev);
0208 
0209     return sprintf(buf, "%d\n", (((data->in_max[nr] - 3) * 10000) / 958));
0210 }
0211 
0212 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
0213                 const char *buf, size_t count)
0214 {
0215     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0216     int nr = sensor_attr->index;
0217     struct vt8231_data *data = dev_get_drvdata(dev);
0218     unsigned long val;
0219     int err;
0220 
0221     err = kstrtoul(buf, 10, &val);
0222     if (err)
0223         return err;
0224 
0225     mutex_lock(&data->update_lock);
0226     data->in_min[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255);
0227     vt8231_write_value(data, regvoltmin[nr], data->in_min[nr]);
0228     mutex_unlock(&data->update_lock);
0229     return count;
0230 }
0231 
0232 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
0233                 const char *buf, size_t count)
0234 {
0235     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0236     int nr = sensor_attr->index;
0237     struct vt8231_data *data = dev_get_drvdata(dev);
0238     unsigned long val;
0239     int err;
0240 
0241     err = kstrtoul(buf, 10, &val);
0242     if (err)
0243         return err;
0244 
0245     mutex_lock(&data->update_lock);
0246     data->in_max[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255);
0247     vt8231_write_value(data, regvoltmax[nr], data->in_max[nr]);
0248     mutex_unlock(&data->update_lock);
0249     return count;
0250 }
0251 
0252 /* Special case for input 5 as this has 3.3V scaling built into the chip */
0253 static ssize_t in5_input_show(struct device *dev,
0254                   struct device_attribute *attr, char *buf)
0255 {
0256     struct vt8231_data *data = vt8231_update_device(dev);
0257 
0258     return sprintf(buf, "%d\n",
0259         (((data->in[5] - 3) * 10000 * 54) / (958 * 34)));
0260 }
0261 
0262 static ssize_t in5_min_show(struct device *dev, struct device_attribute *attr,
0263         char *buf)
0264 {
0265     struct vt8231_data *data = vt8231_update_device(dev);
0266 
0267     return sprintf(buf, "%d\n",
0268         (((data->in_min[5] - 3) * 10000 * 54) / (958 * 34)));
0269 }
0270 
0271 static ssize_t in5_max_show(struct device *dev, struct device_attribute *attr,
0272         char *buf)
0273 {
0274     struct vt8231_data *data = vt8231_update_device(dev);
0275 
0276     return sprintf(buf, "%d\n",
0277         (((data->in_max[5] - 3) * 10000 * 54) / (958 * 34)));
0278 }
0279 
0280 static ssize_t in5_min_store(struct device *dev,
0281                  struct device_attribute *attr, const char *buf,
0282                  size_t count)
0283 {
0284     struct vt8231_data *data = dev_get_drvdata(dev);
0285     unsigned long val;
0286     int err;
0287 
0288     err = kstrtoul(buf, 10, &val);
0289     if (err)
0290         return err;
0291 
0292     mutex_lock(&data->update_lock);
0293     data->in_min[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3,
0294                     0, 255);
0295     vt8231_write_value(data, regvoltmin[5], data->in_min[5]);
0296     mutex_unlock(&data->update_lock);
0297     return count;
0298 }
0299 
0300 static ssize_t in5_max_store(struct device *dev,
0301                  struct device_attribute *attr, const char *buf,
0302                  size_t count)
0303 {
0304     struct vt8231_data *data = dev_get_drvdata(dev);
0305     unsigned long val;
0306     int err;
0307 
0308     err = kstrtoul(buf, 10, &val);
0309     if (err)
0310         return err;
0311 
0312     mutex_lock(&data->update_lock);
0313     data->in_max[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3,
0314                     0, 255);
0315     vt8231_write_value(data, regvoltmax[5], data->in_max[5]);
0316     mutex_unlock(&data->update_lock);
0317     return count;
0318 }
0319 
0320 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
0321 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0322 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0323 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
0324 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0325 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0326 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
0327 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0328 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0329 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
0330 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0331 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0332 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
0333 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0334 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0335 
0336 static DEVICE_ATTR_RO(in5_input);
0337 static DEVICE_ATTR_RW(in5_min);
0338 static DEVICE_ATTR_RW(in5_max);
0339 
0340 /* Temperatures */
0341 static ssize_t temp1_input_show(struct device *dev,
0342                 struct device_attribute *attr, char *buf)
0343 {
0344     struct vt8231_data *data = vt8231_update_device(dev);
0345     return sprintf(buf, "%d\n", data->temp[0] * 250);
0346 }
0347 
0348 static ssize_t temp1_max_show(struct device *dev, struct device_attribute *attr,
0349         char *buf)
0350 {
0351     struct vt8231_data *data = vt8231_update_device(dev);
0352     return sprintf(buf, "%d\n", data->temp_max[0] * 1000);
0353 }
0354 
0355 static ssize_t temp1_max_hyst_show(struct device *dev,
0356                    struct device_attribute *attr, char *buf)
0357 {
0358     struct vt8231_data *data = vt8231_update_device(dev);
0359     return sprintf(buf, "%d\n", data->temp_min[0] * 1000);
0360 }
0361 
0362 static ssize_t temp1_max_store(struct device *dev,
0363                    struct device_attribute *attr, const char *buf,
0364                    size_t count)
0365 {
0366     struct vt8231_data *data = dev_get_drvdata(dev);
0367     long val;
0368     int err;
0369 
0370     err = kstrtol(buf, 10, &val);
0371     if (err)
0372         return err;
0373 
0374     mutex_lock(&data->update_lock);
0375     data->temp_max[0] = clamp_val((val + 500) / 1000, 0, 255);
0376     vt8231_write_value(data, regtempmax[0], data->temp_max[0]);
0377     mutex_unlock(&data->update_lock);
0378     return count;
0379 }
0380 static ssize_t temp1_max_hyst_store(struct device *dev,
0381                     struct device_attribute *attr,
0382                     const char *buf, size_t count)
0383 {
0384     struct vt8231_data *data = dev_get_drvdata(dev);
0385     long val;
0386     int err;
0387 
0388     err = kstrtol(buf, 10, &val);
0389     if (err)
0390         return err;
0391 
0392     mutex_lock(&data->update_lock);
0393     data->temp_min[0] = clamp_val((val + 500) / 1000, 0, 255);
0394     vt8231_write_value(data, regtempmin[0], data->temp_min[0]);
0395     mutex_unlock(&data->update_lock);
0396     return count;
0397 }
0398 
0399 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0400              char *buf)
0401 {
0402     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0403     int nr = sensor_attr->index;
0404     struct vt8231_data *data = vt8231_update_device(dev);
0405     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
0406 }
0407 
0408 static ssize_t temp_max_show(struct device *dev,
0409                  struct device_attribute *attr, char *buf)
0410 {
0411     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0412     int nr = sensor_attr->index;
0413     struct vt8231_data *data = vt8231_update_device(dev);
0414     return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_max[nr]));
0415 }
0416 
0417 static ssize_t temp_min_show(struct device *dev,
0418                  struct device_attribute *attr, char *buf)
0419 {
0420     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0421     int nr = sensor_attr->index;
0422     struct vt8231_data *data = vt8231_update_device(dev);
0423     return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_min[nr]));
0424 }
0425 
0426 static ssize_t temp_max_store(struct device *dev,
0427                   struct device_attribute *attr, const char *buf,
0428                   size_t count)
0429 {
0430     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0431     int nr = sensor_attr->index;
0432     struct vt8231_data *data = dev_get_drvdata(dev);
0433     long val;
0434     int err;
0435 
0436     err = kstrtol(buf, 10, &val);
0437     if (err)
0438         return err;
0439 
0440     mutex_lock(&data->update_lock);
0441     data->temp_max[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255);
0442     vt8231_write_value(data, regtempmax[nr], data->temp_max[nr]);
0443     mutex_unlock(&data->update_lock);
0444     return count;
0445 }
0446 static ssize_t temp_min_store(struct device *dev,
0447                   struct device_attribute *attr, const char *buf,
0448                   size_t count)
0449 {
0450     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0451     int nr = sensor_attr->index;
0452     struct vt8231_data *data = dev_get_drvdata(dev);
0453     long val;
0454     int err;
0455 
0456     err = kstrtol(buf, 10, &val);
0457     if (err)
0458         return err;
0459 
0460     mutex_lock(&data->update_lock);
0461     data->temp_min[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255);
0462     vt8231_write_value(data, regtempmin[nr], data->temp_min[nr]);
0463     mutex_unlock(&data->update_lock);
0464     return count;
0465 }
0466 
0467 /*
0468  * Note that these map the Linux temperature sensor numbering (1-6) to the VIA
0469  * temperature sensor numbering (0-5)
0470  */
0471 
0472 static DEVICE_ATTR_RO(temp1_input);
0473 static DEVICE_ATTR_RW(temp1_max);
0474 static DEVICE_ATTR_RW(temp1_max_hyst);
0475 
0476 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0477 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0478 static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_min, 1);
0479 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0480 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
0481 static SENSOR_DEVICE_ATTR_RW(temp3_max_hyst, temp_min, 2);
0482 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
0483 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
0484 static SENSOR_DEVICE_ATTR_RW(temp4_max_hyst, temp_min, 3);
0485 static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
0486 static SENSOR_DEVICE_ATTR_RW(temp5_max, temp_max, 4);
0487 static SENSOR_DEVICE_ATTR_RW(temp5_max_hyst, temp_min, 4);
0488 static SENSOR_DEVICE_ATTR_RO(temp6_input, temp, 5);
0489 static SENSOR_DEVICE_ATTR_RW(temp6_max, temp_max, 5);
0490 static SENSOR_DEVICE_ATTR_RW(temp6_max_hyst, temp_min, 5);
0491 
0492 /* Fans */
0493 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
0494             char *buf)
0495 {
0496     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0497     int nr = sensor_attr->index;
0498     struct vt8231_data *data = vt8231_update_device(dev);
0499     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
0500                 DIV_FROM_REG(data->fan_div[nr])));
0501 }
0502 
0503 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
0504                 char *buf)
0505 {
0506     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0507     int nr = sensor_attr->index;
0508     struct vt8231_data *data = vt8231_update_device(dev);
0509     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
0510             DIV_FROM_REG(data->fan_div[nr])));
0511 }
0512 
0513 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
0514                 char *buf)
0515 {
0516     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0517     int nr = sensor_attr->index;
0518     struct vt8231_data *data = vt8231_update_device(dev);
0519     return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
0520 }
0521 
0522 static ssize_t fan_min_store(struct device *dev,
0523                  struct device_attribute *attr, const char *buf,
0524                  size_t count)
0525 {
0526     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0527     int nr = sensor_attr->index;
0528     struct vt8231_data *data = dev_get_drvdata(dev);
0529     unsigned long val;
0530     int err;
0531 
0532     err = kstrtoul(buf, 10, &val);
0533     if (err)
0534         return err;
0535 
0536     mutex_lock(&data->update_lock);
0537     data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
0538     vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
0539     mutex_unlock(&data->update_lock);
0540     return count;
0541 }
0542 
0543 static ssize_t fan_div_store(struct device *dev,
0544                  struct device_attribute *attr, const char *buf,
0545                  size_t count)
0546 {
0547     struct vt8231_data *data = dev_get_drvdata(dev);
0548     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0549     unsigned long val;
0550     int nr = sensor_attr->index;
0551     int old = vt8231_read_value(data, VT8231_REG_FANDIV);
0552     long min = FAN_FROM_REG(data->fan_min[nr],
0553                  DIV_FROM_REG(data->fan_div[nr]));
0554     int err;
0555 
0556     err = kstrtoul(buf, 10, &val);
0557     if (err)
0558         return err;
0559 
0560     mutex_lock(&data->update_lock);
0561     switch (val) {
0562     case 1:
0563         data->fan_div[nr] = 0;
0564         break;
0565     case 2:
0566         data->fan_div[nr] = 1;
0567         break;
0568     case 4:
0569         data->fan_div[nr] = 2;
0570         break;
0571     case 8:
0572         data->fan_div[nr] = 3;
0573         break;
0574     default:
0575         dev_err(dev,
0576             "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
0577             val);
0578         mutex_unlock(&data->update_lock);
0579         return -EINVAL;
0580     }
0581 
0582     /* Correct the fan minimum speed */
0583     data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
0584     vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
0585 
0586     old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
0587     vt8231_write_value(data, VT8231_REG_FANDIV, old);
0588     mutex_unlock(&data->update_lock);
0589     return count;
0590 }
0591 
0592 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
0593 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
0594 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
0595 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
0596 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
0597 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
0598 
0599 /* Alarms */
0600 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0601                char *buf)
0602 {
0603     struct vt8231_data *data = vt8231_update_device(dev);
0604     return sprintf(buf, "%d\n", data->alarms);
0605 }
0606 static DEVICE_ATTR_RO(alarms);
0607 
0608 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0609               char *buf)
0610 {
0611     int bitnr = to_sensor_dev_attr(attr)->index;
0612     struct vt8231_data *data = vt8231_update_device(dev);
0613     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0614 }
0615 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
0616 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 11);
0617 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0);
0618 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm, 1);
0619 static SENSOR_DEVICE_ATTR_RO(temp5_alarm, alarm, 3);
0620 static SENSOR_DEVICE_ATTR_RO(temp6_alarm, alarm, 8);
0621 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 11);
0622 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0);
0623 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 1);
0624 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
0625 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
0626 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 2);
0627 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
0628 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
0629 
0630 static ssize_t name_show(struct device *dev, struct device_attribute
0631              *devattr, char *buf)
0632 {
0633     struct vt8231_data *data = dev_get_drvdata(dev);
0634     return sprintf(buf, "%s\n", data->name);
0635 }
0636 static DEVICE_ATTR_RO(name);
0637 
0638 static struct attribute *vt8231_attributes_temps[6][5] = {
0639     {
0640         &dev_attr_temp1_input.attr,
0641         &dev_attr_temp1_max_hyst.attr,
0642         &dev_attr_temp1_max.attr,
0643         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0644         NULL
0645     }, {
0646         &sensor_dev_attr_temp2_input.dev_attr.attr,
0647         &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
0648         &sensor_dev_attr_temp2_max.dev_attr.attr,
0649         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0650         NULL
0651     }, {
0652         &sensor_dev_attr_temp3_input.dev_attr.attr,
0653         &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
0654         &sensor_dev_attr_temp3_max.dev_attr.attr,
0655         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0656         NULL
0657     }, {
0658         &sensor_dev_attr_temp4_input.dev_attr.attr,
0659         &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
0660         &sensor_dev_attr_temp4_max.dev_attr.attr,
0661         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
0662         NULL
0663     }, {
0664         &sensor_dev_attr_temp5_input.dev_attr.attr,
0665         &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
0666         &sensor_dev_attr_temp5_max.dev_attr.attr,
0667         &sensor_dev_attr_temp5_alarm.dev_attr.attr,
0668         NULL
0669     }, {
0670         &sensor_dev_attr_temp6_input.dev_attr.attr,
0671         &sensor_dev_attr_temp6_max_hyst.dev_attr.attr,
0672         &sensor_dev_attr_temp6_max.dev_attr.attr,
0673         &sensor_dev_attr_temp6_alarm.dev_attr.attr,
0674         NULL
0675     }
0676 };
0677 
0678 static const struct attribute_group vt8231_group_temps[6] = {
0679     { .attrs = vt8231_attributes_temps[0] },
0680     { .attrs = vt8231_attributes_temps[1] },
0681     { .attrs = vt8231_attributes_temps[2] },
0682     { .attrs = vt8231_attributes_temps[3] },
0683     { .attrs = vt8231_attributes_temps[4] },
0684     { .attrs = vt8231_attributes_temps[5] },
0685 };
0686 
0687 static struct attribute *vt8231_attributes_volts[6][5] = {
0688     {
0689         &sensor_dev_attr_in0_input.dev_attr.attr,
0690         &sensor_dev_attr_in0_min.dev_attr.attr,
0691         &sensor_dev_attr_in0_max.dev_attr.attr,
0692         &sensor_dev_attr_in0_alarm.dev_attr.attr,
0693         NULL
0694     }, {
0695         &sensor_dev_attr_in1_input.dev_attr.attr,
0696         &sensor_dev_attr_in1_min.dev_attr.attr,
0697         &sensor_dev_attr_in1_max.dev_attr.attr,
0698         &sensor_dev_attr_in1_alarm.dev_attr.attr,
0699         NULL
0700     }, {
0701         &sensor_dev_attr_in2_input.dev_attr.attr,
0702         &sensor_dev_attr_in2_min.dev_attr.attr,
0703         &sensor_dev_attr_in2_max.dev_attr.attr,
0704         &sensor_dev_attr_in2_alarm.dev_attr.attr,
0705         NULL
0706     }, {
0707         &sensor_dev_attr_in3_input.dev_attr.attr,
0708         &sensor_dev_attr_in3_min.dev_attr.attr,
0709         &sensor_dev_attr_in3_max.dev_attr.attr,
0710         &sensor_dev_attr_in3_alarm.dev_attr.attr,
0711         NULL
0712     }, {
0713         &sensor_dev_attr_in4_input.dev_attr.attr,
0714         &sensor_dev_attr_in4_min.dev_attr.attr,
0715         &sensor_dev_attr_in4_max.dev_attr.attr,
0716         &sensor_dev_attr_in4_alarm.dev_attr.attr,
0717         NULL
0718     }, {
0719         &dev_attr_in5_input.attr,
0720         &dev_attr_in5_min.attr,
0721         &dev_attr_in5_max.attr,
0722         &sensor_dev_attr_in5_alarm.dev_attr.attr,
0723         NULL
0724     }
0725 };
0726 
0727 static const struct attribute_group vt8231_group_volts[6] = {
0728     { .attrs = vt8231_attributes_volts[0] },
0729     { .attrs = vt8231_attributes_volts[1] },
0730     { .attrs = vt8231_attributes_volts[2] },
0731     { .attrs = vt8231_attributes_volts[3] },
0732     { .attrs = vt8231_attributes_volts[4] },
0733     { .attrs = vt8231_attributes_volts[5] },
0734 };
0735 
0736 static struct attribute *vt8231_attributes[] = {
0737     &sensor_dev_attr_fan1_input.dev_attr.attr,
0738     &sensor_dev_attr_fan2_input.dev_attr.attr,
0739     &sensor_dev_attr_fan1_min.dev_attr.attr,
0740     &sensor_dev_attr_fan2_min.dev_attr.attr,
0741     &sensor_dev_attr_fan1_div.dev_attr.attr,
0742     &sensor_dev_attr_fan2_div.dev_attr.attr,
0743     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0744     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0745     &dev_attr_alarms.attr,
0746     &dev_attr_name.attr,
0747     NULL
0748 };
0749 
0750 static const struct attribute_group vt8231_group = {
0751     .attrs = vt8231_attributes,
0752 };
0753 
0754 static struct platform_driver vt8231_driver = {
0755     .driver = {
0756         .name   = "vt8231",
0757     },
0758     .probe  = vt8231_probe,
0759     .remove = vt8231_remove,
0760 };
0761 
0762 static const struct pci_device_id vt8231_pci_ids[] = {
0763     { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4) },
0764     { 0, }
0765 };
0766 
0767 MODULE_DEVICE_TABLE(pci, vt8231_pci_ids);
0768 
0769 static int vt8231_pci_probe(struct pci_dev *dev,
0770                       const struct pci_device_id *id);
0771 
0772 static struct pci_driver vt8231_pci_driver = {
0773     .name       = "vt8231",
0774     .id_table   = vt8231_pci_ids,
0775     .probe      = vt8231_pci_probe,
0776 };
0777 
0778 static int vt8231_probe(struct platform_device *pdev)
0779 {
0780     struct resource *res;
0781     struct vt8231_data *data;
0782     int err = 0, i;
0783 
0784     /* Reserve the ISA region */
0785     res = platform_get_resource(pdev, IORESOURCE_IO, 0);
0786     if (!devm_request_region(&pdev->dev, res->start, VT8231_EXTENT,
0787                  vt8231_driver.driver.name)) {
0788         dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n",
0789             (unsigned long)res->start, (unsigned long)res->end);
0790         return -ENODEV;
0791     }
0792 
0793     data = devm_kzalloc(&pdev->dev, sizeof(struct vt8231_data), GFP_KERNEL);
0794     if (!data)
0795         return -ENOMEM;
0796 
0797     platform_set_drvdata(pdev, data);
0798     data->addr = res->start;
0799     data->name = "vt8231";
0800 
0801     mutex_init(&data->update_lock);
0802     vt8231_init_device(data);
0803 
0804     /* Register sysfs hooks */
0805     err = sysfs_create_group(&pdev->dev.kobj, &vt8231_group);
0806     if (err)
0807         return err;
0808 
0809     /* Must update device information to find out the config field */
0810     data->uch_config = vt8231_read_value(data, VT8231_REG_UCH_CONFIG);
0811 
0812     for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) {
0813         if (ISTEMP(i, data->uch_config)) {
0814             err = sysfs_create_group(&pdev->dev.kobj,
0815                          &vt8231_group_temps[i]);
0816             if (err)
0817                 goto exit_remove_files;
0818         }
0819     }
0820 
0821     for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) {
0822         if (ISVOLT(i, data->uch_config)) {
0823             err = sysfs_create_group(&pdev->dev.kobj,
0824                          &vt8231_group_volts[i]);
0825             if (err)
0826                 goto exit_remove_files;
0827         }
0828     }
0829 
0830     data->hwmon_dev = hwmon_device_register(&pdev->dev);
0831     if (IS_ERR(data->hwmon_dev)) {
0832         err = PTR_ERR(data->hwmon_dev);
0833         goto exit_remove_files;
0834     }
0835     return 0;
0836 
0837 exit_remove_files:
0838     for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
0839         sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
0840 
0841     for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
0842         sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
0843 
0844     sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
0845     return err;
0846 }
0847 
0848 static int vt8231_remove(struct platform_device *pdev)
0849 {
0850     struct vt8231_data *data = platform_get_drvdata(pdev);
0851     int i;
0852 
0853     hwmon_device_unregister(data->hwmon_dev);
0854 
0855     for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
0856         sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
0857 
0858     for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
0859         sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
0860 
0861     sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
0862 
0863     return 0;
0864 }
0865 
0866 static void vt8231_init_device(struct vt8231_data *data)
0867 {
0868     vt8231_write_value(data, VT8231_REG_TEMP1_CONFIG, 0);
0869     vt8231_write_value(data, VT8231_REG_TEMP2_CONFIG, 0);
0870 }
0871 
0872 static struct vt8231_data *vt8231_update_device(struct device *dev)
0873 {
0874     struct vt8231_data *data = dev_get_drvdata(dev);
0875     int i;
0876     u16 low;
0877 
0878     mutex_lock(&data->update_lock);
0879 
0880     if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
0881         || !data->valid) {
0882         for (i = 0; i < 6; i++) {
0883             if (ISVOLT(i, data->uch_config)) {
0884                 data->in[i] = vt8231_read_value(data,
0885                         regvolt[i]);
0886                 data->in_min[i] = vt8231_read_value(data,
0887                         regvoltmin[i]);
0888                 data->in_max[i] = vt8231_read_value(data,
0889                         regvoltmax[i]);
0890             }
0891         }
0892         for (i = 0; i < 2; i++) {
0893             data->fan[i] = vt8231_read_value(data,
0894                         VT8231_REG_FAN(i));
0895             data->fan_min[i] = vt8231_read_value(data,
0896                         VT8231_REG_FAN_MIN(i));
0897         }
0898 
0899         low = vt8231_read_value(data, VT8231_REG_TEMP_LOW01);
0900         low = (low >> 6) | ((low & 0x30) >> 2)
0901             | (vt8231_read_value(data, VT8231_REG_TEMP_LOW25) << 4);
0902         for (i = 0; i < 6; i++) {
0903             if (ISTEMP(i, data->uch_config)) {
0904                 data->temp[i] = (vt8231_read_value(data,
0905                                regtemp[i]) << 2)
0906                         | ((low >> (2 * i)) & 0x03);
0907                 data->temp_max[i] = vt8231_read_value(data,
0908                               regtempmax[i]);
0909                 data->temp_min[i] = vt8231_read_value(data,
0910                               regtempmin[i]);
0911             }
0912         }
0913 
0914         i = vt8231_read_value(data, VT8231_REG_FANDIV);
0915         data->fan_div[0] = (i >> 4) & 0x03;
0916         data->fan_div[1] = i >> 6;
0917         data->alarms = vt8231_read_value(data, VT8231_REG_ALARM1) |
0918             (vt8231_read_value(data, VT8231_REG_ALARM2) << 8);
0919 
0920         /* Set alarm flags correctly */
0921         if (!data->fan[0] && data->fan_min[0])
0922             data->alarms |= 0x40;
0923         else if (data->fan[0] && !data->fan_min[0])
0924             data->alarms &= ~0x40;
0925 
0926         if (!data->fan[1] && data->fan_min[1])
0927             data->alarms |= 0x80;
0928         else if (data->fan[1] && !data->fan_min[1])
0929             data->alarms &= ~0x80;
0930 
0931         data->last_updated = jiffies;
0932         data->valid = true;
0933     }
0934 
0935     mutex_unlock(&data->update_lock);
0936 
0937     return data;
0938 }
0939 
0940 static int vt8231_device_add(unsigned short address)
0941 {
0942     struct resource res = {
0943         .start  = address,
0944         .end    = address + VT8231_EXTENT - 1,
0945         .name   = "vt8231",
0946         .flags  = IORESOURCE_IO,
0947     };
0948     int err;
0949 
0950     err = acpi_check_resource_conflict(&res);
0951     if (err)
0952         goto exit;
0953 
0954     pdev = platform_device_alloc("vt8231", address);
0955     if (!pdev) {
0956         err = -ENOMEM;
0957         pr_err("Device allocation failed\n");
0958         goto exit;
0959     }
0960 
0961     err = platform_device_add_resources(pdev, &res, 1);
0962     if (err) {
0963         pr_err("Device resource addition failed (%d)\n", err);
0964         goto exit_device_put;
0965     }
0966 
0967     err = platform_device_add(pdev);
0968     if (err) {
0969         pr_err("Device addition failed (%d)\n", err);
0970         goto exit_device_put;
0971     }
0972 
0973     return 0;
0974 
0975 exit_device_put:
0976     platform_device_put(pdev);
0977 exit:
0978     return err;
0979 }
0980 
0981 static int vt8231_pci_probe(struct pci_dev *dev,
0982                 const struct pci_device_id *id)
0983 {
0984     u16 address, val;
0985     if (force_addr) {
0986         address = force_addr & 0xff00;
0987         dev_warn(&dev->dev, "Forcing ISA address 0x%x\n",
0988              address);
0989 
0990         if (PCIBIOS_SUCCESSFUL !=
0991             pci_write_config_word(dev, VT8231_BASE_REG, address | 1))
0992             return -ENODEV;
0993     }
0994 
0995     pci_read_config_word(dev, VT8231_BASE_REG, &val);
0996     if (val == (u16)~0)
0997         return -ENODEV;
0998 
0999     address = val & ~(VT8231_EXTENT - 1);
1000     if (address == 0) {
1001         dev_err(&dev->dev, "base address not set - upgrade BIOS or use force_addr=0xaddr\n");
1002         return -ENODEV;
1003     }
1004 
1005     pci_read_config_word(dev, VT8231_ENABLE_REG, &val);
1006     if (val == (u16)~0)
1007         return -ENODEV;
1008 
1009     if (!(val & 0x0001)) {
1010         dev_warn(&dev->dev, "enabling sensors\n");
1011         if (PCIBIOS_SUCCESSFUL !=
1012             pci_write_config_word(dev, VT8231_ENABLE_REG,
1013                             val | 0x0001))
1014             return -ENODEV;
1015     }
1016 
1017     if (platform_driver_register(&vt8231_driver))
1018         goto exit;
1019 
1020     /* Sets global pdev as a side effect */
1021     if (vt8231_device_add(address))
1022         goto exit_unregister;
1023 
1024     /*
1025      * Always return failure here.  This is to allow other drivers to bind
1026      * to this pci device.  We don't really want to have control over the
1027      * pci device, we only wanted to read as few register values from it.
1028      */
1029 
1030     /*
1031      * We do, however, mark ourselves as using the PCI device to stop it
1032      * getting unloaded.
1033      */
1034     s_bridge = pci_dev_get(dev);
1035     return -ENODEV;
1036 
1037 exit_unregister:
1038     platform_driver_unregister(&vt8231_driver);
1039 exit:
1040     return -ENODEV;
1041 }
1042 
1043 static int __init sm_vt8231_init(void)
1044 {
1045     return pci_register_driver(&vt8231_pci_driver);
1046 }
1047 
1048 static void __exit sm_vt8231_exit(void)
1049 {
1050     pci_unregister_driver(&vt8231_pci_driver);
1051     if (s_bridge != NULL) {
1052         platform_device_unregister(pdev);
1053         platform_driver_unregister(&vt8231_driver);
1054         pci_dev_put(s_bridge);
1055         s_bridge = NULL;
1056     }
1057 }
1058 
1059 MODULE_AUTHOR("Roger Lucas <vt8231@hiddenengine.co.uk>");
1060 MODULE_DESCRIPTION("VT8231 sensors");
1061 MODULE_LICENSE("GPL");
1062 
1063 module_init(sm_vt8231_init);
1064 module_exit(sm_vt8231_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!