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