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