cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

dell-smm-hwmon.c (33897B)


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