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