1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * dell-smm-hwmon.c -- Linux driver for accessing the SMM BIOS on Dell laptops.
5 * Copyright (C) 2001 Massimo Dal Zotto <dz@debian.org>
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.rohar@gmail.com>
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/cpu.h>
16 #include <linux/delay.h>
17 #include <linux/module.h>
18 #include <linux/types.h>
19 #include <linux/init.h>
20 #include <linux/proc_fs.h>
21 #include <linux/seq_file.h>
22 #include <linux/dmi.h>
23 #include <linux/capability.h>
24 #include <linux/mutex.h>
25 #include <linux/hwmon.h>
26 #include <linux/hwmon-sysfs.h>
27 #include <linux/uaccess.h>
29 #include <linux/sched.h>
30 #include <linux/ctype.h>
31 #include <linux/smp.h>
33 #include <linux/i8k.h>
35 #define I8K_SMM_FN_STATUS 0x0025
36 #define I8K_SMM_POWER_STATUS 0x0069
37 #define I8K_SMM_SET_FAN 0x01a3
38 #define I8K_SMM_GET_FAN 0x00a3
39 #define I8K_SMM_GET_SPEED 0x02a3
40 #define I8K_SMM_GET_FAN_TYPE 0x03a3
41 #define I8K_SMM_GET_NOM_SPEED 0x04a3
42 #define I8K_SMM_GET_TEMP 0x10a3
43 #define I8K_SMM_GET_TEMP_TYPE 0x11a3
44 #define I8K_SMM_GET_DELL_SIG1 0xfea3
45 #define I8K_SMM_GET_DELL_SIG2 0xffa3
47 #define I8K_FAN_MULT 30
48 #define I8K_FAN_MAX_RPM 30000
49 #define I8K_MAX_TEMP 127
51 #define I8K_FN_NONE 0x00
52 #define I8K_FN_UP 0x01
53 #define I8K_FN_DOWN 0x02
54 #define I8K_FN_MUTE 0x04
55 #define I8K_FN_MASK 0x07
56 #define I8K_FN_SHIFT 8
58 #define I8K_POWER_AC 0x05
59 #define I8K_POWER_BATTERY 0x01
61 static DEFINE_MUTEX(i8k_mutex);
62 static char bios_version[4];
63 static char bios_machineid[16];
64 static struct device *i8k_hwmon_dev;
65 static u32 i8k_hwmon_flags;
66 static uint i8k_fan_mult = I8K_FAN_MULT;
67 static uint i8k_pwm_mult;
68 static uint i8k_fan_max = I8K_FAN_HIGH;
69 static bool disallow_fan_type_call;
70 static bool disallow_fan_support;
72 #define I8K_HWMON_HAVE_TEMP1 (1 << 0)
73 #define I8K_HWMON_HAVE_TEMP2 (1 << 1)
74 #define I8K_HWMON_HAVE_TEMP3 (1 << 2)
75 #define I8K_HWMON_HAVE_TEMP4 (1 << 3)
76 #define I8K_HWMON_HAVE_TEMP5 (1 << 4)
77 #define I8K_HWMON_HAVE_TEMP6 (1 << 5)
78 #define I8K_HWMON_HAVE_TEMP7 (1 << 6)
79 #define I8K_HWMON_HAVE_TEMP8 (1 << 7)
80 #define I8K_HWMON_HAVE_TEMP9 (1 << 8)
81 #define I8K_HWMON_HAVE_TEMP10 (1 << 9)
82 #define I8K_HWMON_HAVE_FAN1 (1 << 10)
83 #define I8K_HWMON_HAVE_FAN2 (1 << 11)
84 #define I8K_HWMON_HAVE_FAN3 (1 << 12)
86 MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)");
87 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
88 MODULE_DESCRIPTION("Dell laptop SMM BIOS hwmon driver");
89 MODULE_LICENSE("GPL");
93 module_param(force, bool, 0);
94 MODULE_PARM_DESC(force, "Force loading without checking for supported models");
96 static bool ignore_dmi;
97 module_param(ignore_dmi, bool, 0);
98 MODULE_PARM_DESC(ignore_dmi, "Continue probing hardware even if DMI data does not match");
100 #if IS_ENABLED(CONFIG_I8K)
101 static bool restricted = true;
102 module_param(restricted, bool, 0);
103 MODULE_PARM_DESC(restricted, "Restrict fan control and serial number to CAP_SYS_ADMIN (default: 1)");
105 static bool power_status;
106 module_param(power_status, bool, 0600);
107 MODULE_PARM_DESC(power_status, "Report power status in /proc/i8k (default: 0)");
110 static uint fan_mult;
111 module_param(fan_mult, uint, 0);
112 MODULE_PARM_DESC(fan_mult, "Factor to multiply fan speed with (default: autodetect)");
115 module_param(fan_max, uint, 0);
116 MODULE_PARM_DESC(fan_max, "Maximum configurable fan speed (default: autodetect)");
120 unsigned int ebx __packed;
121 unsigned int ecx __packed;
122 unsigned int edx __packed;
123 unsigned int esi __packed;
124 unsigned int edi __packed;
127 static inline const char *i8k_get_dmi_data(int field)
129 const char *dmi_data = dmi_get_system_info(field);
131 return dmi_data && *dmi_data ? dmi_data : "?";
135 * Call the System Management Mode BIOS. Code provided by Jonathan Buzzard.
137 static int i8k_smm_func(void *par)
140 struct smm_regs *regs = par;
145 unsigned long duration;
146 ktime_t calltime, delta, rettime;
148 calltime = ktime_get();
151 /* SMM requires CPU 0 */
152 if (smp_processor_id() != 0)
155 #if defined(CONFIG_X86_64)
156 asm volatile("pushq %%rax\n\t"
157 "movl 0(%%rax),%%edx\n\t"
159 "movl 4(%%rax),%%ebx\n\t"
160 "movl 8(%%rax),%%ecx\n\t"
161 "movl 12(%%rax),%%edx\n\t"
162 "movl 16(%%rax),%%esi\n\t"
163 "movl 20(%%rax),%%edi\n\t"
167 "xchgq %%rax,(%%rsp)\n\t"
168 "movl %%ebx,4(%%rax)\n\t"
169 "movl %%ecx,8(%%rax)\n\t"
170 "movl %%edx,12(%%rax)\n\t"
171 "movl %%esi,16(%%rax)\n\t"
172 "movl %%edi,20(%%rax)\n\t"
174 "movl %%edx,0(%%rax)\n\t"
180 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory");
182 asm volatile("pushl %%eax\n\t"
183 "movl 0(%%eax),%%edx\n\t"
185 "movl 4(%%eax),%%ebx\n\t"
186 "movl 8(%%eax),%%ecx\n\t"
187 "movl 12(%%eax),%%edx\n\t"
188 "movl 16(%%eax),%%esi\n\t"
189 "movl 20(%%eax),%%edi\n\t"
193 "xchgl %%eax,(%%esp)\n\t"
194 "movl %%ebx,4(%%eax)\n\t"
195 "movl %%ecx,8(%%eax)\n\t"
196 "movl %%edx,12(%%eax)\n\t"
197 "movl %%esi,16(%%eax)\n\t"
198 "movl %%edi,20(%%eax)\n\t"
200 "movl %%edx,0(%%eax)\n\t"
206 : "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory");
208 if (rc != 0 || (regs->eax & 0xffff) == 0xffff || regs->eax == eax)
212 rettime = ktime_get();
213 delta = ktime_sub(rettime, calltime);
214 duration = ktime_to_ns(delta) >> 10;
215 pr_debug("smm(0x%.4x 0x%.4x) = 0x%.4x (took %7lu usecs)\n", eax, ebx,
216 (rc ? 0xffff : regs->eax & 0xffff), duration);
223 * Call the System Management Mode BIOS.
225 static int i8k_smm(struct smm_regs *regs)
230 ret = smp_call_on_cpu(0, i8k_smm_func, regs, true);
237 * Read the fan status.
239 static int i8k_get_fan_status(int fan)
241 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN, };
243 if (disallow_fan_support)
246 regs.ebx = fan & 0xff;
247 return i8k_smm(®s) ? : regs.eax & 0xff;
251 * Read the fan speed in RPM.
253 static int i8k_get_fan_speed(int fan)
255 struct smm_regs regs = { .eax = I8K_SMM_GET_SPEED, };
257 if (disallow_fan_support)
260 regs.ebx = fan & 0xff;
261 return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult;
267 static int _i8k_get_fan_type(int fan)
269 struct smm_regs regs = { .eax = I8K_SMM_GET_FAN_TYPE, };
271 if (disallow_fan_support || disallow_fan_type_call)
274 regs.ebx = fan & 0xff;
275 return i8k_smm(®s) ? : regs.eax & 0xff;
278 static int i8k_get_fan_type(int fan)
280 /* I8K_SMM_GET_FAN_TYPE SMM call is expensive, so cache values */
281 static int types[3] = { INT_MIN, INT_MIN, INT_MIN };
283 if (types[fan] == INT_MIN)
284 types[fan] = _i8k_get_fan_type(fan);
290 * Read the fan nominal rpm for specific fan speed.
292 static int i8k_get_fan_nominal_speed(int fan, int speed)
294 struct smm_regs regs = { .eax = I8K_SMM_GET_NOM_SPEED, };
296 if (disallow_fan_support)
299 regs.ebx = (fan & 0xff) | (speed << 8);
300 return i8k_smm(®s) ? : (regs.eax & 0xffff) * i8k_fan_mult;
304 * Set the fan speed (off, low, high, ...).
306 static int i8k_set_fan(int fan, int speed)
308 struct smm_regs regs = { .eax = I8K_SMM_SET_FAN, };
310 if (disallow_fan_support)
313 speed = (speed < 0) ? 0 : ((speed > i8k_fan_max) ? i8k_fan_max : speed);
314 regs.ebx = (fan & 0xff) | (speed << 8);
316 return i8k_smm(®s);
319 static int i8k_get_temp_type(int sensor)
321 struct smm_regs regs = { .eax = I8K_SMM_GET_TEMP_TYPE, };
323 regs.ebx = sensor & 0xff;
324 return i8k_smm(®s) ? : regs.eax & 0xff;
328 * Read the cpu temperature.
330 static int _i8k_get_temp(int sensor)
332 struct smm_regs regs = {
333 .eax = I8K_SMM_GET_TEMP,
334 .ebx = sensor & 0xff,
337 return i8k_smm(®s) ? : regs.eax & 0xff;
340 static int i8k_get_temp(int sensor)
342 int temp = _i8k_get_temp(sensor);
345 * Sometimes the temperature sensor returns 0x99, which is out of range.
346 * In this case we retry (once) before returning an error.
347 # 1003655137 00000058 00005a4b
348 # 1003655138 00000099 00003a80 <--- 0x99 = 153 degrees
349 # 1003655139 00000054 00005c52
353 temp = _i8k_get_temp(sensor);
356 * Return -ENODATA for all invalid temperatures.
358 * Known instances are the 0x99 value as seen above as well as
359 * 0xc1 (193), which may be returned when trying to read the GPU
360 * temperature if the system supports a GPU and it is currently
363 if (temp > I8K_MAX_TEMP)
369 static int i8k_get_dell_signature(int req_fn)
371 struct smm_regs regs = { .eax = req_fn, };
378 return regs.eax == 1145651527 && regs.edx == 1145392204 ? 0 : -1;
381 #if IS_ENABLED(CONFIG_I8K)
384 * Read the Fn key status.
386 static int i8k_get_fn_status(void)
388 struct smm_regs regs = { .eax = I8K_SMM_FN_STATUS, };
395 switch ((regs.eax >> I8K_FN_SHIFT) & I8K_FN_MASK) {
408 * Read the power status.
410 static int i8k_get_power_status(void)
412 struct smm_regs regs = { .eax = I8K_SMM_POWER_STATUS, };
419 return (regs.eax & 0xff) == I8K_POWER_AC ? I8K_AC : I8K_BATTERY;
427 i8k_ioctl_unlocked(struct file *fp, unsigned int cmd, unsigned long arg)
431 unsigned char buff[16];
432 int __user *argp = (int __user *)arg;
438 case I8K_BIOS_VERSION:
439 if (!isdigit(bios_version[0]) || !isdigit(bios_version[1]) ||
440 !isdigit(bios_version[2]))
443 val = (bios_version[0] << 16) |
444 (bios_version[1] << 8) | bios_version[2];
448 if (restricted && !capable(CAP_SYS_ADMIN))
451 memset(buff, 0, sizeof(buff));
452 strlcpy(buff, bios_machineid, sizeof(buff));
456 val = i8k_get_fn_status();
459 case I8K_POWER_STATUS:
460 val = i8k_get_power_status();
464 val = i8k_get_temp(0);
468 if (copy_from_user(&val, argp, sizeof(int)))
471 val = i8k_get_fan_speed(val);
475 if (copy_from_user(&val, argp, sizeof(int)))
478 val = i8k_get_fan_status(val);
482 if (restricted && !capable(CAP_SYS_ADMIN))
485 if (copy_from_user(&val, argp, sizeof(int)))
488 if (copy_from_user(&speed, argp + 1, sizeof(int)))
491 err = i8k_set_fan(val, speed);
495 val = i8k_get_fan_status(val);
506 case I8K_BIOS_VERSION:
507 if (copy_to_user(argp, &val, 4))
512 if (copy_to_user(argp, buff, 16))
517 if (copy_to_user(argp, &val, sizeof(int)))
526 static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
530 mutex_lock(&i8k_mutex);
531 ret = i8k_ioctl_unlocked(fp, cmd, arg);
532 mutex_unlock(&i8k_mutex);
538 * Print the information for /proc/i8k.
540 static int i8k_proc_show(struct seq_file *seq, void *offset)
542 int fn_key, cpu_temp, ac_power;
543 int left_fan, right_fan, left_speed, right_speed;
545 cpu_temp = i8k_get_temp(0); /* 11100 µs */
546 left_fan = i8k_get_fan_status(I8K_FAN_LEFT); /* 580 µs */
547 right_fan = i8k_get_fan_status(I8K_FAN_RIGHT); /* 580 µs */
548 left_speed = i8k_get_fan_speed(I8K_FAN_LEFT); /* 580 µs */
549 right_speed = i8k_get_fan_speed(I8K_FAN_RIGHT); /* 580 µs */
550 fn_key = i8k_get_fn_status(); /* 750 µs */
552 ac_power = i8k_get_power_status(); /* 14700 µs */
559 * 1) Format version (this will change if format changes)
564 * 6) Right fan status
570 seq_printf(seq, "%s %s %s %d %d %d %d %d %d %d\n",
573 (restricted && !capable(CAP_SYS_ADMIN)) ? "-1" : bios_machineid,
575 left_fan, right_fan, left_speed, right_speed,
581 static int i8k_open_fs(struct inode *inode, struct file *file)
583 return single_open(file, i8k_proc_show, NULL);
586 static const struct file_operations i8k_fops = {
587 .owner = THIS_MODULE,
591 .release = single_release,
592 .unlocked_ioctl = i8k_ioctl,
595 static struct proc_dir_entry *entry;
597 static void __init i8k_init_procfs(void)
599 /* Register the proc entry */
600 entry = proc_create("i8k", 0, NULL, &i8k_fops);
603 static void __exit i8k_exit_procfs(void)
606 remove_proc_entry("i8k", NULL);
611 static inline void __init i8k_init_procfs(void)
615 static inline void __exit i8k_exit_procfs(void)
625 static ssize_t i8k_hwmon_temp_label_show(struct device *dev,
626 struct device_attribute *devattr,
629 static const char * const labels[] = {
637 int index = to_sensor_dev_attr(devattr)->index;
640 type = i8k_get_temp_type(index);
643 if (type >= ARRAY_SIZE(labels))
644 type = ARRAY_SIZE(labels) - 1;
645 return sprintf(buf, "%s\n", labels[type]);
648 static ssize_t i8k_hwmon_temp_show(struct device *dev,
649 struct device_attribute *devattr,
652 int index = to_sensor_dev_attr(devattr)->index;
655 temp = i8k_get_temp(index);
658 return sprintf(buf, "%d\n", temp * 1000);
661 static ssize_t i8k_hwmon_fan_label_show(struct device *dev,
662 struct device_attribute *devattr,
665 static const char * const labels[] = {
673 int index = to_sensor_dev_attr(devattr)->index;
677 type = i8k_get_fan_type(index);
686 if (type >= ARRAY_SIZE(labels))
687 type = (ARRAY_SIZE(labels) - 1);
689 return sprintf(buf, "%s%s\n", (dock ? "Docking " : ""), labels[type]);
692 static ssize_t i8k_hwmon_fan_show(struct device *dev,
693 struct device_attribute *devattr, char *buf)
695 int index = to_sensor_dev_attr(devattr)->index;
698 fan_speed = i8k_get_fan_speed(index);
701 return sprintf(buf, "%d\n", fan_speed);
704 static ssize_t i8k_hwmon_pwm_show(struct device *dev,
705 struct device_attribute *devattr, char *buf)
707 int index = to_sensor_dev_attr(devattr)->index;
710 status = i8k_get_fan_status(index);
713 return sprintf(buf, "%d\n", clamp_val(status * i8k_pwm_mult, 0, 255));
716 static ssize_t i8k_hwmon_pwm_store(struct device *dev,
717 struct device_attribute *attr,
718 const char *buf, size_t count)
720 int index = to_sensor_dev_attr(attr)->index;
724 err = kstrtoul(buf, 10, &val);
727 val = clamp_val(DIV_ROUND_CLOSEST(val, i8k_pwm_mult), 0, i8k_fan_max);
729 mutex_lock(&i8k_mutex);
730 err = i8k_set_fan(index, val);
731 mutex_unlock(&i8k_mutex);
733 return err < 0 ? -EIO : count;
736 static SENSOR_DEVICE_ATTR_RO(temp1_input, i8k_hwmon_temp, 0);
737 static SENSOR_DEVICE_ATTR_RO(temp1_label, i8k_hwmon_temp_label, 0);
738 static SENSOR_DEVICE_ATTR_RO(temp2_input, i8k_hwmon_temp, 1);
739 static SENSOR_DEVICE_ATTR_RO(temp2_label, i8k_hwmon_temp_label, 1);
740 static SENSOR_DEVICE_ATTR_RO(temp3_input, i8k_hwmon_temp, 2);
741 static SENSOR_DEVICE_ATTR_RO(temp3_label, i8k_hwmon_temp_label, 2);
742 static SENSOR_DEVICE_ATTR_RO(temp4_input, i8k_hwmon_temp, 3);
743 static SENSOR_DEVICE_ATTR_RO(temp4_label, i8k_hwmon_temp_label, 3);
744 static SENSOR_DEVICE_ATTR_RO(temp5_input, i8k_hwmon_temp, 4);
745 static SENSOR_DEVICE_ATTR_RO(temp5_label, i8k_hwmon_temp_label, 4);
746 static SENSOR_DEVICE_ATTR_RO(temp6_input, i8k_hwmon_temp, 5);
747 static SENSOR_DEVICE_ATTR_RO(temp6_label, i8k_hwmon_temp_label, 5);
748 static SENSOR_DEVICE_ATTR_RO(temp7_input, i8k_hwmon_temp, 6);
749 static SENSOR_DEVICE_ATTR_RO(temp7_label, i8k_hwmon_temp_label, 6);
750 static SENSOR_DEVICE_ATTR_RO(temp8_input, i8k_hwmon_temp, 7);
751 static SENSOR_DEVICE_ATTR_RO(temp8_label, i8k_hwmon_temp_label, 7);
752 static SENSOR_DEVICE_ATTR_RO(temp9_input, i8k_hwmon_temp, 8);
753 static SENSOR_DEVICE_ATTR_RO(temp9_label, i8k_hwmon_temp_label, 8);
754 static SENSOR_DEVICE_ATTR_RO(temp10_input, i8k_hwmon_temp, 9);
755 static SENSOR_DEVICE_ATTR_RO(temp10_label, i8k_hwmon_temp_label, 9);
756 static SENSOR_DEVICE_ATTR_RO(fan1_input, i8k_hwmon_fan, 0);
757 static SENSOR_DEVICE_ATTR_RO(fan1_label, i8k_hwmon_fan_label, 0);
758 static SENSOR_DEVICE_ATTR_RW(pwm1, i8k_hwmon_pwm, 0);
759 static SENSOR_DEVICE_ATTR_RO(fan2_input, i8k_hwmon_fan, 1);
760 static SENSOR_DEVICE_ATTR_RO(fan2_label, i8k_hwmon_fan_label, 1);
761 static SENSOR_DEVICE_ATTR_RW(pwm2, i8k_hwmon_pwm, 1);
762 static SENSOR_DEVICE_ATTR_RO(fan3_input, i8k_hwmon_fan, 2);
763 static SENSOR_DEVICE_ATTR_RO(fan3_label, i8k_hwmon_fan_label, 2);
764 static SENSOR_DEVICE_ATTR_RW(pwm3, i8k_hwmon_pwm, 2);
766 static struct attribute *i8k_attrs[] = {
767 &sensor_dev_attr_temp1_input.dev_attr.attr, /* 0 */
768 &sensor_dev_attr_temp1_label.dev_attr.attr, /* 1 */
769 &sensor_dev_attr_temp2_input.dev_attr.attr, /* 2 */
770 &sensor_dev_attr_temp2_label.dev_attr.attr, /* 3 */
771 &sensor_dev_attr_temp3_input.dev_attr.attr, /* 4 */
772 &sensor_dev_attr_temp3_label.dev_attr.attr, /* 5 */
773 &sensor_dev_attr_temp4_input.dev_attr.attr, /* 6 */
774 &sensor_dev_attr_temp4_label.dev_attr.attr, /* 7 */
775 &sensor_dev_attr_temp5_input.dev_attr.attr, /* 8 */
776 &sensor_dev_attr_temp5_label.dev_attr.attr, /* 9 */
777 &sensor_dev_attr_temp6_input.dev_attr.attr, /* 10 */
778 &sensor_dev_attr_temp6_label.dev_attr.attr, /* 11 */
779 &sensor_dev_attr_temp7_input.dev_attr.attr, /* 12 */
780 &sensor_dev_attr_temp7_label.dev_attr.attr, /* 13 */
781 &sensor_dev_attr_temp8_input.dev_attr.attr, /* 14 */
782 &sensor_dev_attr_temp8_label.dev_attr.attr, /* 15 */
783 &sensor_dev_attr_temp9_input.dev_attr.attr, /* 16 */
784 &sensor_dev_attr_temp9_label.dev_attr.attr, /* 17 */
785 &sensor_dev_attr_temp10_input.dev_attr.attr, /* 18 */
786 &sensor_dev_attr_temp10_label.dev_attr.attr, /* 19 */
787 &sensor_dev_attr_fan1_input.dev_attr.attr, /* 20 */
788 &sensor_dev_attr_fan1_label.dev_attr.attr, /* 21 */
789 &sensor_dev_attr_pwm1.dev_attr.attr, /* 22 */
790 &sensor_dev_attr_fan2_input.dev_attr.attr, /* 23 */
791 &sensor_dev_attr_fan2_label.dev_attr.attr, /* 24 */
792 &sensor_dev_attr_pwm2.dev_attr.attr, /* 25 */
793 &sensor_dev_attr_fan3_input.dev_attr.attr, /* 26 */
794 &sensor_dev_attr_fan3_label.dev_attr.attr, /* 27 */
795 &sensor_dev_attr_pwm3.dev_attr.attr, /* 28 */
799 static umode_t i8k_is_visible(struct kobject *kobj, struct attribute *attr,
802 if (disallow_fan_support && index >= 20)
804 if (disallow_fan_type_call &&
805 (index == 21 || index == 25 || index == 28))
807 if (index >= 0 && index <= 1 &&
808 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP1))
810 if (index >= 2 && index <= 3 &&
811 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP2))
813 if (index >= 4 && index <= 5 &&
814 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP3))
816 if (index >= 6 && index <= 7 &&
817 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP4))
819 if (index >= 8 && index <= 9 &&
820 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP5))
822 if (index >= 10 && index <= 11 &&
823 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP6))
825 if (index >= 12 && index <= 13 &&
826 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP7))
828 if (index >= 14 && index <= 15 &&
829 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP8))
831 if (index >= 16 && index <= 17 &&
832 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP9))
834 if (index >= 18 && index <= 19 &&
835 !(i8k_hwmon_flags & I8K_HWMON_HAVE_TEMP10))
838 if (index >= 20 && index <= 22 &&
839 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN1))
841 if (index >= 23 && index <= 25 &&
842 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN2))
844 if (index >= 26 && index <= 28 &&
845 !(i8k_hwmon_flags & I8K_HWMON_HAVE_FAN3))
851 static const struct attribute_group i8k_group = {
853 .is_visible = i8k_is_visible,
855 __ATTRIBUTE_GROUPS(i8k);
857 static int __init i8k_init_hwmon(void)
863 /* CPU temperature attributes, if temperature type is OK */
864 err = i8k_get_temp_type(0);
866 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP1;
867 /* check for additional temperature sensors */
868 err = i8k_get_temp_type(1);
870 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP2;
871 err = i8k_get_temp_type(2);
873 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP3;
874 err = i8k_get_temp_type(3);
876 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP4;
877 err = i8k_get_temp_type(4);
879 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP5;
880 err = i8k_get_temp_type(5);
882 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP6;
883 err = i8k_get_temp_type(6);
885 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP7;
886 err = i8k_get_temp_type(7);
888 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP8;
889 err = i8k_get_temp_type(8);
891 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP9;
892 err = i8k_get_temp_type(9);
894 i8k_hwmon_flags |= I8K_HWMON_HAVE_TEMP10;
896 /* First fan attributes, if fan status or type is OK */
897 err = i8k_get_fan_status(0);
899 err = i8k_get_fan_type(0);
901 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN1;
903 /* Second fan attributes, if fan status or type is OK */
904 err = i8k_get_fan_status(1);
906 err = i8k_get_fan_type(1);
908 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN2;
910 /* Third fan attributes, if fan status or type is OK */
911 err = i8k_get_fan_status(2);
913 err = i8k_get_fan_type(2);
915 i8k_hwmon_flags |= I8K_HWMON_HAVE_FAN3;
917 i8k_hwmon_dev = hwmon_device_register_with_groups(NULL, "dell_smm",
919 if (IS_ERR(i8k_hwmon_dev)) {
920 err = PTR_ERR(i8k_hwmon_dev);
921 i8k_hwmon_dev = NULL;
922 pr_err("hwmon registration failed (%d)\n", err);
928 struct i8k_config_data {
940 static const struct i8k_config_data i8k_config_data[] = {
941 [DELL_LATITUDE_D520] = {
943 .fan_max = I8K_FAN_TURBO,
945 [DELL_PRECISION_490] = {
947 .fan_max = I8K_FAN_TURBO,
951 .fan_max = I8K_FAN_HIGH,
955 .fan_max = I8K_FAN_HIGH,
959 static const struct dmi_system_id i8k_dmi_table[] __initconst = {
961 .ident = "Dell Inspiron",
963 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"),
964 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"),
968 .ident = "Dell Latitude",
970 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer"),
971 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"),
975 .ident = "Dell Inspiron 2",
977 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
978 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron"),
982 .ident = "Dell Latitude D520",
984 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
985 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude D520"),
987 .driver_data = (void *)&i8k_config_data[DELL_LATITUDE_D520],
990 .ident = "Dell Latitude 2",
992 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
993 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"),
996 { /* UK Inspiron 6400 */
997 .ident = "Dell Inspiron 3",
999 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1000 DMI_MATCH(DMI_PRODUCT_NAME, "MM061"),
1004 .ident = "Dell Inspiron 3",
1006 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1007 DMI_MATCH(DMI_PRODUCT_NAME, "MP061"),
1011 .ident = "Dell Precision 490",
1013 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1014 DMI_MATCH(DMI_PRODUCT_NAME,
1015 "Precision WorkStation 490"),
1017 .driver_data = (void *)&i8k_config_data[DELL_PRECISION_490],
1020 .ident = "Dell Precision",
1022 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1023 DMI_MATCH(DMI_PRODUCT_NAME, "Precision"),
1027 .ident = "Dell Vostro",
1029 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1030 DMI_MATCH(DMI_PRODUCT_NAME, "Vostro"),
1034 .ident = "Dell XPS421",
1036 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1037 DMI_MATCH(DMI_PRODUCT_NAME, "XPS L421X"),
1041 .ident = "Dell Studio",
1043 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1044 DMI_MATCH(DMI_PRODUCT_NAME, "Studio"),
1046 .driver_data = (void *)&i8k_config_data[DELL_STUDIO],
1049 .ident = "Dell XPS 13",
1051 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1052 DMI_MATCH(DMI_PRODUCT_NAME, "XPS13"),
1054 .driver_data = (void *)&i8k_config_data[DELL_XPS],
1057 .ident = "Dell XPS M140",
1059 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1060 DMI_MATCH(DMI_PRODUCT_NAME, "MXC051"),
1062 .driver_data = (void *)&i8k_config_data[DELL_XPS],
1065 .ident = "Dell XPS 15 9560",
1067 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1068 DMI_MATCH(DMI_PRODUCT_NAME, "XPS 15 9560"),
1072 .ident = "Dell XPS 15 9570",
1074 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1075 DMI_MATCH(DMI_PRODUCT_NAME, "XPS 15 9570"),
1081 MODULE_DEVICE_TABLE(dmi, i8k_dmi_table);
1084 * On some machines once I8K_SMM_GET_FAN_TYPE is issued then CPU fan speed
1085 * randomly going up and down due to bug in Dell SMM or BIOS. Here is blacklist
1086 * of affected Dell machines for which we disallow I8K_SMM_GET_FAN_TYPE call.
1087 * See bug: https://bugzilla.kernel.org/show_bug.cgi?id=100121
1089 static const struct dmi_system_id i8k_blacklist_fan_type_dmi_table[] __initconst = {
1091 .ident = "Dell Studio XPS 8000",
1093 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1094 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8000"),
1098 .ident = "Dell Studio XPS 8100",
1100 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1101 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Studio XPS 8100"),
1105 .ident = "Dell Inspiron 580",
1107 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1108 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Inspiron 580 "),
1115 * On some machines all fan related SMM functions implemented by Dell BIOS
1116 * firmware freeze kernel for about 500ms. Until Dell fixes these problems fan
1117 * support for affected blacklisted Dell machines stay disabled.
1118 * See bug: https://bugzilla.kernel.org/show_bug.cgi?id=195751
1120 static struct dmi_system_id i8k_blacklist_fan_support_dmi_table[] __initdata = {
1122 .ident = "Dell Inspiron 7720",
1124 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1125 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Inspiron 7720"),
1129 .ident = "Dell Vostro 3360",
1131 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1132 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Vostro 3360"),
1136 .ident = "Dell XPS13 9333",
1138 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1139 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS13 9333"),
1146 * Probe for the presence of a supported laptop.
1148 static int __init i8k_probe(void)
1150 const struct dmi_system_id *id;
1154 * Get DMI information
1156 if (!dmi_check_system(i8k_dmi_table)) {
1157 if (!ignore_dmi && !force)
1160 pr_info("not running on a supported Dell system.\n");
1161 pr_info("vendor=%s, model=%s, version=%s\n",
1162 i8k_get_dmi_data(DMI_SYS_VENDOR),
1163 i8k_get_dmi_data(DMI_PRODUCT_NAME),
1164 i8k_get_dmi_data(DMI_BIOS_VERSION));
1167 if (dmi_check_system(i8k_blacklist_fan_support_dmi_table)) {
1168 pr_warn("broken Dell BIOS detected, disallow fan support\n");
1170 disallow_fan_support = true;
1173 if (dmi_check_system(i8k_blacklist_fan_type_dmi_table)) {
1174 pr_warn("broken Dell BIOS detected, disallow fan type call\n");
1176 disallow_fan_type_call = true;
1179 strlcpy(bios_version, i8k_get_dmi_data(DMI_BIOS_VERSION),
1180 sizeof(bios_version));
1181 strlcpy(bios_machineid, i8k_get_dmi_data(DMI_PRODUCT_SERIAL),
1182 sizeof(bios_machineid));
1185 * Get SMM Dell signature
1187 if (i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG1) &&
1188 i8k_get_dell_signature(I8K_SMM_GET_DELL_SIG2)) {
1189 pr_err("unable to get SMM Dell signature\n");
1195 * Set fan multiplier and maximal fan speed from dmi config
1196 * Values specified in module parameters override values from dmi
1198 id = dmi_first_match(i8k_dmi_table);
1199 if (id && id->driver_data) {
1200 const struct i8k_config_data *conf = id->driver_data;
1201 if (!fan_mult && conf->fan_mult)
1202 fan_mult = conf->fan_mult;
1203 if (!fan_max && conf->fan_max)
1204 fan_max = conf->fan_max;
1207 i8k_fan_max = fan_max ? : I8K_FAN_HIGH; /* Must not be 0 */
1208 i8k_pwm_mult = DIV_ROUND_UP(255, i8k_fan_max);
1212 * Autodetect fan multiplier based on nominal rpm
1213 * If fan reports rpm value too high then set multiplier to 1
1215 for (fan = 0; fan < 2; ++fan) {
1216 ret = i8k_get_fan_nominal_speed(fan, i8k_fan_max);
1219 if (ret > I8K_FAN_MAX_RPM)
1224 /* Fan multiplier was specified in module param or in dmi */
1225 i8k_fan_mult = fan_mult;
1231 static int __init i8k_init(void)
1235 /* Are we running on an supported laptop? */
1239 err = i8k_init_hwmon();
1247 static void __exit i8k_exit(void)
1249 hwmon_device_unregister(i8k_hwmon_dev);
1253 module_init(i8k_init);
1254 module_exit(i8k_exit);