drivers/hwmon/sis5595.c

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