1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops. 4 * 5 * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org> 6 * 7 * Hwmon integration: 8 * Copyright (C) 2011 Jean Delvare <jdelvare@suse.de> 9 * Copyright (C) 2013, 2014 Guenter Roeck <linux@roeck-us.net> 10 * Copyright (C) 2014, 2015 Pali Rohár <pali@kernel.org> 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <linux/capability.h> 16 #include <linux/cpu.h> 17 #include <linux/ctype.h> 18 #include <linux/delay.h> 19 #include <linux/dmi.h> 20 #include <linux/err.h> 21 #include <linux/errno.h> 22 #include <linux/hwmon.h> 23 #include <linux/init.h> 24 #include <linux/module.h> 25 #include <linux/mutex.h> 26 #include <linux/platform_device.h> 27 #include <linux/proc_fs.h> 28 #include <linux/seq_file.h> 29 #include <linux/string.h> 30 #include <linux/smp.h> 31 #include <linux/types.h> 32 #include <linux/uaccess.h> 33 34 #include <linux/i8k.h> 35 36 #define I8K_SMM_FN_STATUS 0x0025 37 #define I8K_SMM_POWER_STATUS 0x0069 38 #define I8K_SMM_SET_FAN 0x01a3 39 #define I8K_SMM_GET_FAN 0x00a3 40 #define I8K_SMM_GET_SPEED 0x02a3 41 #define I8K_SMM_GET_FAN_TYPE 0x03a3 42 #define I8K_SMM_GET_NOM_SPEED 0x04a3 43 #define I8K_SMM_GET_TEMP 0x10a3 44 #define I8K_SMM_GET_TEMP_TYPE 0x11a3 45 #define I8K_SMM_GET_DELL_SIG1 0xfea3 46 #define I8K_SMM_GET_DELL_SIG2 0xffa3 47 48 #define I8K_FAN_MULT 30 49 #define I8K_FAN_MAX_RPM 30000 50 #define I8K_MAX_TEMP 127 51 52 #define I8K_FN_NONE 0x00 53 #define I8K_FN_UP 0x01 54 #define I8K_FN_DOWN 0x02 55 #define I8K_FN_MUTE 0x04 56 #define I8K_FN_MASK 0x07 57 #define I8K_FN_SHIFT 8 58 59 #define I8K_POWER_AC 0x05 60 #define I8K_POWER_BATTERY 0x01 61 62 #define DELL_SMM_NO_TEMP 10 63 #define DELL_SMM_NO_FANS 3 64 65 struct dell_smm_data { 66 struct mutex i8k_mutex; /* lock for sensors writes */ 67 char bios_version[4]; 68 char bios_machineid[16]; 69 uint i8k_fan_mult; 70 uint i8k_pwm_mult; 71 uint i8k_fan_max; 72 bool disallow_fan_type_call; 73 bool disallow_fan_support; 74 unsigned int manual_fan; 75 unsigned int auto_fan; 76 int temp_type[DELL_SMM_NO_TEMP]; 77 bool fan[DELL_SMM_NO_FANS]; 78 int fan_type[DELL_SMM_NO_FANS]; 79 int *fan_nominal_speed[DELL_SMM_NO_FANS]; 80 }; 81 82 MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); 83 MODULE_AUTHOR("Pali Rohár <pali@kernel.org>"); 84 MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver"); 85 MODULE_LICENSE("GPL"); 86 MODULE_ALIAS("i8k"); 87 88 static bool force; 89 module_param(force, bool, 0); 90 MODULE_PARM_DESC(force, "Force loading without checking for supported models"); 91 92 static bool ignore_dmi; 93 module_param(ignore_dmi, bool, 0); 94 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match"); 95 96 #if IS_ENABLED(CONFIG_I8K) 97 static bool restricted = true; 98 module_param(restricted, bool, 0); 99 MODULE_PARM_DESC(restricted, "Restrict fan control and serial number to CAP_SYS_ADMIN (default: 1)"); 100 101 static bool power_status; 102 module_param(power_status, bool, 0600); 103 MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k (default: 0)"); 104 #endif 105 106 static uint fan_mult; 107 module_param(fan_mult, uint, 0); 108 MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)"); 109 110 static uint fan_max; 111 module_param(fan_max, uint, 0); 112 MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)"); 113 114 struct smm_regs { 115 unsigned int eax; 116 unsigned int ebx __packed; 117 unsigned int ecx __packed; 118 unsigned int edx __packed; 119 unsigned int esi __packed; 120 unsigned int edi __packed; 121 }; 122 123 static const char * const temp_labels[] = { 124 "CPU", 125 "GPU", 126 "SODIMM", 127 "Other", 128 "Ambient", 129 "Other", 130 }; 131 132 static const char * const fan_labels[] = { 133 "Processor Fan", 134 "Motherboard Fan", 135 "Video Fan", 136 "Power Supply Fan", 137 "Chipset Fan", 138 "Other Fan", 139 }; 140 141 static const char * const docking_labels[] = { 142 "Docking Processor Fan", 143 "Docking Motherboard Fan", 144 "Docking Video Fan", 145 "Docking Power Supply Fan", 146 "Docking Chipset Fan", 147 "Docking Other Fan", 148 }; 149 150 static inline const char __init *i8k_get_dmi_data(int field) 151 { 152 const char *dmi_data = dmi_get_system_info(field); 153 154 return dmi_data && *dmi_data ? dmi_data : "?"; 155 } 156 157 /* 158 * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard. 159 */ 160 static int i8k_smm_func(void *par) 161 { 162 ktime_t calltime = ktime_get(); 163 struct smm_regs *regs = par; 164 int eax = regs->eax; 165 int ebx = regs->ebx; 166 long long duration; 167 int rc; 168 169 /* SMM requires CPU 0 */ 170 if (smp_processor_id() != 0) 171 return -EBUSY; 172 173 #if defined(CONFIG_X86_64) 174 asm volatile("pushq %%rax\n\t" 175 "movl 0(%%rax),%%edx\n\t" 176 "pushq %%rdx\n\t" 177 "movl 4(%%rax),%%ebx\n\t" 178 "movl 8(%%rax),%%ecx\n\t" 179 "movl 12(%%rax),%%edx\n\t" 180 "movl 16(%%rax),%%esi\n\t" 181 "movl 20(%%rax),%%edi\n\t" 182 "popq %%rax\n\t" 183 "out %%al,$0xb2\n\t" 184 "out %%al,$0x84\n\t" 185 "xchgq %%rax,(%%rsp)\n\t" 186 "movl %%ebx,4(%%rax)\n\t" 187 "movl %%ecx,8(%%rax)\n\t" 188 "movl %%edx,12(%%rax)\n\t" 189 "movl %%esi,16(%%rax)\n\t" 190 "movl %%edi,20(%%rax)\n\t" 191 "popq %%rdx\n\t" 192 "movl %%edx,0(%%rax)\n\t" 193 "pushfq\n\t" 194 "popq %%rax\n\t" 195 "andl $1,%%eax\n" 196 : "=a"(rc) 197 : "a"(regs) 198 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 199 #else 200 asm volatile("pushl %%eax\n\t" 201 "movl 0(%%eax),%%edx\n\t" 202 "push %%edx\n\t" 203 "movl 4(%%eax),%%ebx\n\t" 204 "movl 8(%%eax),%%ecx\n\t" 205 "movl 12(%%eax),%%edx\n\t" 206 "movl 16(%%eax),%%esi\n\t" 207 "movl 20(%%eax),%%edi\n\t" 208 "popl %%eax\n\t" 209 "out %%al,$0xb2\n\t" 210 "out %%al,$0x84\n\t" 211 "xchgl %%eax,(%%esp)\n\t" 212 "movl %%ebx,4(%%eax)\n\t" 213 "movl %%ecx,8(%%eax)\n\t" 214 "movl %%edx,12(%%eax)\n\t" 215 "movl %%esi,16(%%eax)\n\t" 216 "movl %%edi,20(%%eax)\n\t" 217 "popl %%edx\n\t" 218 "movl %%edx,0(%%eax)\n\t" 219 "lahf\n\t" 220 "shrl $8,%%eax\n\t" 221 "andl $1,%%eax\n" 222 : "=a"(rc) 223 : "a"(regs) 224 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); 225 #endif 226 if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax) 227 rc = -EINVAL; 228 229 duration = ktime_us_delta(ktime_get(), calltime); 230 pr_debug("smm(0x%.4x 0x%.4x) = 0x%.4x (took %7lld usecs)\n", eax, ebx, 231 (rc ? 0xffff : regs->eax & 0xffff), duration); 232 233 return rc; 234 } 235 236 /* 237 * Call the System Management Mode BIOS. 238 */ 239 static int i8k_smm(struct smm_regs *regs) 240 { 241 int ret; 242 243 cpus_read_lock(); 244 ret = smp_call_on_cpu(0, i8k_smm_func, regs, true); 245 cpus_read_unlock(); 246 247 return ret; 248 } 249 250 /* 251 * Read the fan status. 252 */ 253 static int i8k_get_fan_status(const struct dell_smm_data *data, int fan) 254 { 255 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, }; 256 257 if (data->disallow_fan_support) 258 return -EINVAL; 259 260 regs.ebx = fan & 0xff; 261 return i8k_smm(®s) ? : regs.eax & 0xff; 262 } 263 264 /* 265 * Read the fan speed in RPM. 266 */ 267 static int i8k_get_fan_speed(const struct dell_smm_data *data, int fan) 268 { 269 struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, }; 270 271 if (data->disallow_fan_support) 272 return -EINVAL; 273 274 regs.ebx = fan & 0xff; 275 return i8k_smm(®s) ? : (regs.eax & 0xffff) * data->i8k_fan_mult; 276 } 277 278 /* 279 * Read the fan type. 280 */ 281 static int _i8k_get_fan_type(const struct dell_smm_data *data, int fan) 282 { 283 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, }; 284 285 if (data->disallow_fan_support || data->disallow_fan_type_call) 286 return -EINVAL; 287 288 regs.ebx = fan & 0xff; 289 return i8k_smm(®s) ? : regs.eax & 0xff; 290 } 291 292 static int i8k_get_fan_type(struct dell_smm_data *data, int fan) 293 { 294 /* I8K_SMM_GET_FAN_TYPE SMM call is expensive, so cache values */ 295 if (data->fan_type[fan] == INT_MIN) 296 data->fan_type[fan] = _i8k_get_fan_type(data, fan); 297 298 return data->fan_type[fan]; 299 } 300 301 /* 302 * Read the fan nominal rpm for specific fan speed. 303 */ 304 static int __init i8k_get_fan_nominal_speed(const struct dell_smm_data *data, int fan, int speed) 305 { 306 struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, }; 307 308 if (data->disallow_fan_support) 309 return -EINVAL; 310 311 regs.ebx = (fan & 0xff) | (speed << 8); 312 return i8k_smm(®s) ? : (regs.eax & 0xffff) * data->i8k_fan_mult; 313 } 314 315 /* 316 * Enable or disable automatic BIOS fan control support 317 */ 318 static int i8k_enable_fan_auto_mode(const struct dell_smm_data *data, bool enable) 319 { 320 struct smm_regs regs = { }; 321 322 if (data->disallow_fan_support) 323 return -EINVAL; 324 325 regs.eax = enable ? data->auto_fan : data->manual_fan; 326 return i8k_smm(®s); 327 } 328 329 /* 330 * Set the fan speed (off, low, high, ...). 331 */ 332 static int i8k_set_fan(const struct dell_smm_data *data, int fan, int speed) 333 { 334 struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, }; 335 336 if (data->disallow_fan_support) 337 return -EINVAL; 338 339 speed = (speed < 0) ? 0 : ((speed > data->i8k_fan_max) ? data->i8k_fan_max : speed); 340 regs.ebx = (fan & 0xff) | (speed << 8); 341 342 return i8k_smm(®s); 343 } 344 345 static int __init i8k_get_temp_type(int sensor) 346 { 347 struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, }; 348 349 regs.ebx = sensor & 0xff; 350 return i8k_smm(®s) ? : regs.eax & 0xff; 351 } 352 353 /* 354 * Read the cpu temperature. 355 */ 356 static int _i8k_get_temp(int sensor) 357 { 358 struct smm_regs regs = { 359 .eax = I8K_SMM_GET_TEMP, 360 .ebx = sensor & 0xff, 361 }; 362 363 return i8k_smm(®s) ? : regs.eax & 0xff; 364 } 365 366 static int i8k_get_temp(int sensor) 367 { 368 int temp = _i8k_get_temp(sensor); 369 370 /* 371 * Sometimes the temperature sensor returns 0x99, which is out of range. 372 * In this case we retry (once) before returning an error. 373 # 1003655137 00000058 00005a4b 374 # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees 375 # 1003655139 00000054 00005c52 376 */ 377 if (temp == 0x99) { 378 msleep(100); 379 temp = _i8k_get_temp(sensor); 380 } 381 /* 382 * Return -ENODATA for all invalid temperatures. 383 * 384 * Known instances are the 0x99 value as seen above as well as 385 * 0xc1 (193), which may be returned when trying to read the GPU 386 * temperature if the system supports a GPU and it is currently 387 * turned off. 388 */ 389 if (temp > I8K_MAX_TEMP) 390 return -ENODATA; 391 392 return temp; 393 } 394 395 static int __init i8k_get_dell_signature(int req_fn) 396 { 397 struct smm_regs regs = { .eax = req_fn, }; 398 int rc; 399 400 rc = i8k_smm(®s); 401 if (rc < 0) 402 return rc; 403 404 return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1; 405 } 406 407 #if IS_ENABLED(CONFIG_I8K) 408 409 /* 410 * Read the Fn key status. 411 */ 412 static int i8k_get_fn_status(void) 413 { 414 struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, }; 415 int rc; 416 417 rc = i8k_smm(®s); 418 if (rc < 0) 419 return rc; 420 421 switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) { 422 case I8K_FN_UP: 423 return I8K_VOL_UP; 424 case I8K_FN_DOWN: 425 return I8K_VOL_DOWN; 426 case I8K_FN_MUTE: 427 return I8K_VOL_MUTE; 428 default: 429 return 0; 430 } 431 } 432 433 /* 434 * Read the power status. 435 */ 436 static int i8k_get_power_status(void) 437 { 438 struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, }; 439 int rc; 440 441 rc = i8k_smm(®s); 442 if (rc < 0) 443 return rc; 444 445 return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY; 446 } 447 448 /* 449 * Procfs interface 450 */ 451 452 static int 453 i8k_ioctl_unlocked(struct file *fp, struct dell_smm_data *data, unsigned int cmd, unsigned long arg) 454 { 455 int val = 0; 456 int speed, err; 457 unsigned char buff[16]; 458 int __user *argp = (int __user *)arg; 459 460 if (!argp) 461 return -EINVAL; 462 463 switch (cmd) { 464 case I8K_BIOS_VERSION: 465 if (!isdigit(data->bios_version[0]) || !isdigit(data->bios_version[1]) || 466 !isdigit(data->bios_version[2])) 467 return -EINVAL; 468 469 val = (data->bios_version[0] << 16) | 470 (data->bios_version[1] << 8) | data->bios_version[2]; 471 break; 472 473 case I8K_MACHINE_ID: 474 if (restricted && !capable(CAP_SYS_ADMIN)) 475 return -EPERM; 476 477 strscpy_pad(buff, data->bios_machineid, sizeof(buff)); 478 break; 479 480 case I8K_FN_STATUS: 481 val = i8k_get_fn_status(); 482 break; 483 484 case I8K_POWER_STATUS: 485 val = i8k_get_power_status(); 486 break; 487 488 case I8K_GET_TEMP: 489 val = i8k_get_temp(0); 490 break; 491 492 case I8K_GET_SPEED: 493 if (copy_from_user(&val, argp, sizeof(int))) 494 return -EFAULT; 495 496 val = i8k_get_fan_speed(data, val); 497 break; 498 499 case I8K_GET_FAN: 500 if (copy_from_user(&val, argp, sizeof(int))) 501 return -EFAULT; 502 503 val = i8k_get_fan_status(data, val); 504 break; 505 506 case I8K_SET_FAN: 507 if (restricted && !capable(CAP_SYS_ADMIN)) 508 return -EPERM; 509 510 if (copy_from_user(&val, argp, sizeof(int))) 511 return -EFAULT; 512 513 if (copy_from_user(&speed, argp + 1, sizeof(int))) 514 return -EFAULT; 515 516 err = i8k_set_fan(data, val, speed); 517 if (err < 0) 518 return err; 519 520 val = i8k_get_fan_status(data, val); 521 break; 522 523 default: 524 return -ENOIOCTLCMD; 525 } 526 527 if (val < 0) 528 return val; 529 530 switch (cmd) { 531 case I8K_BIOS_VERSION: 532 if (copy_to_user(argp, &val, 4)) 533 return -EFAULT; 534 535 break; 536 case I8K_MACHINE_ID: 537 if (copy_to_user(argp, buff, 16)) 538 return -EFAULT; 539 540 break; 541 default: 542 if (copy_to_user(argp, &val, sizeof(int))) 543 return -EFAULT; 544 545 break; 546 } 547 548 return 0; 549 } 550 551 static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) 552 { 553 struct dell_smm_data *data = PDE_DATA(file_inode(fp)); 554 long ret; 555 556 mutex_lock(&data->i8k_mutex); 557 ret = i8k_ioctl_unlocked(fp, data, cmd, arg); 558 mutex_unlock(&data->i8k_mutex); 559 560 return ret; 561 } 562 563 /* 564 * Print the information for /proc/i8k. 565 */ 566 static int i8k_proc_show(struct seq_file *seq, void *offset) 567 { 568 struct dell_smm_data *data = seq->private; 569 int fn_key, cpu_temp, ac_power; 570 int left_fan, right_fan, left_speed, right_speed; 571 572 cpu_temp = i8k_get_temp(0); /* 11100 µs */ 573 left_fan = i8k_get_fan_status(data, I8K_FAN_LEFT); /* 580 µs */ 574 right_fan = i8k_get_fan_status(data, I8K_FAN_RIGHT); /* 580 µs */ 575 left_speed = i8k_get_fan_speed(data, I8K_FAN_LEFT); /* 580 µs */ 576 right_speed = i8k_get_fan_speed(data, I8K_FAN_RIGHT); /* 580 µs */ 577 fn_key = i8k_get_fn_status(); /* 750 µs */ 578 if (power_status) 579 ac_power = i8k_get_power_status(); /* 14700 µs */ 580 else 581 ac_power = -1; 582 583 /* 584 * Info: 585 * 586 * 1) Format version (this will change if format changes) 587 * 2) BIOS version 588 * 3) BIOS machine ID 589 * 4) Cpu temperature 590 * 5) Left fan status 591 * 6) Right fan status 592 * 7) Left fan speed 593 * 8) Right fan speed 594 * 9) AC power 595 * 10) Fn Key status 596 */ 597 seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n", 598 I8K_PROC_FMT, 599 data->bios_version, 600 (restricted && !capable(CAP_SYS_ADMIN)) ? "-1" : data->bios_machineid, 601 cpu_temp, 602 left_fan, right_fan, left_speed, right_speed, 603 ac_power, fn_key); 604 605 return 0; 606 } 607 608 static int i8k_open_fs(struct inode *inode, struct file *file) 609 { 610 return single_open(file, i8k_proc_show, PDE_DATA(inode)); 611 } 612 613 static const struct proc_ops i8k_proc_ops = { 614 .proc_open = i8k_open_fs, 615 .proc_read = seq_read, 616 .proc_lseek = seq_lseek, 617 .proc_release = single_release, 618 .proc_ioctl = i8k_ioctl, 619 }; 620 621 static void i8k_exit_procfs(void *param) 622 { 623 remove_proc_entry("i8k", NULL); 624 } 625 626 static void __init i8k_init_procfs(struct device *dev) 627 { 628 struct dell_smm_data *data = dev_get_drvdata(dev); 629 630 /* Register the proc entry */ 631 proc_create_data("i8k", 0, NULL, &i8k_proc_ops, data); 632 633 devm_add_action_or_reset(dev, i8k_exit_procfs, NULL); 634 } 635 636 #else 637 638 static void __init i8k_init_procfs(struct device *dev) 639 { 640 } 641 642 #endif 643 644 /* 645 * Hwmon interface 646 */ 647 648 static umode_t dell_smm_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr, 649 int channel) 650 { 651 const struct dell_smm_data *data = drvdata; 652 653 switch (type) { 654 case hwmon_temp: 655 switch (attr) { 656 case hwmon_temp_input: 657 case hwmon_temp_label: 658 if (data->temp_type[channel] >= 0) 659 return 0444; 660 661 break; 662 default: 663 break; 664 } 665 break; 666 case hwmon_fan: 667 if (data->disallow_fan_support) 668 break; 669 670 switch (attr) { 671 case hwmon_fan_input: 672 if (data->fan[channel]) 673 return 0444; 674 675 break; 676 case hwmon_fan_label: 677 if (data->fan[channel] && !data->disallow_fan_type_call) 678 return 0444; 679 680 break; 681 case hwmon_fan_min: 682 case hwmon_fan_max: 683 case hwmon_fan_target: 684 if (data->fan_nominal_speed[channel]) 685 return 0444; 686 687 break; 688 default: 689 break; 690 } 691 break; 692 case hwmon_pwm: 693 if (data->disallow_fan_support) 694 break; 695 696 switch (attr) { 697 case hwmon_pwm_input: 698 if (data->fan[channel]) 699 return 0644; 700 701 break; 702 case hwmon_pwm_enable: 703 if (data->auto_fan) 704 /* 705 * There is no command for retrieve the current status 706 * from BIOS, and userspace/firmware itself can change 707 * it. 708 * Thus we can only provide write-only access for now. 709 */ 710 return 0200; 711 712 break; 713 default: 714 break; 715 } 716 break; 717 default: 718 break; 719 } 720 721 return 0; 722 } 723 724 static int dell_smm_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 725 long *val) 726 { 727 struct dell_smm_data *data = dev_get_drvdata(dev); 728 int ret; 729 730 switch (type) { 731 case hwmon_temp: 732 switch (attr) { 733 case hwmon_temp_input: 734 ret = i8k_get_temp(channel); 735 if (ret < 0) 736 return ret; 737 738 *val = ret * 1000; 739 740 return 0; 741 default: 742 break; 743 } 744 break; 745 case hwmon_fan: 746 switch (attr) { 747 case hwmon_fan_input: 748 ret = i8k_get_fan_speed(data, channel); 749 if (ret < 0) 750 return ret; 751 752 *val = ret; 753 754 return 0; 755 case hwmon_fan_min: 756 *val = data->fan_nominal_speed[channel][0]; 757 758 return 0; 759 case hwmon_fan_max: 760 *val = data->fan_nominal_speed[channel][data->i8k_fan_max]; 761 762 return 0; 763 case hwmon_fan_target: 764 ret = i8k_get_fan_status(data, channel); 765 if (ret < 0) 766 return ret; 767 768 if (ret > data->i8k_fan_max) 769 ret = data->i8k_fan_max; 770 771 *val = data->fan_nominal_speed[channel][ret]; 772 773 return 0; 774 default: 775 break; 776 } 777 break; 778 case hwmon_pwm: 779 switch (attr) { 780 case hwmon_pwm_input: 781 ret = i8k_get_fan_status(data, channel); 782 if (ret < 0) 783 return ret; 784 785 *val = clamp_val(ret * data->i8k_pwm_mult, 0, 255); 786 787 return 0; 788 default: 789 break; 790 } 791 break; 792 default: 793 break; 794 } 795 796 return -EOPNOTSUPP; 797 } 798 799 static const char *dell_smm_fan_label(struct dell_smm_data *data, int channel) 800 { 801 bool dock = false; 802 int type = i8k_get_fan_type(data, channel); 803 804 if (type < 0) 805 return ERR_PTR(type); 806 807 if (type & 0x10) { 808 dock = true; 809 type &= 0x0F; 810 } 811 812 if (type >= ARRAY_SIZE(fan_labels)) 813 type = ARRAY_SIZE(fan_labels) - 1; 814 815 return dock ? docking_labels[type] : fan_labels[type]; 816 } 817 818 static int dell_smm_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, 819 int channel, const char **str) 820 { 821 struct dell_smm_data *data = dev_get_drvdata(dev); 822 823 switch (type) { 824 case hwmon_temp: 825 switch (attr) { 826 case hwmon_temp_label: 827 *str = temp_labels[data->temp_type[channel]]; 828 return 0; 829 default: 830 break; 831 } 832 break; 833 case hwmon_fan: 834 switch (attr) { 835 case hwmon_fan_label: 836 *str = dell_smm_fan_label(data, channel); 837 return PTR_ERR_OR_ZERO(*str); 838 default: 839 break; 840 } 841 break; 842 default: 843 break; 844 } 845 846 return -EOPNOTSUPP; 847 } 848 849 static int dell_smm_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 850 long val) 851 { 852 struct dell_smm_data *data = dev_get_drvdata(dev); 853 unsigned long pwm; 854 bool enable; 855 int err; 856 857 switch (type) { 858 case hwmon_pwm: 859 switch (attr) { 860 case hwmon_pwm_input: 861 pwm = clamp_val(DIV_ROUND_CLOSEST(val, data->i8k_pwm_mult), 0, 862 data->i8k_fan_max); 863 864 mutex_lock(&data->i8k_mutex); 865 err = i8k_set_fan(data, channel, pwm); 866 mutex_unlock(&data->i8k_mutex); 867 868 if (err < 0) 869 return err; 870 871 return 0; 872 case hwmon_pwm_enable: 873 if (!val) 874 return -EINVAL; 875 876 if (val == 1) 877 enable = false; 878 else 879 enable = true; 880 881 mutex_lock(&data->i8k_mutex); 882 err = i8k_enable_fan_auto_mode(data, enable); 883 mutex_unlock(&data->i8k_mutex); 884 885 if (err < 0) 886 return err; 887 888 return 0; 889 default: 890 break; 891 } 892 break; 893 default: 894 break; 895 } 896 897 return -EOPNOTSUPP; 898 } 899 900 static const struct hwmon_ops dell_smm_ops = { 901 .is_visible = dell_smm_is_visible, 902 .read = dell_smm_read, 903 .read_string = dell_smm_read_string, 904 .write = dell_smm_write, 905 }; 906 907 static const struct hwmon_channel_info *dell_smm_info[] = { 908 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ), 909 HWMON_CHANNEL_INFO(temp, 910 HWMON_T_INPUT | HWMON_T_LABEL, 911 HWMON_T_INPUT | HWMON_T_LABEL, 912 HWMON_T_INPUT | HWMON_T_LABEL, 913 HWMON_T_INPUT | HWMON_T_LABEL, 914 HWMON_T_INPUT | HWMON_T_LABEL, 915 HWMON_T_INPUT | HWMON_T_LABEL, 916 HWMON_T_INPUT | HWMON_T_LABEL, 917 HWMON_T_INPUT | HWMON_T_LABEL, 918 HWMON_T_INPUT | HWMON_T_LABEL, 919 HWMON_T_INPUT | HWMON_T_LABEL 920 ), 921 HWMON_CHANNEL_INFO(fan, 922 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MIN | HWMON_F_MAX | 923 HWMON_F_TARGET, 924 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MIN | HWMON_F_MAX | 925 HWMON_F_TARGET, 926 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MIN | HWMON_F_MAX | 927 HWMON_F_TARGET 928 ), 929 HWMON_CHANNEL_INFO(pwm, 930 HWMON_PWM_INPUT | HWMON_PWM_ENABLE, 931 HWMON_PWM_INPUT, 932 HWMON_PWM_INPUT 933 ), 934 NULL 935 }; 936 937 static const struct hwmon_chip_info dell_smm_chip_info = { 938 .ops = &dell_smm_ops, 939 .info = dell_smm_info, 940 }; 941 942 static int __init dell_smm_init_hwmon(struct device *dev) 943 { 944 struct dell_smm_data *data = dev_get_drvdata(dev); 945 struct device *dell_smm_hwmon_dev; 946 int i, state, err; 947 948 for (i = 0; i < DELL_SMM_NO_TEMP; i++) { 949 data->temp_type[i] = i8k_get_temp_type(i); 950 if (data->temp_type[i] < 0) 951 continue; 952 953 if (data->temp_type[i] >= ARRAY_SIZE(temp_labels)) 954 data->temp_type[i] = ARRAY_SIZE(temp_labels) - 1; 955 } 956 957 for (i = 0; i < DELL_SMM_NO_FANS; i++) { 958 data->fan_type[i] = INT_MIN; 959 err = i8k_get_fan_status(data, i); 960 if (err < 0) 961 err = i8k_get_fan_type(data, i); 962 963 if (err < 0) 964 continue; 965 966 data->fan[i] = true; 967 data->fan_nominal_speed[i] = devm_kmalloc_array(dev, data->i8k_fan_max + 1, 968 sizeof(*data->fan_nominal_speed[i]), 969 GFP_KERNEL); 970 if (!data->fan_nominal_speed[i]) 971 continue; 972 973 for (state = 0; state <= data->i8k_fan_max; state++) { 974 err = i8k_get_fan_nominal_speed(data, i, state); 975 if (err < 0) { 976 /* Mark nominal speed table as invalid in case of error */ 977 devm_kfree(dev, data->fan_nominal_speed[i]); 978 data->fan_nominal_speed[i] = NULL; 979 break; 980 } 981 data->fan_nominal_speed[i][state] = err; 982 } 983 } 984 985 dell_smm_hwmon_dev = devm_hwmon_device_register_with_info(dev, "dell_smm", data, 986 &dell_smm_chip_info, NULL); 987 988 return PTR_ERR_OR_ZERO(dell_smm_hwmon_dev); 989 } 990 991 struct i8k_config_data { 992 uint fan_mult; 993 uint fan_max; 994 }; 995 996 enum i8k_configs { 997 DELL_LATITUDE_D520, 998 DELL_PRECISION_490, 999 DELL_STUDIO, 1000 DELL_XPS, 1001 }; 1002 1003 /* 1004 * Only use for machines which need some special configuration 1005 * in order to work correctly (e.g. if autoconfig fails on this machines). 1006 */ 1007 1008 static const struct i8k_config_data i8k_config_data[] __initconst = { 1009 [DELL_LATITUDE_D520] = { 1010 .fan_mult = 1, 1011 .fan_max = I8K_FAN_TURBO, 1012 }, 1013 [DELL_PRECISION_490] = { 1014 .fan_mult = 1, 1015 .fan_max = I8K_FAN_TURBO, 1016 }, 1017 [DELL_STUDIO] = { 1018 .fan_mult = 1, 1019 .fan_max = I8K_FAN_HIGH, 1020 }, 1021 [DELL_XPS] = { 1022 .fan_mult = 1, 1023 .fan_max = I8K_FAN_HIGH, 1024 }, 1025 }; 1026 1027 static const struct dmi_system_id i8k_dmi_table[] __initconst = { 1028 { 1029 .ident = "Dell Inspiron", 1030 .matches = { 1031 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 1032 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 1033 }, 1034 }, 1035 { 1036 .ident = "Dell Latitude", 1037 .matches = { 1038 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"), 1039 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 1040 }, 1041 }, 1042 { 1043 .ident = "Dell Inspiron 2", 1044 .matches = { 1045 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1046 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"), 1047 }, 1048 }, 1049 { 1050 .ident = "Dell Latitude D520", 1051 .matches = { 1052 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1053 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"), 1054 }, 1055 .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520], 1056 }, 1057 { 1058 .ident = "Dell Latitude 2", 1059 .matches = { 1060 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1061 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"), 1062 }, 1063 }, 1064 { /* UK Inspiron 6400 */ 1065 .ident = "Dell Inspiron 3", 1066 .matches = { 1067 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1068 DMI_MATCH(DMI_PRODUCT_NAME, "MM061"), 1069 }, 1070 }, 1071 { 1072 .ident = "Dell Inspiron 3", 1073 .matches = { 1074 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1075 DMI_MATCH(DMI_PRODUCT_NAME, "MP061"), 1076 }, 1077 }, 1078 { 1079 .ident = "Dell Precision 490", 1080 .matches = { 1081 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1082 DMI_MATCH(DMI_PRODUCT_NAME, 1083 "Precision WorkStation 490"), 1084 }, 1085 .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490], 1086 }, 1087 { 1088 .ident = "Dell Precision", 1089 .matches = { 1090 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1091 DMI_MATCH(DMI_PRODUCT_NAME, "Precision"), 1092 }, 1093 }, 1094 { 1095 .ident = "Dell Vostro", 1096 .matches = { 1097 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1098 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"), 1099 }, 1100 }, 1101 { 1102 .ident = "Dell Studio", 1103 .matches = { 1104 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1105 DMI_MATCH(DMI_PRODUCT_NAME, "Studio"), 1106 }, 1107 .driver_data = (void *)&i8k_config_data[DELL_STUDIO], 1108 }, 1109 { 1110 .ident = "Dell XPS M140", 1111 .matches = { 1112 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1113 DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"), 1114 }, 1115 .driver_data = (void *)&i8k_config_data[DELL_XPS], 1116 }, 1117 { 1118 .ident = "Dell XPS", 1119 .matches = { 1120 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1121 DMI_MATCH(DMI_PRODUCT_NAME, "XPS"), 1122 }, 1123 }, 1124 { } 1125 }; 1126 1127 MODULE_DEVICE_TABLE(dmi, i8k_dmi_table); 1128 1129 /* 1130 * On some machines once I8K_SMM_GET_FAN_TYPE is issued then CPU fan speed 1131 * randomly going up and down due to bug in Dell SMM or BIOS. Here is blacklist 1132 * of affected Dell machines for which we disallow I8K_SMM_GET_FAN_TYPE call. 1133 * See bug: https://bugzilla.kernel.org/show_bug.cgi?id=100121 1134 */ 1135 static const struct dmi_system_id i8k_blacklist_fan_type_dmi_table[] __initconst = { 1136 { 1137 .ident = "Dell Studio XPS 8000", 1138 .matches = { 1139 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1140 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8000"), 1141 }, 1142 }, 1143 { 1144 .ident = "Dell Studio XPS 8100", 1145 .matches = { 1146 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1147 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8100"), 1148 }, 1149 }, 1150 { 1151 .ident = "Dell Inspiron 580", 1152 .matches = { 1153 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1154 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Inspiron 580 "), 1155 }, 1156 }, 1157 { } 1158 }; 1159 1160 /* 1161 * On some machines all fan related SMM functions implemented by Dell BIOS 1162 * firmware freeze kernel for about 500ms. Until Dell fixes these problems fan 1163 * support for affected blacklisted Dell machines stay disabled. 1164 * See bug: https://bugzilla.kernel.org/show_bug.cgi?id=195751 1165 */ 1166 static const struct dmi_system_id i8k_blacklist_fan_support_dmi_table[] __initconst = { 1167 { 1168 .ident = "Dell Inspiron 7720", 1169 .matches = { 1170 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1171 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Inspiron 7720"), 1172 }, 1173 }, 1174 { 1175 .ident = "Dell Vostro 3360", 1176 .matches = { 1177 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1178 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Vostro 3360"), 1179 }, 1180 }, 1181 { 1182 .ident = "Dell XPS13 9333", 1183 .matches = { 1184 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1185 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS13 9333"), 1186 }, 1187 }, 1188 { 1189 .ident = "Dell XPS 15 L502X", 1190 .matches = { 1191 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1192 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Dell System XPS L502X"), 1193 }, 1194 }, 1195 { } 1196 }; 1197 1198 struct i8k_fan_control_data { 1199 unsigned int manual_fan; 1200 unsigned int auto_fan; 1201 }; 1202 1203 enum i8k_fan_controls { 1204 I8K_FAN_34A3_35A3, 1205 }; 1206 1207 static const struct i8k_fan_control_data i8k_fan_control_data[] __initconst = { 1208 [I8K_FAN_34A3_35A3] = { 1209 .manual_fan = 0x34a3, 1210 .auto_fan = 0x35a3, 1211 }, 1212 }; 1213 1214 static const struct dmi_system_id i8k_whitelist_fan_control[] __initconst = { 1215 { 1216 .ident = "Dell Latitude 5480", 1217 .matches = { 1218 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1219 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Latitude 5480"), 1220 }, 1221 .driver_data = (void *)&i8k_fan_control_data[I8K_FAN_34A3_35A3], 1222 }, 1223 { 1224 .ident = "Dell Latitude E6440", 1225 .matches = { 1226 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1227 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Latitude E6440"), 1228 }, 1229 .driver_data = (void *)&i8k_fan_control_data[I8K_FAN_34A3_35A3], 1230 }, 1231 { 1232 .ident = "Dell Latitude E7440", 1233 .matches = { 1234 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1235 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Latitude E7440"), 1236 }, 1237 .driver_data = (void *)&i8k_fan_control_data[I8K_FAN_34A3_35A3], 1238 }, 1239 { 1240 .ident = "Dell Precision 5530", 1241 .matches = { 1242 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1243 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Precision 5530"), 1244 }, 1245 .driver_data = (void *)&i8k_fan_control_data[I8K_FAN_34A3_35A3], 1246 }, 1247 { 1248 .ident = "Dell Precision 7510", 1249 .matches = { 1250 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 1251 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Precision 7510"), 1252 }, 1253 .driver_data = (void *)&i8k_fan_control_data[I8K_FAN_34A3_35A3], 1254 }, 1255 { } 1256 }; 1257 1258 static int __init dell_smm_probe(struct platform_device *pdev) 1259 { 1260 struct dell_smm_data *data; 1261 const struct dmi_system_id *id, *fan_control; 1262 int fan, ret; 1263 1264 data = devm_kzalloc(&pdev->dev, sizeof(struct dell_smm_data), GFP_KERNEL); 1265 if (!data) 1266 return -ENOMEM; 1267 1268 mutex_init(&data->i8k_mutex); 1269 data->i8k_fan_mult = I8K_FAN_MULT; 1270 data->i8k_fan_max = I8K_FAN_HIGH; 1271 platform_set_drvdata(pdev, data); 1272 1273 if (dmi_check_system(i8k_blacklist_fan_support_dmi_table)) { 1274 dev_warn(&pdev->dev, "broken Dell BIOS detected, disallow fan support\n"); 1275 if (!force) 1276 data->disallow_fan_support = true; 1277 } 1278 1279 if (dmi_check_system(i8k_blacklist_fan_type_dmi_table)) { 1280 dev_warn(&pdev->dev, "broken Dell BIOS detected, disallow fan type call\n"); 1281 if (!force) 1282 data->disallow_fan_type_call = true; 1283 } 1284 1285 strscpy(data->bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION), 1286 sizeof(data->bios_version)); 1287 strscpy(data->bios_machineid, i8k_get_dmi_data(DMI_PRODUCT_SERIAL), 1288 sizeof(data->bios_machineid)); 1289 1290 /* 1291 * Set fan multiplier and maximal fan speed from dmi config 1292 * Values specified in module parameters override values from dmi 1293 */ 1294 id = dmi_first_match(i8k_dmi_table); 1295 if (id && id->driver_data) { 1296 const struct i8k_config_data *conf = id->driver_data; 1297 1298 if (!fan_mult && conf->fan_mult) 1299 fan_mult = conf->fan_mult; 1300 1301 if (!fan_max && conf->fan_max) 1302 fan_max = conf->fan_max; 1303 } 1304 1305 data->i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */ 1306 data->i8k_pwm_mult = DIV_ROUND_UP(255, data->i8k_fan_max); 1307 1308 fan_control = dmi_first_match(i8k_whitelist_fan_control); 1309 if (fan_control && fan_control->driver_data) { 1310 const struct i8k_fan_control_data *control = fan_control->driver_data; 1311 1312 data->manual_fan = control->manual_fan; 1313 data->auto_fan = control->auto_fan; 1314 dev_info(&pdev->dev, "enabling support for setting automatic/manual fan control\n"); 1315 } 1316 1317 if (!fan_mult) { 1318 /* 1319 * Autodetect fan multiplier based on nominal rpm 1320 * If fan reports rpm value too high then set multiplier to 1 1321 */ 1322 for (fan = 0; fan < DELL_SMM_NO_FANS; ++fan) { 1323 ret = i8k_get_fan_nominal_speed(data, fan, data->i8k_fan_max); 1324 if (ret < 0) 1325 continue; 1326 1327 if (ret > I8K_FAN_MAX_RPM) 1328 data->i8k_fan_mult = 1; 1329 break; 1330 } 1331 } else { 1332 /* Fan multiplier was specified in module param or in dmi */ 1333 data->i8k_fan_mult = fan_mult; 1334 } 1335 1336 ret = dell_smm_init_hwmon(&pdev->dev); 1337 if (ret) 1338 return ret; 1339 1340 i8k_init_procfs(&pdev->dev); 1341 1342 return 0; 1343 } 1344 1345 static struct platform_driver dell_smm_driver = { 1346 .driver = { 1347 .name = KBUILD_MODNAME, 1348 }, 1349 }; 1350 1351 static struct platform_device *dell_smm_device; 1352 1353 /* 1354 * Probe for the presence of a supported laptop. 1355 */ 1356 static int __init i8k_init(void) 1357 { 1358 /* 1359 * Get DMI information 1360 */ 1361 if (!dmi_check_system(i8k_dmi_table)) { 1362 if (!ignore_dmi && !force) 1363 return -ENODEV; 1364 1365 pr_info("not running on a supported Dell system.\n"); 1366 pr_info("vendor=%s, model=%s, version=%s\n", 1367 i8k_get_dmi_data(DMI_SYS_VENDOR), 1368 i8k_get_dmi_data(DMI_PRODUCT_NAME), 1369 i8k_get_dmi_data(DMI_BIOS_VERSION)); 1370 } 1371 1372 /* 1373 * Get SMM Dell signature 1374 */ 1375 if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) && 1376 i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) { 1377 pr_err("unable to get SMM Dell signature\n"); 1378 if (!force) 1379 return -ENODEV; 1380 } 1381 1382 dell_smm_device = platform_create_bundle(&dell_smm_driver, dell_smm_probe, NULL, 0, NULL, 1383 0); 1384 1385 return PTR_ERR_OR_ZERO(dell_smm_device); 1386 } 1387 1388 static void __exit i8k_exit(void) 1389 { 1390 platform_device_unregister(dell_smm_device); 1391 platform_driver_unregister(&dell_smm_driver); 1392 } 1393 1394 module_init(i8k_init); 1395 module_exit(i8k_exit); 1396