drivers/hwmon/it87.c

   1 /*
   2     it87.c - Part of lm_sensors, Linux kernel modules for hardware
   3              monitoring.
   4
   5     Supports: IT8705F  Super I/O chip w/LPC interface
   6               IT8712F  Super I/O chip w/LPC interface & SMBus
   7               Sis950   A clone of the IT8705F
   8
   9     Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com>
  10     Largely inspired by lm78.c of the same package
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     You should have received a copy of the GNU General Public License
  23     along with this program; if not, write to the Free Software
  24     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25 */
  26
  27 /*
  28     djg@pdp8.net David Gesswein 7/18/01
  29     Modified to fix bug with not all alarms enabled.
  30     Added ability to read battery voltage and select temperature sensor
  31     type at module load time.
  32 */
  33
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/slab.h>
  37 #include <linux/jiffies.h>
  38 #include <linux/i2c.h>
  39 #include <linux/i2c-isa.h>
  40 #include <linux/hwmon.h>
  41 #include <linux/hwmon-sysfs.h>
  42 #include <linux/hwmon-vid.h>
  43 #include <linux/err.h>
  44 #include <linux/mutex.h>
  45 #include <asm/io.h>
  46
  47
  48 /* Addresses to scan */
  49 static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
  50 static unsigned short isa_address;
  51
  52 /* Insmod parameters */
  53 I2C_CLIENT_INSMOD_2(it87, it8712);
  54
  55 #define REG     0x2e    /* The register to read/write */
  56 #define DEV     0x07    /* Register: Logical device select */
  57 #define VAL     0x2f    /* The value to read/write */
  58 #define PME     0x04    /* The device with the fan registers in it */
  59 #define DEVID   0x20    /* Register: Device ID */
  60 #define DEVREV  0x22    /* Register: Device Revision */
  61
  62 static inline int
  63 superio_inb(int reg)
  64 {
  65         outb(reg, REG);
  66         return inb(VAL);
  67 }
  68
  69 static int superio_inw(int reg)
  70 {
  71         int val;
  72         outb(reg++, REG);
  73         val = inb(VAL) << 8;
  74         outb(reg, REG);
  75         val |= inb(VAL);
  76         return val;
  77 }
  78
  79 static inline void
  80 superio_select(void)
  81 {
  82         outb(DEV, REG);
  83         outb(PME, VAL);
  84 }
  85
  86 static inline void
  87 superio_enter(void)
  88 {
  89         outb(0x87, REG);
  90         outb(0x01, REG);
  91         outb(0x55, REG);
  92         outb(0x55, REG);
  93 }
  94
  95 static inline void
  96 superio_exit(void)
  97 {
  98         outb(0x02, REG);
  99         outb(0x02, VAL);
 100 }
 101
 102 #define IT8712F_DEVID 0x8712
 103 #define IT8705F_DEVID 0x8705
 104 #define IT87_ACT_REG  0x30
 105 #define IT87_BASE_REG 0x60
 106
 107 /* Update battery voltage after every reading if true */
 108 static int update_vbat;
 109
 110 /* Not all BIOSes properly configure the PWM registers */
 111 static int fix_pwm_polarity;
 112
 113 /* Chip Type */
 114
 115 static u16 chip_type;
 116
 117 /* Many IT87 constants specified below */
 118
 119 /* Length of ISA address segment */
 120 #define IT87_EXTENT 8
 121
 122 /* Where are the ISA address/data registers relative to the base address */
 123 #define IT87_ADDR_REG_OFFSET 5
 124 #define IT87_DATA_REG_OFFSET 6
 125
 126 /*----- The IT87 registers -----*/
 127
 128 #define IT87_REG_CONFIG        0x00
 129
 130 #define IT87_REG_ALARM1        0x01
 131 #define IT87_REG_ALARM2        0x02
 132 #define IT87_REG_ALARM3        0x03
 133
 134 #define IT87_REG_VID           0x0a
 135 #define IT87_REG_FAN_DIV       0x0b
 136
 137 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
 138
 139 #define IT87_REG_FAN(nr)       (0x0d + (nr))
 140 #define IT87_REG_FAN_MIN(nr)   (0x10 + (nr))
 141 #define IT87_REG_FAN_MAIN_CTRL 0x13
 142 #define IT87_REG_FAN_CTL       0x14
 143 #define IT87_REG_PWM(nr)       (0x15 + (nr))
 144
 145 #define IT87_REG_VIN(nr)       (0x20 + (nr))
 146 #define IT87_REG_TEMP(nr)      (0x29 + (nr))
 147
 148 #define IT87_REG_VIN_MAX(nr)   (0x30 + (nr) * 2)
 149 #define IT87_REG_VIN_MIN(nr)   (0x31 + (nr) * 2)
 150 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
 151 #define IT87_REG_TEMP_LOW(nr)  (0x41 + (nr) * 2)
 152
 153 #define IT87_REG_I2C_ADDR      0x48
 154
 155 #define IT87_REG_VIN_ENABLE    0x50
 156 #define IT87_REG_TEMP_ENABLE   0x51
 157
 158 #define IT87_REG_CHIPID        0x58
 159
 160 #define IN_TO_REG(val)  (SENSORS_LIMIT((((val) + 8)/16),0,255))
 161 #define IN_FROM_REG(val) ((val) * 16)
 162
 163 static inline u8 FAN_TO_REG(long rpm, int div)
 164 {
 165         if (rpm == 0)
 166                 return 255;
 167         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 168         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
 169                              254);
 170 }
 171
 172 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
 173
 174 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
 175                                         ((val)+500)/1000),-128,127))
 176 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
 177
 178 #define PWM_TO_REG(val)   ((val) >> 1)
 179 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
 180
 181 static int DIV_TO_REG(int val)
 182 {
 183         int answer = 0;
 184         while ((val >>= 1) != 0)
 185                 answer++;
 186         return answer;
 187 }
 188 #define DIV_FROM_REG(val) (1 << (val))
 189
 190
 191 /* For each registered IT87, we need to keep some data in memory. That
 192    data is pointed to by it87_list[NR]->data. The structure itself is
 193    dynamically allocated, at the same time when a new it87 client is
 194    allocated. */
 195 struct it87_data {
 196         struct i2c_client client;
 197         struct class_device *class_dev;
 198         struct mutex lock;
 199         enum chips type;
 200
 201         struct mutex update_lock;
 202         char valid;             /* !=0 if following fields are valid */
 203         unsigned long last_updated;     /* In jiffies */
 204
 205         u8 in[9];               /* Register value */
 206         u8 in_max[9];           /* Register value */
 207         u8 in_min[9];           /* Register value */
 208         u8 fan[3];              /* Register value */
 209         u8 fan_min[3];          /* Register value */
 210         u8 temp[3];             /* Register value */
 211         u8 temp_high[3];        /* Register value */
 212         u8 temp_low[3];         /* Register value */
 213         u8 sensor;              /* Register value */
 214         u8 fan_div[3];          /* Register encoding, shifted right */
 215         u8 vid;                 /* Register encoding, combined */
 216         u8 vrm;
 217         u32 alarms;             /* Register encoding, combined */
 218         u8 fan_main_ctrl;       /* Register value */
 219         u8 manual_pwm_ctl[3];   /* manual PWM value set by user */
 220 };
 221
 222
 223 static int it87_attach_adapter(struct i2c_adapter *adapter);
 224 static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
 225 static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
 226 static int it87_detach_client(struct i2c_client *client);
 227
 228 static int it87_read_value(struct i2c_client *client, u8 reg);
 229 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value);
 230 static struct it87_data *it87_update_device(struct device *dev);
 231 static int it87_check_pwm(struct i2c_client *client);
 232 static void it87_init_client(struct i2c_client *client, struct it87_data *data);
 233
 234
 235 static struct i2c_driver it87_driver = {
 236         .driver = {
 237                 .name   = "it87",
 238         },
 239         .id             = I2C_DRIVERID_IT87,
 240         .attach_adapter = it87_attach_adapter,
 241         .detach_client  = it87_detach_client,
 242 };
 243
 244 static struct i2c_driver it87_isa_driver = {
 245         .driver = {
 246                 .owner  = THIS_MODULE,
 247                 .name   = "it87-isa",
 248         },
 249         .attach_adapter = it87_isa_attach_adapter,
 250         .detach_client  = it87_detach_client,
 251 };
 252
 253
 254 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 255                 char *buf)
 256 {
 257         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 258         int nr = sensor_attr->index;
 259
 260         struct it87_data *data = it87_update_device(dev);
 261         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
 262 }
 263
 264 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
 265                 char *buf)
 266 {
 267         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 268         int nr = sensor_attr->index;
 269
 270         struct it87_data *data = it87_update_device(dev);
 271         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
 272 }
 273
 274 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
 275                 char *buf)
 276 {
 277         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 278         int nr = sensor_attr->index;
 279
 280         struct it87_data *data = it87_update_device(dev);
 281         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
 282 }
 283
 284 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
 285                 const char *buf, size_t count)
 286 {
 287         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 288         int nr = sensor_attr->index;
 289
 290         struct i2c_client *client = to_i2c_client(dev);
 291         struct it87_data *data = i2c_get_clientdata(client);
 292         unsigned long val = simple_strtoul(buf, NULL, 10);
 293
 294         mutex_lock(&data->update_lock);
 295         data->in_min[nr] = IN_TO_REG(val);
 296         it87_write_value(client, IT87_REG_VIN_MIN(nr),
 297                         data->in_min[nr]);
 298         mutex_unlock(&data->update_lock);
 299         return count;
 300 }
 301 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
 302                 const char *buf, size_t count)
 303 {
 304         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 305         int nr = sensor_attr->index;
 306
 307         struct i2c_client *client = to_i2c_client(dev);
 308         struct it87_data *data = i2c_get_clientdata(client);
 309         unsigned long val = simple_strtoul(buf, NULL, 10);
 310
 311         mutex_lock(&data->update_lock);
 312         data->in_max[nr] = IN_TO_REG(val);
 313         it87_write_value(client, IT87_REG_VIN_MAX(nr),
 314                         data->in_max[nr]);
 315         mutex_unlock(&data->update_lock);
 316         return count;
 317 }
 318
 319 #define show_in_offset(offset)                                  \
 320 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 321                 show_in, NULL, offset);
 322
 323 #define limit_in_offset(offset)                                 \
 324 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 325                 show_in_min, set_in_min, offset);               \
 326 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 327                 show_in_max, set_in_max, offset);
 328
 329 show_in_offset(0);
 330 limit_in_offset(0);
 331 show_in_offset(1);
 332 limit_in_offset(1);
 333 show_in_offset(2);
 334 limit_in_offset(2);
 335 show_in_offset(3);
 336 limit_in_offset(3);
 337 show_in_offset(4);
 338 limit_in_offset(4);
 339 show_in_offset(5);
 340 limit_in_offset(5);
 341 show_in_offset(6);
 342 limit_in_offset(6);
 343 show_in_offset(7);
 344 limit_in_offset(7);
 345 show_in_offset(8);
 346
 347 /* 3 temperatures */
 348 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 349                 char *buf)
 350 {
 351         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 352         int nr = sensor_attr->index;
 353
 354         struct it87_data *data = it87_update_device(dev);
 355         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
 356 }
 357 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
 358                 char *buf)
 359 {
 360         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 361         int nr = sensor_attr->index;
 362
 363         struct it87_data *data = it87_update_device(dev);
 364         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
 365 }
 366 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
 367                 char *buf)
 368 {
 369         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 370         int nr = sensor_attr->index;
 371
 372         struct it87_data *data = it87_update_device(dev);
 373         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
 374 }
 375 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 376                 const char *buf, size_t count)
 377 {
 378         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 379         int nr = sensor_attr->index;
 380
 381         struct i2c_client *client = to_i2c_client(dev);
 382         struct it87_data *data = i2c_get_clientdata(client);
 383         int val = simple_strtol(buf, NULL, 10);
 384
 385         mutex_lock(&data->update_lock);
 386         data->temp_high[nr] = TEMP_TO_REG(val);
 387         it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
 388         mutex_unlock(&data->update_lock);
 389         return count;
 390 }
 391 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
 392                 const char *buf, size_t count)
 393 {
 394         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 395         int nr = sensor_attr->index;
 396
 397         struct i2c_client *client = to_i2c_client(dev);
 398         struct it87_data *data = i2c_get_clientdata(client);
 399         int val = simple_strtol(buf, NULL, 10);
 400
 401         mutex_lock(&data->update_lock);
 402         data->temp_low[nr] = TEMP_TO_REG(val);
 403         it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
 404         mutex_unlock(&data->update_lock);
 405         return count;
 406 }
 407 #define show_temp_offset(offset)                                        \
 408 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
 409                 show_temp, NULL, offset - 1);                           \
 410 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
 411                 show_temp_max, set_temp_max, offset - 1);               \
 412 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
 413                 show_temp_min, set_temp_min, offset - 1);
 414
 415 show_temp_offset(1);
 416 show_temp_offset(2);
 417 show_temp_offset(3);
 418
 419 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
 420                 char *buf)
 421 {
 422         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 423         int nr = sensor_attr->index;
 424
 425         struct it87_data *data = it87_update_device(dev);
 426         u8 reg = data->sensor; /* In case the value is updated while we use it */
 427
 428         if (reg & (1 << nr))
 429                 return sprintf(buf, "3\n");  /* thermal diode */
 430         if (reg & (8 << nr))
 431                 return sprintf(buf, "2\n");  /* thermistor */
 432         return sprintf(buf, "0\n");      /* disabled */
 433 }
 434 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
 435                 const char *buf, size_t count)
 436 {
 437         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 438         int nr = sensor_attr->index;
 439
 440         struct i2c_client *client = to_i2c_client(dev);
 441         struct it87_data *data = i2c_get_clientdata(client);
 442         int val = simple_strtol(buf, NULL, 10);
 443
 444         mutex_lock(&data->update_lock);
 445
 446         data->sensor &= ~(1 << nr);
 447         data->sensor &= ~(8 << nr);
 448         /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
 449         if (val == 3)
 450             data->sensor |= 1 << nr;
 451         else if (val == 2)
 452             data->sensor |= 8 << nr;
 453         else if (val != 0) {
 454                 mutex_unlock(&data->update_lock);
 455                 return -EINVAL;
 456         }
 457         it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
 458         mutex_unlock(&data->update_lock);
 459         return count;
 460 }
 461 #define show_sensor_offset(offset)                                      \
 462 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR,       \
 463                 show_sensor, set_sensor, offset - 1);
 464
 465 show_sensor_offset(1);
 466 show_sensor_offset(2);
 467 show_sensor_offset(3);
 468
 469 /* 3 Fans */
 470 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
 471                 char *buf)
 472 {
 473         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 474         int nr = sensor_attr->index;
 475
 476         struct it87_data *data = it87_update_device(dev);
 477         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
 478                                 DIV_FROM_REG(data->fan_div[nr])));
 479 }
 480 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
 481                 char *buf)
 482 {
 483         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 484         int nr = sensor_attr->index;
 485
 486         struct it87_data *data = it87_update_device(dev);
 487         return sprintf(buf,"%d\n",
 488                 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
 489 }
 490 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
 491                 char *buf)
 492 {
 493         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 494         int nr = sensor_attr->index;
 495
 496         struct it87_data *data = it87_update_device(dev);
 497         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 498 }
 499 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
 500                 char *buf)
 501 {
 502         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 503         int nr = sensor_attr->index;
 504
 505         struct it87_data *data = it87_update_device(dev);
 506         return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
 507 }
 508 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
 509                 char *buf)
 510 {
 511         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 512         int nr = sensor_attr->index;
 513
 514         struct it87_data *data = it87_update_device(dev);
 515         return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
 516 }
 517 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 518                 const char *buf, size_t count)
 519 {
 520         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 521         int nr = sensor_attr->index;
 522
 523         struct i2c_client *client = to_i2c_client(dev);
 524         struct it87_data *data = i2c_get_clientdata(client);
 525         int val = simple_strtol(buf, NULL, 10);
 526         u8 reg = it87_read_value(client, IT87_REG_FAN_DIV);
 527
 528         mutex_lock(&data->update_lock);
 529         switch (nr) {
 530         case 0: data->fan_div[nr] = reg & 0x07; break;
 531         case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
 532         case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break;
 533         }
 534
 535         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 536         it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
 537         mutex_unlock(&data->update_lock);
 538         return count;
 539 }
 540 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 541                 const char *buf, size_t count)
 542 {
 543         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 544         int nr = sensor_attr->index;
 545
 546         struct i2c_client *client = to_i2c_client(dev);
 547         struct it87_data *data = i2c_get_clientdata(client);
 548         int val = simple_strtol(buf, NULL, 10);
 549         int i, min[3];
 550         u8 old;
 551
 552         mutex_lock(&data->update_lock);
 553         old = it87_read_value(client, IT87_REG_FAN_DIV);
 554
 555         for (i = 0; i < 3; i++)
 556                 min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i]));
 557
 558         switch (nr) {
 559         case 0:
 560         case 1:
 561                 data->fan_div[nr] = DIV_TO_REG(val);
 562                 break;
 563         case 2:
 564                 if (val < 8)
 565                         data->fan_div[nr] = 1;
 566                 else
 567                         data->fan_div[nr] = 3;
 568         }
 569         val = old & 0x80;
 570         val |= (data->fan_div[0] & 0x07);
 571         val |= (data->fan_div[1] & 0x07) << 3;
 572         if (data->fan_div[2] == 3)
 573                 val |= 0x1 << 6;
 574         it87_write_value(client, IT87_REG_FAN_DIV, val);
 575
 576         for (i = 0; i < 3; i++) {
 577                 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i]));
 578                 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
 579         }
 580         mutex_unlock(&data->update_lock);
 581         return count;
 582 }
 583 static ssize_t set_pwm_enable(struct device *dev,
 584                 struct device_attribute *attr, const char *buf, size_t count)
 585 {
 586         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 587         int nr = sensor_attr->index;
 588
 589         struct i2c_client *client = to_i2c_client(dev);
 590         struct it87_data *data = i2c_get_clientdata(client);
 591         int val = simple_strtol(buf, NULL, 10);
 592
 593         mutex_lock(&data->update_lock);
 594
 595         if (val == 0) {
 596                 int tmp;
 597                 /* make sure the fan is on when in on/off mode */
 598                 tmp = it87_read_value(client, IT87_REG_FAN_CTL);
 599                 it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
 600                 /* set on/off mode */
 601                 data->fan_main_ctrl &= ~(1 << nr);
 602                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
 603         } else if (val == 1) {
 604                 /* set SmartGuardian mode */
 605                 data->fan_main_ctrl |= (1 << nr);
 606                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
 607                 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
 608                 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
 609         } else {
 610                 mutex_unlock(&data->update_lock);
 611                 return -EINVAL;
 612         }
 613
 614         mutex_unlock(&data->update_lock);
 615         return count;
 616 }
 617 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
 618                 const char *buf, size_t count)
 619 {
 620         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 621         int nr = sensor_attr->index;
 622
 623         struct i2c_client *client = to_i2c_client(dev);
 624         struct it87_data *data = i2c_get_clientdata(client);
 625         int val = simple_strtol(buf, NULL, 10);
 626
 627         if (val < 0 || val > 255)
 628                 return -EINVAL;
 629
 630         mutex_lock(&data->update_lock);
 631         data->manual_pwm_ctl[nr] = val;
 632         if (data->fan_main_ctrl & (1 << nr))
 633                 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
 634         mutex_unlock(&data->update_lock);
 635         return count;
 636 }
 637
 638 #define show_fan_offset(offset)                                 \
 639 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
 640                 show_fan, NULL, offset - 1);                    \
 641 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 642                 show_fan_min, set_fan_min, offset - 1);         \
 643 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
 644                 show_fan_div, set_fan_div, offset - 1);
 645
 646 show_fan_offset(1);
 647 show_fan_offset(2);
 648 show_fan_offset(3);
 649
 650 #define show_pwm_offset(offset)                                         \
 651 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,      \
 652                 show_pwm_enable, set_pwm_enable, offset - 1);           \
 653 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,               \
 654                 show_pwm, set_pwm, offset - 1);
 655
 656 show_pwm_offset(1);
 657 show_pwm_offset(2);
 658 show_pwm_offset(3);
 659
 660 /* Alarms */
 661 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
 662 {
 663         struct it87_data *data = it87_update_device(dev);
 664         return sprintf(buf, "%u\n", data->alarms);
 665 }
 666 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 667
 668 static ssize_t
 669 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
 670 {
 671         struct it87_data *data = it87_update_device(dev);
 672         return sprintf(buf, "%u\n", data->vrm);
 673 }
 674 static ssize_t
 675 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 676 {
 677         struct i2c_client *client = to_i2c_client(dev);
 678         struct it87_data *data = i2c_get_clientdata(client);
 679         u32 val;
 680
 681         val = simple_strtoul(buf, NULL, 10);
 682         data->vrm = val;
 683
 684         return count;
 685 }
 686 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 687 #define device_create_file_vrm(client) \
 688 device_create_file(&client->dev, &dev_attr_vrm)
 689
 690 static ssize_t
 691 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
 692 {
 693         struct it87_data *data = it87_update_device(dev);
 694         return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
 695 }
 696 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 697 #define device_create_file_vid(client) \
 698 device_create_file(&client->dev, &dev_attr_cpu0_vid)
 699
 700 /* This function is called when:
 701      * it87_driver is inserted (when this module is loaded), for each
 702        available adapter
 703      * when a new adapter is inserted (and it87_driver is still present) */
 704 static int it87_attach_adapter(struct i2c_adapter *adapter)
 705 {
 706         if (!(adapter->class & I2C_CLASS_HWMON))
 707                 return 0;
 708         return i2c_probe(adapter, &addr_data, it87_detect);
 709 }
 710
 711 static int it87_isa_attach_adapter(struct i2c_adapter *adapter)
 712 {
 713         return it87_detect(adapter, isa_address, -1);
 714 }
 715
 716 /* SuperIO detection - will change isa_address if a chip is found */
 717 static int __init it87_find(unsigned short *address)
 718 {
 719         int err = -ENODEV;
 720
 721         superio_enter();
 722         chip_type = superio_inw(DEVID);
 723         if (chip_type != IT8712F_DEVID
 724          && chip_type != IT8705F_DEVID)
 725                 goto exit;
 726
 727         superio_select();
 728         if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
 729                 pr_info("it87: Device not activated, skipping\n");
 730                 goto exit;
 731         }
 732
 733         *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
 734         if (*address == 0) {
 735                 pr_info("it87: Base address not set, skipping\n");
 736                 goto exit;
 737         }
 738
 739         err = 0;
 740         pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
 741                 chip_type, *address, superio_inb(DEVREV) & 0x0f);
 742
 743 exit:
 744         superio_exit();
 745         return err;
 746 }
 747
 748 /* This function is called by i2c_probe */
 749 static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
 750 {
 751         int i;
 752         struct i2c_client *new_client;
 753         struct it87_data *data;
 754         int err = 0;
 755         const char *name = "";
 756         int is_isa = i2c_is_isa_adapter(adapter);
 757         int enable_pwm_interface;
 758
 759         if (!is_isa &&
 760             !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 761                 goto ERROR0;
 762
 763         /* Reserve the ISA region */
 764         if (is_isa)
 765                 if (!request_region(address, IT87_EXTENT,
 766                                     it87_isa_driver.driver.name))
 767                         goto ERROR0;
 768
 769         /* For now, we presume we have a valid client. We create the
 770            client structure, even though we cannot fill it completely yet.
 771            But it allows us to access it87_{read,write}_value. */
 772
 773         if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
 774                 err = -ENOMEM;
 775                 goto ERROR1;
 776         }
 777
 778         new_client = &data->client;
 779         if (is_isa)
 780                 mutex_init(&data->lock);
 781         i2c_set_clientdata(new_client, data);
 782         new_client->addr = address;
 783         new_client->adapter = adapter;
 784         new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
 785         new_client->flags = 0;
 786
 787         /* Now, we do the remaining detection. */
 788
 789         if (kind < 0) {
 790                 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
 791                   || (!is_isa
 792                    && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
 793                         err = -ENODEV;
 794                         goto ERROR2;
 795                 }
 796         }
 797
 798         /* Determine the chip type. */
 799         if (kind <= 0) {
 800                 i = it87_read_value(new_client, IT87_REG_CHIPID);
 801                 if (i == 0x90) {
 802                         kind = it87;
 803                         if ((is_isa) && (chip_type == IT8712F_DEVID))
 804                                 kind = it8712;
 805                 }
 806                 else {
 807                         if (kind == 0)
 808                                 dev_info(&adapter->dev,
 809                                         "Ignoring 'force' parameter for unknown chip at "
 810                                         "adapter %d, address 0x%02x\n",
 811                                         i2c_adapter_id(adapter), address);
 812                         err = -ENODEV;
 813                         goto ERROR2;
 814                 }
 815         }
 816
 817         if (kind == it87) {
 818                 name = "it87";
 819         } else if (kind == it8712) {
 820                 name = "it8712";
 821         }
 822
 823         /* Fill in the remaining client fields and put it into the global list */
 824         strlcpy(new_client->name, name, I2C_NAME_SIZE);
 825         data->type = kind;
 826         data->valid = 0;
 827         mutex_init(&data->update_lock);
 828
 829         /* Tell the I2C layer a new client has arrived */
 830         if ((err = i2c_attach_client(new_client)))
 831                 goto ERROR2;
 832
 833         if (!is_isa)
 834                 dev_info(&new_client->dev, "The I2C interface to IT87xxF "
 835                          "hardware monitoring chips is deprecated. Please "
 836                          "report if you still rely on it.\n");
 837
 838         /* Check PWM configuration */
 839         enable_pwm_interface = it87_check_pwm(new_client);
 840
 841         /* Initialize the IT87 chip */
 842         it87_init_client(new_client, data);
 843
 844         /* Register sysfs hooks */
 845         data->class_dev = hwmon_device_register(&new_client->dev);
 846         if (IS_ERR(data->class_dev)) {
 847                 err = PTR_ERR(data->class_dev);
 848                 goto ERROR3;
 849         }
 850
 851         device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
 852         device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
 853         device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
 854         device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
 855         device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
 856         device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
 857         device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
 858         device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
 859         device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
 860         device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
 861         device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
 862         device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
 863         device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
 864         device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
 865         device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
 866         device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
 867         device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
 868         device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
 869         device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
 870         device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
 871         device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
 872         device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
 873         device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
 874         device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
 875         device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
 876         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
 877         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
 878         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
 879         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
 880         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
 881         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
 882         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
 883         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
 884         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
 885         device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
 886         device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
 887         device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
 888         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
 889         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
 890         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
 891         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
 892         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
 893         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
 894         device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
 895         device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
 896         device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
 897         device_create_file(&new_client->dev, &dev_attr_alarms);
 898         if (enable_pwm_interface) {
 899                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
 900                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
 901                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
 902                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
 903                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
 904                 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
 905         }
 906
 907         if (data->type == it8712) {
 908                 data->vrm = vid_which_vrm();
 909                 device_create_file_vrm(new_client);
 910                 device_create_file_vid(new_client);
 911         }
 912
 913         return 0;
 914
 915 ERROR3:
 916         i2c_detach_client(new_client);
 917 ERROR2:
 918         kfree(data);
 919 ERROR1:
 920         if (is_isa)
 921                 release_region(address, IT87_EXTENT);
 922 ERROR0:
 923         return err;
 924 }
 925
 926 static int it87_detach_client(struct i2c_client *client)
 927 {
 928         struct it87_data *data = i2c_get_clientdata(client);
 929         int err;
 930
 931         hwmon_device_unregister(data->class_dev);
 932
 933         if ((err = i2c_detach_client(client)))
 934                 return err;
 935
 936         if(i2c_is_isa_client(client))
 937                 release_region(client->addr, IT87_EXTENT);
 938         kfree(data);
 939
 940         return 0;
 941 }
 942
 943 /* The SMBus locks itself, but ISA access must be locked explicitly!
 944    We don't want to lock the whole ISA bus, so we lock each client
 945    separately.
 946    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
 947    would slow down the IT87 access and should not be necessary. */
 948 static int it87_read_value(struct i2c_client *client, u8 reg)
 949 {
 950         struct it87_data *data = i2c_get_clientdata(client);
 951
 952         int res;
 953         if (i2c_is_isa_client(client)) {
 954                 mutex_lock(&data->lock);
 955                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
 956                 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
 957                 mutex_unlock(&data->lock);
 958                 return res;
 959         } else
 960                 return i2c_smbus_read_byte_data(client, reg);
 961 }
 962
 963 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 964    We don't want to lock the whole ISA bus, so we lock each client
 965    separately.
 966    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
 967    would slow down the IT87 access and should not be necessary. */
 968 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
 969 {
 970         struct it87_data *data = i2c_get_clientdata(client);
 971
 972         if (i2c_is_isa_client(client)) {
 973                 mutex_lock(&data->lock);
 974                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
 975                 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
 976                 mutex_unlock(&data->lock);
 977                 return 0;
 978         } else
 979                 return i2c_smbus_write_byte_data(client, reg, value);
 980 }
 981
 982 /* Return 1 if and only if the PWM interface is safe to use */
 983 static int it87_check_pwm(struct i2c_client *client)
 984 {
 985         /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
 986          * and polarity set to active low is sign that this is the case so we
 987          * disable pwm control to protect the user. */
 988         int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
 989         if ((tmp & 0x87) == 0) {
 990                 if (fix_pwm_polarity) {
 991                         /* The user asks us to attempt a chip reconfiguration.
 992                          * This means switching to active high polarity and
 993                          * inverting all fan speed values. */
 994                         int i;
 995                         u8 pwm[3];
 996
 997                         for (i = 0; i < 3; i++)
 998                                 pwm[i] = it87_read_value(client,
 999                                                          IT87_REG_PWM(i));
1000
1001                         /* If any fan is in automatic pwm mode, the polarity
1002                          * might be correct, as suspicious as it seems, so we
1003                          * better don't change anything (but still disable the
1004                          * PWM interface). */
1005                         if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1006                                 dev_info(&client->dev, "Reconfiguring PWM to "
1007                                          "active high polarity\n");
1008                                 it87_write_value(client, IT87_REG_FAN_CTL,
1009                                                  tmp | 0x87);
1010                                 for (i = 0; i < 3; i++)
1011                                         it87_write_value(client,
1012                                                          IT87_REG_PWM(i),
1013                                                          0x7f & ~pwm[i]);
1014                                 return 1;
1015                         }
1016
1017                         dev_info(&client->dev, "PWM configuration is "
1018                                  "too broken to be fixed\n");
1019                 }
1020
1021                 dev_info(&client->dev, "Detected broken BIOS "
1022                          "defaults, disabling PWM interface\n");
1023                 return 0;
1024         } else if (fix_pwm_polarity) {
1025                 dev_info(&client->dev, "PWM configuration looks "
1026                          "sane, won't touch\n");
1027         }
1028
1029         return 1;
1030 }
1031
1032 /* Called when we have found a new IT87. */
1033 static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1034 {
1035         int tmp, i;
1036
1037         /* initialize to sane defaults:
1038          * - if the chip is in manual pwm mode, this will be overwritten with
1039          *   the actual settings on the chip (so in this case, initialization
1040          *   is not needed)
1041          * - if in automatic or on/off mode, we could switch to manual mode,
1042          *   read the registers and set manual_pwm_ctl accordingly, but currently
1043          *   this is not implemented, so we initialize to something sane */
1044         for (i = 0; i < 3; i++) {
1045                 data->manual_pwm_ctl[i] = 0xff;
1046         }
1047
1048         /* Check if temperature channnels are reset manually or by some reason */
1049         tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1050         if ((tmp & 0x3f) == 0) {
1051                 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1052                 tmp = (tmp & 0xc0) | 0x2a;
1053                 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1054         }
1055         data->sensor = tmp;
1056
1057         /* Check if voltage monitors are reset manually or by some reason */
1058         tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1059         if ((tmp & 0xff) == 0) {
1060                 /* Enable all voltage monitors */
1061                 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1062         }
1063
1064         /* Check if tachometers are reset manually or by some reason */
1065         data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1066         if ((data->fan_main_ctrl & 0x70) == 0) {
1067                 /* Enable all fan tachometers */
1068                 data->fan_main_ctrl |= 0x70;
1069                 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1070         }
1071
1072         /* Set current fan mode registers and the default settings for the
1073          * other mode registers */
1074         for (i = 0; i < 3; i++) {
1075                 if (data->fan_main_ctrl & (1 << i)) {
1076                         /* pwm mode */
1077                         tmp = it87_read_value(client, IT87_REG_PWM(i));
1078                         if (tmp & 0x80) {
1079                                 /* automatic pwm - not yet implemented, but
1080                                  * leave the settings made by the BIOS alone
1081                                  * until a change is requested via the sysfs
1082                                  * interface */
1083                         } else {
1084                                 /* manual pwm */
1085                                 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1086                         }
1087                 }
1088         }
1089
1090         /* Start monitoring */
1091         it87_write_value(client, IT87_REG_CONFIG,
1092                          (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1093                          | (update_vbat ? 0x41 : 0x01));
1094 }
1095
1096 static struct it87_data *it87_update_device(struct device *dev)
1097 {
1098         struct i2c_client *client = to_i2c_client(dev);
1099         struct it87_data *data = i2c_get_clientdata(client);
1100         int i;
1101
1102         mutex_lock(&data->update_lock);
1103
1104         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1105             || !data->valid) {
1106
1107                 if (update_vbat) {
1108                         /* Cleared after each update, so reenable.  Value
1109                           returned by this read will be previous value */
1110                         it87_write_value(client, IT87_REG_CONFIG,
1111                            it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1112                 }
1113                 for (i = 0; i <= 7; i++) {
1114                         data->in[i] =
1115                             it87_read_value(client, IT87_REG_VIN(i));
1116                         data->in_min[i] =
1117                             it87_read_value(client, IT87_REG_VIN_MIN(i));
1118                         data->in_max[i] =
1119                             it87_read_value(client, IT87_REG_VIN_MAX(i));
1120                 }
1121                 data->in[8] =
1122                     it87_read_value(client, IT87_REG_VIN(8));
1123                 /* Temperature sensor doesn't have limit registers, set
1124                    to min and max value */
1125                 data->in_min[8] = 0;
1126                 data->in_max[8] = 255;
1127
1128                 for (i = 0; i < 3; i++) {
1129                         data->fan[i] =
1130                             it87_read_value(client, IT87_REG_FAN(i));
1131                         data->fan_min[i] =
1132                             it87_read_value(client, IT87_REG_FAN_MIN(i));
1133                 }
1134                 for (i = 0; i < 3; i++) {
1135                         data->temp[i] =
1136                             it87_read_value(client, IT87_REG_TEMP(i));
1137                         data->temp_high[i] =
1138                             it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1139                         data->temp_low[i] =
1140                             it87_read_value(client, IT87_REG_TEMP_LOW(i));
1141                 }
1142
1143                 i = it87_read_value(client, IT87_REG_FAN_DIV);
1144                 data->fan_div[0] = i & 0x07;
1145                 data->fan_div[1] = (i >> 3) & 0x07;
1146                 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1147
1148                 data->alarms =
1149                         it87_read_value(client, IT87_REG_ALARM1) |
1150                         (it87_read_value(client, IT87_REG_ALARM2) << 8) |
1151                         (it87_read_value(client, IT87_REG_ALARM3) << 16);
1152                 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1153
1154                 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1155                 /* The 8705 does not have VID capability */
1156                 if (data->type == it8712) {
1157                         data->vid = it87_read_value(client, IT87_REG_VID);
1158                         data->vid &= 0x1f;
1159                 }
1160                 data->last_updated = jiffies;
1161                 data->valid = 1;
1162         }
1163
1164         mutex_unlock(&data->update_lock);
1165
1166         return data;
1167 }
1168
1169 static int __init sm_it87_init(void)
1170 {
1171         int res;
1172
1173         res = i2c_add_driver(&it87_driver);
1174         if (res)
1175                 return res;
1176
1177         if (!it87_find(&isa_address)) {
1178                 res = i2c_isa_add_driver(&it87_isa_driver);
1179                 if (res) {
1180                         i2c_del_driver(&it87_driver);
1181                         return res;
1182                 }
1183         }
1184
1185         return 0;
1186 }
1187
1188 static void __exit sm_it87_exit(void)
1189 {
1190         if (isa_address)
1191                 i2c_isa_del_driver(&it87_isa_driver);
1192         i2c_del_driver(&it87_driver);
1193 }
1194
1195
1196 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1197 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1198 module_param(update_vbat, bool, 0);
1199 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1200 module_param(fix_pwm_polarity, bool, 0);
1201 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1202 MODULE_LICENSE("GPL");
1203
1204 module_init(sm_it87_init);
1205 module_exit(sm_it87_exit);