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