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