1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Acer WMI Laptop Extras
4	*
5	* Copyright (C) 2007-2009 Carlos Corbacho <carlos@strangeworlds.co.uk>
6	*
7	* Based on acer_acpi:
8	* Copyright (C) 2005-2007 E.M. Smith
9	* Copyright (C) 2007-2008 Carlos Corbacho <cathectic@gmail.com>
10	*/
11
12	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14	#include <linux/kernel.h>
15	#include <linux/module.h>
16	#include <linux/init.h>
17	#include <linux/types.h>
18	#include <linux/dmi.h>
19	#include <linux/fb.h>
20	#include <linux/backlight.h>
21	#include <linux/leds.h>
22	#include <linux/platform_device.h>
23	#include <linux/platform_profile.h>
24	#include <linux/acpi.h>
25	#include <linux/i8042.h>
26	#include <linux/rfkill.h>
27	#include <linux/workqueue.h>
28	#include <linux/debugfs.h>
29	#include <linux/slab.h>
30	#include <linux/input.h>
31	#include <linux/input/sparse-keymap.h>
32	#include <acpi/video.h>
33	#include <linux/hwmon.h>
34	#include <linux/bitfield.h>
35
36	MODULE_AUTHOR("Carlos Corbacho");
37	MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
38	MODULE_LICENSE("GPL");
39
40	/*
41	* Magic Number
42	* Meaning is unknown - this number is required for writing to ACPI for AMW0
43	* (it's also used in acerhk when directly accessing the BIOS)
44	*/
45	#define ACER_AMW0_WRITE 0x9610
46
47	/*
48	* Bit masks for the AMW0 interface
49	*/
50	#define ACER_AMW0_WIRELESS_MASK 0x35
51	#define ACER_AMW0_BLUETOOTH_MASK 0x34
52	#define ACER_AMW0_MAILLED_MASK 0x31
53
54	/*
55	* Method IDs for WMID interface
56	*/
57	#define ACER_WMID_GET_WIRELESS_METHODID 1
58	#define ACER_WMID_GET_BLUETOOTH_METHODID 2
59	#define ACER_WMID_GET_BRIGHTNESS_METHODID 3
60	#define ACER_WMID_SET_WIRELESS_METHODID 4
61	#define ACER_WMID_SET_BLUETOOTH_METHODID 5
62	#define ACER_WMID_SET_BRIGHTNESS_METHODID 6
63	#define ACER_WMID_GET_THREEG_METHODID 10
64	#define ACER_WMID_SET_THREEG_METHODID 11
65
66	#define ACER_WMID_SET_GAMING_LED_METHODID 2
67	#define ACER_WMID_GET_GAMING_LED_METHODID 4
68	#define ACER_WMID_GET_GAMING_SYS_INFO_METHODID 5
69	#define ACER_WMID_SET_GAMING_FAN_BEHAVIOR 14
70	#define ACER_WMID_SET_GAMING_MISC_SETTING_METHODID 22
71
72	#define ACER_PREDATOR_V4_THERMAL_PROFILE_EC_OFFSET 0x54
73
74	#define ACER_PREDATOR_V4_FAN_SPEED_READ_BIT_MASK GENMASK(20, 8)
75
76	/*
77	* Acer ACPI method GUIDs
78	*/
79	#define AMW0_GUID1 "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
80	#define AMW0_GUID2 "431F16ED-0C2B-444C-B267-27DEB140CF9C"
81	#define WMID_GUID1 "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"
82	#define WMID_GUID2 "95764E09-FB56-4E83-B31A-37761F60994A"
83	#define WMID_GUID3 "61EF69EA-865C-4BC3-A502-A0DEBA0CB531"
84	#define WMID_GUID4 "7A4DDFE7-5B5D-40B4-8595-4408E0CC7F56"
85
86	/*
87	* Acer ACPI event GUIDs
88	*/
89	#define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026"
90
91	MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
92	MODULE_ALIAS("wmi:6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3");
93	MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026");
94
95	enum acer_wmi_event_ids {
96	WMID_HOTKEY_EVENT = 0x1,
97	WMID_ACCEL_OR_KBD_DOCK_EVENT = 0x5,
98	WMID_GAMING_TURBO_KEY_EVENT = 0x7,
99	};
100
101	enum acer_wmi_predator_v4_sys_info_command {
102	ACER_WMID_CMD_GET_PREDATOR_V4_BAT_STATUS = 0x02,
103	ACER_WMID_CMD_GET_PREDATOR_V4_CPU_FAN_SPEED = 0x0201,
104	ACER_WMID_CMD_GET_PREDATOR_V4_GPU_FAN_SPEED = 0x0601,
105	};
106
107	static const struct key_entry acer_wmi_keymap[] __initconst = {
108	{KE_KEY, 0x01, {KEY_WLAN} }, /* WiFi */
109	{KE_KEY, 0x03, {KEY_WLAN} }, /* WiFi */
110	{KE_KEY, 0x04, {KEY_WLAN} }, /* WiFi */
111	{KE_KEY, 0x12, {KEY_BLUETOOTH} }, /* BT */
112	{KE_KEY, 0x21, {KEY_PROG1} }, /* Backup */
113	{KE_KEY, 0x22, {KEY_PROG2} }, /* Arcade */
114	{KE_KEY, 0x23, {KEY_PROG3} }, /* P_Key */
115	{KE_KEY, 0x24, {KEY_PROG4} }, /* Social networking_Key */
116	{KE_KEY, 0x27, {KEY_HELP} },
117	{KE_KEY, 0x29, {KEY_PROG3} }, /* P_Key for TM8372 */
118	{KE_IGNORE, 0x41, {KEY_MUTE} },
119	{KE_IGNORE, 0x42, {KEY_PREVIOUSSONG} },
120	{KE_IGNORE, 0x4d, {KEY_PREVIOUSSONG} },
121	{KE_IGNORE, 0x43, {KEY_NEXTSONG} },
122	{KE_IGNORE, 0x4e, {KEY_NEXTSONG} },
123	{KE_IGNORE, 0x44, {KEY_PLAYPAUSE} },
124	{KE_IGNORE, 0x4f, {KEY_PLAYPAUSE} },
125	{KE_IGNORE, 0x45, {KEY_STOP} },
126	{KE_IGNORE, 0x50, {KEY_STOP} },
127	{KE_IGNORE, 0x48, {KEY_VOLUMEUP} },
128	{KE_IGNORE, 0x49, {KEY_VOLUMEDOWN} },
129	{KE_IGNORE, 0x4a, {KEY_VOLUMEDOWN} },
130	/*
131	* 0x61 is KEY_SWITCHVIDEOMODE. Usually this is a duplicate input event
132	* with the "Video Bus" input device events. But sometimes it is not
133	* a dup. Map it to KEY_UNKNOWN instead of using KE_IGNORE so that
134	* udev/hwdb can override it on systems where it is not a dup.
135	*/
136	{KE_KEY, 0x61, {KEY_UNKNOWN} },
137	{KE_IGNORE, 0x62, {KEY_BRIGHTNESSUP} },
138	{KE_IGNORE, 0x63, {KEY_BRIGHTNESSDOWN} },
139	{KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
140	{KE_IGNORE, 0x81, {KEY_SLEEP} },
141	{KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad Toggle */
142	{KE_IGNORE, 0x84, {KEY_KBDILLUMTOGGLE} }, /* Automatic Keyboard background light toggle */
143	{KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} },
144	{KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },
145	{KE_IGNORE, 0x83, {KEY_TOUCHPAD_TOGGLE} },
146	{KE_KEY, 0x85, {KEY_TOUCHPAD_TOGGLE} },
147	{KE_KEY, 0x86, {KEY_WLAN} },
148	{KE_KEY, 0x87, {KEY_POWER} },
149	{KE_END, 0}
150	};
151
152	static struct input_dev *acer_wmi_input_dev;
153	static struct input_dev *acer_wmi_accel_dev;
154
155	struct event_return_value {
156	u8 function;
157	u8 key_num;
158	u16 device_state;
159	u16 reserved1;
160	u8 kbd_dock_state;
161	u8 reserved2;
162	} __packed;
163
164	/*
165	* GUID3 Get Device Status device flags
166	*/
167	#define ACER_WMID3_GDS_WIRELESS (1<<0) /* WiFi */
168	#define ACER_WMID3_GDS_THREEG (1<<6) /* 3G */
169	#define ACER_WMID3_GDS_WIMAX (1<<7) /* WiMAX */
170	#define ACER_WMID3_GDS_BLUETOOTH (1<<11) /* BT */
171	#define ACER_WMID3_GDS_RFBTN (1<<14) /* RF Button */
172
173	#define ACER_WMID3_GDS_TOUCHPAD (1<<1) /* Touchpad */
174
175	/* Hotkey Customized Setting and Acer Application Status.
176	* Set Device Default Value and Report Acer Application Status.
177	* When Acer Application starts, it will run this method to inform
178	* BIOS/EC that Acer Application is on.
179	* App Status
180	* Bit[0]: Launch Manager Status
181	* Bit[1]: ePM Status
182	* Bit[2]: Device Control Status
183	* Bit[3]: Acer Power Button Utility Status
184	* Bit[4]: RF Button Status
185	* Bit[5]: ODD PM Status
186	* Bit[6]: Device Default Value Control
187	* Bit[7]: Hall Sensor Application Status
188	*/
189	struct func_input_params {
190	u8 function_num; /* Function Number */
191	u16 commun_devices; /* Communication type devices default status */
192	u16 devices; /* Other type devices default status */
193	u8 app_status; /* Acer Device Status. LM, ePM, RF Button... */
194	u8 app_mask; /* Bit mask to app_status */
195	u8 reserved;
196	} __packed;
197
198	struct func_return_value {
199	u8 error_code; /* Error Code */
200	u8 ec_return_value; /* EC Return Value */
201	u16 reserved;
202	} __packed;
203
204	struct wmid3_gds_set_input_param { /* Set Device Status input parameter */
205	u8 function_num; /* Function Number */
206	u8 hotkey_number; /* Hotkey Number */
207	u16 devices; /* Set Device */
208	u8 volume_value; /* Volume Value */
209	} __packed;
210
211	struct wmid3_gds_get_input_param { /* Get Device Status input parameter */
212	u8 function_num; /* Function Number */
213	u8 hotkey_number; /* Hotkey Number */
214	u16 devices; /* Get Device */
215	} __packed;
216
217	struct wmid3_gds_return_value { /* Get Device Status return value*/
218	u8 error_code; /* Error Code */
219	u8 ec_return_value; /* EC Return Value */
220	u16 devices; /* Current Device Status */
221	u32 reserved;
222	} __packed;
223
224	struct hotkey_function_type_aa {
225	u8 type;
226	u8 length;
227	u16 handle;
228	u16 commun_func_bitmap;
229	u16 application_func_bitmap;
230	u16 media_func_bitmap;
231	u16 display_func_bitmap;
232	u16 others_func_bitmap;
233	u8 commun_fn_key_number;
234	} __packed;
235
236	/*
237	* Interface capability flags
238	*/
239	#define ACER_CAP_MAILLED BIT(0)
240	#define ACER_CAP_WIRELESS BIT(1)
241	#define ACER_CAP_BLUETOOTH BIT(2)
242	#define ACER_CAP_BRIGHTNESS BIT(3)
243	#define ACER_CAP_THREEG BIT(4)
244	#define ACER_CAP_SET_FUNCTION_MODE BIT(5)
245	#define ACER_CAP_KBD_DOCK BIT(6)
246	#define ACER_CAP_TURBO_OC BIT(7)
247	#define ACER_CAP_TURBO_LED BIT(8)
248	#define ACER_CAP_TURBO_FAN BIT(9)
249	#define ACER_CAP_PLATFORM_PROFILE BIT(10)
250	#define ACER_CAP_FAN_SPEED_READ BIT(11)
251
252	/*
253	* Interface type flags
254	*/
255	enum interface_flags {
256	ACER_AMW0,
257	ACER_AMW0_V2,
258	ACER_WMID,
259	ACER_WMID_v2,
260	};
261
262	#define ACER_DEFAULT_WIRELESS 0
263	#define ACER_DEFAULT_BLUETOOTH 0
264	#define ACER_DEFAULT_MAILLED 0
265	#define ACER_DEFAULT_THREEG 0
266
267	static int max_brightness = 0xF;
268
269	static int mailled = -1;
270	static int brightness = -1;
271	static int threeg = -1;
272	static int force_series;
273	static int force_caps = -1;
274	static bool ec_raw_mode;
275	static bool has_type_aa;
276	static u16 commun_func_bitmap;
277	static u8 commun_fn_key_number;
278	static bool cycle_gaming_thermal_profile = true;
279	static bool predator_v4;
280
281	module_param(mailled, int, 0444);
282	module_param(brightness, int, 0444);
283	module_param(threeg, int, 0444);
284	module_param(force_series, int, 0444);
285	module_param(force_caps, int, 0444);
286	module_param(ec_raw_mode, bool, 0444);
287	module_param(cycle_gaming_thermal_profile, bool, 0644);
288	module_param(predator_v4, bool, 0444);
289	MODULE_PARM_DESC(mailled, "Set initial state of Mail LED");
290	MODULE_PARM_DESC(brightness, "Set initial LCD backlight brightness");
291	MODULE_PARM_DESC(threeg, "Set initial state of 3G hardware");
292	MODULE_PARM_DESC(force_series, "Force a different laptop series");
293	MODULE_PARM_DESC(force_caps, "Force the capability bitmask to this value");
294	MODULE_PARM_DESC(ec_raw_mode, "Enable EC raw mode");
295	MODULE_PARM_DESC(cycle_gaming_thermal_profile,
296	"Set thermal mode key in cycle mode. Disabling it sets the mode key in turbo toggle mode");
297	MODULE_PARM_DESC(predator_v4,
298	"Enable features for predator laptops that use predator sense v4");
299
300	struct acer_data {
301	int mailled;
302	int threeg;
303	int brightness;
304	};
305
306	struct acer_debug {
307	struct dentry *root;
308	u32 wmid_devices;
309	};
310
311	static struct rfkill *wireless_rfkill;
312	static struct rfkill *bluetooth_rfkill;
313	static struct rfkill *threeg_rfkill;
314	static bool rfkill_inited;
315
316	/* Each low-level interface must define at least some of the following */
317	struct wmi_interface {
318	/* The WMI device type */
319	u32 type;
320
321	/* The capabilities this interface provides */
322	u32 capability;
323
324	/* Private data for the current interface */
325	struct acer_data data;
326
327	/* debugfs entries associated with this interface */
328	struct acer_debug debug;
329	};
330
331	/* The static interface pointer, points to the currently detected interface */
332	static struct wmi_interface *interface;
333
334	/*
335	* Embedded Controller quirks
336	* Some laptops require us to directly access the EC to either enable or query
337	* features that are not available through WMI.
338	*/
339
340	struct quirk_entry {
341	u8 wireless;
342	u8 mailled;
343	s8 brightness;
344	u8 bluetooth;
345	u8 turbo;
346	u8 cpu_fans;
347	u8 gpu_fans;
348	u8 predator_v4;
349	};
350
351	static struct quirk_entry *quirks;
352
353	static void __init set_quirks(void)
354	{
355	if (quirks->mailled)
356	interface->capability |= ACER_CAP_MAILLED;
357
358	if (quirks->brightness)
359	interface->capability |= ACER_CAP_BRIGHTNESS;
360
361	if (quirks->turbo)
362	interface->capability |= ACER_CAP_TURBO_OC | ACER_CAP_TURBO_LED
363	| ACER_CAP_TURBO_FAN;
364
365	if (quirks->predator_v4)
366	interface->capability |= ACER_CAP_PLATFORM_PROFILE |
367	ACER_CAP_FAN_SPEED_READ;
368	}
369
370	static int __init dmi_matched(const struct dmi_system_id *dmi)
371	{
372	quirks = dmi->driver_data;
373	return 1;
374	}
375
376	static int __init set_force_caps(const struct dmi_system_id *dmi)
377	{
378	if (force_caps == -1) {
379	force_caps = (uintptr_t)dmi->driver_data;
380	pr_info("Found %s, set force_caps to 0x%x\n", dmi->ident, force_caps);
381	}
382	return 1;
383	}
384
385	static struct quirk_entry quirk_unknown = {
386	};
387
388	static struct quirk_entry quirk_acer_aspire_1520 = {
389	.brightness = -1,
390	};
391
392	static struct quirk_entry quirk_acer_travelmate_2490 = {
393	.mailled = 1,
394	};
395
396	static struct quirk_entry quirk_acer_predator_ph315_53 = {
397	.turbo = 1,
398	.cpu_fans = 1,
399	.gpu_fans = 1,
400	};
401
402	static struct quirk_entry quirk_acer_predator_v4 = {
403	.predator_v4 = 1,
404	};
405
406	/* This AMW0 laptop has no bluetooth */
407	static struct quirk_entry quirk_medion_md_98300 = {
408	.wireless = 1,
409	};
410
411	static struct quirk_entry quirk_fujitsu_amilo_li_1718 = {
412	.wireless = 2,
413	};
414
415	static struct quirk_entry quirk_lenovo_ideapad_s205 = {
416	.wireless = 3,
417	};
418
419	/* The Aspire One has a dummy ACPI-WMI interface - disable it */
420	static const struct dmi_system_id acer_blacklist[] __initconst = {
421	{
422	.ident = "Acer Aspire One (SSD)",
423	.matches = {
424	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
425	DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"),
426	},
427	},
428	{
429	.ident = "Acer Aspire One (HDD)",
430	.matches = {
431	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
432	DMI_MATCH(DMI_PRODUCT_NAME, "AOA150"),
433	},
434	},
435	{}
436	};
437
438	static const struct dmi_system_id amw0_whitelist[] __initconst = {
439	{
440	.ident = "Acer",
441	.matches = {
442	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
443	},
444	},
445	{
446	.ident = "Gateway",
447	.matches = {
448	DMI_MATCH(DMI_SYS_VENDOR, "Gateway"),
449	},
450	},
451	{
452	.ident = "Packard Bell",
453	.matches = {
454	DMI_MATCH(DMI_SYS_VENDOR, "Packard Bell"),
455	},
456	},
457	{}
458	};
459
460	/*
461	* This quirk table is only for Acer/Gateway/Packard Bell family
462	* that those machines are supported by acer-wmi driver.
463	*/
464	static const struct dmi_system_id acer_quirks[] __initconst = {
465	{
466	.callback = dmi_matched,
467	.ident = "Acer Aspire 1360",
468	.matches = {
469	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
470	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1360"),
471	},
472	.driver_data = &quirk_acer_aspire_1520,
473	},
474	{
475	.callback = dmi_matched,
476	.ident = "Acer Aspire 1520",
477	.matches = {
478	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
479	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1520"),
480	},
481	.driver_data = &quirk_acer_aspire_1520,
482	},
483	{
484	.callback = dmi_matched,
485	.ident = "Acer Aspire 3100",
486	.matches = {
487	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
488	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3100"),
489	},
490	.driver_data = &quirk_acer_travelmate_2490,
491	},
492	{
493	.callback = dmi_matched,
494	.ident = "Acer Aspire 3610",
495	.matches = {
496	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
497	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3610"),
498	},
499	.driver_data = &quirk_acer_travelmate_2490,
500	},
501	{
502	.callback = dmi_matched,
503	.ident = "Acer Aspire 5100",
504	.matches = {
505	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
506	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5100"),
507	},
508	.driver_data = &quirk_acer_travelmate_2490,
509	},
510	{
511	.callback = dmi_matched,
512	.ident = "Acer Aspire 5610",
513	.matches = {
514	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
515	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5610"),
516	},
517	.driver_data = &quirk_acer_travelmate_2490,
518	},
519	{
520	.callback = dmi_matched,
521	.ident = "Acer Aspire 5630",
522	.matches = {
523	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
524	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"),
525	},
526	.driver_data = &quirk_acer_travelmate_2490,
527	},
528	{
529	.callback = dmi_matched,
530	.ident = "Acer Aspire 5650",
531	.matches = {
532	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
533	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"),
534	},
535	.driver_data = &quirk_acer_travelmate_2490,
536	},
537	{
538	.callback = dmi_matched,
539	.ident = "Acer Aspire 5680",
540	.matches = {
541	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
542	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"),
543	},
544	.driver_data = &quirk_acer_travelmate_2490,
545	},
546	{
547	.callback = dmi_matched,
548	.ident = "Acer Aspire 9110",
549	.matches = {
550	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
551	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"),
552	},
553	.driver_data = &quirk_acer_travelmate_2490,
554	},
555	{
556	.callback = dmi_matched,
557	.ident = "Acer TravelMate 2490",
558	.matches = {
559	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
560	DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"),
561	},
562	.driver_data = &quirk_acer_travelmate_2490,
563	},
564	{
565	.callback = dmi_matched,
566	.ident = "Acer TravelMate 4200",
567	.matches = {
568	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
569	DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4200"),
570	},
571	.driver_data = &quirk_acer_travelmate_2490,
572	},
573	{
574	.callback = dmi_matched,
575	.ident = "Acer Predator PH315-53",
576	.matches = {
577	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
578	DMI_MATCH(DMI_PRODUCT_NAME, "Predator PH315-53"),
579	},
580	.driver_data = &quirk_acer_predator_ph315_53,
581	},
582	{
583	.callback = dmi_matched,
584	.ident = "Acer Predator PHN16-71",
585	.matches = {
586	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
587	DMI_MATCH(DMI_PRODUCT_NAME, "Predator PHN16-71"),
588	},
589	.driver_data = &quirk_acer_predator_v4,
590	},
591	{
592	.callback = dmi_matched,
593	.ident = "Acer Predator PH16-71",
594	.matches = {
595	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
596	DMI_MATCH(DMI_PRODUCT_NAME, "Predator PH16-71"),
597	},
598	.driver_data = &quirk_acer_predator_v4,
599	},
600	{
601	.callback = dmi_matched,
602	.ident = "Acer Predator PH18-71",
603	.matches = {
604	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
605	DMI_MATCH(DMI_PRODUCT_NAME, "Predator PH18-71"),
606	},
607	.driver_data = &quirk_acer_predator_v4,
608	},
609	{
610	.callback = set_force_caps,
611	.ident = "Acer Aspire Switch 10E SW3-016",
612	.matches = {
613	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
614	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW3-016"),
615	},
616	.driver_data = (void *)ACER_CAP_KBD_DOCK,
617	},
618	{
619	.callback = set_force_caps,
620	.ident = "Acer Aspire Switch 10 SW5-012",
621	.matches = {
622	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
623	DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
624	},
625	.driver_data = (void *)ACER_CAP_KBD_DOCK,
626	},
627	{
628	.callback = set_force_caps,
629	.ident = "Acer Aspire Switch V 10 SW5-017",
630	.matches = {
631	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
632	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SW5-017"),
633	},
634	.driver_data = (void *)ACER_CAP_KBD_DOCK,
635	},
636	{
637	.callback = set_force_caps,
638	.ident = "Acer One 10 (S1003)",
639	.matches = {
640	DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
641	DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "One S1003"),
642	},
643	.driver_data = (void *)ACER_CAP_KBD_DOCK,
644	},
645	{}
646	};
647
648	/*
649	* This quirk list is for those non-acer machines that have AMW0_GUID1
650	* but supported by acer-wmi in past days. Keeping this quirk list here
651	* is only for backward compatible. Please do not add new machine to
652	* here anymore. Those non-acer machines should be supported by
653	* appropriate wmi drivers.
654	*/
655	static const struct dmi_system_id non_acer_quirks[] __initconst = {
656	{
657	.callback = dmi_matched,
658	.ident = "Fujitsu Siemens Amilo Li 1718",
659	.matches = {
660	DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
661	DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Li 1718"),
662	},
663	.driver_data = &quirk_fujitsu_amilo_li_1718,
664	},
665	{
666	.callback = dmi_matched,
667	.ident = "Medion MD 98300",
668	.matches = {
669	DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
670	DMI_MATCH(DMI_PRODUCT_NAME, "WAM2030"),
671	},
672	.driver_data = &quirk_medion_md_98300,
673	},
674	{
675	.callback = dmi_matched,
676	.ident = "Lenovo Ideapad S205",
677	.matches = {
678	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
679	DMI_MATCH(DMI_PRODUCT_NAME, "10382LG"),
680	},
681	.driver_data = &quirk_lenovo_ideapad_s205,
682	},
683	{
684	.callback = dmi_matched,
685	.ident = "Lenovo Ideapad S205 (Brazos)",
686	.matches = {
687	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
688	DMI_MATCH(DMI_PRODUCT_NAME, "Brazos"),
689	},
690	.driver_data = &quirk_lenovo_ideapad_s205,
691	},
692	{
693	.callback = dmi_matched,
694	.ident = "Lenovo 3000 N200",
695	.matches = {
696	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
697	DMI_MATCH(DMI_PRODUCT_NAME, "0687A31"),
698	},
699	.driver_data = &quirk_fujitsu_amilo_li_1718,
700	},
701	{
702	.callback = dmi_matched,
703	.ident = "Lenovo Ideapad S205-10382JG",
704	.matches = {
705	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
706	DMI_MATCH(DMI_PRODUCT_NAME, "10382JG"),
707	},
708	.driver_data = &quirk_lenovo_ideapad_s205,
709	},
710	{
711	.callback = dmi_matched,
712	.ident = "Lenovo Ideapad S205-1038DPG",
713	.matches = {
714	DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
715	DMI_MATCH(DMI_PRODUCT_NAME, "1038DPG"),
716	},
717	.driver_data = &quirk_lenovo_ideapad_s205,
718	},
719	{}
720	};
721
722	static struct platform_profile_handler platform_profile_handler;
723	static bool platform_profile_support;
724
725	/*
726	* The profile used before turbo mode. This variable is needed for
727	* returning from turbo mode when the mode key is in toggle mode.
728	*/
729	static int last_non_turbo_profile;
730
731	enum acer_predator_v4_thermal_profile_ec {
732	ACER_PREDATOR_V4_THERMAL_PROFILE_ECO = 0x04,
733	ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO = 0x03,
734	ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE = 0x02,
735	ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET = 0x01,
736	ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED = 0x00,
737	};
738
739	enum acer_predator_v4_thermal_profile_wmi {
740	ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI = 0x060B,
741	ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI = 0x050B,
742	ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE_WMI = 0x040B,
743	ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET_WMI = 0x0B,
744	ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI = 0x010B,
745	};
746
747	/* Find which quirks are needed for a particular vendor/ model pair */
748	static void __init find_quirks(void)
749	{
750	if (predator_v4) {
751	quirks = &quirk_acer_predator_v4;
752	} else if (!force_series) {
753	dmi_check_system(list: acer_quirks);
754	dmi_check_system(list: non_acer_quirks);
755	} else if (force_series == 2490) {
756	quirks = &quirk_acer_travelmate_2490;
757	}
758
759	if (quirks == NULL)
760	quirks = &quirk_unknown;
761	}
762
763	/*
764	* General interface convenience methods
765	*/
766
767	static bool has_cap(u32 cap)
768	{
769	return interface->capability & cap;
770	}
771
772	/*
773	* AMW0 (V1) interface
774	*/
775	struct wmab_args {
776	u32 eax;
777	u32 ebx;
778	u32 ecx;
779	u32 edx;
780	};
781
782	struct wmab_ret {
783	u32 eax;
784	u32 ebx;
785	u32 ecx;
786	u32 edx;
787	u32 eex;
788	};
789
790	static acpi_status wmab_execute(struct wmab_args *regbuf,
791	struct acpi_buffer *result)
792	{
793	struct acpi_buffer input;
794	acpi_status status;
795	input.length = sizeof(struct wmab_args);
796	input.pointer = (u8 *)regbuf;
797
798	status = wmi_evaluate_method(AMW0_GUID1, instance: 0, method_id: 1, in: &input, out: result);
799
800	return status;
801	}
802
803	static acpi_status AMW0_get_u32(u32 *value, u32 cap)
804	{
805	int err;
806	u8 result;
807
808	switch (cap) {
809	case ACER_CAP_MAILLED:
810	switch (quirks->mailled) {
811	default:
812	err = ec_read(addr: 0xA, val: &result);
813	if (err)
814	return AE_ERROR;
815	*value = (result >> 7) & 0x1;
816	return AE_OK;
817	}
818	break;
819	case ACER_CAP_WIRELESS:
820	switch (quirks->wireless) {
821	case 1:
822	err = ec_read(addr: 0x7B, val: &result);
823	if (err)
824	return AE_ERROR;
825	*value = result & 0x1;
826	return AE_OK;
827	case 2:
828	err = ec_read(addr: 0x71, val: &result);
829	if (err)
830	return AE_ERROR;
831	*value = result & 0x1;
832	return AE_OK;
833	case 3:
834	err = ec_read(addr: 0x78, val: &result);
835	if (err)
836	return AE_ERROR;
837	*value = result & 0x1;
838	return AE_OK;
839	default:
840	err = ec_read(addr: 0xA, val: &result);
841	if (err)
842	return AE_ERROR;
843	*value = (result >> 2) & 0x1;
844	return AE_OK;
845	}
846	break;
847	case ACER_CAP_BLUETOOTH:
848	switch (quirks->bluetooth) {
849	default:
850	err = ec_read(addr: 0xA, val: &result);
851	if (err)
852	return AE_ERROR;
853	*value = (result >> 4) & 0x1;
854	return AE_OK;
855	}
856	break;
857	case ACER_CAP_BRIGHTNESS:
858	switch (quirks->brightness) {
859	default:
860	err = ec_read(addr: 0x83, val: &result);
861	if (err)
862	return AE_ERROR;
863	*value = result;
864	return AE_OK;
865	}
866	break;
867	default:
868	return AE_ERROR;
869	}
870	return AE_OK;
871	}
872
873	static acpi_status AMW0_set_u32(u32 value, u32 cap)
874	{
875	struct wmab_args args;
876
877	args.eax = ACER_AMW0_WRITE;
878	args.ebx = value ? (1<<8) : 0;
879	args.ecx = args.edx = 0;
880
881	switch (cap) {
882	case ACER_CAP_MAILLED:
883	if (value > 1)
884	return AE_BAD_PARAMETER;
885	args.ebx |= ACER_AMW0_MAILLED_MASK;
886	break;
887	case ACER_CAP_WIRELESS:
888	if (value > 1)
889	return AE_BAD_PARAMETER;
890	args.ebx |= ACER_AMW0_WIRELESS_MASK;
891	break;
892	case ACER_CAP_BLUETOOTH:
893	if (value > 1)
894	return AE_BAD_PARAMETER;
895	args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
896	break;
897	case ACER_CAP_BRIGHTNESS:
898	if (value > max_brightness)
899	return AE_BAD_PARAMETER;
900	switch (quirks->brightness) {
901	default:
902	return ec_write(addr: 0x83, val: value);
903	}
904	default:
905	return AE_ERROR;
906	}
907
908	/* Actually do the set */
909	return wmab_execute(regbuf: &args, NULL);
910	}
911
912	static acpi_status __init AMW0_find_mailled(void)
913	{
914	struct wmab_args args;
915	struct wmab_ret ret;
916	acpi_status status = AE_OK;
917	struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
918	union acpi_object *obj;
919
920	args.eax = 0x86;
921	args.ebx = args.ecx = args.edx = 0;
922
923	status = wmab_execute(regbuf: &args, result: &out);
924	if (ACPI_FAILURE(status))
925	return status;
926
927	obj = (union acpi_object *) out.pointer;
928	if (obj && obj->type == ACPI_TYPE_BUFFER &&
929	obj->buffer.length == sizeof(struct wmab_ret)) {
930	ret = *((struct wmab_ret *) obj->buffer.pointer);
931	} else {
932	kfree(objp: out.pointer);
933	return AE_ERROR;
934	}
935
936	if (ret.eex & 0x1)
937	interface->capability |= ACER_CAP_MAILLED;
938
939	kfree(objp: out.pointer);
940
941	return AE_OK;
942	}
943
944	static const struct acpi_device_id norfkill_ids[] __initconst = {
945	{ "VPC2004", 0},
946	{ "IBM0068", 0},
947	{ "LEN0068", 0},
948	{ "SNY5001", 0}, /* sony-laptop in charge */
949	{ "HPQ6601", 0},
950	{ "", 0},
951	};
952
953	static int __init AMW0_set_cap_acpi_check_device(void)
954	{
955	const struct acpi_device_id *id;
956
957	for (id = norfkill_ids; id->id[0]; id++)
958	if (acpi_dev_found(hid: id->id))
959	return true;
960
961	return false;
962	}
963
964	static acpi_status __init AMW0_set_capabilities(void)
965	{
966	struct wmab_args args;
967	struct wmab_ret ret;
968	acpi_status status;
969	struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
970	union acpi_object *obj;
971
972	/*
973	* On laptops with this strange GUID (non Acer), normal probing doesn't
974	* work.
975	*/
976	if (wmi_has_guid(AMW0_GUID2)) {
977	if ((quirks != &quirk_unknown) ||
978	!AMW0_set_cap_acpi_check_device())
979	interface->capability |= ACER_CAP_WIRELESS;
980	return AE_OK;
981	}
982
983	args.eax = ACER_AMW0_WRITE;
984	args.ecx = args.edx = 0;
985
986	args.ebx = 0xa2 << 8;
987	args.ebx |= ACER_AMW0_WIRELESS_MASK;
988
989	status = wmab_execute(regbuf: &args, result: &out);
990	if (ACPI_FAILURE(status))
991	return status;
992
993	obj = out.pointer;
994	if (obj && obj->type == ACPI_TYPE_BUFFER &&
995	obj->buffer.length == sizeof(struct wmab_ret)) {
996	ret = *((struct wmab_ret *) obj->buffer.pointer);
997	} else {
998	status = AE_ERROR;
999	goto out;
1000	}
1001
1002	if (ret.eax & 0x1)
1003	interface->capability |= ACER_CAP_WIRELESS;
1004
1005	args.ebx = 2 << 8;
1006	args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
1007
1008	/*
1009	* It's ok to use existing buffer for next wmab_execute call.
1010	* But we need to kfree(out.pointer) if next wmab_execute fail.
1011	*/
1012	status = wmab_execute(regbuf: &args, result: &out);
1013	if (ACPI_FAILURE(status))
1014	goto out;
1015
1016	obj = (union acpi_object *) out.pointer;
1017	if (obj && obj->type == ACPI_TYPE_BUFFER
1018	&& obj->buffer.length == sizeof(struct wmab_ret)) {
1019	ret = *((struct wmab_ret *) obj->buffer.pointer);
1020	} else {
1021	status = AE_ERROR;
1022	goto out;
1023	}
1024
1025	if (ret.eax & 0x1)
1026	interface->capability |= ACER_CAP_BLUETOOTH;
1027
1028	/*
1029	* This appears to be safe to enable, since all Wistron based laptops
1030	* appear to use the same EC register for brightness, even if they
1031	* differ for wireless, etc
1032	*/
1033	if (quirks->brightness >= 0)
1034	interface->capability |= ACER_CAP_BRIGHTNESS;
1035
1036	status = AE_OK;
1037	out:
1038	kfree(objp: out.pointer);
1039	return status;
1040	}
1041
1042	static struct wmi_interface AMW0_interface = {
1043	.type = ACER_AMW0,
1044	};
1045
1046	static struct wmi_interface AMW0_V2_interface = {
1047	.type = ACER_AMW0_V2,
1048	};
1049
1050	/*
1051	* New interface (The WMID interface)
1052	*/
1053	static acpi_status
1054	WMI_execute_u32(u32 method_id, u32 in, u32 *out)
1055	{
1056	struct acpi_buffer input = { (acpi_size) sizeof(u32), (void *)(&in) };
1057	struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL };
1058	union acpi_object *obj;
1059	u32 tmp = 0;
1060	acpi_status status;
1061
1062	status = wmi_evaluate_method(WMID_GUID1, instance: 0, method_id, in: &input, out: &result);
1063
1064	if (ACPI_FAILURE(status))
1065	return status;
1066
1067	obj = (union acpi_object *) result.pointer;
1068	if (obj) {
1069	if (obj->type == ACPI_TYPE_BUFFER &&
1070	(obj->buffer.length == sizeof(u32) ||
1071	obj->buffer.length == sizeof(u64))) {
1072	tmp = *((u32 *) obj->buffer.pointer);
1073	} else if (obj->type == ACPI_TYPE_INTEGER) {
1074	tmp = (u32) obj->integer.value;
1075	}
1076	}
1077
1078	if (out)
1079	*out = tmp;
1080
1081	kfree(objp: result.pointer);
1082
1083	return status;
1084	}
1085
1086	static acpi_status WMID_get_u32(u32 *value, u32 cap)
1087	{
1088	acpi_status status;
1089	u8 tmp;
1090	u32 result, method_id = 0;
1091
1092	switch (cap) {
1093	case ACER_CAP_WIRELESS:
1094	method_id = ACER_WMID_GET_WIRELESS_METHODID;
1095	break;
1096	case ACER_CAP_BLUETOOTH:
1097	method_id = ACER_WMID_GET_BLUETOOTH_METHODID;
1098	break;
1099	case ACER_CAP_BRIGHTNESS:
1100	method_id = ACER_WMID_GET_BRIGHTNESS_METHODID;
1101	break;
1102	case ACER_CAP_THREEG:
1103	method_id = ACER_WMID_GET_THREEG_METHODID;
1104	break;
1105	case ACER_CAP_MAILLED:
1106	if (quirks->mailled == 1) {
1107	ec_read(addr: 0x9f, val: &tmp);
1108	*value = tmp & 0x1;
1109	return 0;
1110	}
1111	fallthrough;
1112	default:
1113	return AE_ERROR;
1114	}
1115	status = WMI_execute_u32(method_id, in: 0, out: &result);
1116
1117	if (ACPI_SUCCESS(status))
1118	*value = (u8)result;
1119
1120	return status;
1121	}
1122
1123	static acpi_status WMID_set_u32(u32 value, u32 cap)
1124	{
1125	u32 method_id = 0;
1126	char param;
1127
1128	switch (cap) {
1129	case ACER_CAP_BRIGHTNESS:
1130	if (value > max_brightness)
1131	return AE_BAD_PARAMETER;
1132	method_id = ACER_WMID_SET_BRIGHTNESS_METHODID;
1133	break;
1134	case ACER_CAP_WIRELESS:
1135	if (value > 1)
1136	return AE_BAD_PARAMETER;
1137	method_id = ACER_WMID_SET_WIRELESS_METHODID;
1138	break;
1139	case ACER_CAP_BLUETOOTH:
1140	if (value > 1)
1141	return AE_BAD_PARAMETER;
1142	method_id = ACER_WMID_SET_BLUETOOTH_METHODID;
1143	break;
1144	case ACER_CAP_THREEG:
1145	if (value > 1)
1146	return AE_BAD_PARAMETER;
1147	method_id = ACER_WMID_SET_THREEG_METHODID;
1148	break;
1149	case ACER_CAP_MAILLED:
1150	if (value > 1)
1151	return AE_BAD_PARAMETER;
1152	if (quirks->mailled == 1) {
1153	param = value ? 0x92 : 0x93;
1154	i8042_lock_chip();
1155	i8042_command(param: &param, command: 0x1059);
1156	i8042_unlock_chip();
1157	return 0;
1158	}
1159	break;
1160	default:
1161	return AE_ERROR;
1162	}
1163	return WMI_execute_u32(method_id, in: (u32)value, NULL);
1164	}
1165
1166	static acpi_status wmid3_get_device_status(u32 *value, u16 device)
1167	{
1168	struct wmid3_gds_return_value return_value;
1169	acpi_status status;
1170	union acpi_object *obj;
1171	struct wmid3_gds_get_input_param params = {
1172	.function_num = 0x1,
1173	.hotkey_number = commun_fn_key_number,
1174	.devices = device,
1175	};
1176	struct acpi_buffer input = {
1177	sizeof(struct wmid3_gds_get_input_param),
1178	&params
1179	};
1180	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1181
1182	status = wmi_evaluate_method(WMID_GUID3, instance: 0, method_id: 0x2, in: &input, out: &output);
1183	if (ACPI_FAILURE(status))
1184	return status;
1185
1186	obj = output.pointer;
1187
1188	if (!obj)
1189	return AE_ERROR;
1190	else if (obj->type != ACPI_TYPE_BUFFER) {
1191	kfree(objp: obj);
1192	return AE_ERROR;
1193	}
1194	if (obj->buffer.length != 8) {
1195	pr_warn("Unknown buffer length %d\n", obj->buffer.length);
1196	kfree(objp: obj);
1197	return AE_ERROR;
1198	}
1199
1200	return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
1201	kfree(objp: obj);
1202
1203	if (return_value.error_code || return_value.ec_return_value)
1204	pr_warn("Get 0x%x Device Status failed: 0x%x - 0x%x\n",
1205	device,
1206	return_value.error_code,
1207	return_value.ec_return_value);
1208	else
1209	*value = !!(return_value.devices & device);
1210
1211	return status;
1212	}
1213
1214	static acpi_status wmid_v2_get_u32(u32 *value, u32 cap)
1215	{
1216	u16 device;
1217
1218	switch (cap) {
1219	case ACER_CAP_WIRELESS:
1220	device = ACER_WMID3_GDS_WIRELESS;
1221	break;
1222	case ACER_CAP_BLUETOOTH:
1223	device = ACER_WMID3_GDS_BLUETOOTH;
1224	break;
1225	case ACER_CAP_THREEG:
1226	device = ACER_WMID3_GDS_THREEG;
1227	break;
1228	default:
1229	return AE_ERROR;
1230	}
1231	return wmid3_get_device_status(value, device);
1232	}
1233
1234	static acpi_status wmid3_set_device_status(u32 value, u16 device)
1235	{
1236	struct wmid3_gds_return_value return_value;
1237	acpi_status status;
1238	union acpi_object *obj;
1239	u16 devices;
1240	struct wmid3_gds_get_input_param get_params = {
1241	.function_num = 0x1,
1242	.hotkey_number = commun_fn_key_number,
1243	.devices = commun_func_bitmap,
1244	};
1245	struct acpi_buffer get_input = {
1246	sizeof(struct wmid3_gds_get_input_param),
1247	&get_params
1248	};
1249	struct wmid3_gds_set_input_param set_params = {
1250	.function_num = 0x2,
1251	.hotkey_number = commun_fn_key_number,
1252	.devices = commun_func_bitmap,
1253	};
1254	struct acpi_buffer set_input = {
1255	sizeof(struct wmid3_gds_set_input_param),
1256	&set_params
1257	};
1258	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1259	struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL };
1260
1261	status = wmi_evaluate_method(WMID_GUID3, instance: 0, method_id: 0x2, in: &get_input, out: &output);
1262	if (ACPI_FAILURE(status))
1263	return status;
1264
1265	obj = output.pointer;
1266
1267	if (!obj)
1268	return AE_ERROR;
1269	else if (obj->type != ACPI_TYPE_BUFFER) {
1270	kfree(objp: obj);
1271	return AE_ERROR;
1272	}
1273	if (obj->buffer.length != 8) {
1274	pr_warn("Unknown buffer length %d\n", obj->buffer.length);
1275	kfree(objp: obj);
1276	return AE_ERROR;
1277	}
1278
1279	return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
1280	kfree(objp: obj);
1281
1282	if (return_value.error_code || return_value.ec_return_value) {
1283	pr_warn("Get Current Device Status failed: 0x%x - 0x%x\n",
1284	return_value.error_code,
1285	return_value.ec_return_value);
1286	return status;
1287	}
1288
1289	devices = return_value.devices;
1290	set_params.devices = (value) ? (devices | device) : (devices & ~device);
1291
1292	status = wmi_evaluate_method(WMID_GUID3, instance: 0, method_id: 0x1, in: &set_input, out: &output2);
1293	if (ACPI_FAILURE(status))
1294	return status;
1295
1296	obj = output2.pointer;
1297
1298	if (!obj)
1299	return AE_ERROR;
1300	else if (obj->type != ACPI_TYPE_BUFFER) {
1301	kfree(objp: obj);
1302	return AE_ERROR;
1303	}
1304	if (obj->buffer.length != 4) {
1305	pr_warn("Unknown buffer length %d\n", obj->buffer.length);
1306	kfree(objp: obj);
1307	return AE_ERROR;
1308	}
1309
1310	return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
1311	kfree(objp: obj);
1312
1313	if (return_value.error_code || return_value.ec_return_value)
1314	pr_warn("Set Device Status failed: 0x%x - 0x%x\n",
1315	return_value.error_code,
1316	return_value.ec_return_value);
1317
1318	return status;
1319	}
1320
1321	static acpi_status wmid_v2_set_u32(u32 value, u32 cap)
1322	{
1323	u16 device;
1324
1325	switch (cap) {
1326	case ACER_CAP_WIRELESS:
1327	device = ACER_WMID3_GDS_WIRELESS;
1328	break;
1329	case ACER_CAP_BLUETOOTH:
1330	device = ACER_WMID3_GDS_BLUETOOTH;
1331	break;
1332	case ACER_CAP_THREEG:
1333	device = ACER_WMID3_GDS_THREEG;
1334	break;
1335	default:
1336	return AE_ERROR;
1337	}
1338	return wmid3_set_device_status(value, device);
1339	}
1340
1341	static void __init type_aa_dmi_decode(const struct dmi_header *header, void *d)
1342	{
1343	struct hotkey_function_type_aa *type_aa;
1344
1345	/* We are looking for OEM-specific Type AAh */
1346	if (header->type != 0xAA)
1347	return;
1348
1349	has_type_aa = true;
1350	type_aa = (struct hotkey_function_type_aa *) header;
1351
1352	pr_info("Function bitmap for Communication Button: 0x%x\n",
1353	type_aa->commun_func_bitmap);
1354	commun_func_bitmap = type_aa->commun_func_bitmap;
1355
1356	if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_WIRELESS)
1357	interface->capability |= ACER_CAP_WIRELESS;
1358	if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_THREEG)
1359	interface->capability |= ACER_CAP_THREEG;
1360	if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_BLUETOOTH)
1361	interface->capability |= ACER_CAP_BLUETOOTH;
1362	if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_RFBTN)
1363	commun_func_bitmap &= ~ACER_WMID3_GDS_RFBTN;
1364
1365	commun_fn_key_number = type_aa->commun_fn_key_number;
1366	}
1367
1368	static acpi_status __init WMID_set_capabilities(void)
1369	{
1370	struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
1371	union acpi_object *obj;
1372	acpi_status status;
1373	u32 devices;
1374
1375	status = wmi_query_block(WMID_GUID2, instance: 0, out: &out);
1376	if (ACPI_FAILURE(status))
1377	return status;
1378
1379	obj = (union acpi_object *) out.pointer;
1380	if (obj) {
1381	if (obj->type == ACPI_TYPE_BUFFER &&
1382	(obj->buffer.length == sizeof(u32) ||
1383	obj->buffer.length == sizeof(u64))) {
1384	devices = *((u32 *) obj->buffer.pointer);
1385	} else if (obj->type == ACPI_TYPE_INTEGER) {
1386	devices = (u32) obj->integer.value;
1387	} else {
1388	kfree(objp: out.pointer);
1389	return AE_ERROR;
1390	}
1391	} else {
1392	kfree(objp: out.pointer);
1393	return AE_ERROR;
1394	}
1395
1396	pr_info("Function bitmap for Communication Device: 0x%x\n", devices);
1397	if (devices & 0x07)
1398	interface->capability |= ACER_CAP_WIRELESS;
1399	if (devices & 0x40)
1400	interface->capability |= ACER_CAP_THREEG;
1401	if (devices & 0x10)
1402	interface->capability |= ACER_CAP_BLUETOOTH;
1403
1404	if (!(devices & 0x20))
1405	max_brightness = 0x9;
1406
1407	kfree(objp: out.pointer);
1408	return status;
1409	}
1410
1411	static struct wmi_interface wmid_interface = {
1412	.type = ACER_WMID,
1413	};
1414
1415	static struct wmi_interface wmid_v2_interface = {
1416	.type = ACER_WMID_v2,
1417	};
1418
1419	/*
1420	* WMID Gaming interface
1421	*/
1422
1423	static acpi_status
1424	WMI_gaming_execute_u64(u32 method_id, u64 in, u64 *out)
1425	{
1426	struct acpi_buffer input = { (acpi_size) sizeof(u64), (void *)(&in) };
1427	struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL };
1428	union acpi_object *obj;
1429	u64 tmp = 0;
1430	acpi_status status;
1431
1432	status = wmi_evaluate_method(WMID_GUID4, instance: 0, method_id, in: &input, out: &result);
1433
1434	if (ACPI_FAILURE(status))
1435	return status;
1436	obj = (union acpi_object *) result.pointer;
1437
1438	if (obj) {
1439	if (obj->type == ACPI_TYPE_BUFFER) {
1440	if (obj->buffer.length == sizeof(u32))
1441	tmp = *((u32 *) obj->buffer.pointer);
1442	else if (obj->buffer.length == sizeof(u64))
1443	tmp = *((u64 *) obj->buffer.pointer);
1444	} else if (obj->type == ACPI_TYPE_INTEGER) {
1445	tmp = (u64) obj->integer.value;
1446	}
1447	}
1448
1449	if (out)
1450	*out = tmp;
1451
1452	kfree(objp: result.pointer);
1453
1454	return status;
1455	}
1456
1457	static acpi_status WMID_gaming_set_u64(u64 value, u32 cap)
1458	{
1459	u32 method_id = 0;
1460
1461	if (!(interface->capability & cap))
1462	return AE_BAD_PARAMETER;
1463
1464	switch (cap) {
1465	case ACER_CAP_TURBO_LED:
1466	method_id = ACER_WMID_SET_GAMING_LED_METHODID;
1467	break;
1468	case ACER_CAP_TURBO_FAN:
1469	method_id = ACER_WMID_SET_GAMING_FAN_BEHAVIOR;
1470	break;
1471	case ACER_CAP_TURBO_OC:
1472	method_id = ACER_WMID_SET_GAMING_MISC_SETTING_METHODID;
1473	break;
1474	default:
1475	return AE_BAD_PARAMETER;
1476	}
1477
1478	return WMI_gaming_execute_u64(method_id, in: value, NULL);
1479	}
1480
1481	static acpi_status WMID_gaming_get_u64(u64 *value, u32 cap)
1482	{
1483	acpi_status status;
1484	u64 result;
1485	u64 input;
1486	u32 method_id;
1487
1488	if (!(interface->capability & cap))
1489	return AE_BAD_PARAMETER;
1490
1491	switch (cap) {
1492	case ACER_CAP_TURBO_LED:
1493	method_id = ACER_WMID_GET_GAMING_LED_METHODID;
1494	input = 0x1;
1495	break;
1496	default:
1497	return AE_BAD_PARAMETER;
1498	}
1499	status = WMI_gaming_execute_u64(method_id, in: input, out: &result);
1500	if (ACPI_SUCCESS(status))
1501	*value = (u64) result;
1502
1503	return status;
1504	}
1505
1506	static void WMID_gaming_set_fan_mode(u8 fan_mode)
1507	{
1508	/* fan_mode = 1 is used for auto, fan_mode = 2 used for turbo*/
1509	u64 gpu_fan_config1 = 0, gpu_fan_config2 = 0;
1510	int i;
1511
1512	if (quirks->cpu_fans > 0)
1513	gpu_fan_config2 |= 1;
1514	for (i = 0; i < (quirks->cpu_fans + quirks->gpu_fans); ++i)
1515	gpu_fan_config2 |= 1 << (i + 1);
1516	for (i = 0; i < quirks->gpu_fans; ++i)
1517	gpu_fan_config2 |= 1 << (i + 3);
1518	if (quirks->cpu_fans > 0)
1519	gpu_fan_config1 |= fan_mode;
1520	for (i = 0; i < (quirks->cpu_fans + quirks->gpu_fans); ++i)
1521	gpu_fan_config1 |= fan_mode << (2 * i + 2);
1522	for (i = 0; i < quirks->gpu_fans; ++i)
1523	gpu_fan_config1 |= fan_mode << (2 * i + 6);
1524	WMID_gaming_set_u64(value: gpu_fan_config2 | gpu_fan_config1 << 16, ACER_CAP_TURBO_FAN);
1525	}
1526
1527	/*
1528	* Generic Device (interface-independent)
1529	*/
1530
1531	static acpi_status get_u32(u32 *value, u32 cap)
1532	{
1533	acpi_status status = AE_ERROR;
1534
1535	switch (interface->type) {
1536	case ACER_AMW0:
1537	status = AMW0_get_u32(value, cap);
1538	break;
1539	case ACER_AMW0_V2:
1540	if (cap == ACER_CAP_MAILLED) {
1541	status = AMW0_get_u32(value, cap);
1542	break;
1543	}
1544	fallthrough;
1545	case ACER_WMID:
1546	status = WMID_get_u32(value, cap);
1547	break;
1548	case ACER_WMID_v2:
1549	if (cap & (ACER_CAP_WIRELESS |
1550	ACER_CAP_BLUETOOTH |
1551	ACER_CAP_THREEG))
1552	status = wmid_v2_get_u32(value, cap);
1553	else if (wmi_has_guid(WMID_GUID2))
1554	status = WMID_get_u32(value, cap);
1555	break;
1556	}
1557
1558	return status;
1559	}
1560
1561	static acpi_status set_u32(u32 value, u32 cap)
1562	{
1563	acpi_status status;
1564
1565	if (interface->capability & cap) {
1566	switch (interface->type) {
1567	case ACER_AMW0:
1568	return AMW0_set_u32(value, cap);
1569	case ACER_AMW0_V2:
1570	if (cap == ACER_CAP_MAILLED)
1571	return AMW0_set_u32(value, cap);
1572
1573	/*
1574	* On some models, some WMID methods don't toggle
1575	* properly. For those cases, we want to run the AMW0
1576	* method afterwards to be certain we've really toggled
1577	* the device state.
1578	*/
1579	if (cap == ACER_CAP_WIRELESS ||
1580	cap == ACER_CAP_BLUETOOTH) {
1581	status = WMID_set_u32(value, cap);
1582	if (ACPI_FAILURE(status))
1583	return status;
1584
1585	return AMW0_set_u32(value, cap);
1586	}
1587	fallthrough;
1588	case ACER_WMID:
1589	return WMID_set_u32(value, cap);
1590	case ACER_WMID_v2:
1591	if (cap & (ACER_CAP_WIRELESS |
1592	ACER_CAP_BLUETOOTH |
1593	ACER_CAP_THREEG))
1594	return wmid_v2_set_u32(value, cap);
1595	else if (wmi_has_guid(WMID_GUID2))
1596	return WMID_set_u32(value, cap);
1597	fallthrough;
1598	default:
1599	return AE_BAD_PARAMETER;
1600	}
1601	}
1602	return AE_BAD_PARAMETER;
1603	}
1604
1605	static void __init acer_commandline_init(void)
1606	{
1607	/*
1608	* These will all fail silently if the value given is invalid, or the
1609	* capability isn't available on the given interface
1610	*/
1611	if (mailled >= 0)
1612	set_u32(value: mailled, ACER_CAP_MAILLED);
1613	if (!has_type_aa && threeg >= 0)
1614	set_u32(value: threeg, ACER_CAP_THREEG);
1615	if (brightness >= 0)
1616	set_u32(value: brightness, ACER_CAP_BRIGHTNESS);
1617	}
1618
1619	/*
1620	* LED device (Mail LED only, no other LEDs known yet)
1621	*/
1622	static void mail_led_set(struct led_classdev *led_cdev,
1623	enum led_brightness value)
1624	{
1625	set_u32(value, ACER_CAP_MAILLED);
1626	}
1627
1628	static struct led_classdev mail_led = {
1629	.name = "acer-wmi::mail",
1630	.brightness_set = mail_led_set,
1631	};
1632
1633	static int acer_led_init(struct device *dev)
1634	{
1635	return led_classdev_register(parent: dev, led_cdev: &mail_led);
1636	}
1637
1638	static void acer_led_exit(void)
1639	{
1640	set_u32(value: LED_OFF, ACER_CAP_MAILLED);
1641	led_classdev_unregister(led_cdev: &mail_led);
1642	}
1643
1644	/*
1645	* Backlight device
1646	*/
1647	static struct backlight_device *acer_backlight_device;
1648
1649	static int read_brightness(struct backlight_device *bd)
1650	{
1651	u32 value;
1652	get_u32(value: &value, ACER_CAP_BRIGHTNESS);
1653	return value;
1654	}
1655
1656	static int update_bl_status(struct backlight_device *bd)
1657	{
1658	int intensity = backlight_get_brightness(bd);
1659
1660	set_u32(value: intensity, ACER_CAP_BRIGHTNESS);
1661
1662	return 0;
1663	}
1664
1665	static const struct backlight_ops acer_bl_ops = {
1666	.get_brightness = read_brightness,
1667	.update_status = update_bl_status,
1668	};
1669
1670	static int acer_backlight_init(struct device *dev)
1671	{
1672	struct backlight_properties props;
1673	struct backlight_device *bd;
1674
1675	memset(&props, 0, sizeof(struct backlight_properties));
1676	props.type = BACKLIGHT_PLATFORM;
1677	props.max_brightness = max_brightness;
1678	bd = backlight_device_register(name: "acer-wmi", dev, NULL, ops: &acer_bl_ops,
1679	props: &props);
1680	if (IS_ERR(ptr: bd)) {
1681	pr_err("Could not register Acer backlight device\n");
1682	acer_backlight_device = NULL;
1683	return PTR_ERR(ptr: bd);
1684	}
1685
1686	acer_backlight_device = bd;
1687
1688	bd->props.power = FB_BLANK_UNBLANK;
1689	bd->props.brightness = read_brightness(bd);
1690	backlight_update_status(bd);
1691	return 0;
1692	}
1693
1694	static void acer_backlight_exit(void)
1695	{
1696	backlight_device_unregister(bd: acer_backlight_device);
1697	}
1698
1699	/*
1700	* Accelerometer device
1701	*/
1702	static acpi_handle gsensor_handle;
1703
1704	static int acer_gsensor_init(void)
1705	{
1706	acpi_status status;
1707	struct acpi_buffer output;
1708	union acpi_object out_obj;
1709
1710	output.length = sizeof(out_obj);
1711	output.pointer = &out_obj;
1712	status = acpi_evaluate_object(object: gsensor_handle, pathname: "_INI", NULL, return_object_buffer: &output);
1713	if (ACPI_FAILURE(status))
1714	return -1;
1715
1716	return 0;
1717	}
1718
1719	static int acer_gsensor_open(struct input_dev *input)
1720	{
1721	return acer_gsensor_init();
1722	}
1723
1724	static int acer_gsensor_event(void)
1725	{
1726	acpi_status status;
1727	struct acpi_buffer output;
1728	union acpi_object out_obj[5];
1729
1730	if (!acer_wmi_accel_dev)
1731	return -1;
1732
1733	output.length = sizeof(out_obj);
1734	output.pointer = out_obj;
1735
1736	status = acpi_evaluate_object(object: gsensor_handle, pathname: "RDVL", NULL, return_object_buffer: &output);
1737	if (ACPI_FAILURE(status))
1738	return -1;
1739
1740	if (out_obj->package.count != 4)
1741	return -1;
1742
1743	input_report_abs(dev: acer_wmi_accel_dev, ABS_X,
1744	value: (s16)out_obj->package.elements[0].integer.value);
1745	input_report_abs(dev: acer_wmi_accel_dev, ABS_Y,
1746	value: (s16)out_obj->package.elements[1].integer.value);
1747	input_report_abs(dev: acer_wmi_accel_dev, ABS_Z,
1748	value: (s16)out_obj->package.elements[2].integer.value);
1749	input_sync(dev: acer_wmi_accel_dev);
1750	return 0;
1751	}
1752
1753	static int acer_get_fan_speed(int fan)
1754	{
1755	if (quirks->predator_v4) {
1756	acpi_status status;
1757	u64 fanspeed;
1758
1759	status = WMI_gaming_execute_u64(
1760	ACER_WMID_GET_GAMING_SYS_INFO_METHODID,
1761	in: fan == 0 ? ACER_WMID_CMD_GET_PREDATOR_V4_CPU_FAN_SPEED :
1762	ACER_WMID_CMD_GET_PREDATOR_V4_GPU_FAN_SPEED,
1763	out: &fanspeed);
1764
1765	if (ACPI_FAILURE(status))
1766	return -EIO;
1767
1768	return FIELD_GET(ACER_PREDATOR_V4_FAN_SPEED_READ_BIT_MASK, fanspeed);
1769	}
1770	return -EOPNOTSUPP;
1771	}
1772
1773	/*
1774	* Predator series turbo button
1775	*/
1776	static int acer_toggle_turbo(void)
1777	{
1778	u64 turbo_led_state;
1779
1780	/* Get current state from turbo button */
1781	if (ACPI_FAILURE(WMID_gaming_get_u64(&turbo_led_state, ACER_CAP_TURBO_LED)))
1782	return -1;
1783
1784	if (turbo_led_state) {
1785	/* Turn off turbo led */
1786	WMID_gaming_set_u64(value: 0x1, ACER_CAP_TURBO_LED);
1787
1788	/* Set FAN mode to auto */
1789	WMID_gaming_set_fan_mode(fan_mode: 0x1);
1790
1791	/* Set OC to normal */
1792	WMID_gaming_set_u64(value: 0x5, ACER_CAP_TURBO_OC);
1793	WMID_gaming_set_u64(value: 0x7, ACER_CAP_TURBO_OC);
1794	} else {
1795	/* Turn on turbo led */
1796	WMID_gaming_set_u64(value: 0x10001, ACER_CAP_TURBO_LED);
1797
1798	/* Set FAN mode to turbo */
1799	WMID_gaming_set_fan_mode(fan_mode: 0x2);
1800
1801	/* Set OC to turbo mode */
1802	WMID_gaming_set_u64(value: 0x205, ACER_CAP_TURBO_OC);
1803	WMID_gaming_set_u64(value: 0x207, ACER_CAP_TURBO_OC);
1804	}
1805	return turbo_led_state;
1806	}
1807
1808	static int
1809	acer_predator_v4_platform_profile_get(struct platform_profile_handler *pprof,
1810	enum platform_profile_option *profile)
1811	{
1812	u8 tp;
1813	int err;
1814
1815	err = ec_read(ACER_PREDATOR_V4_THERMAL_PROFILE_EC_OFFSET, val: &tp);
1816
1817	if (err < 0)
1818	return err;
1819
1820	switch (tp) {
1821	case ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO:
1822	*profile = PLATFORM_PROFILE_PERFORMANCE;
1823	break;
1824	case ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE:
1825	*profile = PLATFORM_PROFILE_BALANCED_PERFORMANCE;
1826	break;
1827	case ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED:
1828	*profile = PLATFORM_PROFILE_BALANCED;
1829	break;
1830	case ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET:
1831	*profile = PLATFORM_PROFILE_QUIET;
1832	break;
1833	case ACER_PREDATOR_V4_THERMAL_PROFILE_ECO:
1834	*profile = PLATFORM_PROFILE_LOW_POWER;
1835	break;
1836	default:
1837	return -EOPNOTSUPP;
1838	}
1839
1840	return 0;
1841	}
1842
1843	static int
1844	acer_predator_v4_platform_profile_set(struct platform_profile_handler *pprof,
1845	enum platform_profile_option profile)
1846	{
1847	int tp;
1848	acpi_status status;
1849
1850	switch (profile) {
1851	case PLATFORM_PROFILE_PERFORMANCE:
1852	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1853	break;
1854	case PLATFORM_PROFILE_BALANCED_PERFORMANCE:
1855	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE_WMI;
1856	break;
1857	case PLATFORM_PROFILE_BALANCED:
1858	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1859	break;
1860	case PLATFORM_PROFILE_QUIET:
1861	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET_WMI;
1862	break;
1863	case PLATFORM_PROFILE_LOW_POWER:
1864	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI;
1865	break;
1866	default:
1867	return -EOPNOTSUPP;
1868	}
1869
1870	status = WMI_gaming_execute_u64(
1871	ACER_WMID_SET_GAMING_MISC_SETTING_METHODID, in: tp, NULL);
1872
1873	if (ACPI_FAILURE(status))
1874	return -EIO;
1875
1876	if (tp != ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI)
1877	last_non_turbo_profile = tp;
1878
1879	return 0;
1880	}
1881
1882	static int acer_platform_profile_setup(void)
1883	{
1884	if (quirks->predator_v4) {
1885	int err;
1886
1887	platform_profile_handler.profile_get =
1888	acer_predator_v4_platform_profile_get;
1889	platform_profile_handler.profile_set =
1890	acer_predator_v4_platform_profile_set;
1891
1892	set_bit(nr: PLATFORM_PROFILE_PERFORMANCE,
1893	addr: platform_profile_handler.choices);
1894	set_bit(nr: PLATFORM_PROFILE_BALANCED_PERFORMANCE,
1895	addr: platform_profile_handler.choices);
1896	set_bit(nr: PLATFORM_PROFILE_BALANCED,
1897	addr: platform_profile_handler.choices);
1898	set_bit(nr: PLATFORM_PROFILE_QUIET,
1899	addr: platform_profile_handler.choices);
1900	set_bit(nr: PLATFORM_PROFILE_LOW_POWER,
1901	addr: platform_profile_handler.choices);
1902
1903	err = platform_profile_register(pprof: &platform_profile_handler);
1904	if (err)
1905	return err;
1906
1907	platform_profile_support = true;
1908
1909	/* Set default non-turbo profile */
1910	last_non_turbo_profile =
1911	ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1912	}
1913	return 0;
1914	}
1915
1916	static int acer_thermal_profile_change(void)
1917	{
1918	/*
1919	* This mode key can rotate each mode or toggle turbo mode.
1920	* On battery, only ECO and BALANCED mode are available.
1921	*/
1922	if (quirks->predator_v4) {
1923	u8 current_tp;
1924	int tp, err;
1925	u64 on_AC;
1926	acpi_status status;
1927
1928	err = ec_read(ACER_PREDATOR_V4_THERMAL_PROFILE_EC_OFFSET,
1929	val: &current_tp);
1930
1931	if (err < 0)
1932	return err;
1933
1934	/* Check power source */
1935	status = WMI_gaming_execute_u64(
1936	ACER_WMID_GET_GAMING_SYS_INFO_METHODID,
1937	in: ACER_WMID_CMD_GET_PREDATOR_V4_BAT_STATUS, out: &on_AC);
1938
1939	if (ACPI_FAILURE(status))
1940	return -EIO;
1941
1942	switch (current_tp) {
1943	case ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO:
1944	if (!on_AC)
1945	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1946	else if (cycle_gaming_thermal_profile)
1947	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI;
1948	else
1949	tp = last_non_turbo_profile;
1950	break;
1951	case ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE:
1952	if (!on_AC)
1953	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1954	else
1955	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1956	break;
1957	case ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED:
1958	if (!on_AC)
1959	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI;
1960	else if (cycle_gaming_thermal_profile)
1961	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE_WMI;
1962	else
1963	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1964	break;
1965	case ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET:
1966	if (!on_AC)
1967	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1968	else if (cycle_gaming_thermal_profile)
1969	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1970	else
1971	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1972	break;
1973	case ACER_PREDATOR_V4_THERMAL_PROFILE_ECO:
1974	if (!on_AC)
1975	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1976	else if (cycle_gaming_thermal_profile)
1977	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET_WMI;
1978	else
1979	tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1980	break;
1981	default:
1982	return -EOPNOTSUPP;
1983	}
1984
1985	status = WMI_gaming_execute_u64(
1986	ACER_WMID_SET_GAMING_MISC_SETTING_METHODID, in: tp, NULL);
1987
1988	if (ACPI_FAILURE(status))
1989	return -EIO;
1990
1991	/* Store non-turbo profile for turbo mode toggle*/
1992	if (tp != ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI)
1993	last_non_turbo_profile = tp;
1994
1995	platform_profile_notify();
1996	}
1997
1998	return 0;
1999	}
2000
2001	/*
2002	* Switch series keyboard dock status
2003	*/
2004	static int acer_kbd_dock_state_to_sw_tablet_mode(u8 kbd_dock_state)
2005	{
2006	switch (kbd_dock_state) {
2007	case 0x01: /* Docked, traditional clamshell laptop mode */
2008	return 0;
2009	case 0x04: /* Stand-alone tablet */
2010	case 0x40: /* Docked, tent mode, keyboard not usable */
2011	return 1;
2012	default:
2013	pr_warn("Unknown kbd_dock_state 0x%02x\n", kbd_dock_state);
2014	}
2015
2016	return 0;
2017	}
2018
2019	static void acer_kbd_dock_get_initial_state(void)
2020	{
2021	u8 *output, input[8] = { 0x05, 0x00, };
2022	struct acpi_buffer input_buf = { sizeof(input), input };
2023	struct acpi_buffer output_buf = { ACPI_ALLOCATE_BUFFER, NULL };
2024	union acpi_object *obj;
2025	acpi_status status;
2026	int sw_tablet_mode;
2027
2028	status = wmi_evaluate_method(WMID_GUID3, instance: 0, method_id: 0x2, in: &input_buf, out: &output_buf);
2029	if (ACPI_FAILURE(status)) {
2030	pr_err("Error getting keyboard-dock initial status: %s\n",
2031	acpi_format_exception(status));
2032	return;
2033	}
2034
2035	obj = output_buf.pointer;
2036	if (!obj || obj->type != ACPI_TYPE_BUFFER || obj->buffer.length != 8) {
2037	pr_err("Unexpected output format getting keyboard-dock initial status\n");
2038	goto out_free_obj;
2039	}
2040
2041	output = obj->buffer.pointer;
2042	if (output[0] != 0x00 || (output[3] != 0x05 && output[3] != 0x45)) {
2043	pr_err("Unexpected output [0]=0x%02x [3]=0x%02x getting keyboard-dock initial status\n",
2044	output[0], output[3]);
2045	goto out_free_obj;
2046	}
2047
2048	sw_tablet_mode = acer_kbd_dock_state_to_sw_tablet_mode(kbd_dock_state: output[4]);
2049	input_report_switch(dev: acer_wmi_input_dev, SW_TABLET_MODE, value: sw_tablet_mode);
2050
2051	out_free_obj:
2052	kfree(objp: obj);
2053	}
2054
2055	static void acer_kbd_dock_event(const struct event_return_value *event)
2056	{
2057	int sw_tablet_mode;
2058
2059	if (!has_cap(ACER_CAP_KBD_DOCK))
2060	return;
2061
2062	sw_tablet_mode = acer_kbd_dock_state_to_sw_tablet_mode(kbd_dock_state: event->kbd_dock_state);
2063	input_report_switch(dev: acer_wmi_input_dev, SW_TABLET_MODE, value: sw_tablet_mode);
2064	input_sync(dev: acer_wmi_input_dev);
2065	}
2066
2067	/*
2068	* Rfkill devices
2069	*/
2070	static void acer_rfkill_update(struct work_struct *ignored);
2071	static DECLARE_DELAYED_WORK(acer_rfkill_work, acer_rfkill_update);
2072	static void acer_rfkill_update(struct work_struct *ignored)
2073	{
2074	u32 state;
2075	acpi_status status;
2076
2077	if (has_cap(ACER_CAP_WIRELESS)) {
2078	status = get_u32(value: &state, ACER_CAP_WIRELESS);
2079	if (ACPI_SUCCESS(status)) {
2080	if (quirks->wireless == 3)
2081	rfkill_set_hw_state(rfkill: wireless_rfkill, blocked: !state);
2082	else
2083	rfkill_set_sw_state(rfkill: wireless_rfkill, blocked: !state);
2084	}
2085	}
2086
2087	if (has_cap(ACER_CAP_BLUETOOTH)) {
2088	status = get_u32(value: &state, ACER_CAP_BLUETOOTH);
2089	if (ACPI_SUCCESS(status))
2090	rfkill_set_sw_state(rfkill: bluetooth_rfkill, blocked: !state);
2091	}
2092
2093	if (has_cap(ACER_CAP_THREEG) && wmi_has_guid(WMID_GUID3)) {
2094	status = get_u32(value: &state, ACER_WMID3_GDS_THREEG);
2095	if (ACPI_SUCCESS(status))
2096	rfkill_set_sw_state(rfkill: threeg_rfkill, blocked: !state);
2097	}
2098
2099	schedule_delayed_work(dwork: &acer_rfkill_work, delay: round_jiffies_relative(HZ));
2100	}
2101
2102	static int acer_rfkill_set(void *data, bool blocked)
2103	{
2104	acpi_status status;
2105	u32 cap = (unsigned long)data;
2106
2107	if (rfkill_inited) {
2108	status = set_u32(value: !blocked, cap);
2109	if (ACPI_FAILURE(status))
2110	return -ENODEV;
2111	}
2112
2113	return 0;
2114	}
2115
2116	static const struct rfkill_ops acer_rfkill_ops = {
2117	.set_block = acer_rfkill_set,
2118	};
2119
2120	static struct rfkill *acer_rfkill_register(struct device *dev,
2121	enum rfkill_type type,
2122	char *name, u32 cap)
2123	{
2124	int err;
2125	struct rfkill *rfkill_dev;
2126	u32 state;
2127	acpi_status status;
2128
2129	rfkill_dev = rfkill_alloc(name, parent: dev, type,
2130	ops: &acer_rfkill_ops,
2131	ops_data: (void *)(unsigned long)cap);
2132	if (!rfkill_dev)
2133	return ERR_PTR(error: -ENOMEM);
2134
2135	status = get_u32(value: &state, cap);
2136
2137	err = rfkill_register(rfkill: rfkill_dev);
2138	if (err) {
2139	rfkill_destroy(rfkill: rfkill_dev);
2140	return ERR_PTR(error: err);
2141	}
2142
2143	if (ACPI_SUCCESS(status))
2144	rfkill_set_sw_state(rfkill: rfkill_dev, blocked: !state);
2145
2146	return rfkill_dev;
2147	}
2148
2149	static int acer_rfkill_init(struct device *dev)
2150	{
2151	int err;
2152
2153	if (has_cap(ACER_CAP_WIRELESS)) {
2154	wireless_rfkill = acer_rfkill_register(dev, type: RFKILL_TYPE_WLAN,
2155	name: "acer-wireless", ACER_CAP_WIRELESS);
2156	if (IS_ERR(ptr: wireless_rfkill)) {
2157	err = PTR_ERR(ptr: wireless_rfkill);
2158	goto error_wireless;
2159	}
2160	}
2161
2162	if (has_cap(ACER_CAP_BLUETOOTH)) {
2163	bluetooth_rfkill = acer_rfkill_register(dev,
2164	type: RFKILL_TYPE_BLUETOOTH, name: "acer-bluetooth",
2165	ACER_CAP_BLUETOOTH);
2166	if (IS_ERR(ptr: bluetooth_rfkill)) {
2167	err = PTR_ERR(ptr: bluetooth_rfkill);
2168	goto error_bluetooth;
2169	}
2170	}
2171
2172	if (has_cap(ACER_CAP_THREEG)) {
2173	threeg_rfkill = acer_rfkill_register(dev,
2174	type: RFKILL_TYPE_WWAN, name: "acer-threeg",
2175	ACER_CAP_THREEG);
2176	if (IS_ERR(ptr: threeg_rfkill)) {
2177	err = PTR_ERR(ptr: threeg_rfkill);
2178	goto error_threeg;
2179	}
2180	}
2181
2182	rfkill_inited = true;
2183
2184	if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) &&
2185	has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG))
2186	schedule_delayed_work(dwork: &acer_rfkill_work,
2187	delay: round_jiffies_relative(HZ));
2188
2189	return 0;
2190
2191	error_threeg:
2192	if (has_cap(ACER_CAP_BLUETOOTH)) {
2193	rfkill_unregister(rfkill: bluetooth_rfkill);
2194	rfkill_destroy(rfkill: bluetooth_rfkill);
2195	}
2196	error_bluetooth:
2197	if (has_cap(ACER_CAP_WIRELESS)) {
2198	rfkill_unregister(rfkill: wireless_rfkill);
2199	rfkill_destroy(rfkill: wireless_rfkill);
2200	}
2201	error_wireless:
2202	return err;
2203	}
2204
2205	static void acer_rfkill_exit(void)
2206	{
2207	if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) &&
2208	has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG))
2209	cancel_delayed_work_sync(dwork: &acer_rfkill_work);
2210
2211	if (has_cap(ACER_CAP_WIRELESS)) {
2212	rfkill_unregister(rfkill: wireless_rfkill);
2213	rfkill_destroy(rfkill: wireless_rfkill);
2214	}
2215
2216	if (has_cap(ACER_CAP_BLUETOOTH)) {
2217	rfkill_unregister(rfkill: bluetooth_rfkill);
2218	rfkill_destroy(rfkill: bluetooth_rfkill);
2219	}
2220
2221	if (has_cap(ACER_CAP_THREEG)) {
2222	rfkill_unregister(rfkill: threeg_rfkill);
2223	rfkill_destroy(rfkill: threeg_rfkill);
2224	}
2225	}
2226
2227	static void acer_wmi_notify(u32 value, void *context)
2228	{
2229	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
2230	union acpi_object *obj;
2231	struct event_return_value return_value;
2232	acpi_status status;
2233	u16 device_state;
2234	const struct key_entry *key;
2235	u32 scancode;
2236
2237	status = wmi_get_event_data(event: value, out: &response);
2238	if (status != AE_OK) {
2239	pr_warn("bad event status 0x%x\n", status);
2240	return;
2241	}
2242
2243	obj = (union acpi_object *)response.pointer;
2244
2245	if (!obj)
2246	return;
2247	if (obj->type != ACPI_TYPE_BUFFER) {
2248	pr_warn("Unknown response received %d\n", obj->type);
2249	kfree(objp: obj);
2250	return;
2251	}
2252	if (obj->buffer.length != 8) {
2253	pr_warn("Unknown buffer length %d\n", obj->buffer.length);
2254	kfree(objp: obj);
2255	return;
2256	}
2257
2258	return_value = *((struct event_return_value *)obj->buffer.pointer);
2259	kfree(objp: obj);
2260
2261	switch (return_value.function) {
2262	case WMID_HOTKEY_EVENT:
2263	device_state = return_value.device_state;
2264	pr_debug("device state: 0x%x\n", device_state);
2265
2266	key = sparse_keymap_entry_from_scancode(dev: acer_wmi_input_dev,
2267	code: return_value.key_num);
2268	if (!key) {
2269	pr_warn("Unknown key number - 0x%x\n",
2270	return_value.key_num);
2271	} else {
2272	scancode = return_value.key_num;
2273	switch (key->keycode) {
2274	case KEY_WLAN:
2275	case KEY_BLUETOOTH:
2276	if (has_cap(ACER_CAP_WIRELESS))
2277	rfkill_set_sw_state(rfkill: wireless_rfkill,
2278	blocked: !(device_state & ACER_WMID3_GDS_WIRELESS));
2279	if (has_cap(ACER_CAP_THREEG))
2280	rfkill_set_sw_state(rfkill: threeg_rfkill,
2281	blocked: !(device_state & ACER_WMID3_GDS_THREEG));
2282	if (has_cap(ACER_CAP_BLUETOOTH))
2283	rfkill_set_sw_state(rfkill: bluetooth_rfkill,
2284	blocked: !(device_state & ACER_WMID3_GDS_BLUETOOTH));
2285	break;
2286	case KEY_TOUCHPAD_TOGGLE:
2287	scancode = (device_state & ACER_WMID3_GDS_TOUCHPAD) ?
2288	KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF;
2289	}
2290	sparse_keymap_report_event(dev: acer_wmi_input_dev, code: scancode, value: 1, autorelease: true);
2291	}
2292	break;
2293	case WMID_ACCEL_OR_KBD_DOCK_EVENT:
2294	acer_gsensor_event();
2295	acer_kbd_dock_event(event: &return_value);
2296	break;
2297	case WMID_GAMING_TURBO_KEY_EVENT:
2298	if (return_value.key_num == 0x4)
2299	acer_toggle_turbo();
2300	if (return_value.key_num == 0x5 && has_cap(ACER_CAP_PLATFORM_PROFILE))
2301	acer_thermal_profile_change();
2302	break;
2303	default:
2304	pr_warn("Unknown function number - %d - %d\n",
2305	return_value.function, return_value.key_num);
2306	break;
2307	}
2308	}
2309
2310	static acpi_status __init
2311	wmid3_set_function_mode(struct func_input_params *params,
2312	struct func_return_value *return_value)
2313	{
2314	acpi_status status;
2315	union acpi_object *obj;
2316
2317	struct acpi_buffer input = { sizeof(struct func_input_params), params };
2318	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
2319
2320	status = wmi_evaluate_method(WMID_GUID3, instance: 0, method_id: 0x1, in: &input, out: &output);
2321	if (ACPI_FAILURE(status))
2322	return status;
2323
2324	obj = output.pointer;
2325
2326	if (!obj)
2327	return AE_ERROR;
2328	else if (obj->type != ACPI_TYPE_BUFFER) {
2329	kfree(objp: obj);
2330	return AE_ERROR;
2331	}
2332	if (obj->buffer.length != 4) {
2333	pr_warn("Unknown buffer length %d\n", obj->buffer.length);
2334	kfree(objp: obj);
2335	return AE_ERROR;
2336	}
2337
2338	*return_value = *((struct func_return_value *)obj->buffer.pointer);
2339	kfree(objp: obj);
2340
2341	return status;
2342	}
2343
2344	static int __init acer_wmi_enable_ec_raw(void)
2345	{
2346	struct func_return_value return_value;
2347	acpi_status status;
2348	struct func_input_params params = {
2349	.function_num = 0x1,
2350	.commun_devices = 0xFFFF,
2351	.devices = 0xFFFF,
2352	.app_status = 0x00, /* Launch Manager Deactive */
2353	.app_mask = 0x01,
2354	};
2355
2356	status = wmid3_set_function_mode(params: &params, return_value: &return_value);
2357
2358	if (return_value.error_code || return_value.ec_return_value)
2359	pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
2360	return_value.error_code,
2361	return_value.ec_return_value);
2362	else
2363	pr_info("Enabled EC raw mode\n");
2364
2365	return status;
2366	}
2367
2368	static int __init acer_wmi_enable_lm(void)
2369	{
2370	struct func_return_value return_value;
2371	acpi_status status;
2372	struct func_input_params params = {
2373	.function_num = 0x1,
2374	.commun_devices = 0xFFFF,
2375	.devices = 0xFFFF,
2376	.app_status = 0x01, /* Launch Manager Active */
2377	.app_mask = 0x01,
2378	};
2379
2380	status = wmid3_set_function_mode(params: &params, return_value: &return_value);
2381
2382	if (return_value.error_code || return_value.ec_return_value)
2383	pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
2384	return_value.error_code,
2385	return_value.ec_return_value);
2386
2387	return status;
2388	}
2389
2390	static int __init acer_wmi_enable_rf_button(void)
2391	{
2392	struct func_return_value return_value;
2393	acpi_status status;
2394	struct func_input_params params = {
2395	.function_num = 0x1,
2396	.commun_devices = 0xFFFF,
2397	.devices = 0xFFFF,
2398	.app_status = 0x10, /* RF Button Active */
2399	.app_mask = 0x10,
2400	};
2401
2402	status = wmid3_set_function_mode(params: &params, return_value: &return_value);
2403
2404	if (return_value.error_code || return_value.ec_return_value)
2405	pr_warn("Enabling RF Button failed: 0x%x - 0x%x\n",
2406	return_value.error_code,
2407	return_value.ec_return_value);
2408
2409	return status;
2410	}
2411
2412	static int __init acer_wmi_accel_setup(void)
2413	{
2414	struct acpi_device *adev;
2415	int err;
2416
2417	adev = acpi_dev_get_first_match_dev(hid: "BST0001", NULL, hrv: -1);
2418	if (!adev)
2419	return -ENODEV;
2420
2421	gsensor_handle = acpi_device_handle(adev);
2422	acpi_dev_put(adev);
2423
2424	acer_wmi_accel_dev = input_allocate_device();
2425	if (!acer_wmi_accel_dev)
2426	return -ENOMEM;
2427
2428	acer_wmi_accel_dev->open = acer_gsensor_open;
2429
2430	acer_wmi_accel_dev->name = "Acer BMA150 accelerometer";
2431	acer_wmi_accel_dev->phys = "wmi/input1";
2432	acer_wmi_accel_dev->id.bustype = BUS_HOST;
2433	acer_wmi_accel_dev->evbit[0] = BIT_MASK(EV_ABS);
2434	input_set_abs_params(dev: acer_wmi_accel_dev, ABS_X, min: -16384, max: 16384, fuzz: 0, flat: 0);
2435	input_set_abs_params(dev: acer_wmi_accel_dev, ABS_Y, min: -16384, max: 16384, fuzz: 0, flat: 0);
2436	input_set_abs_params(dev: acer_wmi_accel_dev, ABS_Z, min: -16384, max: 16384, fuzz: 0, flat: 0);
2437
2438	err = input_register_device(acer_wmi_accel_dev);
2439	if (err)
2440	goto err_free_dev;
2441
2442	return 0;
2443
2444	err_free_dev:
2445	input_free_device(dev: acer_wmi_accel_dev);
2446	return err;
2447	}
2448
2449	static int __init acer_wmi_input_setup(void)
2450	{
2451	acpi_status status;
2452	int err;
2453
2454	acer_wmi_input_dev = input_allocate_device();
2455	if (!acer_wmi_input_dev)
2456	return -ENOMEM;
2457
2458	acer_wmi_input_dev->name = "Acer WMI hotkeys";
2459	acer_wmi_input_dev->phys = "wmi/input0";
2460	acer_wmi_input_dev->id.bustype = BUS_HOST;
2461
2462	err = sparse_keymap_setup(dev: acer_wmi_input_dev, keymap: acer_wmi_keymap, NULL);
2463	if (err)
2464	goto err_free_dev;
2465
2466	if (has_cap(ACER_CAP_KBD_DOCK))
2467	input_set_capability(dev: acer_wmi_input_dev, EV_SW, SW_TABLET_MODE);
2468
2469	status = wmi_install_notify_handler(ACERWMID_EVENT_GUID,
2470	handler: acer_wmi_notify, NULL);
2471	if (ACPI_FAILURE(status)) {
2472	err = -EIO;
2473	goto err_free_dev;
2474	}
2475
2476	if (has_cap(ACER_CAP_KBD_DOCK))
2477	acer_kbd_dock_get_initial_state();
2478
2479	err = input_register_device(acer_wmi_input_dev);
2480	if (err)
2481	goto err_uninstall_notifier;
2482
2483	return 0;
2484
2485	err_uninstall_notifier:
2486	wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
2487	err_free_dev:
2488	input_free_device(dev: acer_wmi_input_dev);
2489	return err;
2490	}
2491
2492	static void acer_wmi_input_destroy(void)
2493	{
2494	wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
2495	input_unregister_device(acer_wmi_input_dev);
2496	}
2497
2498	/*
2499	* debugfs functions
2500	*/
2501	static u32 get_wmid_devices(void)
2502	{
2503	struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
2504	union acpi_object *obj;
2505	acpi_status status;
2506	u32 devices = 0;
2507
2508	status = wmi_query_block(WMID_GUID2, instance: 0, out: &out);
2509	if (ACPI_FAILURE(status))
2510	return 0;
2511
2512	obj = (union acpi_object *) out.pointer;
2513	if (obj) {
2514	if (obj->type == ACPI_TYPE_BUFFER &&
2515	(obj->buffer.length == sizeof(u32) ||
2516	obj->buffer.length == sizeof(u64))) {
2517	devices = *((u32 *) obj->buffer.pointer);
2518	} else if (obj->type == ACPI_TYPE_INTEGER) {
2519	devices = (u32) obj->integer.value;
2520	}
2521	}
2522
2523	kfree(objp: out.pointer);
2524	return devices;
2525	}
2526
2527	static int acer_wmi_hwmon_init(void);
2528
2529	/*
2530	* Platform device
2531	*/
2532	static int acer_platform_probe(struct platform_device *device)
2533	{
2534	int err;
2535
2536	if (has_cap(ACER_CAP_MAILLED)) {
2537	err = acer_led_init(dev: &device->dev);
2538	if (err)
2539	goto error_mailled;
2540	}
2541
2542	if (has_cap(ACER_CAP_BRIGHTNESS)) {
2543	err = acer_backlight_init(dev: &device->dev);
2544	if (err)
2545	goto error_brightness;
2546	}
2547
2548	err = acer_rfkill_init(dev: &device->dev);
2549	if (err)
2550	goto error_rfkill;
2551
2552	if (has_cap(ACER_CAP_PLATFORM_PROFILE)) {
2553	err = acer_platform_profile_setup();
2554	if (err)
2555	goto error_platform_profile;
2556	}
2557
2558	if (has_cap(ACER_CAP_FAN_SPEED_READ)) {
2559	err = acer_wmi_hwmon_init();
2560	if (err)
2561	goto error_hwmon;
2562	}
2563
2564	return 0;
2565
2566	error_hwmon:
2567	if (platform_profile_support)
2568	platform_profile_remove();
2569	error_platform_profile:
2570	acer_rfkill_exit();
2571	error_rfkill:
2572	if (has_cap(ACER_CAP_BRIGHTNESS))
2573	acer_backlight_exit();
2574	error_brightness:
2575	if (has_cap(ACER_CAP_MAILLED))
2576	acer_led_exit();
2577	error_mailled:
2578	return err;
2579	}
2580
2581	static void acer_platform_remove(struct platform_device *device)
2582	{
2583	if (has_cap(ACER_CAP_MAILLED))
2584	acer_led_exit();
2585	if (has_cap(ACER_CAP_BRIGHTNESS))
2586	acer_backlight_exit();
2587
2588	acer_rfkill_exit();
2589
2590	if (platform_profile_support)
2591	platform_profile_remove();
2592	}
2593
2594	#ifdef CONFIG_PM_SLEEP
2595	static int acer_suspend(struct device *dev)
2596	{
2597	u32 value;
2598	struct acer_data *data = &interface->data;
2599
2600	if (!data)
2601	return -ENOMEM;
2602
2603	if (has_cap(ACER_CAP_MAILLED)) {
2604	get_u32(value: &value, ACER_CAP_MAILLED);
2605	set_u32(value: LED_OFF, ACER_CAP_MAILLED);
2606	data->mailled = value;
2607	}
2608
2609	if (has_cap(ACER_CAP_BRIGHTNESS)) {
2610	get_u32(value: &value, ACER_CAP_BRIGHTNESS);
2611	data->brightness = value;
2612	}
2613
2614	return 0;
2615	}
2616
2617	static int acer_resume(struct device *dev)
2618	{
2619	struct acer_data *data = &interface->data;
2620
2621	if (!data)
2622	return -ENOMEM;
2623
2624	if (has_cap(ACER_CAP_MAILLED))
2625	set_u32(value: data->mailled, ACER_CAP_MAILLED);
2626
2627	if (has_cap(ACER_CAP_BRIGHTNESS))
2628	set_u32(value: data->brightness, ACER_CAP_BRIGHTNESS);
2629
2630	if (acer_wmi_accel_dev)
2631	acer_gsensor_init();
2632
2633	return 0;
2634	}
2635	#else
2636	#define acer_suspend NULL
2637	#define acer_resume NULL
2638	#endif
2639
2640	static SIMPLE_DEV_PM_OPS(acer_pm, acer_suspend, acer_resume);
2641
2642	static void acer_platform_shutdown(struct platform_device *device)
2643	{
2644	struct acer_data *data = &interface->data;
2645
2646	if (!data)
2647	return;
2648
2649	if (has_cap(ACER_CAP_MAILLED))
2650	set_u32(value: LED_OFF, ACER_CAP_MAILLED);
2651	}
2652
2653	static struct platform_driver acer_platform_driver = {
2654	.driver = {
2655	.name = "acer-wmi",
2656	.pm = &acer_pm,
2657	},
2658	.probe = acer_platform_probe,
2659	.remove_new = acer_platform_remove,
2660	.shutdown = acer_platform_shutdown,
2661	};
2662
2663	static struct platform_device *acer_platform_device;
2664
2665	static void remove_debugfs(void)
2666	{
2667	debugfs_remove_recursive(dentry: interface->debug.root);
2668	}
2669
2670	static void __init create_debugfs(void)
2671	{
2672	interface->debug.root = debugfs_create_dir(name: "acer-wmi", NULL);
2673
2674	debugfs_create_u32(name: "devices", S_IRUGO, parent: interface->debug.root,
2675	value: &interface->debug.wmid_devices);
2676	}
2677
2678	static umode_t acer_wmi_hwmon_is_visible(const void *data,
2679	enum hwmon_sensor_types type, u32 attr,
2680	int channel)
2681	{
2682	switch (type) {
2683	case hwmon_fan:
2684	if (acer_get_fan_speed(fan: channel) >= 0)
2685	return 0444;
2686	break;
2687	default:
2688	return 0;
2689	}
2690
2691	return 0;
2692	}
2693
2694	static int acer_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
2695	u32 attr, int channel, long *val)
2696	{
2697	int ret;
2698
2699	switch (type) {
2700	case hwmon_fan:
2701	ret = acer_get_fan_speed(fan: channel);
2702	if (ret < 0)
2703	return ret;
2704	*val = ret;
2705	break;
2706	default:
2707	return -EOPNOTSUPP;
2708	}
2709
2710	return 0;
2711	}
2712
2713	static const struct hwmon_channel_info *const acer_wmi_hwmon_info[] = {
2714	HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT, HWMON_F_INPUT), NULL
2715	};
2716
2717	static const struct hwmon_ops acer_wmi_hwmon_ops = {
2718	.read = acer_wmi_hwmon_read,
2719	.is_visible = acer_wmi_hwmon_is_visible,
2720	};
2721
2722	static const struct hwmon_chip_info acer_wmi_hwmon_chip_info = {
2723	.ops = &acer_wmi_hwmon_ops,
2724	.info = acer_wmi_hwmon_info,
2725	};
2726
2727	static int acer_wmi_hwmon_init(void)
2728	{
2729	struct device *dev = &acer_platform_device->dev;
2730	struct device *hwmon;
2731
2732	hwmon = devm_hwmon_device_register_with_info(dev, name: "acer",
2733	drvdata: &acer_platform_driver,
2734	info: &acer_wmi_hwmon_chip_info,
2735	NULL);
2736
2737	if (IS_ERR(ptr: hwmon)) {
2738	dev_err(dev, "Could not register acer hwmon device\n");
2739	return PTR_ERR(ptr: hwmon);
2740	}
2741
2742	return 0;
2743	}
2744
2745	static int __init acer_wmi_init(void)
2746	{
2747	int err;
2748
2749	pr_info("Acer Laptop ACPI-WMI Extras\n");
2750
2751	if (dmi_check_system(list: acer_blacklist)) {
2752	pr_info("Blacklisted hardware detected - not loading\n");
2753	return -ENODEV;
2754	}
2755
2756	find_quirks();
2757
2758	/*
2759	* The AMW0_GUID1 wmi is not only found on Acer family but also other
2760	* machines like Lenovo, Fujitsu and Medion. In the past days,
2761	* acer-wmi driver handled those non-Acer machines by quirks list.
2762	* But actually acer-wmi driver was loaded on any machines that have
2763	* AMW0_GUID1. This behavior is strange because those machines should
2764	* be supported by appropriate wmi drivers. e.g. fujitsu-laptop,
2765	* ideapad-laptop. So, here checks the machine that has AMW0_GUID1
2766	* should be in Acer/Gateway/Packard Bell white list, or it's already
2767	* in the past quirk list.
2768	*/
2769	if (wmi_has_guid(AMW0_GUID1) &&
2770	!dmi_check_system(list: amw0_whitelist) &&
2771	quirks == &quirk_unknown) {
2772	pr_debug("Unsupported machine has AMW0_GUID1, unable to load\n");
2773	return -ENODEV;
2774	}
2775
2776	/*
2777	* Detect which ACPI-WMI interface we're using.
2778	*/
2779	if (wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
2780	interface = &AMW0_V2_interface;
2781
2782	if (!wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
2783	interface = &wmid_interface;
2784
2785	if (wmi_has_guid(WMID_GUID3))
2786	interface = &wmid_v2_interface;
2787
2788	if (interface)
2789	dmi_walk(decode: type_aa_dmi_decode, NULL);
2790
2791	if (wmi_has_guid(WMID_GUID2) && interface) {
2792	if (!has_type_aa && ACPI_FAILURE(WMID_set_capabilities())) {
2793	pr_err("Unable to detect available WMID devices\n");
2794	return -ENODEV;
2795	}
2796	/* WMID always provides brightness methods */
2797	interface->capability |= ACER_CAP_BRIGHTNESS;
2798	} else if (!wmi_has_guid(WMID_GUID2) && interface && !has_type_aa && force_caps == -1) {
2799	pr_err("No WMID device detection method found\n");
2800	return -ENODEV;
2801	}
2802
2803	if (wmi_has_guid(AMW0_GUID1) && !wmi_has_guid(WMID_GUID1)) {
2804	interface = &AMW0_interface;
2805
2806	if (ACPI_FAILURE(AMW0_set_capabilities())) {
2807	pr_err("Unable to detect available AMW0 devices\n");
2808	return -ENODEV;
2809	}
2810	}
2811
2812	if (wmi_has_guid(AMW0_GUID1))
2813	AMW0_find_mailled();
2814
2815	if (!interface) {
2816	pr_err("No or unsupported WMI interface, unable to load\n");
2817	return -ENODEV;
2818	}
2819
2820	set_quirks();
2821
2822	if (acpi_video_get_backlight_type() != acpi_backlight_vendor)
2823	interface->capability &= ~ACER_CAP_BRIGHTNESS;
2824
2825	if (wmi_has_guid(WMID_GUID3))
2826	interface->capability |= ACER_CAP_SET_FUNCTION_MODE;
2827
2828	if (force_caps != -1)
2829	interface->capability = force_caps;
2830
2831	if (wmi_has_guid(WMID_GUID3) &&
2832	(interface->capability & ACER_CAP_SET_FUNCTION_MODE)) {
2833	if (ACPI_FAILURE(acer_wmi_enable_rf_button()))
2834	pr_warn("Cannot enable RF Button Driver\n");
2835
2836	if (ec_raw_mode) {
2837	if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
2838	pr_err("Cannot enable EC raw mode\n");
2839	return -ENODEV;
2840	}
2841	} else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
2842	pr_err("Cannot enable Launch Manager mode\n");
2843	return -ENODEV;
2844	}
2845	} else if (ec_raw_mode) {
2846	pr_info("No WMID EC raw mode enable method\n");
2847	}
2848
2849	if (wmi_has_guid(ACERWMID_EVENT_GUID)) {
2850	err = acer_wmi_input_setup();
2851	if (err)
2852	return err;
2853	err = acer_wmi_accel_setup();
2854	if (err && err != -ENODEV)
2855	pr_warn("Cannot enable accelerometer\n");
2856	}
2857
2858	err = platform_driver_register(&acer_platform_driver);
2859	if (err) {
2860	pr_err("Unable to register platform driver\n");
2861	goto error_platform_register;
2862	}
2863
2864	acer_platform_device = platform_device_alloc(name: "acer-wmi", PLATFORM_DEVID_NONE);
2865	if (!acer_platform_device) {
2866	err = -ENOMEM;
2867	goto error_device_alloc;
2868	}
2869
2870	err = platform_device_add(pdev: acer_platform_device);
2871	if (err)
2872	goto error_device_add;
2873
2874	if (wmi_has_guid(WMID_GUID2)) {
2875	interface->debug.wmid_devices = get_wmid_devices();
2876	create_debugfs();
2877	}
2878
2879	/* Override any initial settings with values from the commandline */
2880	acer_commandline_init();
2881
2882	return 0;
2883
2884	error_device_add:
2885	platform_device_put(pdev: acer_platform_device);
2886	error_device_alloc:
2887	platform_driver_unregister(&acer_platform_driver);
2888	error_platform_register:
2889	if (wmi_has_guid(ACERWMID_EVENT_GUID))
2890	acer_wmi_input_destroy();
2891	if (acer_wmi_accel_dev)
2892	input_unregister_device(acer_wmi_accel_dev);
2893
2894	return err;
2895	}
2896
2897	static void __exit acer_wmi_exit(void)
2898	{
2899	if (wmi_has_guid(ACERWMID_EVENT_GUID))
2900	acer_wmi_input_destroy();
2901
2902	if (acer_wmi_accel_dev)
2903	input_unregister_device(acer_wmi_accel_dev);
2904
2905	remove_debugfs();
2906	platform_device_unregister(acer_platform_device);
2907	platform_driver_unregister(&acer_platform_driver);
2908
2909	pr_info("Acer Laptop WMI Extras unloaded\n");
2910	}
2911
2912	module_init(acer_wmi_init);
2913	module_exit(acer_wmi_exit);
2914