1 /* 2 * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. 3 * 4 * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> 5 * 6 * Hwmon integration: 7 * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> 8 * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> 9 * Copyright (C) 2014, 2015 Pali Rohár <pali.rohar@gmail.com> 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the 13 * Free Software Foundation; either version 2, or (at your option) any 14 * later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 */ 21 22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 23 24 #include <linux/delay.h> 25 #include <linux/module.h> 26 #include <linux/types.h> 27 #include <linux/init.h> 28 #include <linux/proc_fs.h> 29 #include <linux/seq_file.h> 30 #include <linux/dmi.h> 31 #include <linux/capability.h> 32 #include <linux/mutex.h> 33 #include <linux/hwmon.h> 34 #include <linux/hwmon-sysfs.h> 35 #include <linux/uaccess.h> 36 #include <linux/io.h> 37 #include <linux/sched.h> 38 #include <linux/ctype.h> 39 40 #include <linux/i8k.h> 41 42 #define I8K_SMM_FN_STATUS 0x0025 43 #define I8K_SMM_POWER_STATUS 0x0069 44 #define I8K_SMM_SET_FAN 0x01a3 45 #define I8K_SMM_GET_FAN 0x00a3 46 #define I8K_SMM_GET_SPEED 0x02a3 47 #define I8K_SMM_GET_FAN_TYPE 0x03a3 48 #define I8K_SMM_GET_NOM_SPEED 0x04a3 49 #define I8K_SMM_GET_TEMP 0x10a3 50 #define I8K_SMM_GET_TEMP_TYPE 0x11a3 51 #define I8K_SMM_GET_DELL_SIG1 0xfea3 52 #define I8K_SMM_GET_DELL_SIG2 0xffa3 53 54 #define I8K_FAN_MULT 30 55 #define I8K_FAN_MAX_RPM 30000 56 #define I8K_MAX_TEMP 127 57 58 #define I8K_FN_NONE 0x00 59 #define I8K_FN_UP 0x01 60 #define I8K_FN_DOWN 0x02 61 #define I8K_FN_MUTE 0x04 62 #define I8K_FN_MASK 0x07 63 #define I8K_FN_SHIFT 8 64 65 #define I8K_POWER_AC 0x05 66 #define I8K_POWER_BATTERY 0x01 67 68 static DEFINE_MUTEX(i8k_mutex); 69 static char bios_version[4]; 70 static char bios_machineid[16]; 71 static struct device *i8k_hwmon_dev; 72 static u32 i8k_hwmon_flags; 73 static uint i8k_fan_mult = I8K_FAN_MULT; 74 static uint i8k_pwm_mult; 75 static uint i8k_fan_max = I8K_FAN_HIGH; 76 static bool disallow_fan_type_call; 77 78 #define I8K_HWMON_HAVE_TEMP1 (1 << 0) 79 #define I8K_HWMON_HAVE_TEMP2 (1 << 1) 80 #define I8K_HWMON_HAVE_TEMP3 (1 << 2) 81 #define I8K_HWMON_HAVE_TEMP4 (1 << 3) 82 #define I8K_HWMON_HAVE_FAN1 (1 << 4) 83 #define I8K_HWMON_HAVE_FAN2 (1 << 5) 84 85 MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); 86 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>"); 87 MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); 88 MODULE_LICENSE("GPL"); 89 MODULE_ALIAS("i8k"); 90 91 static bool force; 92 module_param(force, bool, 0); 93 MODULE_PARM_DESC(force, "Force loading without checking for supported models"); 94 95 static bool ignore_dmi; 96 module_param(ignore_dmi, bool, 0); 97 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); 98 99 #if IS_ENABLED(CONFIG_I8K) 100 static bool restricted = true; 101 module_param(restricted, bool, 0); 102 MODULE_PARM_DESC(restricted, "Restrict fan control and serial number to CAP_SYS_ADMIN (default: 1)"); 103 104 static bool power_status; 105 module_param(power_status, bool, 0600); 106 MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k (default: 0)"); 107 #endif 108 109 static uint fan_mult; 110 module_param(fan_mult, uint, 0); 111 MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); 112 113 static uint fan_max; 114 module_param(fan_max, uint, 0); 115 MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); 116 117 struct smm_regs { 118 unsigned int eax; 119 unsigned int ebx __packed; 120 unsigned int ecx __packed; 121 unsigned int edx __packed; 122 unsigned int esi __packed; 123 unsigned int edi __packed; 124 }; 125 126 static inline const char *i8k_get_dmi_data(int field) 127 { 128 const char *dmi_data = dmi_get_system_info(field); 129 130 return dmi_data && *dmi_data ? dmi_data : "?"; 131 } 132 133 /* 134 * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. 135 */ 136 static int i8k_smm(struct smm_regs *regs) 137 { 138 int rc; 139 int eax = regs->eax; 140 cpumask_var_t old_mask; 141 142 /* SMM requires CPU 0 */ 143 if (!alloc_cpumask_var(&old_mask, GFP_KERNEL)) 144 return -ENOMEM; 145 cpumask_copy(old_mask, ¤t->cpus_allowed); 146 rc = set_cpus_allowed_ptr(current, cpumask_of(0)); 147 if (rc) 148 goto out; 149 if (smp_processor_id() != 0) { 150 rc = -EBUSY; 151 goto out; 152 } 153 154 #if defined(CONFIG_X86_64) 155 asm volatile("pushq %%rax\n\t" 156 "movl 0(%%rax),%%edx\n\t" 157 "pushq %%rdx\n\t" 158 "movl 4(%%rax),%%ebx\n\t" 159 "movl 8(%%rax),%%ecx\n\t" 160 "movl 12(%%rax),%%edx\n\t" 161 "movl 16(%%rax),%%esi\n\t" 162 "movl 20(%%rax),%%edi\n\t" 163 "popq %%rax\n\t" 164 "out %%al,$0xb2\n\t" 165 "out %%al,$0x84\n\t" 166 "xchgq %%rax,(%%rsp)\n\t" 167 "movl %%ebx,4(%%rax)\n\t" 168 "movl %%ecx,8(%%rax)\n\t" 169 "movl %%edx,12(%%rax)\n\t" 170 "movl %%esi,16(%%rax)\n\t" 171 "movl %%edi,20(%%rax)\n\t" 172 "popq %%rdx\n\t" 173 "movl %%edx,0(%%rax)\n\t" 174 "pushfq\n\t" 175 "popq %%rax\n\t" 176 "andl $1,%%eax\n" 177 : "=a"(rc) 178 : "a"(regs) 179 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 180 #else 181 asm volatile("pushl %%eax\n\t" 182 "movl 0(%%eax),%%edx\n\t" 183 "push %%edx\n\t" 184 "movl 4(%%eax),%%ebx\n\t" 185 "movl 8(%%eax),%%ecx\n\t" 186 "movl 12(%%eax),%%edx\n\t" 187 "movl 16(%%eax),%%esi\n\t" 188 "movl 20(%%eax),%%edi\n\t" 189 "popl %%eax\n\t" 190 "out %%al,$0xb2\n\t" 191 "out %%al,$0x84\n\t" 192 "xchgl %%eax,(%%esp)\n\t" 193 "movl %%ebx,4(%%eax)\n\t" 194 "movl %%ecx,8(%%eax)\n\t" 195 "movl %%edx,12(%%eax)\n\t" 196 "movl %%esi,16(%%eax)\n\t" 197 "movl %%edi,20(%%eax)\n\t" 198 "popl %%edx\n\t" 199 "movl %%edx,0(%%eax)\n\t" 200 "lahf\n\t" 201 "shrl $8,%%eax\n\t" 202 "andl $1,%%eax\n" 203 : "=a"(rc) 204 : "a"(regs) 205 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 206 #endif 207 if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) 208 rc = -EINVAL; 209 210 out: 211 set_cpus_allowed_ptr(current, old_mask); 212 free_cpumask_var(old_mask); 213 return rc; 214 } 215 216 /* 217 * Read the fan status. 218 */ 219 static int i8k_get_fan_status(int fan) 220 { 221 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; 222 223 regs.ebx = fan & 0xff; 224 return i8k_smm(®s) ? : regs.eax & 0xff; 225 } 226 227 /* 228 * Read the fan speed in RPM. 229 */ 230 static int i8k_get_fan_speed(int fan) 231 { 232 struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; 233 234 regs.ebx = fan & 0xff; 235 return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; 236 } 237 238 /* 239 * Read the fan type. 240 */ 241 static int _i8k_get_fan_type(int fan) 242 { 243 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; 244 245 if (disallow_fan_type_call) 246 return -EINVAL; 247 248 regs.ebx = fan & 0xff; 249 return i8k_smm(®s) ? : regs.eax & 0xff; 250 } 251 252 static int i8k_get_fan_type(int fan) 253 { 254 /* I8K_SMM_GET_FAN_TYPE SMM call is expensive, so cache values */ 255 static int types[2] = { INT_MIN, INT_MIN }; 256 257 if (types[fan] == INT_MIN) 258 types[fan] = _i8k_get_fan_type(fan); 259 260 return types[fan]; 261 } 262 263 /* 264 * Read the fan nominal rpm for specific fan speed. 265 */ 266 static int i8k_get_fan_nominal_speed(int fan, int speed) 267 { 268 struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; 269 270 regs.ebx = (fan & 0xff) | (speed << 8); 271 return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult; 272 } 273 274 /* 275 * Set the fan speed (off, low, high). Returns the new fan status. 276 */ 277 static int i8k_set_fan(int fan, int speed) 278 { 279 struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; 280 281 speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed); 282 regs.ebx = (fan & 0xff) | (speed << 8); 283 284 return i8k_smm(®s) ? : i8k_get_fan_status(fan); 285 } 286 287 static int i8k_get_temp_type(int sensor) 288 { 289 struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; 290 291 regs.ebx = sensor & 0xff; 292 return i8k_smm(®s) ? : regs.eax & 0xff; 293 } 294 295 /* 296 * Read the cpu temperature. 297 */ 298 static int _i8k_get_temp(int sensor) 299 { 300 struct smm_regs regs = { 301 .eax = I8K_SMM_GET_TEMP, 302 .ebx = sensor & 0xff, 303 }; 304 305 return i8k_smm(®s) ? : regs.eax & 0xff; 306 } 307 308 static int i8k_get_temp(int sensor) 309 { 310 int temp = _i8k_get_temp(sensor); 311 312 /* 313 * Sometimes the temperature sensor returns 0x99, which is out of range. 314 * In this case we retry (once) before returning an error. 315 # 1003655137 00000058 00005a4b 316 # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees 317 # 1003655139 00000054 00005c52 318 */ 319 if (temp == 0x99) { 320 msleep(100); 321 temp = _i8k_get_temp(sensor); 322 } 323 /* 324 * Return -ENODATA for all invalid temperatures. 325 * 326 * Known instances are the 0x99 value as seen above as well as 327 * 0xc1 (193), which may be returned when trying to read the GPU 328 * temperature if the system supports a GPU and it is currently 329 * turned off. 330 */ 331 if (temp > I8K_MAX_TEMP) 332 return -ENODATA; 333 334 return temp; 335 } 336 337 static int i8k_get_dell_signature(int req_fn) 338 { 339 struct smm_regs regs = { .eax = req_fn, }; 340 int rc; 341 342 rc = i8k_smm(®s); 343 if (rc < 0) 344 return rc; 345 346 return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; 347 } 348 349 #if IS_ENABLED(CONFIG_I8K) 350 351 /* 352 * Read the Fn key status. 353 */ 354 static int i8k_get_fn_status(void) 355 { 356 struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; 357 int rc; 358 359 rc = i8k_smm(®s); 360 if (rc < 0) 361 return rc; 362 363 switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { 364 case I8K_FN_UP: 365 return I8K_VOL_UP; 366 case I8K_FN_DOWN: 367 return I8K_VOL_DOWN; 368 case I8K_FN_MUTE: 369 return I8K_VOL_MUTE; 370 default: 371 return 0; 372 } 373 } 374 375 /* 376 * Read the power status. 377 */ 378 static int i8k_get_power_status(void) 379 { 380 struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; 381 int rc; 382 383 rc = i8k_smm(®s); 384 if (rc < 0) 385 return rc; 386 387 return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; 388 } 389 390 /* 391 * Procfs interface 392 */ 393 394 static int 395 i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg) 396 { 397 int val = 0; 398 int speed; 399 unsigned char buff[16]; 400 int __user *argp = (int __user *)arg; 401 402 if (!argp) 403 return -EINVAL; 404 405 switch (cmd) { 406 case I8K_BIOS_VERSION: 407 if (!isdigit(bios_version[0]) || !isdigit(bios_version[1]) || 408 !isdigit(bios_version[2])) 409 return -EINVAL; 410 411 val = (bios_version[0] << 16) | 412 (bios_version[1] << 8) | bios_version[2]; 413 break; 414 415 case I8K_MACHINE_ID: 416 if (restricted && !capable(CAP_SYS_ADMIN)) 417 return -EPERM; 418 419 memset(buff, 0, sizeof(buff)); 420 strlcpy(buff, bios_machineid, sizeof(buff)); 421 break; 422 423 case I8K_FN_STATUS: 424 val = i8k_get_fn_status(); 425 break; 426 427 case I8K_POWER_STATUS: 428 val = i8k_get_power_status(); 429 break; 430 431 case I8K_GET_TEMP: 432 val = i8k_get_temp(0); 433 break; 434 435 case I8K_GET_SPEED: 436 if (copy_from_user(&val, argp, sizeof(int))) 437 return -EFAULT; 438 439 val = i8k_get_fan_speed(val); 440 break; 441 442 case I8K_GET_FAN: 443 if (copy_from_user(&val, argp, sizeof(int))) 444 return -EFAULT; 445 446 val = i8k_get_fan_status(val); 447 break; 448 449 case I8K_SET_FAN: 450 if (restricted && !capable(CAP_SYS_ADMIN)) 451 return -EPERM; 452 453 if (copy_from_user(&val, argp, sizeof(int))) 454 return -EFAULT; 455 456 if (copy_from_user(&speed, argp + 1, sizeof(int))) 457 return -EFAULT; 458 459 val = i8k_set_fan(val, speed); 460 break; 461 462 default: 463 return -EINVAL; 464 } 465 466 if (val < 0) 467 return val; 468 469 switch (cmd) { 470 case I8K_BIOS_VERSION: 471 if (copy_to_user(argp, &val, 4)) 472 return -EFAULT; 473 474 break; 475 case I8K_MACHINE_ID: 476 if (copy_to_user(argp, buff, 16)) 477 return -EFAULT; 478 479 break; 480 default: 481 if (copy_to_user(argp, &val, sizeof(int))) 482 return -EFAULT; 483 484 break; 485 } 486 487 return 0; 488 } 489 490 static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) 491 { 492 long ret; 493 494 mutex_lock(&i8k_mutex); 495 ret = i8k_ioctl_unlocked(fp, cmd, arg); 496 mutex_unlock(&i8k_mutex); 497 498 return ret; 499 } 500 501 /* 502 * Print the information for /proc/i8k. 503 */ 504 static int i8k_proc_show(struct seq_file *seq, void *offset) 505 { 506 int fn_key, cpu_temp, ac_power; 507 int left_fan, right_fan, left_speed, right_speed; 508 509 cpu_temp = i8k_get_temp(0); /* 11100 µs */ 510 left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */ 511 right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */ 512 left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */ 513 right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */ 514 fn_key = i8k_get_fn_status(); /* 750 µs */ 515 if (power_status) 516 ac_power = i8k_get_power_status(); /* 14700 µs */ 517 else 518 ac_power = -1; 519 520 /* 521 * Info: 522 * 523 * 1) Format version (this will change if format changes) 524 * 2) BIOS version 525 * 3) BIOS machine ID 526 * 4) Cpu temperature 527 * 5) Left fan status 528 * 6) Right fan status 529 * 7) Left fan speed 530 * 8) Right fan speed 531 * 9) AC power 532 * 10) Fn Key status 533 */ 534 seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", 535 I8K_PROC_FMT, 536 bios_version, 537 (restricted && !capable(CAP_SYS_ADMIN)) ? "-1" : bios_machineid, 538 cpu_temp, 539 left_fan, right_fan, left_speed, right_speed, 540 ac_power, fn_key); 541 542 return 0; 543 } 544 545 static int i8k_open_fs(struct inode *inode, struct file *file) 546 { 547 return single_open(file, i8k_proc_show, NULL); 548 } 549 550 static const struct file_operations i8k_fops = { 551 .owner = THIS_MODULE, 552 .open = i8k_open_fs, 553 .read = seq_read, 554 .llseek = seq_lseek, 555 .release = single_release, 556 .unlocked_ioctl = i8k_ioctl, 557 }; 558 559 static void __init i8k_init_procfs(void) 560 { 561 /* Register the proc entry */ 562 proc_create("i8k", 0, NULL, &i8k_fops); 563 } 564 565 static void __exit i8k_exit_procfs(void) 566 { 567 remove_proc_entry("i8k", NULL); 568 } 569 570 #else 571 572 static inline void __init i8k_init_procfs(void) 573 { 574 } 575 576 static inline void __exit i8k_exit_procfs(void) 577 { 578 } 579 580 #endif 581 582 /* 583 * Hwmon interface 584 */ 585 586 static ssize_t i8k_hwmon_show_temp_label(struct device *dev, 587 struct device_attribute *devattr, 588 char *buf) 589 { 590 static const char * const labels[] = { 591 "CPU", 592 "GPU", 593 "SODIMM", 594 "Other", 595 "Ambient", 596 "Other", 597 }; 598 int index = to_sensor_dev_attr(devattr)->index; 599 int type; 600 601 type = i8k_get_temp_type(index); 602 if (type < 0) 603 return type; 604 if (type >= ARRAY_SIZE(labels)) 605 type = ARRAY_SIZE(labels) - 1; 606 return sprintf(buf, "%s\n", labels[type]); 607 } 608 609 static ssize_t i8k_hwmon_show_temp(struct device *dev, 610 struct device_attribute *devattr, 611 char *buf) 612 { 613 int index = to_sensor_dev_attr(devattr)->index; 614 int temp; 615 616 temp = i8k_get_temp(index); 617 if (temp < 0) 618 return temp; 619 return sprintf(buf, "%d\n", temp * 1000); 620 } 621 622 static ssize_t i8k_hwmon_show_fan_label(struct device *dev, 623 struct device_attribute *devattr, 624 char *buf) 625 { 626 static const char * const labels[] = { 627 "Processor Fan", 628 "Motherboard Fan", 629 "Video Fan", 630 "Power Supply Fan", 631 "Chipset Fan", 632 "Other Fan", 633 }; 634 int index = to_sensor_dev_attr(devattr)->index; 635 bool dock = false; 636 int type; 637 638 type = i8k_get_fan_type(index); 639 if (type < 0) 640 return type; 641 642 if (type & 0x10) { 643 dock = true; 644 type &= 0x0F; 645 } 646 647 if (type >= ARRAY_SIZE(labels)) 648 type = (ARRAY_SIZE(labels) - 1); 649 650 return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]); 651 } 652 653 static ssize_t i8k_hwmon_show_fan(struct device *dev, 654 struct device_attribute *devattr, 655 char *buf) 656 { 657 int index = to_sensor_dev_attr(devattr)->index; 658 int fan_speed; 659 660 fan_speed = i8k_get_fan_speed(index); 661 if (fan_speed < 0) 662 return fan_speed; 663 return sprintf(buf, "%d\n", fan_speed); 664 } 665 666 static ssize_t i8k_hwmon_show_pwm(struct device *dev, 667 struct device_attribute *devattr, 668 char *buf) 669 { 670 int index = to_sensor_dev_attr(devattr)->index; 671 int status; 672 673 status = i8k_get_fan_status(index); 674 if (status < 0) 675 return -EIO; 676 return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255)); 677 } 678 679 static ssize_t i8k_hwmon_set_pwm(struct device *dev, 680 struct device_attribute *attr, 681 const char *buf, size_t count) 682 { 683 int index = to_sensor_dev_attr(attr)->index; 684 unsigned long val; 685 int err; 686 687 err = kstrtoul(buf, 10, &val); 688 if (err) 689 return err; 690 val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max); 691 692 mutex_lock(&i8k_mutex); 693 err = i8k_set_fan(index, val); 694 mutex_unlock(&i8k_mutex); 695 696 return err < 0 ? -EIO : count; 697 } 698 699 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 0); 700 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 701 0); 702 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 1); 703 static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 704 1); 705 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 2); 706 static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 707 2); 708 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, i8k_hwmon_show_temp, NULL, 3); 709 static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, i8k_hwmon_show_temp_label, NULL, 710 3); 711 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 0); 712 static SENSOR_DEVICE_ATTR(fan1_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, 713 0); 714 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, 715 i8k_hwmon_set_pwm, 0); 716 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, i8k_hwmon_show_fan, NULL, 717 1); 718 static SENSOR_DEVICE_ATTR(fan2_label, S_IRUGO, i8k_hwmon_show_fan_label, NULL, 719 1); 720 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, i8k_hwmon_show_pwm, 721 i8k_hwmon_set_pwm, 1); 722 723 static struct attribute *i8k_attrs[] = { 724 &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */ 725 &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */ 726 &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */ 727 &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */ 728 &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */ 729 &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */ 730 &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */ 731 &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */ 732 &sensor_dev_attr_fan1_input.dev_attr.attr, /* 8 */ 733 &sensor_dev_attr_fan1_label.dev_attr.attr, /* 9 */ 734 &sensor_dev_attr_pwm1.dev_attr.attr, /* 10 */ 735 &sensor_dev_attr_fan2_input.dev_attr.attr, /* 11 */ 736 &sensor_dev_attr_fan2_label.dev_attr.attr, /* 12 */ 737 &sensor_dev_attr_pwm2.dev_attr.attr, /* 13 */ 738 NULL 739 }; 740 741 static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr, 742 int index) 743 { 744 if (disallow_fan_type_call && 745 (index == 9 || index == 12)) 746 return 0; 747 if (index >= 0 && index <= 1 && 748 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1)) 749 return 0; 750 if (index >= 2 && index <= 3 && 751 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2)) 752 return 0; 753 if (index >= 4 && index <= 5 && 754 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3)) 755 return 0; 756 if (index >= 6 && index <= 7 && 757 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4)) 758 return 0; 759 if (index >= 8 && index <= 10 && 760 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1)) 761 return 0; 762 if (index >= 11 && index <= 13 && 763 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2)) 764 return 0; 765 766 return attr->mode; 767 } 768 769 static const struct attribute_group i8k_group = { 770 .attrs = i8k_attrs, 771 .is_visible = i8k_is_visible, 772 }; 773 __ATTRIBUTE_GROUPS(i8k); 774 775 static int __init i8k_init_hwmon(void) 776 { 777 int err; 778 779 i8k_hwmon_flags = 0; 780 781 /* CPU temperature attributes, if temperature type is OK */ 782 err = i8k_get_temp_type(0); 783 if (err >= 0) 784 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1; 785 /* check for additional temperature sensors */ 786 err = i8k_get_temp_type(1); 787 if (err >= 0) 788 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2; 789 err = i8k_get_temp_type(2); 790 if (err >= 0) 791 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3; 792 err = i8k_get_temp_type(3); 793 if (err >= 0) 794 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4; 795 796 /* First fan attributes, if fan status or type is OK */ 797 err = i8k_get_fan_status(0); 798 if (err < 0) 799 err = i8k_get_fan_type(0); 800 if (err >= 0) 801 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1; 802 803 /* Second fan attributes, if fan status or type is OK */ 804 err = i8k_get_fan_status(1); 805 if (err < 0) 806 err = i8k_get_fan_type(1); 807 if (err >= 0) 808 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2; 809 810 i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell_smm", 811 NULL, i8k_groups); 812 if (IS_ERR(i8k_hwmon_dev)) { 813 err = PTR_ERR(i8k_hwmon_dev); 814 i8k_hwmon_dev = NULL; 815 pr_err("hwmon registration failed (%d)\n", err); 816 return err; 817 } 818 return 0; 819 } 820 821 struct i8k_config_data { 822 uint fan_mult; 823 uint fan_max; 824 }; 825 826 enum i8k_configs { 827 DELL_LATITUDE_D520, 828 DELL_PRECISION_490, 829 DELL_STUDIO, 830 DELL_XPS, 831 }; 832 833 static const struct i8k_config_data i8k_config_data[] = { 834 [DELL_LATITUDE_D520] = { 835 .fan_mult = 1, 836 .fan_max = I8K_FAN_TURBO, 837 }, 838 [DELL_PRECISION_490] = { 839 .fan_mult = 1, 840 .fan_max = I8K_FAN_TURBO, 841 }, 842 [DELL_STUDIO] = { 843 .fan_mult = 1, 844 .fan_max = I8K_FAN_HIGH, 845 }, 846 [DELL_XPS] = { 847 .fan_mult = 1, 848 .fan_max = I8K_FAN_HIGH, 849 }, 850 }; 851 852 static struct dmi_system_id i8k_dmi_table[] __initdata = { 853 { 854 .ident = "Dell Inspiron", 855 .matches = { 856 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 857 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 858 }, 859 }, 860 { 861 .ident = "Dell Latitude", 862 .matches = { 863 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 864 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 865 }, 866 }, 867 { 868 .ident = "Dell Inspiron 2", 869 .matches = { 870 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 871 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 872 }, 873 }, 874 { 875 .ident = "Dell Latitude D520", 876 .matches = { 877 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 878 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), 879 }, 880 .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], 881 }, 882 { 883 .ident = "Dell Latitude 2", 884 .matches = { 885 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 886 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 887 }, 888 }, 889 { /* UK Inspiron 6400 */ 890 .ident = "Dell Inspiron 3", 891 .matches = { 892 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 893 DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), 894 }, 895 }, 896 { 897 .ident = "Dell Inspiron 3", 898 .matches = { 899 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 900 DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), 901 }, 902 }, 903 { 904 .ident = "Dell Precision 490", 905 .matches = { 906 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 907 DMI_MATCH(DMI_PRODUCT_NAME, 908 "Precision WorkStation 490"), 909 }, 910 .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], 911 }, 912 { 913 .ident = "Dell Precision", 914 .matches = { 915 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 916 DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), 917 }, 918 }, 919 { 920 .ident = "Dell Vostro", 921 .matches = { 922 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 923 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), 924 }, 925 }, 926 { 927 .ident = "Dell XPS421", 928 .matches = { 929 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 930 DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"), 931 }, 932 }, 933 { 934 .ident = "Dell Studio", 935 .matches = { 936 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 937 DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), 938 }, 939 .driver_data = (void *)&i8k_config_data[DELL_STUDIO], 940 }, 941 { 942 .ident = "Dell XPS 13", 943 .matches = { 944 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 945 DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"), 946 }, 947 .driver_data = (void *)&i8k_config_data[DELL_XPS], 948 }, 949 { 950 .ident = "Dell XPS M140", 951 .matches = { 952 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 953 DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), 954 }, 955 .driver_data = (void *)&i8k_config_data[DELL_XPS], 956 }, 957 { } 958 }; 959 960 MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); 961 962 /* 963 * On some machines once I8K_SMM_GET_FAN_TYPE is issued then CPU fan speed 964 * randomly going up and down due to bug in Dell SMM or BIOS. Here is blacklist 965 * of affected Dell machines for which we disallow I8K_SMM_GET_FAN_TYPE call. 966 * See bug: https://bugzilla.kernel.org/show_bug.cgi?id=100121 967 */ 968 static struct dmi_system_id i8k_blacklist_fan_type_dmi_table[] __initdata = { 969 { 970 .ident = "Dell Studio XPS 8000", 971 .matches = { 972 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 973 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8000"), 974 }, 975 }, 976 { 977 .ident = "Dell Studio XPS 8100", 978 .matches = { 979 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 980 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8100"), 981 }, 982 }, 983 { 984 .ident = "Dell Inspiron 580", 985 .matches = { 986 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 987 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Inspiron 580 "), 988 }, 989 }, 990 { } 991 }; 992 993 /* 994 * Probe for the presence of a supported laptop. 995 */ 996 static int __init i8k_probe(void) 997 { 998 const struct dmi_system_id *id; 999 int fan, ret; 1000 1001 /* 1002 * Get DMI information 1003 */ 1004 if (!dmi_check_system(i8k_dmi_table)) { 1005 if (!ignore_dmi && !force) 1006 return -ENODEV; 1007 1008 pr_info("not running on a supported Dell system.\n"); 1009 pr_info("vendor=%s, model=%s, version=%s\n", 1010 i8k_get_dmi_data(DMI_SYS_VENDOR), 1011 i8k_get_dmi_data(DMI_PRODUCT_NAME), 1012 i8k_get_dmi_data(DMI_BIOS_VERSION)); 1013 } 1014 1015 if (dmi_check_system(i8k_blacklist_fan_type_dmi_table)) 1016 disallow_fan_type_call = true; 1017 1018 strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), 1019 sizeof(bios_version)); 1020 strlcpy(bios_machineid, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), 1021 sizeof(bios_machineid)); 1022 1023 /* 1024 * Get SMM Dell signature 1025 */ 1026 if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && 1027 i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { 1028 pr_err("unable to get SMM Dell signature\n"); 1029 if (!force) 1030 return -ENODEV; 1031 } 1032 1033 /* 1034 * Set fan multiplier and maximal fan speed from dmi config 1035 * Values specified in module parameters override values from dmi 1036 */ 1037 id = dmi_first_match(i8k_dmi_table); 1038 if (id && id->driver_data) { 1039 const struct i8k_config_data *conf = id->driver_data; 1040 if (!fan_mult && conf->fan_mult) 1041 fan_mult = conf->fan_mult; 1042 if (!fan_max && conf->fan_max) 1043 fan_max = conf->fan_max; 1044 } 1045 1046 i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ 1047 i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max); 1048 1049 if (!fan_mult) { 1050 /* 1051 * Autodetect fan multiplier based on nominal rpm 1052 * If fan reports rpm value too high then set multiplier to 1 1053 */ 1054 for (fan = 0; fan < 2; ++fan) { 1055 ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max); 1056 if (ret < 0) 1057 continue; 1058 if (ret > I8K_FAN_MAX_RPM) 1059 i8k_fan_mult = 1; 1060 break; 1061 } 1062 } else { 1063 /* Fan multiplier was specified in module param or in dmi */ 1064 i8k_fan_mult = fan_mult; 1065 } 1066 1067 return 0; 1068 } 1069 1070 static int __init i8k_init(void) 1071 { 1072 int err; 1073 1074 /* Are we running on an supported laptop? */ 1075 if (i8k_probe()) 1076 return -ENODEV; 1077 1078 err = i8k_init_hwmon(); 1079 if (err) 1080 return err; 1081 1082 i8k_init_procfs(); 1083 return 0; 1084 } 1085 1086 static void __exit i8k_exit(void) 1087 { 1088 hwmon_device_unregister(i8k_hwmon_dev); 1089 i8k_exit_procfs(); 1090 } 1091 1092 module_init(i8k_init); 1093 module_exit(i8k_exit); 1094