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
 157  * REG: 0, 1, 2, or 3 (respectively)
 158  */
 159 #define DIV_FROM_REG(val) (1 << (val))
 160
 161 /*
 162  * For each registered chip, we need to keep some data in memory.
 163  * The structure is dynamically allocated.
 164  */
 165 struct sis5595_data {
 166         unsigned short addr;
 167         const char *name;
 168         struct device *hwmon_dev;
 169         struct mutex lock;
 170
 171         struct mutex update_lock;
 172         bool valid;             /* true if following fields are valid */
 173         unsigned long last_updated;     /* In jiffies */
 174         char maxins;            /* == 3 if temp enabled, otherwise == 4 */
 175         u8 revision;            /* Reg. value */
 176
 177         u8 in[5];               /* Register value */
 178         u8 in_max[5];           /* Register value */
 179         u8 in_min[5];           /* Register value */
 180         u8 fan[2];              /* Register value */
 181         u8 fan_min[2];          /* Register value */
 182         s8 temp;                /* Register value */
 183         s8 temp_over;           /* Register value */
 184         s8 temp_hyst;           /* Register value */
 185         u8 fan_div[2];          /* Register encoding, shifted right */
 186         u16 alarms;             /* Register encoding, combined */
 187 };
 188
 189 static struct pci_dev *s_bridge;        /* pointer to the (only) sis5595 */
 190
 191 /* ISA access must be locked explicitly. */
 192 static int sis5595_read_value(struct sis5595_data *data, u8 reg)
 193 {
 194         int res;
 195
 196         mutex_lock(&data->lock);
 197         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
 198         res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
 199         mutex_unlock(&data->lock);
 200         return res;
 201 }
 202
 203 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
 204 {
 205         mutex_lock(&data->lock);
 206         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
 207         outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
 208         mutex_unlock(&data->lock);
 209 }
 210
 211 static struct sis5595_data *sis5595_update_device(struct device *dev)
 212 {
 213         struct sis5595_data *data = dev_get_drvdata(dev);
 214         int i;
 215
 216         mutex_lock(&data->update_lock);
 217
 218         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 219             || !data->valid) {
 220
 221                 for (i = 0; i <= data->maxins; i++) {
 222                         data->in[i] =
 223                             sis5595_read_value(data, SIS5595_REG_IN(i));
 224                         data->in_min[i] =
 225                             sis5595_read_value(data,
 226                                                SIS5595_REG_IN_MIN(i));
 227                         data->in_max[i] =
 228                             sis5595_read_value(data,
 229                                                SIS5595_REG_IN_MAX(i));
 230                 }
 231                 for (i = 0; i < 2; i++) {
 232                         data->fan[i] =
 233                             sis5595_read_value(data, SIS5595_REG_FAN(i));
 234                         data->fan_min[i] =
 235                             sis5595_read_value(data,
 236                                                SIS5595_REG_FAN_MIN(i));
 237                 }
 238                 if (data->maxins == 3) {
 239                         data->temp =
 240                             sis5595_read_value(data, SIS5595_REG_TEMP);
 241                         data->temp_over =
 242                             sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
 243                         data->temp_hyst =
 244                             sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
 245                 }
 246                 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
 247                 data->fan_div[0] = (i >> 4) & 0x03;
 248                 data->fan_div[1] = i >> 6;
 249                 data->alarms =
 250                     sis5595_read_value(data, SIS5595_REG_ALARM1) |
 251                     (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
 252                 data->last_updated = jiffies;
 253                 data->valid = true;
 254         }
 255
 256         mutex_unlock(&data->update_lock);
 257
 258         return data;
 259 }
 260
 261 /* 4 Voltages */
 262 static ssize_t in_show(struct device *dev, struct device_attribute *da,
 263                        char *buf)
 264 {
 265         struct sis5595_data *data = sis5595_update_device(dev);
 266         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 267         int nr = attr->index;
 268         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
 269 }
 270
 271 static ssize_t in_min_show(struct device *dev, struct device_attribute *da,
 272                            char *buf)
 273 {
 274         struct sis5595_data *data = sis5595_update_device(dev);
 275         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 276         int nr = attr->index;
 277         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
 278 }
 279
 280 static ssize_t in_max_show(struct device *dev, struct device_attribute *da,
 281                            char *buf)
 282 {
 283         struct sis5595_data *data = sis5595_update_device(dev);
 284         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 285         int nr = attr->index;
 286         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
 287 }
 288
 289 static ssize_t in_min_store(struct device *dev, struct device_attribute *da,
 290                             const char *buf, size_t count)
 291 {
 292         struct sis5595_data *data = dev_get_drvdata(dev);
 293         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 294         int nr = attr->index;
 295         unsigned long val;
 296         int err;
 297
 298         err = kstrtoul(buf, 10, &val);
 299         if (err)
 300                 return err;
 301
 302         mutex_lock(&data->update_lock);
 303         data->in_min[nr] = IN_TO_REG(val);
 304         sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
 305         mutex_unlock(&data->update_lock);
 306         return count;
 307 }
 308
 309 static ssize_t in_max_store(struct device *dev, struct device_attribute *da,
 310                             const char *buf, size_t count)
 311 {
 312         struct sis5595_data *data = dev_get_drvdata(dev);
 313         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 314         int nr = attr->index;
 315         unsigned long val;
 316         int err;
 317
 318         err = kstrtoul(buf, 10, &val);
 319         if (err)
 320                 return err;
 321
 322         mutex_lock(&data->update_lock);
 323         data->in_max[nr] = IN_TO_REG(val);
 324         sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
 325         mutex_unlock(&data->update_lock);
 326         return count;
 327 }
 328
 329 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
 330 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
 331 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
 332 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
 333 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
 334 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
 335 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
 336 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
 337 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
 338 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
 339 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
 340 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
 341 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
 342 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
 343 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
 344
 345 /* Temperature */
 346 static ssize_t temp1_input_show(struct device *dev,
 347                                 struct device_attribute *attr, char *buf)
 348 {
 349         struct sis5595_data *data = sis5595_update_device(dev);
 350         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 351 }
 352
 353 static ssize_t temp1_max_show(struct device *dev, struct device_attribute *attr,
 354                               char *buf)
 355 {
 356         struct sis5595_data *data = sis5595_update_device(dev);
 357         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 358 }
 359
 360 static ssize_t temp1_max_store(struct device *dev,
 361                                struct device_attribute *attr, const char *buf,
 362                                size_t count)
 363 {
 364         struct sis5595_data *data = dev_get_drvdata(dev);
 365         long val;
 366         int err;
 367
 368         err = kstrtol(buf, 10, &val);
 369         if (err)
 370                 return err;
 371
 372         mutex_lock(&data->update_lock);
 373         data->temp_over = TEMP_TO_REG(val);
 374         sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
 375         mutex_unlock(&data->update_lock);
 376         return count;
 377 }
 378
 379 static ssize_t temp1_max_hyst_show(struct device *dev,
 380                                    struct device_attribute *attr, char *buf)
 381 {
 382         struct sis5595_data *data = sis5595_update_device(dev);
 383         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 384 }
 385
 386 static ssize_t temp1_max_hyst_store(struct device *dev,
 387                                     struct device_attribute *attr,
 388                                     const char *buf, size_t count)
 389 {
 390         struct sis5595_data *data = dev_get_drvdata(dev);
 391         long val;
 392         int err;
 393
 394         err = kstrtol(buf, 10, &val);
 395         if (err)
 396                 return err;
 397
 398         mutex_lock(&data->update_lock);
 399         data->temp_hyst = TEMP_TO_REG(val);
 400         sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
 401         mutex_unlock(&data->update_lock);
 402         return count;
 403 }
 404
 405 static DEVICE_ATTR_RO(temp1_input);
 406 static DEVICE_ATTR_RW(temp1_max);
 407 static DEVICE_ATTR_RW(temp1_max_hyst);
 408
 409 /* 2 Fans */
 410 static ssize_t fan_show(struct device *dev, struct device_attribute *da,
 411                         char *buf)
 412 {
 413         struct sis5595_data *data = sis5595_update_device(dev);
 414         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 415         int nr = attr->index;
 416         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 417                 DIV_FROM_REG(data->fan_div[nr])));
 418 }
 419
 420 static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,
 421                             char *buf)
 422 {
 423         struct sis5595_data *data = sis5595_update_device(dev);
 424         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 425         int nr = attr->index;
 426         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 427                 DIV_FROM_REG(data->fan_div[nr])));
 428 }
 429
 430 static ssize_t fan_min_store(struct device *dev, struct device_attribute *da,
 431                              const char *buf, size_t count)
 432 {
 433         struct sis5595_data *data = dev_get_drvdata(dev);
 434         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 435         int nr = attr->index;
 436         unsigned long val;
 437         int err;
 438
 439         err = kstrtoul(buf, 10, &val);
 440         if (err)
 441                 return err;
 442
 443         mutex_lock(&data->update_lock);
 444         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 445         sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
 446         mutex_unlock(&data->update_lock);
 447         return count;
 448 }
 449
 450 static ssize_t fan_div_show(struct device *dev, struct device_attribute *da,
 451                             char *buf)
 452 {
 453         struct sis5595_data *data = sis5595_update_device(dev);
 454         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 455         int nr = attr->index;
 456         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 457 }
 458
 459 /*
 460  * Note: we save and restore the fan minimum here, because its value is
 461  * determined in part by the fan divisor.  This follows the principle of
 462  * least surprise; the user doesn't expect the fan minimum to change just
 463  * because the divisor changed.
 464  */
 465 static ssize_t fan_div_store(struct device *dev, struct device_attribute *da,
 466                              const char *buf, size_t count)
 467 {
 468         struct sis5595_data *data = dev_get_drvdata(dev);
 469         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 470         int nr = attr->index;
 471         unsigned long min;
 472         int reg;
 473         unsigned long val;
 474         int err;
 475
 476         err = kstrtoul(buf, 10, &val);
 477         if (err)
 478                 return err;
 479
 480         mutex_lock(&data->update_lock);
 481         min = FAN_FROM_REG(data->fan_min[nr],
 482                         DIV_FROM_REG(data->fan_div[nr]));
 483         reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
 484
 485         switch (val) {
 486         case 1:
 487                 data->fan_div[nr] = 0;
 488                 break;
 489         case 2:
 490                 data->fan_div[nr] = 1;
 491                 break;
 492         case 4:
 493                 data->fan_div[nr] = 2;
 494                 break;
 495         case 8:
 496                 data->fan_div[nr] = 3;
 497                 break;
 498         default:
 499                 dev_err(dev,
 500                         "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
 501                         val);
 502                 mutex_unlock(&data->update_lock);
 503                 return -EINVAL;
 504         }
 505
 506         switch (nr) {
 507         case 0:
 508                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 509                 break;
 510         case 1:
 511                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 512                 break;
 513         }
 514         sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
 515         data->fan_min[nr] =
 516                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 517         sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
 518         mutex_unlock(&data->update_lock);
 519         return count;
 520 }
 521
 522 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
 523 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
 524 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
 525 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
 526 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
 527 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
 528
 529 /* Alarms */
 530 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
 531                            char *buf)
 532 {
 533         struct sis5595_data *data = sis5595_update_device(dev);
 534         return sprintf(buf, "%d\n", data->alarms);
 535 }
 536 static DEVICE_ATTR_RO(alarms);
 537
 538 static ssize_t alarm_show(struct device *dev, struct device_attribute *da,
 539                           char *buf)
 540 {
 541         struct sis5595_data *data = sis5595_update_device(dev);
 542         int nr = to_sensor_dev_attr(da)->index;
 543         return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 544 }
 545 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
 546 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
 547 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
 548 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
 549 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 15);
 550 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
 551 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
 552 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 15);
 553
 554 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 555                          char *buf)
 556 {
 557         struct sis5595_data *data = dev_get_drvdata(dev);
 558         return sprintf(buf, "%s\n", data->name);
 559 }
 560 static DEVICE_ATTR_RO(name);
 561
 562 static struct attribute *sis5595_attributes[] = {
 563         &sensor_dev_attr_in0_input.dev_attr.attr,
 564         &sensor_dev_attr_in0_min.dev_attr.attr,
 565         &sensor_dev_attr_in0_max.dev_attr.attr,
 566         &sensor_dev_attr_in0_alarm.dev_attr.attr,
 567         &sensor_dev_attr_in1_input.dev_attr.attr,
 568         &sensor_dev_attr_in1_min.dev_attr.attr,
 569         &sensor_dev_attr_in1_max.dev_attr.attr,
 570         &sensor_dev_attr_in1_alarm.dev_attr.attr,
 571         &sensor_dev_attr_in2_input.dev_attr.attr,
 572         &sensor_dev_attr_in2_min.dev_attr.attr,
 573         &sensor_dev_attr_in2_max.dev_attr.attr,
 574         &sensor_dev_attr_in2_alarm.dev_attr.attr,
 575         &sensor_dev_attr_in3_input.dev_attr.attr,
 576         &sensor_dev_attr_in3_min.dev_attr.attr,
 577         &sensor_dev_attr_in3_max.dev_attr.attr,
 578         &sensor_dev_attr_in3_alarm.dev_attr.attr,
 579
 580         &sensor_dev_attr_fan1_input.dev_attr.attr,
 581         &sensor_dev_attr_fan1_min.dev_attr.attr,
 582         &sensor_dev_attr_fan1_div.dev_attr.attr,
 583         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 584         &sensor_dev_attr_fan2_input.dev_attr.attr,
 585         &sensor_dev_attr_fan2_min.dev_attr.attr,
 586         &sensor_dev_attr_fan2_div.dev_attr.attr,
 587         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 588
 589         &dev_attr_alarms.attr,
 590         &dev_attr_name.attr,
 591         NULL
 592 };
 593
 594 static const struct attribute_group sis5595_group = {
 595         .attrs = sis5595_attributes,
 596 };
 597
 598 static struct attribute *sis5595_attributes_in4[] = {
 599         &sensor_dev_attr_in4_input.dev_attr.attr,
 600         &sensor_dev_attr_in4_min.dev_attr.attr,
 601         &sensor_dev_attr_in4_max.dev_attr.attr,
 602         &sensor_dev_attr_in4_alarm.dev_attr.attr,
 603         NULL
 604 };
 605
 606 static const struct attribute_group sis5595_group_in4 = {
 607         .attrs = sis5595_attributes_in4,
 608 };
 609
 610 static struct attribute *sis5595_attributes_temp1[] = {
 611         &dev_attr_temp1_input.attr,
 612         &dev_attr_temp1_max.attr,
 613         &dev_attr_temp1_max_hyst.attr,
 614         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 615         NULL
 616 };
 617
 618 static const struct attribute_group sis5595_group_temp1 = {
 619         .attrs = sis5595_attributes_temp1,
 620 };
 621
 622 /* Called when we have found a new SIS5595. */
 623 static void sis5595_init_device(struct sis5595_data *data)
 624 {
 625         u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
 626         if (!(config & 0x01))
 627                 sis5595_write_value(data, SIS5595_REG_CONFIG,
 628                                 (config & 0xf7) | 0x01);
 629 }
 630
 631 /* This is called when the module is loaded */
 632 static int sis5595_probe(struct platform_device *pdev)
 633 {
 634         int err = 0;
 635         int i;
 636         struct sis5595_data *data;
 637         struct resource *res;
 638         char val;
 639
 640         /* Reserve the ISA region */
 641         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 642         if (!devm_request_region(&pdev->dev, res->start, SIS5595_EXTENT,
 643                                  DRIVER_NAME))
 644                 return -EBUSY;
 645
 646         data = devm_kzalloc(&pdev->dev, sizeof(struct sis5595_data),
 647                             GFP_KERNEL);
 648         if (!data)
 649                 return -ENOMEM;
 650
 651         mutex_init(&data->lock);
 652         mutex_init(&data->update_lock);
 653         data->addr = res->start;
 654         data->name = DRIVER_NAME;
 655         platform_set_drvdata(pdev, data);
 656
 657         /*
 658          * Check revision and pin registers to determine whether 4 or 5 voltages
 659          */
 660         data->revision = s_bridge->revision;
 661         /* 4 voltages, 1 temp */
 662         data->maxins = 3;
 663         if (data->revision >= REV2MIN) {
 664                 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
 665                 if (!(val & 0x80))
 666                         /* 5 voltages, no temps */
 667                         data->maxins = 4;
 668         }
 669
 670         /* Initialize the SIS5595 chip */
 671         sis5595_init_device(data);
 672
 673         /* A few vars need to be filled upon startup */
 674         for (i = 0; i < 2; i++) {
 675                 data->fan_min[i] = sis5595_read_value(data,
 676                                         SIS5595_REG_FAN_MIN(i));
 677         }
 678
 679         /* Register sysfs hooks */
 680         err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group);
 681         if (err)
 682                 return err;
 683         if (data->maxins == 4) {
 684                 err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group_in4);
 685                 if (err)
 686                         goto exit_remove_files;
 687         } else {
 688                 err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group_temp1);
 689                 if (err)
 690                         goto exit_remove_files;
 691         }
 692
 693         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 694         if (IS_ERR(data->hwmon_dev)) {
 695                 err = PTR_ERR(data->hwmon_dev);
 696                 goto exit_remove_files;
 697         }
 698
 699         return 0;
 700
 701 exit_remove_files:
 702         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
 703         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
 704         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
 705         return err;
 706 }
 707
 708 static void sis5595_remove(struct platform_device *pdev)
 709 {
 710         struct sis5595_data *data = platform_get_drvdata(pdev);
 711
 712         hwmon_device_unregister(data->hwmon_dev);
 713         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
 714         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
 715         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
 716 }
 717
 718 static const struct pci_device_id sis5595_pci_ids[] = {
 719         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
 720         { 0, }
 721 };
 722
 723 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
 724
 725 static int blacklist[] = {
 726         PCI_DEVICE_ID_SI_540,
 727         PCI_DEVICE_ID_SI_550,
 728         PCI_DEVICE_ID_SI_630,
 729         PCI_DEVICE_ID_SI_645,
 730         PCI_DEVICE_ID_SI_730,
 731         PCI_DEVICE_ID_SI_735,
 732         PCI_DEVICE_ID_SI_5511, /*
 733                                 * 5513 chip has the 0008 device but
 734                                 * that ID shows up in other chips so we
 735                                 * use the 5511 ID for recognition
 736                                 */
 737         PCI_DEVICE_ID_SI_5597,
 738         PCI_DEVICE_ID_SI_5598,
 739         0 };
 740
 741 static int sis5595_device_add(unsigned short address)
 742 {
 743         struct resource res = {
 744                 .start  = address,
 745                 .end    = address + SIS5595_EXTENT - 1,
 746                 .name   = DRIVER_NAME,
 747                 .flags  = IORESOURCE_IO,
 748         };
 749         int err;
 750
 751         err = acpi_check_resource_conflict(&res);
 752         if (err)
 753                 goto exit;
 754
 755         pdev = platform_device_alloc(DRIVER_NAME, address);
 756         if (!pdev) {
 757                 err = -ENOMEM;
 758                 pr_err("Device allocation failed\n");
 759                 goto exit;
 760         }
 761
 762         err = platform_device_add_resources(pdev, &res, 1);
 763         if (err) {
 764                 pr_err("Device resource addition failed (%d)\n", err);
 765                 goto exit_device_put;
 766         }
 767
 768         err = platform_device_add(pdev);
 769         if (err) {
 770                 pr_err("Device addition failed (%d)\n", err);
 771                 goto exit_device_put;
 772         }
 773
 774         return 0;
 775
 776 exit_device_put:
 777         platform_device_put(pdev);
 778 exit:
 779         return err;
 780 }
 781
 782 static struct platform_driver sis5595_driver = {
 783         .driver = {
 784                 .name   = DRIVER_NAME,
 785         },
 786         .probe          = sis5595_probe,
 787         .remove_new     = sis5595_remove,
 788 };
 789
 790 static int sis5595_pci_probe(struct pci_dev *dev,
 791                                        const struct pci_device_id *id)
 792 {
 793         u16 address;
 794         u8 enable;
 795         int *i, err;
 796
 797         for (i = blacklist; *i != 0; i++) {
 798                 struct pci_dev *d;
 799                 d = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
 800                 if (d) {
 801                         dev_err(&d->dev,
 802                                 "Looked for SIS5595 but found unsupported device %.4x\n",
 803                                 *i);
 804                         pci_dev_put(d);
 805                         return -ENODEV;
 806                 }
 807         }
 808
 809         force_addr &= ~(SIS5595_EXTENT - 1);
 810         if (force_addr) {
 811                 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
 812                 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
 813         }
 814
 815         err = pci_read_config_word(dev, SIS5595_BASE_REG, &address);
 816         if (err != PCIBIOS_SUCCESSFUL) {
 817                 dev_err(&dev->dev, "Failed to read ISA address\n");
 818                 return -ENODEV;
 819         }
 820
 821         address &= ~(SIS5595_EXTENT - 1);
 822         if (!address) {
 823                 dev_err(&dev->dev,
 824                         "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
 825                 return -ENODEV;
 826         }
 827         if (force_addr && address != force_addr) {
 828                 /* doesn't work for some chips? */
 829                 dev_err(&dev->dev, "Failed to force ISA address\n");
 830                 return -ENODEV;
 831         }
 832
 833         err = pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable);
 834         if (err != PCIBIOS_SUCCESSFUL) {
 835                 dev_err(&dev->dev, "Failed to read enable register\n");
 836                 return -ENODEV;
 837         }
 838         if (!(enable & 0x80)) {
 839                 err = pci_write_config_byte(dev, SIS5595_ENABLE_REG, enable | 0x80);
 840                 if (err != PCIBIOS_SUCCESSFUL)
 841                         goto enable_fail;
 842
 843                 err = pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable);
 844                 if (err != PCIBIOS_SUCCESSFUL)
 845                         goto enable_fail;
 846
 847                 /* doesn't work for some chips! */
 848                 if (!(enable & 0x80))
 849                         goto enable_fail;
 850         }
 851
 852         if (platform_driver_register(&sis5595_driver)) {
 853                 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
 854                 goto exit;
 855         }
 856
 857         s_bridge = pci_dev_get(dev);
 858         /* Sets global pdev as a side effect */
 859         if (sis5595_device_add(address))
 860                 goto exit_unregister;
 861
 862         /*
 863          * Always return failure here.  This is to allow other drivers to bind
 864          * to this pci device.  We don't really want to have control over the
 865          * pci device, we only wanted to read as few register values from it.
 866          */
 867         return -ENODEV;
 868
 869 enable_fail:
 870         dev_err(&dev->dev, "Failed to enable HWM device\n");
 871         goto exit;
 872
 873 exit_unregister:
 874         pci_dev_put(dev);
 875         platform_driver_unregister(&sis5595_driver);
 876 exit:
 877         return -ENODEV;
 878 }
 879
 880 static struct pci_driver sis5595_pci_driver = {
 881         .name            = DRIVER_NAME,
 882         .id_table        = sis5595_pci_ids,
 883         .probe           = sis5595_pci_probe,
 884 };
 885
 886 static int __init sm_sis5595_init(void)
 887 {
 888         return pci_register_driver(&sis5595_pci_driver);
 889 }
 890
 891 static void __exit sm_sis5595_exit(void)
 892 {
 893         pci_unregister_driver(&sis5595_pci_driver);
 894         if (s_bridge != NULL) {
 895                 platform_device_unregister(pdev);
 896                 platform_driver_unregister(&sis5595_driver);
 897                 pci_dev_put(s_bridge);
 898                 s_bridge = NULL;
 899         }
 900 }
 901
 902 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
 903 MODULE_DESCRIPTION("SiS 5595 Sensor device");
 904 MODULE_LICENSE("GPL");
 905
 906 module_init(sm_sis5595_init);
 907 module_exit(sm_sis5595_exit);