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