drivers/hwmon/vt8231.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * vt8231.c - Part of lm_sensors, Linux kernel modules
   4  *            for hardware monitoring
   5  *
   6  * Copyright (c) 2005 Roger Lucas <vt8231@hiddenengine.co.uk>
   7  * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
   8  *                    Aaron M. Marsh <amarsh@sdf.lonestar.org>
   9  */
  10
  11 /*
  12  * Supports VIA VT8231 South Bridge embedded sensors
  13  */
  14
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/slab.h>
  20 #include <linux/pci.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/hwmon.h>
  24 #include <linux/hwmon-sysfs.h>
  25 #include <linux/hwmon-vid.h>
  26 #include <linux/err.h>
  27 #include <linux/mutex.h>
  28 #include <linux/acpi.h>
  29 #include <linux/io.h>
  30
  31 static int force_addr;
  32 module_param(force_addr, int, 0);
  33 MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors");
  34
  35 static struct platform_device *pdev;
  36
  37 #define VT8231_EXTENT 0x80
  38 #define VT8231_BASE_REG 0x70
  39 #define VT8231_ENABLE_REG 0x74
  40
  41 #define DRIVER_NAME "vt8231"
  42
  43 /*
  44  * The VT8231 registers
  45  *
  46  * The reset value for the input channel configuration is used (Reg 0x4A=0x07)
  47  * which sets the selected inputs marked with '*' below if multiple options are
  48  * possible:
  49  *
  50  *                  Voltage Mode          Temperature Mode
  51  *      Sensor        Linux Id        Linux Id        VIA Id
  52  *      --------      --------        --------        ------
  53  *      CPU Diode       N/A             temp1           0
  54  *      UIC1            in0             temp2 *         1
  55  *      UIC2            in1 *           temp3           2
  56  *      UIC3            in2 *           temp4           3
  57  *      UIC4            in3 *           temp5           4
  58  *      UIC5            in4 *           temp6           5
  59  *      3.3V            in5             N/A
  60  *
  61  * Note that the BIOS may set the configuration register to a different value
  62  * to match the motherboard configuration.
  63  */
  64
  65 /* fans numbered 0-1 */
  66 #define VT8231_REG_FAN_MIN(nr)  (0x3b + (nr))
  67 #define VT8231_REG_FAN(nr)      (0x29 + (nr))
  68
  69 /* Voltage inputs numbered 0-5 */
  70
  71 static const u8 regvolt[]    = { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26 };
  72 static const u8 regvoltmax[] = { 0x3d, 0x2b, 0x2d, 0x2f, 0x31, 0x33 };
  73 static const u8 regvoltmin[] = { 0x3e, 0x2c, 0x2e, 0x30, 0x32, 0x34 };
  74
  75 /*
  76  * Temperatures are numbered 1-6 according to the Linux kernel specification.
  77  *
  78  * In the VIA datasheet, however, the temperatures are numbered from zero.
  79  * Since it is important that this driver can easily be compared to the VIA
  80  * datasheet, we will use the VIA numbering within this driver and map the
  81  * kernel sysfs device name to the VIA number in the sysfs callback.
  82  */
  83
  84 #define VT8231_REG_TEMP_LOW01   0x49
  85 #define VT8231_REG_TEMP_LOW25   0x4d
  86
  87 static const u8 regtemp[]    = { 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25 };
  88 static const u8 regtempmax[] = { 0x39, 0x3d, 0x2b, 0x2d, 0x2f, 0x31 };
  89 static const u8 regtempmin[] = { 0x3a, 0x3e, 0x2c, 0x2e, 0x30, 0x32 };
  90
  91 #define TEMP_FROM_REG(reg)              (((253 * 4 - (reg)) * 550 + 105) / 210)
  92 #define TEMP_MAXMIN_FROM_REG(reg)       (((253 - (reg)) * 2200 + 105) / 210)
  93 #define TEMP_MAXMIN_TO_REG(val)         (253 - ((val) * 210 + 1100) / 2200)
  94
  95 #define VT8231_REG_CONFIG 0x40
  96 #define VT8231_REG_ALARM1 0x41
  97 #define VT8231_REG_ALARM2 0x42
  98 #define VT8231_REG_FANDIV 0x47
  99 #define VT8231_REG_UCH_CONFIG 0x4a
 100 #define VT8231_REG_TEMP1_CONFIG 0x4b
 101 #define VT8231_REG_TEMP2_CONFIG 0x4c
 102
 103 /*
 104  * temps 0-5 as numbered in VIA datasheet - see later for mapping to Linux
 105  * numbering
 106  */
 107 #define ISTEMP(i, ch_config) ((i) == 0 ? 1 : \
 108                               ((ch_config) >> ((i)+1)) & 0x01)
 109 /* voltages 0-5 */
 110 #define ISVOLT(i, ch_config) ((i) == 5 ? 1 : \
 111                               !(((ch_config) >> ((i)+2)) & 0x01))
 112
 113 #define DIV_FROM_REG(val) (1 << (val))
 114
 115 /*
 116  * NB  The values returned here are NOT temperatures.  The calibration curves
 117  *     for the thermistor curves are board-specific and must go in the
 118  *     sensors.conf file.  Temperature sensors are actually ten bits, but the
 119  *     VIA datasheet only considers the 8 MSBs obtained from the regtemp[]
 120  *     register.  The temperature value returned should have a magnitude of 3,
 121  *     so we use the VIA scaling as the "true" scaling and use the remaining 2
 122  *     LSBs as fractional precision.
 123  *
 124  *     All the on-chip hardware temperature comparisons for the alarms are only
 125  *     8-bits wide, and compare against the 8 MSBs of the temperature.  The bits
 126  *     in the registers VT8231_REG_TEMP_LOW01 and VT8231_REG_TEMP_LOW25 are
 127  *     ignored.
 128  */
 129
 130 /*
 131  ****** FAN RPM CONVERSIONS ********
 132  * This chip saturates back at 0, not at 255 like many the other chips.
 133  * So, 0 means 0 RPM
 134  */
 135 static inline u8 FAN_TO_REG(long rpm, int div)
 136 {
 137         if (rpm <= 0 || rpm > 1310720)
 138                 return 0;
 139         return clamp_val(1310720 / (rpm * div), 1, 255);
 140 }
 141
 142 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div)))
 143
 144 struct vt8231_data {
 145         unsigned short addr;
 146         const char *name;
 147
 148         struct mutex update_lock;
 149         struct device *hwmon_dev;
 150         bool valid;             /* true if following fields are valid */
 151         unsigned long last_updated;     /* In jiffies */
 152
 153         u8 in[6];               /* Register value */
 154         u8 in_max[6];           /* Register value */
 155         u8 in_min[6];           /* Register value */
 156         u16 temp[6];            /* Register value 10 bit, right aligned */
 157         u8 temp_max[6];         /* Register value */
 158         u8 temp_min[6];         /* Register value */
 159         u8 fan[2];              /* Register value */
 160         u8 fan_min[2];          /* Register value */
 161         u8 fan_div[2];          /* Register encoding, shifted right */
 162         u16 alarms;             /* Register encoding */
 163         u8 uch_config;
 164 };
 165
 166 static struct pci_dev *s_bridge;
 167
 168 static inline int vt8231_read_value(struct vt8231_data *data, u8 reg)
 169 {
 170         return inb_p(data->addr + reg);
 171 }
 172
 173 static inline void vt8231_write_value(struct vt8231_data *data, u8 reg,
 174                                         u8 value)
 175 {
 176         outb_p(value, data->addr + reg);
 177 }
 178
 179 static struct vt8231_data *vt8231_update_device(struct device *dev)
 180 {
 181         struct vt8231_data *data = dev_get_drvdata(dev);
 182         int i;
 183         u16 low;
 184
 185         mutex_lock(&data->update_lock);
 186
 187         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 188             || !data->valid) {
 189                 for (i = 0; i < 6; i++) {
 190                         if (ISVOLT(i, data->uch_config)) {
 191                                 data->in[i] = vt8231_read_value(data,
 192                                                 regvolt[i]);
 193                                 data->in_min[i] = vt8231_read_value(data,
 194                                                 regvoltmin[i]);
 195                                 data->in_max[i] = vt8231_read_value(data,
 196                                                 regvoltmax[i]);
 197                         }
 198                 }
 199                 for (i = 0; i < 2; i++) {
 200                         data->fan[i] = vt8231_read_value(data,
 201                                                 VT8231_REG_FAN(i));
 202                         data->fan_min[i] = vt8231_read_value(data,
 203                                                 VT8231_REG_FAN_MIN(i));
 204                 }
 205
 206                 low = vt8231_read_value(data, VT8231_REG_TEMP_LOW01);
 207                 low = (low >> 6) | ((low & 0x30) >> 2)
 208                     | (vt8231_read_value(data, VT8231_REG_TEMP_LOW25) << 4);
 209                 for (i = 0; i < 6; i++) {
 210                         if (ISTEMP(i, data->uch_config)) {
 211                                 data->temp[i] = (vt8231_read_value(data,
 212                                                        regtemp[i]) << 2)
 213                                                 | ((low >> (2 * i)) & 0x03);
 214                                 data->temp_max[i] = vt8231_read_value(data,
 215                                                       regtempmax[i]);
 216                                 data->temp_min[i] = vt8231_read_value(data,
 217                                                       regtempmin[i]);
 218                         }
 219                 }
 220
 221                 i = vt8231_read_value(data, VT8231_REG_FANDIV);
 222                 data->fan_div[0] = (i >> 4) & 0x03;
 223                 data->fan_div[1] = i >> 6;
 224                 data->alarms = vt8231_read_value(data, VT8231_REG_ALARM1) |
 225                         (vt8231_read_value(data, VT8231_REG_ALARM2) << 8);
 226
 227                 /* Set alarm flags correctly */
 228                 if (!data->fan[0] && data->fan_min[0])
 229                         data->alarms |= 0x40;
 230                 else if (data->fan[0] && !data->fan_min[0])
 231                         data->alarms &= ~0x40;
 232
 233                 if (!data->fan[1] && data->fan_min[1])
 234                         data->alarms |= 0x80;
 235                 else if (data->fan[1] && !data->fan_min[1])
 236                         data->alarms &= ~0x80;
 237
 238                 data->last_updated = jiffies;
 239                 data->valid = true;
 240         }
 241
 242         mutex_unlock(&data->update_lock);
 243
 244         return data;
 245 }
 246
 247 /* following are the sysfs callback functions */
 248 static ssize_t in_show(struct device *dev, struct device_attribute *attr,
 249                        char *buf)
 250 {
 251         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 252         int nr = sensor_attr->index;
 253         struct vt8231_data *data = vt8231_update_device(dev);
 254
 255         return sprintf(buf, "%d\n", ((data->in[nr] - 3) * 10000) / 958);
 256 }
 257
 258 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
 259                            char *buf)
 260 {
 261         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 262         int nr = sensor_attr->index;
 263         struct vt8231_data *data = vt8231_update_device(dev);
 264
 265         return sprintf(buf, "%d\n", ((data->in_min[nr] - 3) * 10000) / 958);
 266 }
 267
 268 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
 269                            char *buf)
 270 {
 271         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 272         int nr = sensor_attr->index;
 273         struct vt8231_data *data = vt8231_update_device(dev);
 274
 275         return sprintf(buf, "%d\n", (((data->in_max[nr] - 3) * 10000) / 958));
 276 }
 277
 278 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
 279                             const char *buf, size_t count)
 280 {
 281         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 282         int nr = sensor_attr->index;
 283         struct vt8231_data *data = dev_get_drvdata(dev);
 284         unsigned long val;
 285         int err;
 286
 287         err = kstrtoul(buf, 10, &val);
 288         if (err)
 289                 return err;
 290
 291         mutex_lock(&data->update_lock);
 292         data->in_min[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255);
 293         vt8231_write_value(data, regvoltmin[nr], data->in_min[nr]);
 294         mutex_unlock(&data->update_lock);
 295         return count;
 296 }
 297
 298 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
 299                             const char *buf, size_t count)
 300 {
 301         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 302         int nr = sensor_attr->index;
 303         struct vt8231_data *data = dev_get_drvdata(dev);
 304         unsigned long val;
 305         int err;
 306
 307         err = kstrtoul(buf, 10, &val);
 308         if (err)
 309                 return err;
 310
 311         mutex_lock(&data->update_lock);
 312         data->in_max[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255);
 313         vt8231_write_value(data, regvoltmax[nr], data->in_max[nr]);
 314         mutex_unlock(&data->update_lock);
 315         return count;
 316 }
 317
 318 /* Special case for input 5 as this has 3.3V scaling built into the chip */
 319 static ssize_t in5_input_show(struct device *dev,
 320                               struct device_attribute *attr, char *buf)
 321 {
 322         struct vt8231_data *data = vt8231_update_device(dev);
 323
 324         return sprintf(buf, "%d\n",
 325                 (((data->in[5] - 3) * 10000 * 54) / (958 * 34)));
 326 }
 327
 328 static ssize_t in5_min_show(struct device *dev, struct device_attribute *attr,
 329                 char *buf)
 330 {
 331         struct vt8231_data *data = vt8231_update_device(dev);
 332
 333         return sprintf(buf, "%d\n",
 334                 (((data->in_min[5] - 3) * 10000 * 54) / (958 * 34)));
 335 }
 336
 337 static ssize_t in5_max_show(struct device *dev, struct device_attribute *attr,
 338                 char *buf)
 339 {
 340         struct vt8231_data *data = vt8231_update_device(dev);
 341
 342         return sprintf(buf, "%d\n",
 343                 (((data->in_max[5] - 3) * 10000 * 54) / (958 * 34)));
 344 }
 345
 346 static ssize_t in5_min_store(struct device *dev,
 347                              struct device_attribute *attr, const char *buf,
 348                              size_t count)
 349 {
 350         struct vt8231_data *data = dev_get_drvdata(dev);
 351         unsigned long val;
 352         int err;
 353
 354         err = kstrtoul(buf, 10, &val);
 355         if (err)
 356                 return err;
 357
 358         mutex_lock(&data->update_lock);
 359         data->in_min[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3,
 360                                     0, 255);
 361         vt8231_write_value(data, regvoltmin[5], data->in_min[5]);
 362         mutex_unlock(&data->update_lock);
 363         return count;
 364 }
 365
 366 static ssize_t in5_max_store(struct device *dev,
 367                              struct device_attribute *attr, const char *buf,
 368                              size_t count)
 369 {
 370         struct vt8231_data *data = dev_get_drvdata(dev);
 371         unsigned long val;
 372         int err;
 373
 374         err = kstrtoul(buf, 10, &val);
 375         if (err)
 376                 return err;
 377
 378         mutex_lock(&data->update_lock);
 379         data->in_max[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3,
 380                                     0, 255);
 381         vt8231_write_value(data, regvoltmax[5], data->in_max[5]);
 382         mutex_unlock(&data->update_lock);
 383         return count;
 384 }
 385
 386 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
 387 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
 388 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
 389 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
 390 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
 391 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
 392 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
 393 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
 394 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
 395 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
 396 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
 397 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
 398 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
 399 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
 400 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
 401
 402 static DEVICE_ATTR_RO(in5_input);
 403 static DEVICE_ATTR_RW(in5_min);
 404 static DEVICE_ATTR_RW(in5_max);
 405
 406 /* Temperatures */
 407 static ssize_t temp1_input_show(struct device *dev,
 408                                 struct device_attribute *attr, char *buf)
 409 {
 410         struct vt8231_data *data = vt8231_update_device(dev);
 411         return sprintf(buf, "%d\n", data->temp[0] * 250);
 412 }
 413
 414 static ssize_t temp1_max_show(struct device *dev, struct device_attribute *attr,
 415                 char *buf)
 416 {
 417         struct vt8231_data *data = vt8231_update_device(dev);
 418         return sprintf(buf, "%d\n", data->temp_max[0] * 1000);
 419 }
 420
 421 static ssize_t temp1_max_hyst_show(struct device *dev,
 422                                    struct device_attribute *attr, char *buf)
 423 {
 424         struct vt8231_data *data = vt8231_update_device(dev);
 425         return sprintf(buf, "%d\n", data->temp_min[0] * 1000);
 426 }
 427
 428 static ssize_t temp1_max_store(struct device *dev,
 429                                struct device_attribute *attr, const char *buf,
 430                                size_t count)
 431 {
 432         struct vt8231_data *data = dev_get_drvdata(dev);
 433         long val;
 434         int err;
 435
 436         err = kstrtol(buf, 10, &val);
 437         if (err)
 438                 return err;
 439
 440         mutex_lock(&data->update_lock);
 441         data->temp_max[0] = clamp_val((val + 500) / 1000, 0, 255);
 442         vt8231_write_value(data, regtempmax[0], data->temp_max[0]);
 443         mutex_unlock(&data->update_lock);
 444         return count;
 445 }
 446 static ssize_t temp1_max_hyst_store(struct device *dev,
 447                                     struct device_attribute *attr,
 448                                     const char *buf, size_t count)
 449 {
 450         struct vt8231_data *data = dev_get_drvdata(dev);
 451         long val;
 452         int err;
 453
 454         err = kstrtol(buf, 10, &val);
 455         if (err)
 456                 return err;
 457
 458         mutex_lock(&data->update_lock);
 459         data->temp_min[0] = clamp_val((val + 500) / 1000, 0, 255);
 460         vt8231_write_value(data, regtempmin[0], data->temp_min[0]);
 461         mutex_unlock(&data->update_lock);
 462         return count;
 463 }
 464
 465 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
 466                          char *buf)
 467 {
 468         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 469         int nr = sensor_attr->index;
 470         struct vt8231_data *data = vt8231_update_device(dev);
 471         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
 472 }
 473
 474 static ssize_t temp_max_show(struct device *dev,
 475                              struct device_attribute *attr, char *buf)
 476 {
 477         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 478         int nr = sensor_attr->index;
 479         struct vt8231_data *data = vt8231_update_device(dev);
 480         return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_max[nr]));
 481 }
 482
 483 static ssize_t temp_min_show(struct device *dev,
 484                              struct device_attribute *attr, char *buf)
 485 {
 486         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 487         int nr = sensor_attr->index;
 488         struct vt8231_data *data = vt8231_update_device(dev);
 489         return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_min[nr]));
 490 }
 491
 492 static ssize_t temp_max_store(struct device *dev,
 493                               struct device_attribute *attr, const char *buf,
 494                               size_t count)
 495 {
 496         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 497         int nr = sensor_attr->index;
 498         struct vt8231_data *data = dev_get_drvdata(dev);
 499         long val;
 500         int err;
 501
 502         err = kstrtol(buf, 10, &val);
 503         if (err)
 504                 return err;
 505
 506         mutex_lock(&data->update_lock);
 507         data->temp_max[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255);
 508         vt8231_write_value(data, regtempmax[nr], data->temp_max[nr]);
 509         mutex_unlock(&data->update_lock);
 510         return count;
 511 }
 512 static ssize_t temp_min_store(struct device *dev,
 513                               struct device_attribute *attr, const char *buf,
 514                               size_t count)
 515 {
 516         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 517         int nr = sensor_attr->index;
 518         struct vt8231_data *data = dev_get_drvdata(dev);
 519         long val;
 520         int err;
 521
 522         err = kstrtol(buf, 10, &val);
 523         if (err)
 524                 return err;
 525
 526         mutex_lock(&data->update_lock);
 527         data->temp_min[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255);
 528         vt8231_write_value(data, regtempmin[nr], data->temp_min[nr]);
 529         mutex_unlock(&data->update_lock);
 530         return count;
 531 }
 532
 533 /*
 534  * Note that these map the Linux temperature sensor numbering (1-6) to the VIA
 535  * temperature sensor numbering (0-5)
 536  */
 537
 538 static DEVICE_ATTR_RO(temp1_input);
 539 static DEVICE_ATTR_RW(temp1_max);
 540 static DEVICE_ATTR_RW(temp1_max_hyst);
 541
 542 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
 543 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
 544 static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_min, 1);
 545 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
 546 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
 547 static SENSOR_DEVICE_ATTR_RW(temp3_max_hyst, temp_min, 2);
 548 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
 549 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
 550 static SENSOR_DEVICE_ATTR_RW(temp4_max_hyst, temp_min, 3);
 551 static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
 552 static SENSOR_DEVICE_ATTR_RW(temp5_max, temp_max, 4);
 553 static SENSOR_DEVICE_ATTR_RW(temp5_max_hyst, temp_min, 4);
 554 static SENSOR_DEVICE_ATTR_RO(temp6_input, temp, 5);
 555 static SENSOR_DEVICE_ATTR_RW(temp6_max, temp_max, 5);
 556 static SENSOR_DEVICE_ATTR_RW(temp6_max_hyst, temp_min, 5);
 557
 558 /* Fans */
 559 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
 560                         char *buf)
 561 {
 562         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 563         int nr = sensor_attr->index;
 564         struct vt8231_data *data = vt8231_update_device(dev);
 565         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 566                                 DIV_FROM_REG(data->fan_div[nr])));
 567 }
 568
 569 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
 570                             char *buf)
 571 {
 572         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 573         int nr = sensor_attr->index;
 574         struct vt8231_data *data = vt8231_update_device(dev);
 575         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 576                         DIV_FROM_REG(data->fan_div[nr])));
 577 }
 578
 579 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
 580                             char *buf)
 581 {
 582         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 583         int nr = sensor_attr->index;
 584         struct vt8231_data *data = vt8231_update_device(dev);
 585         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 586 }
 587
 588 static ssize_t fan_min_store(struct device *dev,
 589                              struct device_attribute *attr, const char *buf,
 590                              size_t count)
 591 {
 592         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 593         int nr = sensor_attr->index;
 594         struct vt8231_data *data = dev_get_drvdata(dev);
 595         unsigned long val;
 596         int err;
 597
 598         err = kstrtoul(buf, 10, &val);
 599         if (err)
 600                 return err;
 601
 602         mutex_lock(&data->update_lock);
 603         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 604         vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
 605         mutex_unlock(&data->update_lock);
 606         return count;
 607 }
 608
 609 static ssize_t fan_div_store(struct device *dev,
 610                              struct device_attribute *attr, const char *buf,
 611                              size_t count)
 612 {
 613         struct vt8231_data *data = dev_get_drvdata(dev);
 614         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 615         unsigned long val;
 616         int nr = sensor_attr->index;
 617         int old = vt8231_read_value(data, VT8231_REG_FANDIV);
 618         long min = FAN_FROM_REG(data->fan_min[nr],
 619                                  DIV_FROM_REG(data->fan_div[nr]));
 620         int err;
 621
 622         err = kstrtoul(buf, 10, &val);
 623         if (err)
 624                 return err;
 625
 626         mutex_lock(&data->update_lock);
 627         switch (val) {
 628         case 1:
 629                 data->fan_div[nr] = 0;
 630                 break;
 631         case 2:
 632                 data->fan_div[nr] = 1;
 633                 break;
 634         case 4:
 635                 data->fan_div[nr] = 2;
 636                 break;
 637         case 8:
 638                 data->fan_div[nr] = 3;
 639                 break;
 640         default:
 641                 dev_err(dev,
 642                         "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
 643                         val);
 644                 mutex_unlock(&data->update_lock);
 645                 return -EINVAL;
 646         }
 647
 648         /* Correct the fan minimum speed */
 649         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 650         vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
 651
 652         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
 653         vt8231_write_value(data, VT8231_REG_FANDIV, old);
 654         mutex_unlock(&data->update_lock);
 655         return count;
 656 }
 657
 658 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
 659 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
 660 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
 661 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
 662 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
 663 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
 664
 665 /* Alarms */
 666 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
 667                            char *buf)
 668 {
 669         struct vt8231_data *data = vt8231_update_device(dev);
 670         return sprintf(buf, "%d\n", data->alarms);
 671 }
 672 static DEVICE_ATTR_RO(alarms);
 673
 674 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
 675                           char *buf)
 676 {
 677         int bitnr = to_sensor_dev_attr(attr)->index;
 678         struct vt8231_data *data = vt8231_update_device(dev);
 679         return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
 680 }
 681 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
 682 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 11);
 683 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0);
 684 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm, 1);
 685 static SENSOR_DEVICE_ATTR_RO(temp5_alarm, alarm, 3);
 686 static SENSOR_DEVICE_ATTR_RO(temp6_alarm, alarm, 8);
 687 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 11);
 688 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0);
 689 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 1);
 690 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
 691 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
 692 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 2);
 693 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
 694 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
 695
 696 static ssize_t name_show(struct device *dev, struct device_attribute
 697                          *devattr, char *buf)
 698 {
 699         struct vt8231_data *data = dev_get_drvdata(dev);
 700         return sprintf(buf, "%s\n", data->name);
 701 }
 702 static DEVICE_ATTR_RO(name);
 703
 704 static struct attribute *vt8231_attributes_temps[6][5] = {
 705         {
 706                 &dev_attr_temp1_input.attr,
 707                 &dev_attr_temp1_max_hyst.attr,
 708                 &dev_attr_temp1_max.attr,
 709                 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 710                 NULL
 711         }, {
 712                 &sensor_dev_attr_temp2_input.dev_attr.attr,
 713                 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
 714                 &sensor_dev_attr_temp2_max.dev_attr.attr,
 715                 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 716                 NULL
 717         }, {
 718                 &sensor_dev_attr_temp3_input.dev_attr.attr,
 719                 &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
 720                 &sensor_dev_attr_temp3_max.dev_attr.attr,
 721                 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
 722                 NULL
 723         }, {
 724                 &sensor_dev_attr_temp4_input.dev_attr.attr,
 725                 &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
 726                 &sensor_dev_attr_temp4_max.dev_attr.attr,
 727                 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
 728                 NULL
 729         }, {
 730                 &sensor_dev_attr_temp5_input.dev_attr.attr,
 731                 &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
 732                 &sensor_dev_attr_temp5_max.dev_attr.attr,
 733                 &sensor_dev_attr_temp5_alarm.dev_attr.attr,
 734                 NULL
 735         }, {
 736                 &sensor_dev_attr_temp6_input.dev_attr.attr,
 737                 &sensor_dev_attr_temp6_max_hyst.dev_attr.attr,
 738                 &sensor_dev_attr_temp6_max.dev_attr.attr,
 739                 &sensor_dev_attr_temp6_alarm.dev_attr.attr,
 740                 NULL
 741         }
 742 };
 743
 744 static const struct attribute_group vt8231_group_temps[6] = {
 745         { .attrs = vt8231_attributes_temps[0] },
 746         { .attrs = vt8231_attributes_temps[1] },
 747         { .attrs = vt8231_attributes_temps[2] },
 748         { .attrs = vt8231_attributes_temps[3] },
 749         { .attrs = vt8231_attributes_temps[4] },
 750         { .attrs = vt8231_attributes_temps[5] },
 751 };
 752
 753 static struct attribute *vt8231_attributes_volts[6][5] = {
 754         {
 755                 &sensor_dev_attr_in0_input.dev_attr.attr,
 756                 &sensor_dev_attr_in0_min.dev_attr.attr,
 757                 &sensor_dev_attr_in0_max.dev_attr.attr,
 758                 &sensor_dev_attr_in0_alarm.dev_attr.attr,
 759                 NULL
 760         }, {
 761                 &sensor_dev_attr_in1_input.dev_attr.attr,
 762                 &sensor_dev_attr_in1_min.dev_attr.attr,
 763                 &sensor_dev_attr_in1_max.dev_attr.attr,
 764                 &sensor_dev_attr_in1_alarm.dev_attr.attr,
 765                 NULL
 766         }, {
 767                 &sensor_dev_attr_in2_input.dev_attr.attr,
 768                 &sensor_dev_attr_in2_min.dev_attr.attr,
 769                 &sensor_dev_attr_in2_max.dev_attr.attr,
 770                 &sensor_dev_attr_in2_alarm.dev_attr.attr,
 771                 NULL
 772         }, {
 773                 &sensor_dev_attr_in3_input.dev_attr.attr,
 774                 &sensor_dev_attr_in3_min.dev_attr.attr,
 775                 &sensor_dev_attr_in3_max.dev_attr.attr,
 776                 &sensor_dev_attr_in3_alarm.dev_attr.attr,
 777                 NULL
 778         }, {
 779                 &sensor_dev_attr_in4_input.dev_attr.attr,
 780                 &sensor_dev_attr_in4_min.dev_attr.attr,
 781                 &sensor_dev_attr_in4_max.dev_attr.attr,
 782                 &sensor_dev_attr_in4_alarm.dev_attr.attr,
 783                 NULL
 784         }, {
 785                 &dev_attr_in5_input.attr,
 786                 &dev_attr_in5_min.attr,
 787                 &dev_attr_in5_max.attr,
 788                 &sensor_dev_attr_in5_alarm.dev_attr.attr,
 789                 NULL
 790         }
 791 };
 792
 793 static const struct attribute_group vt8231_group_volts[6] = {
 794         { .attrs = vt8231_attributes_volts[0] },
 795         { .attrs = vt8231_attributes_volts[1] },
 796         { .attrs = vt8231_attributes_volts[2] },
 797         { .attrs = vt8231_attributes_volts[3] },
 798         { .attrs = vt8231_attributes_volts[4] },
 799         { .attrs = vt8231_attributes_volts[5] },
 800 };
 801
 802 static struct attribute *vt8231_attributes[] = {
 803         &sensor_dev_attr_fan1_input.dev_attr.attr,
 804         &sensor_dev_attr_fan2_input.dev_attr.attr,
 805         &sensor_dev_attr_fan1_min.dev_attr.attr,
 806         &sensor_dev_attr_fan2_min.dev_attr.attr,
 807         &sensor_dev_attr_fan1_div.dev_attr.attr,
 808         &sensor_dev_attr_fan2_div.dev_attr.attr,
 809         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 810         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 811         &dev_attr_alarms.attr,
 812         &dev_attr_name.attr,
 813         NULL
 814 };
 815
 816 static const struct attribute_group vt8231_group = {
 817         .attrs = vt8231_attributes,
 818 };
 819
 820 static void vt8231_init_device(struct vt8231_data *data)
 821 {
 822         vt8231_write_value(data, VT8231_REG_TEMP1_CONFIG, 0);
 823         vt8231_write_value(data, VT8231_REG_TEMP2_CONFIG, 0);
 824 }
 825
 826 static int vt8231_probe(struct platform_device *pdev)
 827 {
 828         struct resource *res;
 829         struct vt8231_data *data;
 830         int err = 0, i;
 831
 832         /* Reserve the ISA region */
 833         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 834         if (!devm_request_region(&pdev->dev, res->start, VT8231_EXTENT,
 835                                  DRIVER_NAME)) {
 836                 dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n",
 837                         (unsigned long)res->start, (unsigned long)res->end);
 838                 return -ENODEV;
 839         }
 840
 841         data = devm_kzalloc(&pdev->dev, sizeof(struct vt8231_data), GFP_KERNEL);
 842         if (!data)
 843                 return -ENOMEM;
 844
 845         platform_set_drvdata(pdev, data);
 846         data->addr = res->start;
 847         data->name = DRIVER_NAME;
 848
 849         mutex_init(&data->update_lock);
 850         vt8231_init_device(data);
 851
 852         /* Register sysfs hooks */
 853         err = sysfs_create_group(&pdev->dev.kobj, &vt8231_group);
 854         if (err)
 855                 return err;
 856
 857         /* Must update device information to find out the config field */
 858         data->uch_config = vt8231_read_value(data, VT8231_REG_UCH_CONFIG);
 859
 860         for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) {
 861                 if (ISTEMP(i, data->uch_config)) {
 862                         err = sysfs_create_group(&pdev->dev.kobj,
 863                                                  &vt8231_group_temps[i]);
 864                         if (err)
 865                                 goto exit_remove_files;
 866                 }
 867         }
 868
 869         for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) {
 870                 if (ISVOLT(i, data->uch_config)) {
 871                         err = sysfs_create_group(&pdev->dev.kobj,
 872                                                  &vt8231_group_volts[i]);
 873                         if (err)
 874                                 goto exit_remove_files;
 875                 }
 876         }
 877
 878         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 879         if (IS_ERR(data->hwmon_dev)) {
 880                 err = PTR_ERR(data->hwmon_dev);
 881                 goto exit_remove_files;
 882         }
 883         return 0;
 884
 885 exit_remove_files:
 886         for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
 887                 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
 888
 889         for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
 890                 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
 891
 892         sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
 893         return err;
 894 }
 895
 896 static int vt8231_remove(struct platform_device *pdev)
 897 {
 898         struct vt8231_data *data = platform_get_drvdata(pdev);
 899         int i;
 900
 901         hwmon_device_unregister(data->hwmon_dev);
 902
 903         for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
 904                 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
 905
 906         for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
 907                 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
 908
 909         sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
 910
 911         return 0;
 912 }
 913
 914
 915 static struct platform_driver vt8231_driver = {
 916         .driver = {
 917                 .name   = DRIVER_NAME,
 918         },
 919         .probe  = vt8231_probe,
 920         .remove = vt8231_remove,
 921 };
 922
 923 static const struct pci_device_id vt8231_pci_ids[] = {
 924         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4) },
 925         { 0, }
 926 };
 927
 928 MODULE_DEVICE_TABLE(pci, vt8231_pci_ids);
 929
 930 static int vt8231_device_add(unsigned short address)
 931 {
 932         struct resource res = {
 933                 .start  = address,
 934                 .end    = address + VT8231_EXTENT - 1,
 935                 .name   = DRIVER_NAME,
 936                 .flags  = IORESOURCE_IO,
 937         };
 938         int err;
 939
 940         err = acpi_check_resource_conflict(&res);
 941         if (err)
 942                 goto exit;
 943
 944         pdev = platform_device_alloc(DRIVER_NAME, address);
 945         if (!pdev) {
 946                 err = -ENOMEM;
 947                 pr_err("Device allocation failed\n");
 948                 goto exit;
 949         }
 950
 951         err = platform_device_add_resources(pdev, &res, 1);
 952         if (err) {
 953                 pr_err("Device resource addition failed (%d)\n", err);
 954                 goto exit_device_put;
 955         }
 956
 957         err = platform_device_add(pdev);
 958         if (err) {
 959                 pr_err("Device addition failed (%d)\n", err);
 960                 goto exit_device_put;
 961         }
 962
 963         return 0;
 964
 965 exit_device_put:
 966         platform_device_put(pdev);
 967 exit:
 968         return err;
 969 }
 970
 971 static int vt8231_pci_probe(struct pci_dev *dev,
 972                                 const struct pci_device_id *id)
 973 {
 974         u16 address, val;
 975         if (force_addr) {
 976                 address = force_addr & 0xff00;
 977                 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n",
 978                          address);
 979
 980                 if (PCIBIOS_SUCCESSFUL !=
 981                     pci_write_config_word(dev, VT8231_BASE_REG, address | 1))
 982                         return -ENODEV;
 983         }
 984
 985         pci_read_config_word(dev, VT8231_BASE_REG, &val);
 986         if (val == (u16)~0)
 987                 return -ENODEV;
 988
 989         address = val & ~(VT8231_EXTENT - 1);
 990         if (address == 0) {
 991                 dev_err(&dev->dev, "base address not set - upgrade BIOS or use force_addr=0xaddr\n");
 992                 return -ENODEV;
 993         }
 994
 995         pci_read_config_word(dev, VT8231_ENABLE_REG, &val);
 996         if (val == (u16)~0)
 997                 return -ENODEV;
 998
 999         if (!(val & 0x0001)) {
1000                 dev_warn(&dev->dev, "enabling sensors\n");
1001                 if (PCIBIOS_SUCCESSFUL !=
1002                         pci_write_config_word(dev, VT8231_ENABLE_REG,
1003                                                         val | 0x0001))
1004                         return -ENODEV;
1005         }
1006
1007         if (platform_driver_register(&vt8231_driver))
1008                 goto exit;
1009
1010         /* Sets global pdev as a side effect */
1011         if (vt8231_device_add(address))
1012                 goto exit_unregister;
1013
1014         /*
1015          * Always return failure here.  This is to allow other drivers to bind
1016          * to this pci device.  We don't really want to have control over the
1017          * pci device, we only wanted to read as few register values from it.
1018          */
1019
1020         /*
1021          * We do, however, mark ourselves as using the PCI device to stop it
1022          * getting unloaded.
1023          */
1024         s_bridge = pci_dev_get(dev);
1025         return -ENODEV;
1026
1027 exit_unregister:
1028         platform_driver_unregister(&vt8231_driver);
1029 exit:
1030         return -ENODEV;
1031 }
1032
1033 static struct pci_driver vt8231_pci_driver = {
1034         .name           = DRIVER_NAME,
1035         .id_table       = vt8231_pci_ids,
1036         .probe          = vt8231_pci_probe,
1037 };
1038
1039 static int __init sm_vt8231_init(void)
1040 {
1041         return pci_register_driver(&vt8231_pci_driver);
1042 }
1043
1044 static void __exit sm_vt8231_exit(void)
1045 {
1046         pci_unregister_driver(&vt8231_pci_driver);
1047         if (s_bridge != NULL) {
1048                 platform_device_unregister(pdev);
1049                 platform_driver_unregister(&vt8231_driver);
1050                 pci_dev_put(s_bridge);
1051                 s_bridge = NULL;
1052         }
1053 }
1054
1055 MODULE_AUTHOR("Roger Lucas <vt8231@hiddenengine.co.uk>");
1056 MODULE_DESCRIPTION("VT8231 sensors");
1057 MODULE_LICENSE("GPL");
1058
1059 module_init(sm_vt8231_init);
1060 module_exit(sm_vt8231_exit);