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