1 /* 2 it87.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring. 4 5 Supports: IT8705F Super I/O chip w/LPC interface 6 IT8712F Super I/O chip w/LPC interface & SMBus 7 Sis950 A clone of the IT8705F 8 9 Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com> 10 Largely inspired by lm78.c of the same package 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 */ 26 27 /* 28 djg@pdp8.net David Gesswein 7/18/01 29 Modified to fix bug with not all alarms enabled. 30 Added ability to read battery voltage and select temperature sensor 31 type at module load time. 32 */ 33 34 #include <linux/module.h> 35 #include <linux/init.h> 36 #include <linux/slab.h> 37 #include <linux/jiffies.h> 38 #include <linux/i2c.h> 39 #include <linux/i2c-isa.h> 40 #include <linux/hwmon.h> 41 #include <linux/hwmon-sysfs.h> 42 #include <linux/hwmon-vid.h> 43 #include <linux/err.h> 44 #include <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; 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 u8 reg = it87_read_value(client, IT87_REG_FAN_DIV); 526 527 down(&data->update_lock); 528 switch (nr) { 529 case 0: data->fan_div[nr] = reg & 0x07; break; 530 case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break; 531 case 2: data->fan_div[nr] = (reg & 0x40) ? 3 : 1; break; 532 } 533 534 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 535 it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]); 536 up(&data->update_lock); 537 return count; 538 } 539 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 540 const char *buf, size_t count) 541 { 542 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 543 int nr = sensor_attr->index; 544 545 struct i2c_client *client = to_i2c_client(dev); 546 struct it87_data *data = i2c_get_clientdata(client); 547 int val = simple_strtol(buf, NULL, 10); 548 int i, min[3]; 549 u8 old; 550 551 down(&data->update_lock); 552 old = it87_read_value(client, IT87_REG_FAN_DIV); 553 554 for (i = 0; i < 3; i++) 555 min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i])); 556 557 switch (nr) { 558 case 0: 559 case 1: 560 data->fan_div[nr] = DIV_TO_REG(val); 561 break; 562 case 2: 563 if (val < 8) 564 data->fan_div[nr] = 1; 565 else 566 data->fan_div[nr] = 3; 567 } 568 val = old & 0x80; 569 val |= (data->fan_div[0] & 0x07); 570 val |= (data->fan_div[1] & 0x07) << 3; 571 if (data->fan_div[2] == 3) 572 val |= 0x1 << 6; 573 it87_write_value(client, IT87_REG_FAN_DIV, val); 574 575 for (i = 0; i < 3; i++) { 576 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i])); 577 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]); 578 } 579 up(&data->update_lock); 580 return count; 581 } 582 static ssize_t set_pwm_enable(struct device *dev, 583 struct device_attribute *attr, const char *buf, size_t count) 584 { 585 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 586 int nr = sensor_attr->index; 587 588 struct i2c_client *client = to_i2c_client(dev); 589 struct it87_data *data = i2c_get_clientdata(client); 590 int val = simple_strtol(buf, NULL, 10); 591 592 down(&data->update_lock); 593 594 if (val == 0) { 595 int tmp; 596 /* make sure the fan is on when in on/off mode */ 597 tmp = it87_read_value(client, IT87_REG_FAN_CTL); 598 it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr)); 599 /* set on/off mode */ 600 data->fan_main_ctrl &= ~(1 << nr); 601 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); 602 } else if (val == 1) { 603 /* set SmartGuardian mode */ 604 data->fan_main_ctrl |= (1 << nr); 605 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); 606 /* set saved pwm value, clear FAN_CTLX PWM mode bit */ 607 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); 608 } else { 609 up(&data->update_lock); 610 return -EINVAL; 611 } 612 613 up(&data->update_lock); 614 return count; 615 } 616 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 617 const char *buf, size_t count) 618 { 619 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 620 int nr = sensor_attr->index; 621 622 struct i2c_client *client = to_i2c_client(dev); 623 struct it87_data *data = i2c_get_clientdata(client); 624 int val = simple_strtol(buf, NULL, 10); 625 626 if (val < 0 || val > 255) 627 return -EINVAL; 628 629 down(&data->update_lock); 630 data->manual_pwm_ctl[nr] = val; 631 if (data->fan_main_ctrl & (1 << nr)) 632 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); 633 up(&data->update_lock); 634 return count; 635 } 636 637 #define show_fan_offset(offset) \ 638 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 639 show_fan, NULL, offset - 1); \ 640 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 641 show_fan_min, set_fan_min, offset - 1); \ 642 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 643 show_fan_div, set_fan_div, offset - 1); 644 645 show_fan_offset(1); 646 show_fan_offset(2); 647 show_fan_offset(3); 648 649 #define show_pwm_offset(offset) \ 650 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ 651 show_pwm_enable, set_pwm_enable, offset - 1); \ 652 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ 653 show_pwm, set_pwm, offset - 1); 654 655 show_pwm_offset(1); 656 show_pwm_offset(2); 657 show_pwm_offset(3); 658 659 /* Alarms */ 660 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 661 { 662 struct it87_data *data = it87_update_device(dev); 663 return sprintf(buf, "%u\n", data->alarms); 664 } 665 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 666 667 static ssize_t 668 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf) 669 { 670 struct it87_data *data = it87_update_device(dev); 671 return sprintf(buf, "%ld\n", (long) data->vrm); 672 } 673 static ssize_t 674 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 675 { 676 struct i2c_client *client = to_i2c_client(dev); 677 struct it87_data *data = i2c_get_clientdata(client); 678 u32 val; 679 680 val = simple_strtoul(buf, NULL, 10); 681 data->vrm = val; 682 683 return count; 684 } 685 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 686 #define device_create_file_vrm(client) \ 687 device_create_file(&client->dev, &dev_attr_vrm) 688 689 static ssize_t 690 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf) 691 { 692 struct it87_data *data = it87_update_device(dev); 693 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm)); 694 } 695 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 696 #define device_create_file_vid(client) \ 697 device_create_file(&client->dev, &dev_attr_cpu0_vid) 698 699 /* This function is called when: 700 * it87_driver is inserted (when this module is loaded), for each 701 available adapter 702 * when a new adapter is inserted (and it87_driver is still present) */ 703 static int it87_attach_adapter(struct i2c_adapter *adapter) 704 { 705 if (!(adapter->class & I2C_CLASS_HWMON)) 706 return 0; 707 return i2c_probe(adapter, &addr_data, it87_detect); 708 } 709 710 static int it87_isa_attach_adapter(struct i2c_adapter *adapter) 711 { 712 return it87_detect(adapter, isa_address, -1); 713 } 714 715 /* SuperIO detection - will change isa_address if a chip is found */ 716 static int __init it87_find(unsigned short *address) 717 { 718 int err = -ENODEV; 719 720 superio_enter(); 721 chip_type = superio_inw(DEVID); 722 if (chip_type != IT8712F_DEVID 723 && chip_type != IT8705F_DEVID) 724 goto exit; 725 726 superio_select(); 727 if (!(superio_inb(IT87_ACT_REG) & 0x01)) { 728 pr_info("it87: Device not activated, skipping\n"); 729 goto exit; 730 } 731 732 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1); 733 if (*address == 0) { 734 pr_info("it87: Base address not set, skipping\n"); 735 goto exit; 736 } 737 738 err = 0; 739 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n", 740 chip_type, *address, superio_inb(DEVREV) & 0x0f); 741 742 exit: 743 superio_exit(); 744 return err; 745 } 746 747 /* This function is called by i2c_probe */ 748 static int it87_detect(struct i2c_adapter *adapter, int address, int kind) 749 { 750 int i; 751 struct i2c_client *new_client; 752 struct it87_data *data; 753 int err = 0; 754 const char *name = ""; 755 int is_isa = i2c_is_isa_adapter(adapter); 756 int enable_pwm_interface; 757 758 if (!is_isa && 759 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 760 goto ERROR0; 761 762 /* Reserve the ISA region */ 763 if (is_isa) 764 if (!request_region(address, IT87_EXTENT, it87_isa_driver.name)) 765 goto ERROR0; 766 767 /* For now, we presume we have a valid client. We create the 768 client structure, even though we cannot fill it completely yet. 769 But it allows us to access it87_{read,write}_value. */ 770 771 if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) { 772 err = -ENOMEM; 773 goto ERROR1; 774 } 775 776 new_client = &data->client; 777 if (is_isa) 778 init_MUTEX(&data->lock); 779 i2c_set_clientdata(new_client, data); 780 new_client->addr = address; 781 new_client->adapter = adapter; 782 new_client->driver = is_isa ? &it87_isa_driver : &it87_driver; 783 new_client->flags = 0; 784 785 /* Now, we do the remaining detection. */ 786 787 if (kind < 0) { 788 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80) 789 || (!is_isa 790 && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) { 791 err = -ENODEV; 792 goto ERROR2; 793 } 794 } 795 796 /* Determine the chip type. */ 797 if (kind <= 0) { 798 i = it87_read_value(new_client, IT87_REG_CHIPID); 799 if (i == 0x90) { 800 kind = it87; 801 if ((is_isa) && (chip_type == IT8712F_DEVID)) 802 kind = it8712; 803 } 804 else { 805 if (kind == 0) 806 dev_info(&adapter->dev, 807 "Ignoring 'force' parameter for unknown chip at " 808 "adapter %d, address 0x%02x\n", 809 i2c_adapter_id(adapter), address); 810 err = -ENODEV; 811 goto ERROR2; 812 } 813 } 814 815 if (kind == it87) { 816 name = "it87"; 817 } else if (kind == it8712) { 818 name = "it8712"; 819 } 820 821 /* Fill in the remaining client fields and put it into the global list */ 822 strlcpy(new_client->name, name, I2C_NAME_SIZE); 823 data->type = kind; 824 data->valid = 0; 825 init_MUTEX(&data->update_lock); 826 827 /* Tell the I2C layer a new client has arrived */ 828 if ((err = i2c_attach_client(new_client))) 829 goto ERROR2; 830 831 /* Check PWM configuration */ 832 enable_pwm_interface = it87_check_pwm(new_client); 833 834 /* Initialize the IT87 chip */ 835 it87_init_client(new_client, data); 836 837 /* Register sysfs hooks */ 838 data->class_dev = hwmon_device_register(&new_client->dev); 839 if (IS_ERR(data->class_dev)) { 840 err = PTR_ERR(data->class_dev); 841 goto ERROR3; 842 } 843 844 device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr); 845 device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr); 846 device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr); 847 device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr); 848 device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr); 849 device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr); 850 device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr); 851 device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr); 852 device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr); 853 device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr); 854 device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr); 855 device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr); 856 device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr); 857 device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr); 858 device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr); 859 device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr); 860 device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr); 861 device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr); 862 device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr); 863 device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr); 864 device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr); 865 device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr); 866 device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr); 867 device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr); 868 device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr); 869 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr); 870 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr); 871 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr); 872 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr); 873 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr); 874 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr); 875 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr); 876 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr); 877 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr); 878 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr); 879 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr); 880 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr); 881 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr); 882 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr); 883 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr); 884 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr); 885 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr); 886 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr); 887 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr); 888 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr); 889 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr); 890 device_create_file(&new_client->dev, &dev_attr_alarms); 891 if (enable_pwm_interface) { 892 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr); 893 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr); 894 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr); 895 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr); 896 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr); 897 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr); 898 } 899 900 if (data->type == it8712) { 901 data->vrm = vid_which_vrm(); 902 device_create_file_vrm(new_client); 903 device_create_file_vid(new_client); 904 } 905 906 return 0; 907 908 ERROR3: 909 i2c_detach_client(new_client); 910 ERROR2: 911 kfree(data); 912 ERROR1: 913 if (is_isa) 914 release_region(address, IT87_EXTENT); 915 ERROR0: 916 return err; 917 } 918 919 static int it87_detach_client(struct i2c_client *client) 920 { 921 struct it87_data *data = i2c_get_clientdata(client); 922 int err; 923 924 hwmon_device_unregister(data->class_dev); 925 926 if ((err = i2c_detach_client(client))) 927 return err; 928 929 if(i2c_is_isa_client(client)) 930 release_region(client->addr, IT87_EXTENT); 931 kfree(data); 932 933 return 0; 934 } 935 936 /* The SMBus locks itself, but ISA access must be locked explicitly! 937 We don't want to lock the whole ISA bus, so we lock each client 938 separately. 939 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks, 940 would slow down the IT87 access and should not be necessary. */ 941 static int it87_read_value(struct i2c_client *client, u8 reg) 942 { 943 struct it87_data *data = i2c_get_clientdata(client); 944 945 int res; 946 if (i2c_is_isa_client(client)) { 947 down(&data->lock); 948 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET); 949 res = inb_p(client->addr + IT87_DATA_REG_OFFSET); 950 up(&data->lock); 951 return res; 952 } else 953 return i2c_smbus_read_byte_data(client, reg); 954 } 955 956 /* The SMBus locks itself, but ISA access muse be locked explicitly! 957 We don't want to lock the whole ISA bus, so we lock each client 958 separately. 959 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks, 960 would slow down the IT87 access and should not be necessary. */ 961 static int it87_write_value(struct i2c_client *client, u8 reg, u8 value) 962 { 963 struct it87_data *data = i2c_get_clientdata(client); 964 965 if (i2c_is_isa_client(client)) { 966 down(&data->lock); 967 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET); 968 outb_p(value, client->addr + IT87_DATA_REG_OFFSET); 969 up(&data->lock); 970 return 0; 971 } else 972 return i2c_smbus_write_byte_data(client, reg, value); 973 } 974 975 /* Return 1 if and only if the PWM interface is safe to use */ 976 static int it87_check_pwm(struct i2c_client *client) 977 { 978 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off 979 * and polarity set to active low is sign that this is the case so we 980 * disable pwm control to protect the user. */ 981 int tmp = it87_read_value(client, IT87_REG_FAN_CTL); 982 if ((tmp & 0x87) == 0) { 983 if (fix_pwm_polarity) { 984 /* The user asks us to attempt a chip reconfiguration. 985 * This means switching to active high polarity and 986 * inverting all fan speed values. */ 987 int i; 988 u8 pwm[3]; 989 990 for (i = 0; i < 3; i++) 991 pwm[i] = it87_read_value(client, 992 IT87_REG_PWM(i)); 993 994 /* If any fan is in automatic pwm mode, the polarity 995 * might be correct, as suspicious as it seems, so we 996 * better don't change anything (but still disable the 997 * PWM interface). */ 998 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) { 999 dev_info(&client->dev, "Reconfiguring PWM to " 1000 "active high polarity\n"); 1001 it87_write_value(client, IT87_REG_FAN_CTL, 1002 tmp | 0x87); 1003 for (i = 0; i < 3; i++) 1004 it87_write_value(client, 1005 IT87_REG_PWM(i), 1006 0x7f & ~pwm[i]); 1007 return 1; 1008 } 1009 1010 dev_info(&client->dev, "PWM configuration is " 1011 "too broken to be fixed\n"); 1012 } 1013 1014 dev_info(&client->dev, "Detected broken BIOS " 1015 "defaults, disabling PWM interface\n"); 1016 return 0; 1017 } else if (fix_pwm_polarity) { 1018 dev_info(&client->dev, "PWM configuration looks " 1019 "sane, won't touch\n"); 1020 } 1021 1022 return 1; 1023 } 1024 1025 /* Called when we have found a new IT87. */ 1026 static void it87_init_client(struct i2c_client *client, struct it87_data *data) 1027 { 1028 int tmp, i; 1029 1030 /* initialize to sane defaults: 1031 * - if the chip is in manual pwm mode, this will be overwritten with 1032 * the actual settings on the chip (so in this case, initialization 1033 * is not needed) 1034 * - if in automatic or on/off mode, we could switch to manual mode, 1035 * read the registers and set manual_pwm_ctl accordingly, but currently 1036 * this is not implemented, so we initialize to something sane */ 1037 for (i = 0; i < 3; i++) { 1038 data->manual_pwm_ctl[i] = 0xff; 1039 } 1040 1041 /* Check if temperature channnels are reset manually or by some reason */ 1042 tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE); 1043 if ((tmp & 0x3f) == 0) { 1044 /* Temp1,Temp3=thermistor; Temp2=thermal diode */ 1045 tmp = (tmp & 0xc0) | 0x2a; 1046 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp); 1047 } 1048 data->sensor = tmp; 1049 1050 /* Check if voltage monitors are reset manually or by some reason */ 1051 tmp = it87_read_value(client, IT87_REG_VIN_ENABLE); 1052 if ((tmp & 0xff) == 0) { 1053 /* Enable all voltage monitors */ 1054 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff); 1055 } 1056 1057 /* Check if tachometers are reset manually or by some reason */ 1058 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL); 1059 if ((data->fan_main_ctrl & 0x70) == 0) { 1060 /* Enable all fan tachometers */ 1061 data->fan_main_ctrl |= 0x70; 1062 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); 1063 } 1064 1065 /* Set current fan mode registers and the default settings for the 1066 * other mode registers */ 1067 for (i = 0; i < 3; i++) { 1068 if (data->fan_main_ctrl & (1 << i)) { 1069 /* pwm mode */ 1070 tmp = it87_read_value(client, IT87_REG_PWM(i)); 1071 if (tmp & 0x80) { 1072 /* automatic pwm - not yet implemented, but 1073 * leave the settings made by the BIOS alone 1074 * until a change is requested via the sysfs 1075 * interface */ 1076 } else { 1077 /* manual pwm */ 1078 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp); 1079 } 1080 } 1081 } 1082 1083 /* Start monitoring */ 1084 it87_write_value(client, IT87_REG_CONFIG, 1085 (it87_read_value(client, IT87_REG_CONFIG) & 0x36) 1086 | (update_vbat ? 0x41 : 0x01)); 1087 } 1088 1089 static struct it87_data *it87_update_device(struct device *dev) 1090 { 1091 struct i2c_client *client = to_i2c_client(dev); 1092 struct it87_data *data = i2c_get_clientdata(client); 1093 int i; 1094 1095 down(&data->update_lock); 1096 1097 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 1098 || !data->valid) { 1099 1100 if (update_vbat) { 1101 /* Cleared after each update, so reenable. Value 1102 returned by this read will be previous value */ 1103 it87_write_value(client, IT87_REG_CONFIG, 1104 it87_read_value(client, IT87_REG_CONFIG) | 0x40); 1105 } 1106 for (i = 0; i <= 7; i++) { 1107 data->in[i] = 1108 it87_read_value(client, IT87_REG_VIN(i)); 1109 data->in_min[i] = 1110 it87_read_value(client, IT87_REG_VIN_MIN(i)); 1111 data->in_max[i] = 1112 it87_read_value(client, IT87_REG_VIN_MAX(i)); 1113 } 1114 data->in[8] = 1115 it87_read_value(client, IT87_REG_VIN(8)); 1116 /* Temperature sensor doesn't have limit registers, set 1117 to min and max value */ 1118 data->in_min[8] = 0; 1119 data->in_max[8] = 255; 1120 1121 for (i = 0; i < 3; i++) { 1122 data->fan[i] = 1123 it87_read_value(client, IT87_REG_FAN(i)); 1124 data->fan_min[i] = 1125 it87_read_value(client, IT87_REG_FAN_MIN(i)); 1126 } 1127 for (i = 0; i < 3; i++) { 1128 data->temp[i] = 1129 it87_read_value(client, IT87_REG_TEMP(i)); 1130 data->temp_high[i] = 1131 it87_read_value(client, IT87_REG_TEMP_HIGH(i)); 1132 data->temp_low[i] = 1133 it87_read_value(client, IT87_REG_TEMP_LOW(i)); 1134 } 1135 1136 i = it87_read_value(client, IT87_REG_FAN_DIV); 1137 data->fan_div[0] = i & 0x07; 1138 data->fan_div[1] = (i >> 3) & 0x07; 1139 data->fan_div[2] = (i & 0x40) ? 3 : 1; 1140 1141 data->alarms = 1142 it87_read_value(client, IT87_REG_ALARM1) | 1143 (it87_read_value(client, IT87_REG_ALARM2) << 8) | 1144 (it87_read_value(client, IT87_REG_ALARM3) << 16); 1145 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL); 1146 1147 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE); 1148 /* The 8705 does not have VID capability */ 1149 if (data->type == it8712) { 1150 data->vid = it87_read_value(client, IT87_REG_VID); 1151 data->vid &= 0x1f; 1152 } 1153 data->last_updated = jiffies; 1154 data->valid = 1; 1155 } 1156 1157 up(&data->update_lock); 1158 1159 return data; 1160 } 1161 1162 static int __init sm_it87_init(void) 1163 { 1164 int res; 1165 1166 res = i2c_add_driver(&it87_driver); 1167 if (res) 1168 return res; 1169 1170 if (!it87_find(&isa_address)) { 1171 res = i2c_isa_add_driver(&it87_isa_driver); 1172 if (res) { 1173 i2c_del_driver(&it87_driver); 1174 return res; 1175 } 1176 } 1177 1178 return 0; 1179 } 1180 1181 static void __exit sm_it87_exit(void) 1182 { 1183 i2c_isa_del_driver(&it87_isa_driver); 1184 i2c_del_driver(&it87_driver); 1185 } 1186 1187 1188 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>"); 1189 MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver"); 1190 module_param(update_vbat, bool, 0); 1191 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value"); 1192 module_param(fix_pwm_polarity, bool, 0); 1193 MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)"); 1194 MODULE_LICENSE("GPL"); 1195 1196 module_init(sm_it87_init); 1197 module_exit(sm_it87_exit); 1198