drivers/hwmon/sis5595.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * sis5595.c - Part of lm_sensors, Linux kernel modules
   4  *             for hardware monitoring
   5  *
   6  * Copyright (C) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
   7  *                           Kyösti Mälkki <kmalkki@cc.hut.fi>, and
   8  *                           Mark D. Studebaker <mdsxyz123@yahoo.com>
   9  * Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
  10  * the help of Jean Delvare <jdelvare@suse.de>
  11  */
  12
  13 /*
  14  * SiS southbridge has a LM78-like chip integrated on the same IC.
  15  * This driver is a customized copy of lm78.c
  16  *
  17  * Supports following revisions:
  18  *      Version         PCI ID          PCI Revision
  19  *      1               1039/0008       AF or less
  20  *      2               1039/0008       B0 or greater
  21  *
  22  *  Note: these chips contain a 0008 device which is incompatible with the
  23  *       5595. We recognize these by the presence of the listed
  24  *       "blacklist" PCI ID and refuse to load.
  25  *
  26  * NOT SUPPORTED        PCI ID          BLACKLIST PCI ID
  27  *       540            0008            0540
  28  *       550            0008            0550
  29  *      5513            0008            5511
  30  *      5581            0008            5597
  31  *      5582            0008            5597
  32  *      5597            0008            5597
  33  *      5598            0008            5597/5598
  34  *       630            0008            0630
  35  *       645            0008            0645
  36  *       730            0008            0730
  37  *       735            0008            0735
  38  */
  39
  40 #define DRIVER_NAME "sis5595"
  41 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  42
  43 #include <linux/module.h>
  44 #include <linux/slab.h>
  45 #include <linux/ioport.h>
  46 #include <linux/pci.h>
  47 #include <linux/platform_device.h>
  48 #include <linux/hwmon.h>
  49 #include <linux/hwmon-sysfs.h>
  50 #include <linux/err.h>
  51 #include <linux/init.h>
  52 #include <linux/jiffies.h>
  53 #include <linux/mutex.h>
  54 #include <linux/sysfs.h>
  55 #include <linux/acpi.h>
  56 #include <linux/io.h>
  57
  58 /*
  59  * If force_addr is set to anything different from 0, we forcibly enable
  60  * the device at the given address.
  61  */
  62 static u16 force_addr;
  63 module_param(force_addr, ushort, 0);
  64 MODULE_PARM_DESC(force_addr,
  65                  "Initialize the base address of the sensors");
  66
  67 static struct platform_device *pdev;
  68
  69 /* Many SIS5595 constants specified below */
  70
  71 /* Length of ISA address segment */
  72 #define SIS5595_EXTENT 8
  73 /* PCI Config Registers */
  74 #define SIS5595_BASE_REG 0x68
  75 #define SIS5595_PIN_REG 0x7A
  76 #define SIS5595_ENABLE_REG 0x7B
  77
  78 /* Where are the ISA address/data registers relative to the base address */
  79 #define SIS5595_ADDR_REG_OFFSET 5
  80 #define SIS5595_DATA_REG_OFFSET 6
  81
  82 /* The SIS5595 registers */
  83 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  84 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  85 #define SIS5595_REG_IN(nr) (0x20 + (nr))
  86
  87 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
  88 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
  89
  90 /*
  91  * On the first version of the chip, the temp registers are separate.
  92  * On the second version,
  93  * TEMP pin is shared with IN4, configured in PCI register 0x7A.
  94  * The registers are the same as well.
  95  * OVER and HYST are really MAX and MIN.
  96  */
  97
  98 #define REV2MIN 0xb0
  99 #define SIS5595_REG_TEMP        (((data->revision) >= REV2MIN) ? \
 100                                         SIS5595_REG_IN(4) : 0x27)
 101 #define SIS5595_REG_TEMP_OVER   (((data->revision) >= REV2MIN) ? \
 102                                         SIS5595_REG_IN_MAX(4) : 0x39)
 103 #define SIS5595_REG_TEMP_HYST   (((data->revision) >= REV2MIN) ? \
 104                                         SIS5595_REG_IN_MIN(4) : 0x3a)
 105
 106 #define SIS5595_REG_CONFIG 0x40
 107 #define SIS5595_REG_ALARM1 0x41
 108 #define SIS5595_REG_ALARM2 0x42
 109 #define SIS5595_REG_FANDIV 0x47
 110
 111 /*
 112  * Conversions. Limit checking is only done on the TO_REG
 113  * variants.
 114  */
 115
 116 /*
 117  * IN: mV, (0V to 4.08V)
 118  * REG: 16mV/bit
 119  */
 120 static inline u8 IN_TO_REG(unsigned long val)
 121 {
 122         unsigned long nval = clamp_val(val, 0, 4080);
 123         return (nval + 8) / 16;
 124 }
 125 #define IN_FROM_REG(val) ((val) *  16)
 126
 127 static inline u8 FAN_TO_REG(long rpm, int div)
 128 {
 129         if (rpm <= 0)
 130                 return 255;
 131         if (rpm > 1350000)
 132                 return 1;
 133         return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 134 }
 135
 136 static inline int FAN_FROM_REG(u8 val, int div)
 137 {
 138         return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
 139 }
 140
 141 /*
 142  * TEMP: mC (-54.12C to +157.53C)
 143  * REG: 0.83C/bit + 52.12, two's complement
 144  */
 145 static inline int TEMP_FROM_REG(s8 val)
 146 {
 147         return val * 830 + 52120;
 148 }
 149 static inline s8 TEMP_TO_REG(long val)
 150 {
 151         int nval = clamp_val(val, -54120, 157530) ;
 152         return nval < 0 ? (nval - 5212 - 415) / 830 : (nval - 5212 + 415) / 830;
 153 }
 154
 155 /*
 156  * FAN DIV: 1, 2, 4, or 8 (defaults to 2)
 157  * REG: 0, 1, 2, or 3 (respectively) (defaults to 1)
 158  */
 159 static inline u8 DIV_TO_REG(int val)
 160 {
 161         return val == 8 ? 3 : val == 4 ? 2 : val == 1 ? 0 : 1;
 162 }
 163 #define DIV_FROM_REG(val) (1 << (val))
 164
 165 /*
 166  * For each registered chip, we need to keep some data in memory.
 167  * The structure is dynamically allocated.
 168  */
 169 struct sis5595_data {
 170         unsigned short addr;
 171         const char *name;
 172         struct device *hwmon_dev;
 173         struct mutex lock;
 174
 175         struct mutex update_lock;
 176         bool valid;             /* true if following fields are valid */
 177         unsigned long last_updated;     /* In jiffies */
 178         char maxins;            /* == 3 if temp enabled, otherwise == 4 */
 179         u8 revision;            /* Reg. value */
 180
 181         u8 in[5];               /* Register value */
 182         u8 in_max[5];           /* Register value */
 183         u8 in_min[5];           /* Register value */
 184         u8 fan[2];              /* Register value */
 185         u8 fan_min[2];          /* Register value */
 186         s8 temp;                /* Register value */
 187         s8 temp_over;           /* Register value */
 188         s8 temp_hyst;           /* Register value */
 189         u8 fan_div[2];          /* Register encoding, shifted right */
 190         u16 alarms;             /* Register encoding, combined */
 191 };
 192
 193 static struct pci_dev *s_bridge;        /* pointer to the (only) sis5595 */
 194
 195 /* ISA access must be locked explicitly. */
 196 static int sis5595_read_value(struct sis5595_data *data, u8 reg)
 197 {
 198         int res;
 199
 200         mutex_lock(&data->lock);
 201         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
 202         res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
 203         mutex_unlock(&data->lock);
 204         return res;
 205 }
 206
 207 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
 208 {
 209         mutex_lock(&data->lock);
 210         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
 211         outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
 212         mutex_unlock(&data->lock);
 213 }
 214
 215 static struct sis5595_data *sis5595_update_device(struct device *dev)
 216 {
 217         struct sis5595_data *data = dev_get_drvdata(dev);
 218         int i;
 219
 220         mutex_lock(&data->update_lock);
 221
 222         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 223             || !data->valid) {
 224
 225                 for (i = 0; i <= data->maxins; i++) {
 226                         data->in[i] =
 227                             sis5595_read_value(data, SIS5595_REG_IN(i));
 228                         data->in_min[i] =
 229                             sis5595_read_value(data,
 230                                                SIS5595_REG_IN_MIN(i));
 231                         data->in_max[i] =
 232                             sis5595_read_value(data,
 233                                                SIS5595_REG_IN_MAX(i));
 234                 }
 235                 for (i = 0; i < 2; i++) {
 236                         data->fan[i] =
 237                             sis5595_read_value(data, SIS5595_REG_FAN(i));
 238                         data->fan_min[i] =
 239                             sis5595_read_value(data,
 240                                                SIS5595_REG_FAN_MIN(i));
 241                 }
 242                 if (data->maxins == 3) {
 243                         data->temp =
 244                             sis5595_read_value(data, SIS5595_REG_TEMP);
 245                         data->temp_over =
 246                             sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
 247                         data->temp_hyst =
 248                             sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
 249                 }
 250                 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
 251                 data->fan_div[0] = (i >> 4) & 0x03;
 252                 data->fan_div[1] = i >> 6;
 253                 data->alarms =
 254                     sis5595_read_value(data, SIS5595_REG_ALARM1) |
 255                     (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
 256                 data->last_updated = jiffies;
 257                 data->valid = true;
 258         }
 259
 260         mutex_unlock(&data->update_lock);
 261
 262         return data;
 263 }
 264
 265 /* 4 Voltages */
 266 static ssize_t in_show(struct device *dev, struct device_attribute *da,
 267                        char *buf)
 268 {
 269         struct sis5595_data *data = sis5595_update_device(dev);
 270         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 271         int nr = attr->index;
 272         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
 273 }
 274
 275 static ssize_t in_min_show(struct device *dev, struct device_attribute *da,
 276                            char *buf)
 277 {
 278         struct sis5595_data *data = sis5595_update_device(dev);
 279         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 280         int nr = attr->index;
 281         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
 282 }
 283
 284 static ssize_t in_max_show(struct device *dev, struct device_attribute *da,
 285                            char *buf)
 286 {
 287         struct sis5595_data *data = sis5595_update_device(dev);
 288         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 289         int nr = attr->index;
 290         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
 291 }
 292
 293 static ssize_t in_min_store(struct device *dev, struct device_attribute *da,
 294                             const char *buf, size_t count)
 295 {
 296         struct sis5595_data *data = dev_get_drvdata(dev);
 297         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 298         int nr = attr->index;
 299         unsigned long val;
 300         int err;
 301
 302         err = kstrtoul(buf, 10, &val);
 303         if (err)
 304                 return err;
 305
 306         mutex_lock(&data->update_lock);
 307         data->in_min[nr] = IN_TO_REG(val);
 308         sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
 309         mutex_unlock(&data->update_lock);
 310         return count;
 311 }
 312
 313 static ssize_t in_max_store(struct device *dev, struct device_attribute *da,
 314                             const char *buf, size_t count)
 315 {
 316         struct sis5595_data *data = dev_get_drvdata(dev);
 317         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 318         int nr = attr->index;
 319         unsigned long val;
 320         int err;
 321
 322         err = kstrtoul(buf, 10, &val);
 323         if (err)
 324                 return err;
 325
 326         mutex_lock(&data->update_lock);
 327         data->in_max[nr] = IN_TO_REG(val);
 328         sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
 329         mutex_unlock(&data->update_lock);
 330         return count;
 331 }
 332
 333 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
 334 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
 335 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
 336 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
 337 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
 338 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
 339 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
 340 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
 341 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
 342 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
 343 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
 344 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
 345 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
 346 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
 347 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
 348
 349 /* Temperature */
 350 static ssize_t temp1_input_show(struct device *dev,
 351                                 struct device_attribute *attr, char *buf)
 352 {
 353         struct sis5595_data *data = sis5595_update_device(dev);
 354         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 355 }
 356
 357 static ssize_t temp1_max_show(struct device *dev, struct device_attribute *attr,
 358                               char *buf)
 359 {
 360         struct sis5595_data *data = sis5595_update_device(dev);
 361         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 362 }
 363
 364 static ssize_t temp1_max_store(struct device *dev,
 365                                struct device_attribute *attr, const char *buf,
 366                                size_t count)
 367 {
 368         struct sis5595_data *data = dev_get_drvdata(dev);
 369         long val;
 370         int err;
 371
 372         err = kstrtol(buf, 10, &val);
 373         if (err)
 374                 return err;
 375
 376         mutex_lock(&data->update_lock);
 377         data->temp_over = TEMP_TO_REG(val);
 378         sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
 379         mutex_unlock(&data->update_lock);
 380         return count;
 381 }
 382
 383 static ssize_t temp1_max_hyst_show(struct device *dev,
 384                                    struct device_attribute *attr, char *buf)
 385 {
 386         struct sis5595_data *data = sis5595_update_device(dev);
 387         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 388 }
 389
 390 static ssize_t temp1_max_hyst_store(struct device *dev,
 391                                     struct device_attribute *attr,
 392                                     const char *buf, size_t count)
 393 {
 394         struct sis5595_data *data = dev_get_drvdata(dev);
 395         long val;
 396         int err;
 397
 398         err = kstrtol(buf, 10, &val);
 399         if (err)
 400                 return err;
 401
 402         mutex_lock(&data->update_lock);
 403         data->temp_hyst = TEMP_TO_REG(val);
 404         sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
 405         mutex_unlock(&data->update_lock);
 406         return count;
 407 }
 408
 409 static DEVICE_ATTR_RO(temp1_input);
 410 static DEVICE_ATTR_RW(temp1_max);
 411 static DEVICE_ATTR_RW(temp1_max_hyst);
 412
 413 /* 2 Fans */
 414 static ssize_t fan_show(struct device *dev, struct device_attribute *da,
 415                         char *buf)
 416 {
 417         struct sis5595_data *data = sis5595_update_device(dev);
 418         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 419         int nr = attr->index;
 420         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 421                 DIV_FROM_REG(data->fan_div[nr])));
 422 }
 423
 424 static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,
 425                             char *buf)
 426 {
 427         struct sis5595_data *data = sis5595_update_device(dev);
 428         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 429         int nr = attr->index;
 430         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 431                 DIV_FROM_REG(data->fan_div[nr])));
 432 }
 433
 434 static ssize_t fan_min_store(struct device *dev, struct device_attribute *da,
 435                              const char *buf, size_t count)
 436 {
 437         struct sis5595_data *data = dev_get_drvdata(dev);
 438         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 439         int nr = attr->index;
 440         unsigned long val;
 441         int err;
 442
 443         err = kstrtoul(buf, 10, &val);
 444         if (err)
 445                 return err;
 446
 447         mutex_lock(&data->update_lock);
 448         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 449         sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
 450         mutex_unlock(&data->update_lock);
 451         return count;
 452 }
 453
 454 static ssize_t fan_div_show(struct device *dev, struct device_attribute *da,
 455                             char *buf)
 456 {
 457         struct sis5595_data *data = sis5595_update_device(dev);
 458         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 459         int nr = attr->index;
 460         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 461 }
 462
 463 /*
 464  * Note: we save and restore the fan minimum here, because its value is
 465  * determined in part by the fan divisor.  This follows the principle of
 466  * least surprise; the user doesn't expect the fan minimum to change just
 467  * because the divisor changed.
 468  */
 469 static ssize_t fan_div_store(struct device *dev, struct device_attribute *da,
 470                              const char *buf, size_t count)
 471 {
 472         struct sis5595_data *data = dev_get_drvdata(dev);
 473         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 474         int nr = attr->index;
 475         unsigned long min;
 476         int reg;
 477         unsigned long val;
 478         int err;
 479
 480         err = kstrtoul(buf, 10, &val);
 481         if (err)
 482                 return err;
 483
 484         mutex_lock(&data->update_lock);
 485         min = FAN_FROM_REG(data->fan_min[nr],
 486                         DIV_FROM_REG(data->fan_div[nr]));
 487         reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
 488
 489         switch (val) {
 490         case 1:
 491                 data->fan_div[nr] = 0;
 492                 break;
 493         case 2:
 494                 data->fan_div[nr] = 1;
 495                 break;
 496         case 4:
 497                 data->fan_div[nr] = 2;
 498                 break;
 499         case 8:
 500                 data->fan_div[nr] = 3;
 501                 break;
 502         default:
 503                 dev_err(dev,
 504                         "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
 505                         val);
 506                 mutex_unlock(&data->update_lock);
 507                 return -EINVAL;
 508         }
 509
 510         switch (nr) {
 511         case 0:
 512                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 513                 break;
 514         case 1:
 515                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 516                 break;
 517         }
 518         sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
 519         data->fan_min[nr] =
 520                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 521         sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
 522         mutex_unlock(&data->update_lock);
 523         return count;
 524 }
 525
 526 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
 527 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
 528 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
 529 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
 530 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
 531 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
 532
 533 /* Alarms */
 534 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
 535                            char *buf)
 536 {
 537         struct sis5595_data *data = sis5595_update_device(dev);
 538         return sprintf(buf, "%d\n", data->alarms);
 539 }
 540 static DEVICE_ATTR_RO(alarms);
 541
 542 static ssize_t alarm_show(struct device *dev, struct device_attribute *da,
 543                           char *buf)
 544 {
 545         struct sis5595_data *data = sis5595_update_device(dev);
 546         int nr = to_sensor_dev_attr(da)->index;
 547         return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 548 }
 549 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
 550 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
 551 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
 552 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
 553 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 15);
 554 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
 555 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
 556 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 15);
 557
 558 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 559                          char *buf)
 560 {
 561         struct sis5595_data *data = dev_get_drvdata(dev);
 562         return sprintf(buf, "%s\n", data->name);
 563 }
 564 static DEVICE_ATTR_RO(name);
 565
 566 static struct attribute *sis5595_attributes[] = {
 567         &sensor_dev_attr_in0_input.dev_attr.attr,
 568         &sensor_dev_attr_in0_min.dev_attr.attr,
 569         &sensor_dev_attr_in0_max.dev_attr.attr,
 570         &sensor_dev_attr_in0_alarm.dev_attr.attr,
 571         &sensor_dev_attr_in1_input.dev_attr.attr,
 572         &sensor_dev_attr_in1_min.dev_attr.attr,
 573         &sensor_dev_attr_in1_max.dev_attr.attr,
 574         &sensor_dev_attr_in1_alarm.dev_attr.attr,
 575         &sensor_dev_attr_in2_input.dev_attr.attr,
 576         &sensor_dev_attr_in2_min.dev_attr.attr,
 577         &sensor_dev_attr_in2_max.dev_attr.attr,
 578         &sensor_dev_attr_in2_alarm.dev_attr.attr,
 579         &sensor_dev_attr_in3_input.dev_attr.attr,
 580         &sensor_dev_attr_in3_min.dev_attr.attr,
 581         &sensor_dev_attr_in3_max.dev_attr.attr,
 582         &sensor_dev_attr_in3_alarm.dev_attr.attr,
 583
 584         &sensor_dev_attr_fan1_input.dev_attr.attr,
 585         &sensor_dev_attr_fan1_min.dev_attr.attr,
 586         &sensor_dev_attr_fan1_div.dev_attr.attr,
 587         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 588         &sensor_dev_attr_fan2_input.dev_attr.attr,
 589         &sensor_dev_attr_fan2_min.dev_attr.attr,
 590         &sensor_dev_attr_fan2_div.dev_attr.attr,
 591         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 592
 593         &dev_attr_alarms.attr,
 594         &dev_attr_name.attr,
 595         NULL
 596 };
 597
 598 static const struct attribute_group sis5595_group = {
 599         .attrs = sis5595_attributes,
 600 };
 601
 602 static struct attribute *sis5595_attributes_in4[] = {
 603         &sensor_dev_attr_in4_input.dev_attr.attr,
 604         &sensor_dev_attr_in4_min.dev_attr.attr,
 605         &sensor_dev_attr_in4_max.dev_attr.attr,
 606         &sensor_dev_attr_in4_alarm.dev_attr.attr,
 607         NULL
 608 };
 609
 610 static const struct attribute_group sis5595_group_in4 = {
 611         .attrs = sis5595_attributes_in4,
 612 };
 613
 614 static struct attribute *sis5595_attributes_temp1[] = {
 615         &dev_attr_temp1_input.attr,
 616         &dev_attr_temp1_max.attr,
 617         &dev_attr_temp1_max_hyst.attr,
 618         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 619         NULL
 620 };
 621
 622 static const struct attribute_group sis5595_group_temp1 = {
 623         .attrs = sis5595_attributes_temp1,
 624 };
 625
 626 /* Called when we have found a new SIS5595. */
 627 static void sis5595_init_device(struct sis5595_data *data)
 628 {
 629         u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
 630         if (!(config & 0x01))
 631                 sis5595_write_value(data, SIS5595_REG_CONFIG,
 632                                 (config & 0xf7) | 0x01);
 633 }
 634
 635 /* This is called when the module is loaded */
 636 static int sis5595_probe(struct platform_device *pdev)
 637 {
 638         int err = 0;
 639         int i;
 640         struct sis5595_data *data;
 641         struct resource *res;
 642         char val;
 643
 644         /* Reserve the ISA region */
 645         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 646         if (!devm_request_region(&pdev->dev, res->start, SIS5595_EXTENT,
 647                                  DRIVER_NAME))
 648                 return -EBUSY;
 649
 650         data = devm_kzalloc(&pdev->dev, sizeof(struct sis5595_data),
 651                             GFP_KERNEL);
 652         if (!data)
 653                 return -ENOMEM;
 654
 655         mutex_init(&data->lock);
 656         mutex_init(&data->update_lock);
 657         data->addr = res->start;
 658         data->name = DRIVER_NAME;
 659         platform_set_drvdata(pdev, data);
 660
 661         /*
 662          * Check revision and pin registers to determine whether 4 or 5 voltages
 663          */
 664         data->revision = s_bridge->revision;
 665         /* 4 voltages, 1 temp */
 666         data->maxins = 3;
 667         if (data->revision >= REV2MIN) {
 668                 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
 669                 if (!(val & 0x80))
 670                         /* 5 voltages, no temps */
 671                         data->maxins = 4;
 672         }
 673
 674         /* Initialize the SIS5595 chip */
 675         sis5595_init_device(data);
 676
 677         /* A few vars need to be filled upon startup */
 678         for (i = 0; i < 2; i++) {
 679                 data->fan_min[i] = sis5595_read_value(data,
 680                                         SIS5595_REG_FAN_MIN(i));
 681         }
 682
 683         /* Register sysfs hooks */
 684         err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group);
 685         if (err)
 686                 return err;
 687         if (data->maxins == 4) {
 688                 err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group_in4);
 689                 if (err)
 690                         goto exit_remove_files;
 691         } else {
 692                 err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group_temp1);
 693                 if (err)
 694                         goto exit_remove_files;
 695         }
 696
 697         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 698         if (IS_ERR(data->hwmon_dev)) {
 699                 err = PTR_ERR(data->hwmon_dev);
 700                 goto exit_remove_files;
 701         }
 702
 703         return 0;
 704
 705 exit_remove_files:
 706         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
 707         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
 708         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
 709         return err;
 710 }
 711
 712 static int sis5595_remove(struct platform_device *pdev)
 713 {
 714         struct sis5595_data *data = platform_get_drvdata(pdev);
 715
 716         hwmon_device_unregister(data->hwmon_dev);
 717         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
 718         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
 719         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
 720
 721         return 0;
 722 }
 723
 724 static const struct pci_device_id sis5595_pci_ids[] = {
 725         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
 726         { 0, }
 727 };
 728
 729 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
 730
 731 static int blacklist[] = {
 732         PCI_DEVICE_ID_SI_540,
 733         PCI_DEVICE_ID_SI_550,
 734         PCI_DEVICE_ID_SI_630,
 735         PCI_DEVICE_ID_SI_645,
 736         PCI_DEVICE_ID_SI_730,
 737         PCI_DEVICE_ID_SI_735,
 738         PCI_DEVICE_ID_SI_5511, /*
 739                                 * 5513 chip has the 0008 device but
 740                                 * that ID shows up in other chips so we
 741                                 * use the 5511 ID for recognition
 742                                 */
 743         PCI_DEVICE_ID_SI_5597,
 744         PCI_DEVICE_ID_SI_5598,
 745         0 };
 746
 747 static int sis5595_device_add(unsigned short address)
 748 {
 749         struct resource res = {
 750                 .start  = address,
 751                 .end    = address + SIS5595_EXTENT - 1,
 752                 .name   = DRIVER_NAME,
 753                 .flags  = IORESOURCE_IO,
 754         };
 755         int err;
 756
 757         err = acpi_check_resource_conflict(&res);
 758         if (err)
 759                 goto exit;
 760
 761         pdev = platform_device_alloc(DRIVER_NAME, address);
 762         if (!pdev) {
 763                 err = -ENOMEM;
 764                 pr_err("Device allocation failed\n");
 765                 goto exit;
 766         }
 767
 768         err = platform_device_add_resources(pdev, &res, 1);
 769         if (err) {
 770                 pr_err("Device resource addition failed (%d)\n", err);
 771                 goto exit_device_put;
 772         }
 773
 774         err = platform_device_add(pdev);
 775         if (err) {
 776                 pr_err("Device addition failed (%d)\n", err);
 777                 goto exit_device_put;
 778         }
 779
 780         return 0;
 781
 782 exit_device_put:
 783         platform_device_put(pdev);
 784 exit:
 785         return err;
 786 }
 787
 788 static struct platform_driver sis5595_driver = {
 789         .driver = {
 790                 .name   = DRIVER_NAME,
 791         },
 792         .probe          = sis5595_probe,
 793         .remove         = sis5595_remove,
 794 };
 795
 796 static int sis5595_pci_probe(struct pci_dev *dev,
 797                                        const struct pci_device_id *id)
 798 {
 799         u16 address;
 800         u8 enable;
 801         int *i, err;
 802
 803         for (i = blacklist; *i != 0; i++) {
 804                 struct pci_dev *d;
 805                 d = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
 806                 if (d) {
 807                         dev_err(&d->dev,
 808                                 "Looked for SIS5595 but found unsupported device %.4x\n",
 809                                 *i);
 810                         pci_dev_put(d);
 811                         return -ENODEV;
 812                 }
 813         }
 814
 815         force_addr &= ~(SIS5595_EXTENT - 1);
 816         if (force_addr) {
 817                 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
 818                 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
 819         }
 820
 821         err = pci_read_config_word(dev, SIS5595_BASE_REG, &address);
 822         if (err != PCIBIOS_SUCCESSFUL) {
 823                 dev_err(&dev->dev, "Failed to read ISA address\n");
 824                 return -ENODEV;
 825         }
 826
 827         address &= ~(SIS5595_EXTENT - 1);
 828         if (!address) {
 829                 dev_err(&dev->dev,
 830                         "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
 831                 return -ENODEV;
 832         }
 833         if (force_addr && address != force_addr) {
 834                 /* doesn't work for some chips? */
 835                 dev_err(&dev->dev, "Failed to force ISA address\n");
 836                 return -ENODEV;
 837         }
 838
 839         err = pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable);
 840         if (err != PCIBIOS_SUCCESSFUL) {
 841                 dev_err(&dev->dev, "Failed to read enable register\n");
 842                 return -ENODEV;
 843         }
 844         if (!(enable & 0x80)) {
 845                 err = pci_write_config_byte(dev, SIS5595_ENABLE_REG, enable | 0x80);
 846                 if (err != PCIBIOS_SUCCESSFUL)
 847                         goto enable_fail;
 848
 849                 err = pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable);
 850                 if (err != PCIBIOS_SUCCESSFUL)
 851                         goto enable_fail;
 852
 853                 /* doesn't work for some chips! */
 854                 if (!(enable & 0x80))
 855                         goto enable_fail;
 856         }
 857
 858         if (platform_driver_register(&sis5595_driver)) {
 859                 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
 860                 goto exit;
 861         }
 862
 863         s_bridge = pci_dev_get(dev);
 864         /* Sets global pdev as a side effect */
 865         if (sis5595_device_add(address))
 866                 goto exit_unregister;
 867
 868         /*
 869          * Always return failure here.  This is to allow other drivers to bind
 870          * to this pci device.  We don't really want to have control over the
 871          * pci device, we only wanted to read as few register values from it.
 872          */
 873         return -ENODEV;
 874
 875 enable_fail:
 876         dev_err(&dev->dev, "Failed to enable HWM device\n");
 877         goto exit;
 878
 879 exit_unregister:
 880         pci_dev_put(dev);
 881         platform_driver_unregister(&sis5595_driver);
 882 exit:
 883         return -ENODEV;
 884 }
 885
 886 static struct pci_driver sis5595_pci_driver = {
 887         .name            = DRIVER_NAME,
 888         .id_table        = sis5595_pci_ids,
 889         .probe           = sis5595_pci_probe,
 890 };
 891
 892 static int __init sm_sis5595_init(void)
 893 {
 894         return pci_register_driver(&sis5595_pci_driver);
 895 }
 896
 897 static void __exit sm_sis5595_exit(void)
 898 {
 899         pci_unregister_driver(&sis5595_pci_driver);
 900         if (s_bridge != NULL) {
 901                 platform_device_unregister(pdev);
 902                 platform_driver_unregister(&sis5595_driver);
 903                 pci_dev_put(s_bridge);
 904                 s_bridge = NULL;
 905         }
 906 }
 907
 908 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
 909 MODULE_DESCRIPTION("SiS 5595 Sensor device");
 910 MODULE_LICENSE("GPL");
 911
 912 module_init(sm_sis5595_init);
 913 module_exit(sm_sis5595_exit);