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