drivers/hwmon/dell-smm-hwmon.c

   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(&regs) ? : 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(&regs) ? : (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(&regs) ? : 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(&regs) ? : (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(&regs);
 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(&regs);
 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(&regs) ? : 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(&regs) ? : 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(&regs);
 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(&regs);
 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(&regs);
 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);