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