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-isa.h> 40 #include <linux/hwmon.h> 41 #include <linux/hwmon-sysfs.h> 42 #include <linux/hwmon-vid.h> 43 #include <linux/err.h> 44 #include <asm/io.h> 45 46 47 /* Addresses to scan */ 48 static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 49 0x2e, 0x2f, I2C_CLIENT_END }; 50 static unsigned short isa_address = 0x290; 51 52 /* Insmod parameters */ 53 I2C_CLIENT_INSMOD_2(it87, it8712); 54 55 #define REG 0x2e /* The register to read/write */ 56 #define DEV 0x07 /* Register: Logical device select */ 57 #define VAL 0x2f /* The value to read/write */ 58 #define PME 0x04 /* The device with the fan registers in it */ 59 #define DEVID 0x20 /* Register: Device ID */ 60 #define DEVREV 0x22 /* Register: Device Revision */ 61 62 static inline int 63 superio_inb(int reg) 64 { 65 outb(reg, REG); 66 return inb(VAL); 67 } 68 69 static int superio_inw(int reg) 70 { 71 int val; 72 outb(reg++, REG); 73 val = inb(VAL) << 8; 74 outb(reg, REG); 75 val |= inb(VAL); 76 return val; 77 } 78 79 static inline void 80 superio_select(void) 81 { 82 outb(DEV, REG); 83 outb(PME, VAL); 84 } 85 86 static inline void 87 superio_enter(void) 88 { 89 outb(0x87, REG); 90 outb(0x01, REG); 91 outb(0x55, REG); 92 outb(0x55, REG); 93 } 94 95 static inline void 96 superio_exit(void) 97 { 98 outb(0x02, REG); 99 outb(0x02, VAL); 100 } 101 102 #define IT8712F_DEVID 0x8712 103 #define IT8705F_DEVID 0x8705 104 #define IT87_ACT_REG 0x30 105 #define IT87_BASE_REG 0x60 106 107 /* Update battery voltage after every reading if true */ 108 static int update_vbat; 109 110 /* Not all BIOSes properly configure the PWM registers */ 111 static int fix_pwm_polarity; 112 113 /* Chip Type */ 114 115 static u16 chip_type; 116 117 /* Many IT87 constants specified below */ 118 119 /* Length of ISA address segment */ 120 #define IT87_EXTENT 8 121 122 /* Where are the ISA address/data registers relative to the base address */ 123 #define IT87_ADDR_REG_OFFSET 5 124 #define IT87_DATA_REG_OFFSET 6 125 126 /*----- The IT87 registers -----*/ 127 128 #define IT87_REG_CONFIG 0x00 129 130 #define IT87_REG_ALARM1 0x01 131 #define IT87_REG_ALARM2 0x02 132 #define IT87_REG_ALARM3 0x03 133 134 #define IT87_REG_VID 0x0a 135 #define IT87_REG_FAN_DIV 0x0b 136 137 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */ 138 139 #define IT87_REG_FAN(nr) (0x0d + (nr)) 140 #define IT87_REG_FAN_MIN(nr) (0x10 + (nr)) 141 #define IT87_REG_FAN_MAIN_CTRL 0x13 142 #define IT87_REG_FAN_CTL 0x14 143 #define IT87_REG_PWM(nr) (0x15 + (nr)) 144 145 #define IT87_REG_VIN(nr) (0x20 + (nr)) 146 #define IT87_REG_TEMP(nr) (0x29 + (nr)) 147 148 #define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2) 149 #define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2) 150 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2) 151 #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2) 152 153 #define IT87_REG_I2C_ADDR 0x48 154 155 #define IT87_REG_VIN_ENABLE 0x50 156 #define IT87_REG_TEMP_ENABLE 0x51 157 158 #define IT87_REG_CHIPID 0x58 159 160 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255)) 161 #define IN_FROM_REG(val) ((val) * 16) 162 163 static inline u8 FAN_TO_REG(long rpm, int div) 164 { 165 if (rpm == 0) 166 return 255; 167 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 168 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 169 254); 170 } 171 172 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div))) 173 174 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\ 175 ((val)+500)/1000),-128,127)) 176 #define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000) 177 178 #define PWM_TO_REG(val) ((val) >> 1) 179 #define PWM_FROM_REG(val) (((val)&0x7f) << 1) 180 181 static int DIV_TO_REG(int val) 182 { 183 int answer = 0; 184 while ((val >>= 1) != 0) 185 answer++; 186 return answer; 187 } 188 #define DIV_FROM_REG(val) (1 << (val)) 189 190 191 /* For each registered IT87, we need to keep some data in memory. That 192 data is pointed to by it87_list[NR]->data. The structure itself is 193 dynamically allocated, at the same time when a new it87 client is 194 allocated. */ 195 struct it87_data { 196 struct i2c_client client; 197 struct class_device *class_dev; 198 struct semaphore lock; 199 enum chips type; 200 201 struct semaphore update_lock; 202 char valid; /* !=0 if following fields are valid */ 203 unsigned long last_updated; /* In jiffies */ 204 205 u8 in[9]; /* Register value */ 206 u8 in_max[9]; /* Register value */ 207 u8 in_min[9]; /* Register value */ 208 u8 fan[3]; /* Register value */ 209 u8 fan_min[3]; /* Register value */ 210 u8 temp[3]; /* Register value */ 211 u8 temp_high[3]; /* Register value */ 212 u8 temp_low[3]; /* Register value */ 213 u8 sensor; /* Register value */ 214 u8 fan_div[3]; /* Register encoding, shifted right */ 215 u8 vid; /* Register encoding, combined */ 216 int vrm; 217 u32 alarms; /* Register encoding, combined */ 218 u8 fan_main_ctrl; /* Register value */ 219 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */ 220 }; 221 222 223 static int it87_attach_adapter(struct i2c_adapter *adapter); 224 static int it87_isa_attach_adapter(struct i2c_adapter *adapter); 225 static int it87_detect(struct i2c_adapter *adapter, int address, int kind); 226 static int it87_detach_client(struct i2c_client *client); 227 228 static int it87_read_value(struct i2c_client *client, u8 register); 229 static int it87_write_value(struct i2c_client *client, u8 register, 230 u8 value); 231 static struct it87_data *it87_update_device(struct device *dev); 232 static int it87_check_pwm(struct i2c_client *client); 233 static void it87_init_client(struct i2c_client *client, struct it87_data *data); 234 235 236 static struct i2c_driver it87_driver = { 237 .owner = THIS_MODULE, 238 .name = "it87", 239 .id = I2C_DRIVERID_IT87, 240 .flags = I2C_DF_NOTIFY, 241 .attach_adapter = it87_attach_adapter, 242 .detach_client = it87_detach_client, 243 }; 244 245 static struct i2c_driver it87_isa_driver = { 246 .owner = THIS_MODULE, 247 .name = "it87-isa", 248 .attach_adapter = it87_isa_attach_adapter, 249 .detach_client = it87_detach_client, 250 }; 251 252 253 static ssize_t show_in(struct device *dev, struct device_attribute *attr, 254 char *buf) 255 { 256 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 257 int nr = sensor_attr->index; 258 259 struct it87_data *data = it87_update_device(dev); 260 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr])); 261 } 262 263 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr, 264 char *buf) 265 { 266 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 267 int nr = sensor_attr->index; 268 269 struct it87_data *data = it87_update_device(dev); 270 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr])); 271 } 272 273 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr, 274 char *buf) 275 { 276 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 277 int nr = sensor_attr->index; 278 279 struct it87_data *data = it87_update_device(dev); 280 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr])); 281 } 282 283 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, 284 const char *buf, size_t count) 285 { 286 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 287 int nr = sensor_attr->index; 288 289 struct i2c_client *client = to_i2c_client(dev); 290 struct it87_data *data = i2c_get_clientdata(client); 291 unsigned long val = simple_strtoul(buf, NULL, 10); 292 293 down(&data->update_lock); 294 data->in_min[nr] = IN_TO_REG(val); 295 it87_write_value(client, IT87_REG_VIN_MIN(nr), 296 data->in_min[nr]); 297 up(&data->update_lock); 298 return count; 299 } 300 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, 301 const char *buf, size_t count) 302 { 303 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 304 int nr = sensor_attr->index; 305 306 struct i2c_client *client = to_i2c_client(dev); 307 struct it87_data *data = i2c_get_clientdata(client); 308 unsigned long val = simple_strtoul(buf, NULL, 10); 309 310 down(&data->update_lock); 311 data->in_max[nr] = IN_TO_REG(val); 312 it87_write_value(client, IT87_REG_VIN_MAX(nr), 313 data->in_max[nr]); 314 up(&data->update_lock); 315 return count; 316 } 317 318 #define show_in_offset(offset) \ 319 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 320 show_in, NULL, offset); 321 322 #define limit_in_offset(offset) \ 323 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 324 show_in_min, set_in_min, offset); \ 325 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 326 show_in_max, set_in_max, offset); 327 328 show_in_offset(0); 329 limit_in_offset(0); 330 show_in_offset(1); 331 limit_in_offset(1); 332 show_in_offset(2); 333 limit_in_offset(2); 334 show_in_offset(3); 335 limit_in_offset(3); 336 show_in_offset(4); 337 limit_in_offset(4); 338 show_in_offset(5); 339 limit_in_offset(5); 340 show_in_offset(6); 341 limit_in_offset(6); 342 show_in_offset(7); 343 limit_in_offset(7); 344 show_in_offset(8); 345 346 /* 3 temperatures */ 347 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 348 char *buf) 349 { 350 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 351 int nr = sensor_attr->index; 352 353 struct it87_data *data = it87_update_device(dev); 354 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr])); 355 } 356 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, 357 char *buf) 358 { 359 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 360 int nr = sensor_attr->index; 361 362 struct it87_data *data = it87_update_device(dev); 363 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr])); 364 } 365 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr, 366 char *buf) 367 { 368 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 369 int nr = sensor_attr->index; 370 371 struct it87_data *data = it87_update_device(dev); 372 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr])); 373 } 374 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 375 const char *buf, size_t count) 376 { 377 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 378 int nr = sensor_attr->index; 379 380 struct i2c_client *client = to_i2c_client(dev); 381 struct it87_data *data = i2c_get_clientdata(client); 382 int val = simple_strtol(buf, NULL, 10); 383 384 down(&data->update_lock); 385 data->temp_high[nr] = TEMP_TO_REG(val); 386 it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]); 387 up(&data->update_lock); 388 return count; 389 } 390 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 391 const char *buf, size_t count) 392 { 393 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 394 int nr = sensor_attr->index; 395 396 struct i2c_client *client = to_i2c_client(dev); 397 struct it87_data *data = i2c_get_clientdata(client); 398 int val = simple_strtol(buf, NULL, 10); 399 400 down(&data->update_lock); 401 data->temp_low[nr] = TEMP_TO_REG(val); 402 it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]); 403 up(&data->update_lock); 404 return count; 405 } 406 #define show_temp_offset(offset) \ 407 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 408 show_temp, NULL, offset - 1); \ 409 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 410 show_temp_max, set_temp_max, offset - 1); \ 411 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 412 show_temp_min, set_temp_min, offset - 1); 413 414 show_temp_offset(1); 415 show_temp_offset(2); 416 show_temp_offset(3); 417 418 static ssize_t show_sensor(struct device *dev, struct device_attribute *attr, 419 char *buf) 420 { 421 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 422 int nr = sensor_attr->index; 423 424 struct it87_data *data = it87_update_device(dev); 425 u8 reg = data->sensor; /* In case the value is updated while we use it */ 426 427 if (reg & (1 << nr)) 428 return sprintf(buf, "3\n"); /* thermal diode */ 429 if (reg & (8 << nr)) 430 return sprintf(buf, "2\n"); /* thermistor */ 431 return sprintf(buf, "0\n"); /* disabled */ 432 } 433 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr, 434 const char *buf, size_t count) 435 { 436 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 437 int nr = sensor_attr->index; 438 439 struct i2c_client *client = to_i2c_client(dev); 440 struct it87_data *data = i2c_get_clientdata(client); 441 int val = simple_strtol(buf, NULL, 10); 442 443 down(&data->update_lock); 444 445 data->sensor &= ~(1 << nr); 446 data->sensor &= ~(8 << nr); 447 /* 3 = thermal diode; 2 = thermistor; 0 = disabled */ 448 if (val == 3) 449 data->sensor |= 1 << nr; 450 else if (val == 2) 451 data->sensor |= 8 << nr; 452 else if (val != 0) { 453 up(&data->update_lock); 454 return -EINVAL; 455 } 456 it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor); 457 up(&data->update_lock); 458 return count; 459 } 460 #define show_sensor_offset(offset) \ 461 static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \ 462 show_sensor, set_sensor, offset - 1); 463 464 show_sensor_offset(1); 465 show_sensor_offset(2); 466 show_sensor_offset(3); 467 468 /* 3 Fans */ 469 static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 470 char *buf) 471 { 472 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 473 int nr = sensor_attr->index; 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, struct device_attribute *attr, 480 char *buf) 481 { 482 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 483 int nr = sensor_attr->index; 484 485 struct it87_data *data = it87_update_device(dev); 486 return sprintf(buf,"%d\n", 487 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]))); 488 } 489 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 490 char *buf) 491 { 492 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 493 int nr = sensor_attr->index; 494 495 struct it87_data *data = it87_update_device(dev); 496 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr])); 497 } 498 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr, 499 char *buf) 500 { 501 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 502 int nr = sensor_attr->index; 503 504 struct it87_data *data = it87_update_device(dev); 505 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0); 506 } 507 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 508 char *buf) 509 { 510 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 511 int nr = sensor_attr->index; 512 513 struct it87_data *data = it87_update_device(dev); 514 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]); 515 } 516 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 517 const char *buf, size_t count) 518 { 519 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 520 int nr = sensor_attr->index; 521 522 struct i2c_client *client = to_i2c_client(dev); 523 struct it87_data *data = i2c_get_clientdata(client); 524 int val = simple_strtol(buf, NULL, 10); 525 526 down(&data->update_lock); 527 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 528 it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]); 529 up(&data->update_lock); 530 return count; 531 } 532 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 533 const char *buf, size_t count) 534 { 535 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 536 int nr = sensor_attr->index; 537 538 struct i2c_client *client = to_i2c_client(dev); 539 struct it87_data *data = i2c_get_clientdata(client); 540 int val = simple_strtol(buf, NULL, 10); 541 int i, min[3]; 542 u8 old; 543 544 down(&data->update_lock); 545 old = it87_read_value(client, IT87_REG_FAN_DIV); 546 547 for (i = 0; i < 3; i++) 548 min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i])); 549 550 switch (nr) { 551 case 0: 552 case 1: 553 data->fan_div[nr] = DIV_TO_REG(val); 554 break; 555 case 2: 556 if (val < 8) 557 data->fan_div[nr] = 1; 558 else 559 data->fan_div[nr] = 3; 560 } 561 val = old & 0x80; 562 val |= (data->fan_div[0] & 0x07); 563 val |= (data->fan_div[1] & 0x07) << 3; 564 if (data->fan_div[2] == 3) 565 val |= 0x1 << 6; 566 it87_write_value(client, IT87_REG_FAN_DIV, val); 567 568 for (i = 0; i < 3; i++) { 569 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i])); 570 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]); 571 } 572 up(&data->update_lock); 573 return count; 574 } 575 static ssize_t set_pwm_enable(struct device *dev, 576 struct device_attribute *attr, const char *buf, size_t count) 577 { 578 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 579 int nr = sensor_attr->index; 580 581 struct i2c_client *client = to_i2c_client(dev); 582 struct it87_data *data = i2c_get_clientdata(client); 583 int val = simple_strtol(buf, NULL, 10); 584 585 down(&data->update_lock); 586 587 if (val == 0) { 588 int tmp; 589 /* make sure the fan is on when in on/off mode */ 590 tmp = it87_read_value(client, IT87_REG_FAN_CTL); 591 it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr)); 592 /* set on/off mode */ 593 data->fan_main_ctrl &= ~(1 << nr); 594 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); 595 } else if (val == 1) { 596 /* set SmartGuardian mode */ 597 data->fan_main_ctrl |= (1 << nr); 598 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); 599 /* set saved pwm value, clear FAN_CTLX PWM mode bit */ 600 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); 601 } else { 602 up(&data->update_lock); 603 return -EINVAL; 604 } 605 606 up(&data->update_lock); 607 return count; 608 } 609 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 610 const char *buf, size_t count) 611 { 612 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 613 int nr = sensor_attr->index; 614 615 struct i2c_client *client = to_i2c_client(dev); 616 struct it87_data *data = i2c_get_clientdata(client); 617 int val = simple_strtol(buf, NULL, 10); 618 619 if (val < 0 || val > 255) 620 return -EINVAL; 621 622 down(&data->update_lock); 623 data->manual_pwm_ctl[nr] = val; 624 if (data->fan_main_ctrl & (1 << nr)) 625 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); 626 up(&data->update_lock); 627 return count; 628 } 629 630 #define show_fan_offset(offset) \ 631 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 632 show_fan, NULL, offset - 1); \ 633 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 634 show_fan_min, set_fan_min, offset - 1); \ 635 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 636 show_fan_div, set_fan_div, offset - 1); 637 638 show_fan_offset(1); 639 show_fan_offset(2); 640 show_fan_offset(3); 641 642 #define show_pwm_offset(offset) \ 643 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ 644 show_pwm_enable, set_pwm_enable, offset - 1); \ 645 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ 646 show_pwm, set_pwm, offset - 1); 647 648 show_pwm_offset(1); 649 show_pwm_offset(2); 650 show_pwm_offset(3); 651 652 /* Alarms */ 653 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 654 { 655 struct it87_data *data = it87_update_device(dev); 656 return sprintf(buf, "%u\n", data->alarms); 657 } 658 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 659 660 static ssize_t 661 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf) 662 { 663 struct it87_data *data = it87_update_device(dev); 664 return sprintf(buf, "%ld\n", (long) data->vrm); 665 } 666 static ssize_t 667 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 668 { 669 struct i2c_client *client = to_i2c_client(dev); 670 struct it87_data *data = i2c_get_clientdata(client); 671 u32 val; 672 673 val = simple_strtoul(buf, NULL, 10); 674 data->vrm = val; 675 676 return count; 677 } 678 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 679 #define device_create_file_vrm(client) \ 680 device_create_file(&client->dev, &dev_attr_vrm) 681 682 static ssize_t 683 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf) 684 { 685 struct it87_data *data = it87_update_device(dev); 686 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm)); 687 } 688 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 689 #define device_create_file_vid(client) \ 690 device_create_file(&client->dev, &dev_attr_cpu0_vid) 691 692 /* This function is called when: 693 * it87_driver is inserted (when this module is loaded), for each 694 available adapter 695 * when a new adapter is inserted (and it87_driver is still present) */ 696 static int it87_attach_adapter(struct i2c_adapter *adapter) 697 { 698 if (!(adapter->class & I2C_CLASS_HWMON)) 699 return 0; 700 return i2c_probe(adapter, &addr_data, it87_detect); 701 } 702 703 static int it87_isa_attach_adapter(struct i2c_adapter *adapter) 704 { 705 return it87_detect(adapter, isa_address, -1); 706 } 707 708 /* SuperIO detection - will change isa_address if a chip is found */ 709 static int __init it87_find(int *address) 710 { 711 int err = -ENODEV; 712 713 superio_enter(); 714 chip_type = superio_inw(DEVID); 715 if (chip_type != IT8712F_DEVID 716 && chip_type != IT8705F_DEVID) 717 goto exit; 718 719 superio_select(); 720 if (!(superio_inb(IT87_ACT_REG) & 0x01)) { 721 pr_info("it87: Device not activated, skipping\n"); 722 goto exit; 723 } 724 725 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1); 726 if (*address == 0) { 727 pr_info("it87: Base address not set, skipping\n"); 728 goto exit; 729 } 730 731 err = 0; 732 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n", 733 chip_type, *address, superio_inb(DEVREV) & 0x0f); 734 735 exit: 736 superio_exit(); 737 return err; 738 } 739 740 /* This function is called by i2c_probe */ 741 int it87_detect(struct i2c_adapter *adapter, int address, int kind) 742 { 743 int i; 744 struct i2c_client *new_client; 745 struct it87_data *data; 746 int err = 0; 747 const char *name = ""; 748 int is_isa = i2c_is_isa_adapter(adapter); 749 int enable_pwm_interface; 750 751 if (!is_isa && 752 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 753 goto ERROR0; 754 755 /* Reserve the ISA region */ 756 if (is_isa) 757 if (!request_region(address, IT87_EXTENT, it87_isa_driver.name)) 758 goto ERROR0; 759 760 /* Probe whether there is anything available on this address. Already 761 done for SMBus and Super-I/O clients */ 762 if (kind < 0) { 763 if (is_isa && !chip_type) { 764 #define REALLY_SLOW_IO 765 /* We need the timeouts for at least some IT87-like chips. But only 766 if we read 'undefined' registers. */ 767 i = inb_p(address + 1); 768 if (inb_p(address + 2) != i 769 || inb_p(address + 3) != i 770 || inb_p(address + 7) != i) { 771 err = -ENODEV; 772 goto ERROR1; 773 } 774 #undef REALLY_SLOW_IO 775 776 /* Let's just hope nothing breaks here */ 777 i = inb_p(address + 5) & 0x7f; 778 outb_p(~i & 0x7f, address + 5); 779 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) { 780 outb_p(i, address + 5); 781 err = -ENODEV; 782 goto ERROR1; 783 } 784 } 785 } 786 787 /* OK. For now, we presume we have a valid client. We now create the 788 client structure, even though we cannot fill it completely yet. 789 But it allows us to access it87_{read,write}_value. */ 790 791 if (!(data = kmalloc(sizeof(struct it87_data), GFP_KERNEL))) { 792 err = -ENOMEM; 793 goto ERROR1; 794 } 795 memset(data, 0, sizeof(struct it87_data)); 796 797 new_client = &data->client; 798 if (is_isa) 799 init_MUTEX(&data->lock); 800 i2c_set_clientdata(new_client, data); 801 new_client->addr = address; 802 new_client->adapter = adapter; 803 new_client->driver = is_isa ? &it87_isa_driver : &it87_driver; 804 new_client->flags = 0; 805 806 /* Now, we do the remaining detection. */ 807 808 if (kind < 0) { 809 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80) 810 || (!is_isa 811 && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) { 812 err = -ENODEV; 813 goto ERROR2; 814 } 815 } 816 817 /* Determine the chip type. */ 818 if (kind <= 0) { 819 i = it87_read_value(new_client, IT87_REG_CHIPID); 820 if (i == 0x90) { 821 kind = it87; 822 if ((is_isa) && (chip_type == IT8712F_DEVID)) 823 kind = it8712; 824 } 825 else { 826 if (kind == 0) 827 dev_info(&adapter->dev, 828 "Ignoring 'force' parameter for unknown chip at " 829 "adapter %d, address 0x%02x\n", 830 i2c_adapter_id(adapter), address); 831 err = -ENODEV; 832 goto ERROR2; 833 } 834 } 835 836 if (kind == it87) { 837 name = "it87"; 838 } else if (kind == it8712) { 839 name = "it8712"; 840 } 841 842 /* Fill in the remaining client fields and put it into the global list */ 843 strlcpy(new_client->name, name, I2C_NAME_SIZE); 844 data->type = kind; 845 data->valid = 0; 846 init_MUTEX(&data->update_lock); 847 848 /* Tell the I2C layer a new client has arrived */ 849 if ((err = i2c_attach_client(new_client))) 850 goto ERROR2; 851 852 /* Check PWM configuration */ 853 enable_pwm_interface = it87_check_pwm(new_client); 854 855 /* Initialize the IT87 chip */ 856 it87_init_client(new_client, data); 857 858 /* Register sysfs hooks */ 859 data->class_dev = hwmon_device_register(&new_client->dev); 860 if (IS_ERR(data->class_dev)) { 861 err = PTR_ERR(data->class_dev); 862 goto ERROR3; 863 } 864 865 device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr); 866 device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr); 867 device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr); 868 device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr); 869 device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr); 870 device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr); 871 device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr); 872 device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr); 873 device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr); 874 device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr); 875 device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr); 876 device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr); 877 device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr); 878 device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr); 879 device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr); 880 device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr); 881 device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr); 882 device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr); 883 device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr); 884 device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr); 885 device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr); 886 device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr); 887 device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr); 888 device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr); 889 device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr); 890 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr); 891 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr); 892 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr); 893 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr); 894 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr); 895 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr); 896 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr); 897 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr); 898 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr); 899 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr); 900 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr); 901 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr); 902 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr); 903 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr); 904 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr); 905 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr); 906 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr); 907 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr); 908 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr); 909 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr); 910 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr); 911 device_create_file(&new_client->dev, &dev_attr_alarms); 912 if (enable_pwm_interface) { 913 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr); 914 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr); 915 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr); 916 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr); 917 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr); 918 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr); 919 } 920 921 if (data->type == it8712) { 922 data->vrm = vid_which_vrm(); 923 device_create_file_vrm(new_client); 924 device_create_file_vid(new_client); 925 } 926 927 return 0; 928 929 ERROR3: 930 i2c_detach_client(new_client); 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 struct it87_data *data = i2c_get_clientdata(client); 943 int err; 944 945 hwmon_device_unregister(data->class_dev); 946 947 if ((err = i2c_detach_client(client))) 948 return err; 949 950 if(i2c_is_isa_client(client)) 951 release_region(client->addr, IT87_EXTENT); 952 kfree(data); 953 954 return 0; 955 } 956 957 /* The SMBus locks itself, but ISA access must be locked explicitly! 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 explicitly! 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, res; 1186 1187 if (!it87_find(&addr)) { 1188 isa_address = addr; 1189 } 1190 1191 res = i2c_add_driver(&it87_driver); 1192 if (res) 1193 return res; 1194 1195 res = i2c_isa_add_driver(&it87_isa_driver); 1196 if (res) { 1197 i2c_del_driver(&it87_driver); 1198 return res; 1199 } 1200 1201 return 0; 1202 } 1203 1204 static void __exit sm_it87_exit(void) 1205 { 1206 i2c_isa_del_driver(&it87_isa_driver); 1207 i2c_del_driver(&it87_driver); 1208 } 1209 1210 1211 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>"); 1212 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver"); 1213 module_param(update_vbat, bool, 0); 1214 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value"); 1215 module_param(fix_pwm_polarity, bool, 0); 1216 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)"); 1217 MODULE_LICENSE("GPL"); 1218 1219 module_init(sm_it87_init); 1220 module_exit(sm_it87_exit); 1221