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