xref: /linux/drivers/platform/x86/asus-wmi.c (revision 84bbfe6b6435658132df2880258d34babe46d3e0)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Asus PC WMI hotkey driver
4  *
5  * Copyright(C) 2010 Intel Corporation.
6  * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
7  *
8  * Portions based on wistron_btns.c:
9  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
10  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
11  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
12  */
13 
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 
16 #include <linux/acpi.h>
17 #include <linux/backlight.h>
18 #include <linux/debugfs.h>
19 #include <linux/delay.h>
20 #include <linux/dmi.h>
21 #include <linux/hwmon.h>
22 #include <linux/hwmon-sysfs.h>
23 #include <linux/init.h>
24 #include <linux/input.h>
25 #include <linux/input/sparse-keymap.h>
26 #include <linux/kernel.h>
27 #include <linux/leds.h>
28 #include <linux/minmax.h>
29 #include <linux/module.h>
30 #include <linux/pci.h>
31 #include <linux/pci_hotplug.h>
32 #include <linux/platform_data/x86/asus-wmi.h>
33 #include <linux/platform_device.h>
34 #include <linux/platform_profile.h>
35 #include <linux/power_supply.h>
36 #include <linux/rfkill.h>
37 #include <linux/seq_file.h>
38 #include <linux/slab.h>
39 #include <linux/types.h>
40 #include <linux/units.h>
41 
42 #include <acpi/battery.h>
43 #include <acpi/video.h>
44 
45 #include "asus-wmi.h"
46 
47 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>");
48 MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
49 MODULE_DESCRIPTION("Asus Generic WMI Driver");
50 MODULE_LICENSE("GPL");
51 
52 static bool fnlock_default = true;
53 module_param(fnlock_default, bool, 0444);
54 
55 #define to_asus_wmi_driver(pdrv)					\
56 	(container_of((pdrv), struct asus_wmi_driver, platform_driver))
57 
58 #define ASUS_WMI_MGMT_GUID	"97845ED0-4E6D-11DE-8A39-0800200C9A66"
59 
60 #define NOTIFY_BRNUP_MIN		0x11
61 #define NOTIFY_BRNUP_MAX		0x1f
62 #define NOTIFY_BRNDOWN_MIN		0x20
63 #define NOTIFY_BRNDOWN_MAX		0x2e
64 #define NOTIFY_FNLOCK_TOGGLE		0x4e
65 #define NOTIFY_KBD_DOCK_CHANGE		0x75
66 #define NOTIFY_KBD_BRTUP		0xc4
67 #define NOTIFY_KBD_BRTDWN		0xc5
68 #define NOTIFY_KBD_BRTTOGGLE		0xc7
69 #define NOTIFY_KBD_FBM			0x99
70 #define NOTIFY_KBD_TTP			0xae
71 #define NOTIFY_LID_FLIP			0xfa
72 #define NOTIFY_LID_FLIP_ROG		0xbd
73 
74 #define ASUS_WMI_FNLOCK_BIOS_DISABLED	BIT(0)
75 
76 #define ASUS_MID_FAN_DESC		"mid_fan"
77 #define ASUS_GPU_FAN_DESC		"gpu_fan"
78 #define ASUS_FAN_DESC			"cpu_fan"
79 #define ASUS_FAN_MFUN			0x13
80 #define ASUS_FAN_SFUN_READ		0x06
81 #define ASUS_FAN_SFUN_WRITE		0x07
82 
83 /* Based on standard hwmon pwmX_enable values */
84 #define ASUS_FAN_CTRL_FULLSPEED		0
85 #define ASUS_FAN_CTRL_MANUAL		1
86 #define ASUS_FAN_CTRL_AUTO		2
87 
88 #define ASUS_FAN_BOOST_MODE_NORMAL		0
89 #define ASUS_FAN_BOOST_MODE_OVERBOOST		1
90 #define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK	0x01
91 #define ASUS_FAN_BOOST_MODE_SILENT		2
92 #define ASUS_FAN_BOOST_MODE_SILENT_MASK		0x02
93 #define ASUS_FAN_BOOST_MODES_MASK		0x03
94 
95 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT	0
96 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST	1
97 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT	2
98 
99 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT_VIVO	0
100 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT_VIVO	1
101 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST_VIVO	2
102 
103 #define PLATFORM_PROFILE_MAX 2
104 
105 #define USB_INTEL_XUSB2PR		0xD0
106 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI	0x9c31
107 
108 #define ASUS_ACPI_UID_ASUSWMI		"ASUSWMI"
109 
110 #define WMI_EVENT_MASK			0xFFFF
111 
112 #define FAN_CURVE_POINTS		8
113 #define FAN_CURVE_BUF_LEN		32
114 #define FAN_CURVE_DEV_CPU		0x00
115 #define FAN_CURVE_DEV_GPU		0x01
116 #define FAN_CURVE_DEV_MID		0x02
117 /* Mask to determine if setting temperature or percentage */
118 #define FAN_CURVE_PWM_MASK		0x04
119 
120 /* Limits for tunables available on ASUS ROG laptops */
121 #define PPT_TOTAL_MIN		5
122 #define PPT_TOTAL_MAX		250
123 #define PPT_CPU_MIN			5
124 #define PPT_CPU_MAX			130
125 #define NVIDIA_BOOST_MIN	5
126 #define NVIDIA_BOOST_MAX	25
127 #define NVIDIA_TEMP_MIN		75
128 #define NVIDIA_TEMP_MAX		87
129 
130 #define ASUS_SCREENPAD_BRIGHT_MIN 20
131 #define ASUS_SCREENPAD_BRIGHT_MAX 255
132 #define ASUS_SCREENPAD_BRIGHT_DEFAULT 60
133 
134 #define ASUS_MINI_LED_MODE_MASK		0x03
135 /* Standard modes for devices with only on/off */
136 #define ASUS_MINI_LED_OFF		0x00
137 #define ASUS_MINI_LED_ON		0x01
138 /* New mode on some devices, define here to clarify remapping later */
139 #define ASUS_MINI_LED_STRONG_MODE	0x02
140 /* New modes for devices with 3 mini-led mode types */
141 #define ASUS_MINI_LED_2024_WEAK		0x00
142 #define ASUS_MINI_LED_2024_STRONG	0x01
143 #define ASUS_MINI_LED_2024_OFF		0x02
144 
145 /* Controls the power state of the USB0 hub on ROG Ally which input is on */
146 #define ASUS_USB0_PWR_EC0_CSEE "\\_SB.PCI0.SBRG.EC0.CSEE"
147 /* 300ms so far seems to produce a reliable result on AC and battery */
148 #define ASUS_USB0_PWR_EC0_CSEE_WAIT 1500
149 
150 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
151 
152 static int throttle_thermal_policy_write(struct asus_wmi *);
153 
154 static const struct dmi_system_id asus_ally_mcu_quirk[] = {
155 	{
156 		.matches = {
157 			DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
158 		},
159 	},
160 	{
161 		.matches = {
162 			DMI_MATCH(DMI_BOARD_NAME, "RC72L"),
163 		},
164 	},
165 	{ },
166 };
167 
168 static bool ashs_present(void)
169 {
170 	int i = 0;
171 	while (ashs_ids[i]) {
172 		if (acpi_dev_found(ashs_ids[i++]))
173 			return true;
174 	}
175 	return false;
176 }
177 
178 struct bios_args {
179 	u32 arg0;
180 	u32 arg1;
181 	u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
182 	u32 arg3;
183 	u32 arg4; /* Some ROG laptops require a full 5 input args */
184 	u32 arg5;
185 } __packed;
186 
187 /*
188  * Struct that's used for all methods called via AGFN. Naming is
189  * identically to the AML code.
190  */
191 struct agfn_args {
192 	u16 mfun; /* probably "Multi-function" to be called */
193 	u16 sfun; /* probably "Sub-function" to be called */
194 	u16 len;  /* size of the hole struct, including subfunction fields */
195 	u8 stas;  /* not used by now */
196 	u8 err;   /* zero on success */
197 } __packed;
198 
199 /* struct used for calling fan read and write methods */
200 struct agfn_fan_args {
201 	struct agfn_args agfn;	/* common fields */
202 	u8 fan;			/* fan number: 0: set auto mode 1: 1st fan */
203 	u32 speed;		/* read: RPM/100 - write: 0-255 */
204 } __packed;
205 
206 /*
207  * <platform>/    - debugfs root directory
208  *   dev_id      - current dev_id
209  *   ctrl_param  - current ctrl_param
210  *   method_id   - current method_id
211  *   devs        - call DEVS(dev_id, ctrl_param) and print result
212  *   dsts        - call DSTS(dev_id)  and print result
213  *   call        - call method_id(dev_id, ctrl_param) and print result
214  */
215 struct asus_wmi_debug {
216 	struct dentry *root;
217 	u32 method_id;
218 	u32 dev_id;
219 	u32 ctrl_param;
220 };
221 
222 struct asus_rfkill {
223 	struct asus_wmi *asus;
224 	struct rfkill *rfkill;
225 	u32 dev_id;
226 };
227 
228 enum fan_type {
229 	FAN_TYPE_NONE = 0,
230 	FAN_TYPE_AGFN,		/* deprecated on newer platforms */
231 	FAN_TYPE_SPEC83,	/* starting in Spec 8.3, use CPU_FAN_CTRL */
232 };
233 
234 struct fan_curve_data {
235 	bool enabled;
236 	u32 device_id;
237 	u8 temps[FAN_CURVE_POINTS];
238 	u8 percents[FAN_CURVE_POINTS];
239 };
240 
241 struct asus_wmi {
242 	int dsts_id;
243 	int spec;
244 	int sfun;
245 
246 	struct input_dev *inputdev;
247 	struct backlight_device *backlight_device;
248 	struct backlight_device *screenpad_backlight_device;
249 	struct platform_device *platform_device;
250 
251 	struct led_classdev wlan_led;
252 	int wlan_led_wk;
253 	struct led_classdev tpd_led;
254 	int tpd_led_wk;
255 	struct led_classdev kbd_led;
256 	int kbd_led_wk;
257 	struct led_classdev lightbar_led;
258 	int lightbar_led_wk;
259 	struct led_classdev micmute_led;
260 	struct led_classdev camera_led;
261 	struct workqueue_struct *led_workqueue;
262 	struct work_struct tpd_led_work;
263 	struct work_struct wlan_led_work;
264 	struct work_struct lightbar_led_work;
265 
266 	struct asus_rfkill wlan;
267 	struct asus_rfkill bluetooth;
268 	struct asus_rfkill wimax;
269 	struct asus_rfkill wwan3g;
270 	struct asus_rfkill gps;
271 	struct asus_rfkill uwb;
272 
273 	int tablet_switch_event_code;
274 	u32 tablet_switch_dev_id;
275 	bool tablet_switch_inverted;
276 
277 	/* The ROG Ally device requires the MCU USB device be disconnected before suspend */
278 	bool ally_mcu_usb_switch;
279 
280 	enum fan_type fan_type;
281 	enum fan_type gpu_fan_type;
282 	enum fan_type mid_fan_type;
283 	int fan_pwm_mode;
284 	int gpu_fan_pwm_mode;
285 	int mid_fan_pwm_mode;
286 	int agfn_pwm;
287 
288 	bool fan_boost_mode_available;
289 	u8 fan_boost_mode_mask;
290 	u8 fan_boost_mode;
291 
292 	bool egpu_enable_available;
293 	bool dgpu_disable_available;
294 	u32 gpu_mux_dev;
295 
296 	/* Tunables provided by ASUS for gaming laptops */
297 	u32 ppt_pl2_sppt;
298 	u32 ppt_pl1_spl;
299 	u32 ppt_apu_sppt;
300 	u32 ppt_platform_sppt;
301 	u32 ppt_fppt;
302 	u32 nv_dynamic_boost;
303 	u32 nv_temp_target;
304 
305 	u32 kbd_rgb_dev;
306 	bool kbd_rgb_state_available;
307 
308 	u8 throttle_thermal_policy_mode;
309 	u32 throttle_thermal_policy_dev;
310 
311 	bool cpu_fan_curve_available;
312 	bool gpu_fan_curve_available;
313 	bool mid_fan_curve_available;
314 	struct fan_curve_data custom_fan_curves[3];
315 
316 	struct platform_profile_handler platform_profile_handler;
317 	bool platform_profile_support;
318 
319 	// The RSOC controls the maximum charging percentage.
320 	bool battery_rsoc_available;
321 
322 	bool panel_overdrive_available;
323 	u32 mini_led_dev_id;
324 
325 	struct hotplug_slot hotplug_slot;
326 	struct mutex hotplug_lock;
327 	struct mutex wmi_lock;
328 	struct workqueue_struct *hotplug_workqueue;
329 	struct work_struct hotplug_work;
330 
331 	bool fnlock_locked;
332 
333 	struct asus_wmi_debug debug;
334 
335 	struct asus_wmi_driver *driver;
336 };
337 
338 /* WMI ************************************************************************/
339 
340 static int asus_wmi_evaluate_method3(u32 method_id,
341 		u32 arg0, u32 arg1, u32 arg2, u32 *retval)
342 {
343 	struct bios_args args = {
344 		.arg0 = arg0,
345 		.arg1 = arg1,
346 		.arg2 = arg2,
347 	};
348 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
349 	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
350 	acpi_status status;
351 	union acpi_object *obj;
352 	u32 tmp = 0;
353 
354 	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
355 				     &input, &output);
356 
357 	pr_debug("%s called (0x%08x) with args: 0x%08x, 0x%08x, 0x%08x\n",
358 		__func__, method_id, arg0, arg1, arg2);
359 	if (ACPI_FAILURE(status)) {
360 		pr_debug("%s, (0x%08x), arg 0x%08x failed: %d\n",
361 			__func__, method_id, arg0, -EIO);
362 		return -EIO;
363 	}
364 
365 	obj = (union acpi_object *)output.pointer;
366 	if (obj && obj->type == ACPI_TYPE_INTEGER)
367 		tmp = (u32) obj->integer.value;
368 
369 	pr_debug("Result: 0x%08x\n", tmp);
370 	if (retval)
371 		*retval = tmp;
372 
373 	kfree(obj);
374 
375 	if (tmp == ASUS_WMI_UNSUPPORTED_METHOD) {
376 		pr_debug("%s, (0x%08x), arg 0x%08x failed: %d\n",
377 			__func__, method_id, arg0, -ENODEV);
378 		return -ENODEV;
379 	}
380 
381 	return 0;
382 }
383 
384 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
385 {
386 	return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
387 }
388 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
389 
390 static int asus_wmi_evaluate_method5(u32 method_id,
391 		u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval)
392 {
393 	struct bios_args args = {
394 		.arg0 = arg0,
395 		.arg1 = arg1,
396 		.arg2 = arg2,
397 		.arg3 = arg3,
398 		.arg4 = arg4,
399 	};
400 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
401 	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
402 	acpi_status status;
403 	union acpi_object *obj;
404 	u32 tmp = 0;
405 
406 	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
407 				     &input, &output);
408 
409 	pr_debug("%s called (0x%08x) with args: 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
410 		__func__, method_id, arg0, arg1, arg2, arg3, arg4);
411 	if (ACPI_FAILURE(status)) {
412 		pr_debug("%s, (0x%08x), arg 0x%08x failed: %d\n",
413 			__func__, method_id, arg0, -EIO);
414 		return -EIO;
415 	}
416 
417 	obj = (union acpi_object *)output.pointer;
418 	if (obj && obj->type == ACPI_TYPE_INTEGER)
419 		tmp = (u32) obj->integer.value;
420 
421 	pr_debug("Result: %x\n", tmp);
422 	if (retval)
423 		*retval = tmp;
424 
425 	kfree(obj);
426 
427 	if (tmp == ASUS_WMI_UNSUPPORTED_METHOD) {
428 		pr_debug("%s, (0x%08x), arg 0x%08x failed: %d\n",
429 			__func__, method_id, arg0, -ENODEV);
430 		return -ENODEV;
431 	}
432 
433 	return 0;
434 }
435 
436 /*
437  * Returns as an error if the method output is not a buffer. Typically this
438  * means that the method called is unsupported.
439  */
440 static int asus_wmi_evaluate_method_buf(u32 method_id,
441 		u32 arg0, u32 arg1, u8 *ret_buffer, size_t size)
442 {
443 	struct bios_args args = {
444 		.arg0 = arg0,
445 		.arg1 = arg1,
446 		.arg2 = 0,
447 	};
448 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
449 	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
450 	acpi_status status;
451 	union acpi_object *obj;
452 	int err = 0;
453 
454 	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
455 				     &input, &output);
456 
457 	pr_debug("%s called (0x%08x) with args: 0x%08x, 0x%08x\n",
458 		__func__, method_id, arg0, arg1);
459 	if (ACPI_FAILURE(status)) {
460 		pr_debug("%s, (0x%08x), arg 0x%08x failed: %d\n",
461 			__func__, method_id, arg0, -EIO);
462 		return -EIO;
463 	}
464 
465 	obj = (union acpi_object *)output.pointer;
466 
467 	switch (obj->type) {
468 	case ACPI_TYPE_BUFFER:
469 		if (obj->buffer.length > size) {
470 			err = -ENOSPC;
471 			break;
472 		}
473 		if (obj->buffer.length == 0) {
474 			err = -ENODATA;
475 			break;
476 		}
477 
478 		memcpy(ret_buffer, obj->buffer.pointer, obj->buffer.length);
479 		break;
480 	case ACPI_TYPE_INTEGER:
481 		err = (u32)obj->integer.value;
482 
483 		if (err == ASUS_WMI_UNSUPPORTED_METHOD)
484 			err = -ENODEV;
485 		/*
486 		 * At least one method returns a 0 with no buffer if no arg
487 		 * is provided, such as ASUS_WMI_DEVID_CPU_FAN_CURVE
488 		 */
489 		if (err == 0)
490 			err = -ENODATA;
491 		break;
492 	default:
493 		err = -ENODATA;
494 		break;
495 	}
496 
497 	kfree(obj);
498 
499 	if (err) {
500 		pr_debug("%s, (0x%08x), arg 0x%08x failed: %d\n",
501 			__func__, method_id, arg0, err);
502 		return err;
503 	}
504 
505 	return 0;
506 }
507 
508 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
509 {
510 	struct acpi_buffer input;
511 	u64 phys_addr;
512 	u32 retval;
513 	u32 status;
514 
515 	/*
516 	 * Copy to dma capable address otherwise memory corruption occurs as
517 	 * bios has to be able to access it.
518 	 */
519 	input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
520 	input.length = args.length;
521 	if (!input.pointer)
522 		return -ENOMEM;
523 	phys_addr = virt_to_phys(input.pointer);
524 
525 	status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
526 					phys_addr, 0, &retval);
527 	if (!status)
528 		memcpy(args.pointer, input.pointer, args.length);
529 
530 	kfree(input.pointer);
531 	if (status)
532 		return -ENXIO;
533 
534 	return retval;
535 }
536 
537 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
538 {
539 	int err;
540 
541 	err = asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
542 
543 	if (err)
544 		return err;
545 
546 	if (*retval == ~0)
547 		return -ENODEV;
548 
549 	return 0;
550 }
551 
552 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
553 				 u32 *retval)
554 {
555 	return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
556 					ctrl_param, retval);
557 }
558 
559 /* Helper for special devices with magic return codes */
560 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
561 				      u32 dev_id, u32 mask)
562 {
563 	u32 retval = 0;
564 	int err;
565 
566 	err = asus_wmi_get_devstate(asus, dev_id, &retval);
567 	if (err < 0)
568 		return err;
569 
570 	if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
571 		return -ENODEV;
572 
573 	if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
574 		if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
575 			return -ENODEV;
576 	}
577 
578 	return retval & mask;
579 }
580 
581 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
582 {
583 	return asus_wmi_get_devstate_bits(asus, dev_id,
584 					  ASUS_WMI_DSTS_STATUS_BIT);
585 }
586 
587 static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
588 {
589 	u32 retval;
590 	int status = asus_wmi_get_devstate(asus, dev_id, &retval);
591 	pr_debug("%s called (0x%08x), retval: 0x%08x\n", __func__, dev_id, retval);
592 
593 	return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
594 }
595 
596 /* Input **********************************************************************/
597 static void asus_wmi_tablet_sw_report(struct asus_wmi *asus, bool value)
598 {
599 	input_report_switch(asus->inputdev, SW_TABLET_MODE,
600 			    asus->tablet_switch_inverted ? !value : value);
601 	input_sync(asus->inputdev);
602 }
603 
604 static void asus_wmi_tablet_sw_init(struct asus_wmi *asus, u32 dev_id, int event_code)
605 {
606 	struct device *dev = &asus->platform_device->dev;
607 	int result;
608 
609 	result = asus_wmi_get_devstate_simple(asus, dev_id);
610 	if (result >= 0) {
611 		input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
612 		asus_wmi_tablet_sw_report(asus, result);
613 		asus->tablet_switch_dev_id = dev_id;
614 		asus->tablet_switch_event_code = event_code;
615 	} else if (result == -ENODEV) {
616 		dev_err(dev, "This device has tablet-mode-switch quirk but got ENODEV checking it. This is a bug.");
617 	} else {
618 		dev_err(dev, "Error checking for tablet-mode-switch: %d\n", result);
619 	}
620 }
621 
622 static int asus_wmi_input_init(struct asus_wmi *asus)
623 {
624 	struct device *dev = &asus->platform_device->dev;
625 	int err;
626 
627 	asus->inputdev = input_allocate_device();
628 	if (!asus->inputdev)
629 		return -ENOMEM;
630 
631 	asus->inputdev->name = asus->driver->input_name;
632 	asus->inputdev->phys = asus->driver->input_phys;
633 	asus->inputdev->id.bustype = BUS_HOST;
634 	asus->inputdev->dev.parent = dev;
635 	set_bit(EV_REP, asus->inputdev->evbit);
636 
637 	err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
638 	if (err)
639 		goto err_free_dev;
640 
641 	switch (asus->driver->quirks->tablet_switch_mode) {
642 	case asus_wmi_no_tablet_switch:
643 		break;
644 	case asus_wmi_kbd_dock_devid:
645 		asus->tablet_switch_inverted = true;
646 		asus_wmi_tablet_sw_init(asus, ASUS_WMI_DEVID_KBD_DOCK, NOTIFY_KBD_DOCK_CHANGE);
647 		break;
648 	case asus_wmi_lid_flip_devid:
649 		asus_wmi_tablet_sw_init(asus, ASUS_WMI_DEVID_LID_FLIP, NOTIFY_LID_FLIP);
650 		break;
651 	case asus_wmi_lid_flip_rog_devid:
652 		asus_wmi_tablet_sw_init(asus, ASUS_WMI_DEVID_LID_FLIP_ROG, NOTIFY_LID_FLIP_ROG);
653 		break;
654 	}
655 
656 	err = input_register_device(asus->inputdev);
657 	if (err)
658 		goto err_free_dev;
659 
660 	return 0;
661 
662 err_free_dev:
663 	input_free_device(asus->inputdev);
664 	return err;
665 }
666 
667 static void asus_wmi_input_exit(struct asus_wmi *asus)
668 {
669 	if (asus->inputdev)
670 		input_unregister_device(asus->inputdev);
671 
672 	asus->inputdev = NULL;
673 }
674 
675 /* Tablet mode ****************************************************************/
676 
677 static void asus_wmi_tablet_mode_get_state(struct asus_wmi *asus)
678 {
679 	int result;
680 
681 	if (!asus->tablet_switch_dev_id)
682 		return;
683 
684 	result = asus_wmi_get_devstate_simple(asus, asus->tablet_switch_dev_id);
685 	if (result >= 0)
686 		asus_wmi_tablet_sw_report(asus, result);
687 }
688 
689 /* Charging mode, 1=Barrel, 2=USB ******************************************/
690 static ssize_t charge_mode_show(struct device *dev,
691 				   struct device_attribute *attr, char *buf)
692 {
693 	struct asus_wmi *asus = dev_get_drvdata(dev);
694 	int result, value;
695 
696 	result = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CHARGE_MODE, &value);
697 	if (result < 0)
698 		return result;
699 
700 	return sysfs_emit(buf, "%d\n", value & 0xff);
701 }
702 
703 static DEVICE_ATTR_RO(charge_mode);
704 
705 /* dGPU ********************************************************************/
706 static ssize_t dgpu_disable_show(struct device *dev,
707 				   struct device_attribute *attr, char *buf)
708 {
709 	struct asus_wmi *asus = dev_get_drvdata(dev);
710 	int result;
711 
712 	result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU);
713 	if (result < 0)
714 		return result;
715 
716 	return sysfs_emit(buf, "%d\n", result);
717 }
718 
719 /*
720  * A user may be required to store the value twice, typcial store first, then
721  * rescan PCI bus to activate power, then store a second time to save correctly.
722  * The reason for this is that an extra code path in the ACPI is enabled when
723  * the device and bus are powered.
724  */
725 static ssize_t dgpu_disable_store(struct device *dev,
726 				    struct device_attribute *attr,
727 				    const char *buf, size_t count)
728 {
729 	int result, err;
730 	u32 disable;
731 
732 	struct asus_wmi *asus = dev_get_drvdata(dev);
733 
734 	result = kstrtou32(buf, 10, &disable);
735 	if (result)
736 		return result;
737 
738 	if (disable > 1)
739 		return -EINVAL;
740 
741 	if (asus->gpu_mux_dev) {
742 		result = asus_wmi_get_devstate_simple(asus, asus->gpu_mux_dev);
743 		if (result < 0)
744 			/* An error here may signal greater failure of GPU handling */
745 			return result;
746 		if (!result && disable) {
747 			err = -ENODEV;
748 			pr_warn("Can not disable dGPU when the MUX is in dGPU mode: %d\n", err);
749 			return err;
750 		}
751 	}
752 
753 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result);
754 	if (err) {
755 		pr_warn("Failed to set dgpu disable: %d\n", err);
756 		return err;
757 	}
758 
759 	if (result > 1) {
760 		pr_warn("Failed to set dgpu disable (result): 0x%x\n", result);
761 		return -EIO;
762 	}
763 
764 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "dgpu_disable");
765 
766 	return count;
767 }
768 static DEVICE_ATTR_RW(dgpu_disable);
769 
770 /* eGPU ********************************************************************/
771 static ssize_t egpu_enable_show(struct device *dev,
772 				   struct device_attribute *attr, char *buf)
773 {
774 	struct asus_wmi *asus = dev_get_drvdata(dev);
775 	int result;
776 
777 	result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU);
778 	if (result < 0)
779 		return result;
780 
781 	return sysfs_emit(buf, "%d\n", result);
782 }
783 
784 /* The ACPI call to enable the eGPU also disables the internal dGPU */
785 static ssize_t egpu_enable_store(struct device *dev,
786 				    struct device_attribute *attr,
787 				    const char *buf, size_t count)
788 {
789 	int result, err;
790 	u32 enable;
791 
792 	struct asus_wmi *asus = dev_get_drvdata(dev);
793 
794 	err = kstrtou32(buf, 10, &enable);
795 	if (err)
796 		return err;
797 
798 	if (enable > 1)
799 		return -EINVAL;
800 
801 	err = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED);
802 	if (err < 0) {
803 		pr_warn("Failed to get egpu connection status: %d\n", err);
804 		return err;
805 	}
806 
807 	if (asus->gpu_mux_dev) {
808 		result = asus_wmi_get_devstate_simple(asus, asus->gpu_mux_dev);
809 		if (result < 0) {
810 			/* An error here may signal greater failure of GPU handling */
811 			pr_warn("Failed to get gpu mux status: %d\n", result);
812 			return result;
813 		}
814 		if (!result && enable) {
815 			err = -ENODEV;
816 			pr_warn("Can not enable eGPU when the MUX is in dGPU mode: %d\n", err);
817 			return err;
818 		}
819 	}
820 
821 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result);
822 	if (err) {
823 		pr_warn("Failed to set egpu state: %d\n", err);
824 		return err;
825 	}
826 
827 	if (result > 1) {
828 		pr_warn("Failed to set egpu state (retval): 0x%x\n", result);
829 		return -EIO;
830 	}
831 
832 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "egpu_enable");
833 
834 	return count;
835 }
836 static DEVICE_ATTR_RW(egpu_enable);
837 
838 /* Is eGPU connected? *********************************************************/
839 static ssize_t egpu_connected_show(struct device *dev,
840 				   struct device_attribute *attr, char *buf)
841 {
842 	struct asus_wmi *asus = dev_get_drvdata(dev);
843 	int result;
844 
845 	result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED);
846 	if (result < 0)
847 		return result;
848 
849 	return sysfs_emit(buf, "%d\n", result);
850 }
851 
852 static DEVICE_ATTR_RO(egpu_connected);
853 
854 /* gpu mux switch *************************************************************/
855 static ssize_t gpu_mux_mode_show(struct device *dev,
856 				 struct device_attribute *attr, char *buf)
857 {
858 	struct asus_wmi *asus = dev_get_drvdata(dev);
859 	int result;
860 
861 	result = asus_wmi_get_devstate_simple(asus, asus->gpu_mux_dev);
862 	if (result < 0)
863 		return result;
864 
865 	return sysfs_emit(buf, "%d\n", result);
866 }
867 
868 static ssize_t gpu_mux_mode_store(struct device *dev,
869 				  struct device_attribute *attr,
870 				  const char *buf, size_t count)
871 {
872 	struct asus_wmi *asus = dev_get_drvdata(dev);
873 	int result, err;
874 	u32 optimus;
875 
876 	err = kstrtou32(buf, 10, &optimus);
877 	if (err)
878 		return err;
879 
880 	if (optimus > 1)
881 		return -EINVAL;
882 
883 	if (asus->dgpu_disable_available) {
884 		result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU);
885 		if (result < 0)
886 			/* An error here may signal greater failure of GPU handling */
887 			return result;
888 		if (result && !optimus) {
889 			err = -ENODEV;
890 			pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %d\n", err);
891 			return err;
892 		}
893 	}
894 
895 	if (asus->egpu_enable_available) {
896 		result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU);
897 		if (result < 0)
898 			/* An error here may signal greater failure of GPU handling */
899 			return result;
900 		if (result && !optimus) {
901 			err = -ENODEV;
902 			pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled: %d\n", err);
903 			return err;
904 		}
905 	}
906 
907 	err = asus_wmi_set_devstate(asus->gpu_mux_dev, optimus, &result);
908 	if (err) {
909 		dev_err(dev, "Failed to set GPU MUX mode: %d\n", err);
910 		return err;
911 	}
912 	/* !1 is considered a fail by ASUS */
913 	if (result != 1) {
914 		dev_warn(dev, "Failed to set GPU MUX mode (result): 0x%x\n", result);
915 		return -EIO;
916 	}
917 
918 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "gpu_mux_mode");
919 
920 	return count;
921 }
922 static DEVICE_ATTR_RW(gpu_mux_mode);
923 
924 /* TUF Laptop Keyboard RGB Modes **********************************************/
925 static ssize_t kbd_rgb_mode_store(struct device *dev,
926 				 struct device_attribute *attr,
927 				 const char *buf, size_t count)
928 {
929 	u32 cmd, mode, r, g, b, speed;
930 	struct led_classdev *led;
931 	struct asus_wmi *asus;
932 	int err;
933 
934 	led = dev_get_drvdata(dev);
935 	asus = container_of(led, struct asus_wmi, kbd_led);
936 
937 	if (sscanf(buf, "%d %d %d %d %d %d", &cmd, &mode, &r, &g, &b, &speed) != 6)
938 		return -EINVAL;
939 
940 	/* B3 is set and B4 is save to BIOS */
941 	switch (cmd) {
942 	case 0:
943 		cmd = 0xb3;
944 		break;
945 	case 1:
946 		cmd = 0xb4;
947 		break;
948 	default:
949 		return -EINVAL;
950 	}
951 
952 	/* These are the known usable modes across all TUF/ROG */
953 	if (mode >= 12 || mode == 9)
954 		mode = 10;
955 
956 	switch (speed) {
957 	case 0:
958 		speed = 0xe1;
959 		break;
960 	case 1:
961 		speed = 0xeb;
962 		break;
963 	case 2:
964 		speed = 0xf5;
965 		break;
966 	default:
967 		speed = 0xeb;
968 	}
969 
970 	err = asus_wmi_evaluate_method3(ASUS_WMI_METHODID_DEVS, asus->kbd_rgb_dev,
971 			cmd | (mode << 8) | (r << 16) | (g << 24), b | (speed << 8), NULL);
972 	if (err)
973 		return err;
974 
975 	return count;
976 }
977 static DEVICE_ATTR_WO(kbd_rgb_mode);
978 
979 static DEVICE_STRING_ATTR_RO(kbd_rgb_mode_index, 0444,
980 			     "cmd mode red green blue speed");
981 
982 static struct attribute *kbd_rgb_mode_attrs[] = {
983 	&dev_attr_kbd_rgb_mode.attr,
984 	&dev_attr_kbd_rgb_mode_index.attr.attr,
985 	NULL,
986 };
987 
988 static const struct attribute_group kbd_rgb_mode_group = {
989 	.attrs = kbd_rgb_mode_attrs,
990 };
991 
992 /* TUF Laptop Keyboard RGB State **********************************************/
993 static ssize_t kbd_rgb_state_store(struct device *dev,
994 				 struct device_attribute *attr,
995 				 const char *buf, size_t count)
996 {
997 	u32 flags, cmd, boot, awake, sleep, keyboard;
998 	int err;
999 
1000 	if (sscanf(buf, "%d %d %d %d %d", &cmd, &boot, &awake, &sleep, &keyboard) != 5)
1001 		return -EINVAL;
1002 
1003 	if (cmd)
1004 		cmd = BIT(2);
1005 
1006 	flags = 0;
1007 	if (boot)
1008 		flags |= BIT(1);
1009 	if (awake)
1010 		flags |= BIT(3);
1011 	if (sleep)
1012 		flags |= BIT(5);
1013 	if (keyboard)
1014 		flags |= BIT(7);
1015 
1016 	/* 0xbd is the required default arg0 for the method. Nothing happens otherwise */
1017 	err = asus_wmi_evaluate_method3(ASUS_WMI_METHODID_DEVS,
1018 			ASUS_WMI_DEVID_TUF_RGB_STATE, 0xbd | cmd << 8 | (flags << 16), 0, NULL);
1019 	if (err)
1020 		return err;
1021 
1022 	return count;
1023 }
1024 static DEVICE_ATTR_WO(kbd_rgb_state);
1025 
1026 static DEVICE_STRING_ATTR_RO(kbd_rgb_state_index, 0444,
1027 			     "cmd boot awake sleep keyboard");
1028 
1029 static struct attribute *kbd_rgb_state_attrs[] = {
1030 	&dev_attr_kbd_rgb_state.attr,
1031 	&dev_attr_kbd_rgb_state_index.attr.attr,
1032 	NULL,
1033 };
1034 
1035 static const struct attribute_group kbd_rgb_state_group = {
1036 	.attrs = kbd_rgb_state_attrs,
1037 };
1038 
1039 static const struct attribute_group *kbd_rgb_mode_groups[] = {
1040 	NULL,
1041 	NULL,
1042 	NULL,
1043 };
1044 
1045 /* Tunable: PPT: Intel=PL1, AMD=SPPT *****************************************/
1046 static ssize_t ppt_pl2_sppt_store(struct device *dev,
1047 				    struct device_attribute *attr,
1048 				    const char *buf, size_t count)
1049 {
1050 	struct asus_wmi *asus = dev_get_drvdata(dev);
1051 	int result, err;
1052 	u32 value;
1053 
1054 	result = kstrtou32(buf, 10, &value);
1055 	if (result)
1056 		return result;
1057 
1058 	if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
1059 		return -EINVAL;
1060 
1061 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PL2_SPPT, value, &result);
1062 	if (err) {
1063 		pr_warn("Failed to set ppt_pl2_sppt: %d\n", err);
1064 		return err;
1065 	}
1066 
1067 	if (result > 1) {
1068 		pr_warn("Failed to set ppt_pl2_sppt (result): 0x%x\n", result);
1069 		return -EIO;
1070 	}
1071 
1072 	asus->ppt_pl2_sppt = value;
1073 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_pl2_sppt");
1074 
1075 	return count;
1076 }
1077 
1078 static ssize_t ppt_pl2_sppt_show(struct device *dev,
1079 				       struct device_attribute *attr,
1080 				       char *buf)
1081 {
1082 	struct asus_wmi *asus = dev_get_drvdata(dev);
1083 
1084 	return sysfs_emit(buf, "%u\n", asus->ppt_pl2_sppt);
1085 }
1086 static DEVICE_ATTR_RW(ppt_pl2_sppt);
1087 
1088 /* Tunable: PPT, Intel=PL1, AMD=SPL ******************************************/
1089 static ssize_t ppt_pl1_spl_store(struct device *dev,
1090 				    struct device_attribute *attr,
1091 				    const char *buf, size_t count)
1092 {
1093 	struct asus_wmi *asus = dev_get_drvdata(dev);
1094 	int result, err;
1095 	u32 value;
1096 
1097 	result = kstrtou32(buf, 10, &value);
1098 	if (result)
1099 		return result;
1100 
1101 	if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
1102 		return -EINVAL;
1103 
1104 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PL1_SPL, value, &result);
1105 	if (err) {
1106 		pr_warn("Failed to set ppt_pl1_spl: %d\n", err);
1107 		return err;
1108 	}
1109 
1110 	if (result > 1) {
1111 		pr_warn("Failed to set ppt_pl1_spl (result): 0x%x\n", result);
1112 		return -EIO;
1113 	}
1114 
1115 	asus->ppt_pl1_spl = value;
1116 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_pl1_spl");
1117 
1118 	return count;
1119 }
1120 static ssize_t ppt_pl1_spl_show(struct device *dev,
1121 				 struct device_attribute *attr,
1122 				 char *buf)
1123 {
1124 	struct asus_wmi *asus = dev_get_drvdata(dev);
1125 
1126 	return sysfs_emit(buf, "%u\n", asus->ppt_pl1_spl);
1127 }
1128 static DEVICE_ATTR_RW(ppt_pl1_spl);
1129 
1130 /* Tunable: PPT APU FPPT ******************************************************/
1131 static ssize_t ppt_fppt_store(struct device *dev,
1132 				    struct device_attribute *attr,
1133 				    const char *buf, size_t count)
1134 {
1135 	struct asus_wmi *asus = dev_get_drvdata(dev);
1136 	int result, err;
1137 	u32 value;
1138 
1139 	result = kstrtou32(buf, 10, &value);
1140 	if (result)
1141 		return result;
1142 
1143 	if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
1144 		return -EINVAL;
1145 
1146 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_FPPT, value, &result);
1147 	if (err) {
1148 		pr_warn("Failed to set ppt_fppt: %d\n", err);
1149 		return err;
1150 	}
1151 
1152 	if (result > 1) {
1153 		pr_warn("Failed to set ppt_fppt (result): 0x%x\n", result);
1154 		return -EIO;
1155 	}
1156 
1157 	asus->ppt_fppt = value;
1158 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_fpu_sppt");
1159 
1160 	return count;
1161 }
1162 
1163 static ssize_t ppt_fppt_show(struct device *dev,
1164 				struct device_attribute *attr,
1165 				char *buf)
1166 {
1167 	struct asus_wmi *asus = dev_get_drvdata(dev);
1168 
1169 	return sysfs_emit(buf, "%u\n", asus->ppt_fppt);
1170 }
1171 static DEVICE_ATTR_RW(ppt_fppt);
1172 
1173 /* Tunable: PPT APU SPPT *****************************************************/
1174 static ssize_t ppt_apu_sppt_store(struct device *dev,
1175 				    struct device_attribute *attr,
1176 				    const char *buf, size_t count)
1177 {
1178 	struct asus_wmi *asus = dev_get_drvdata(dev);
1179 	int result, err;
1180 	u32 value;
1181 
1182 	result = kstrtou32(buf, 10, &value);
1183 	if (result)
1184 		return result;
1185 
1186 	if (value < PPT_CPU_MIN || value > PPT_CPU_MAX)
1187 		return -EINVAL;
1188 
1189 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_APU_SPPT, value, &result);
1190 	if (err) {
1191 		pr_warn("Failed to set ppt_apu_sppt: %d\n", err);
1192 		return err;
1193 	}
1194 
1195 	if (result > 1) {
1196 		pr_warn("Failed to set ppt_apu_sppt (result): 0x%x\n", result);
1197 		return -EIO;
1198 	}
1199 
1200 	asus->ppt_apu_sppt = value;
1201 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_apu_sppt");
1202 
1203 	return count;
1204 }
1205 
1206 static ssize_t ppt_apu_sppt_show(struct device *dev,
1207 			     struct device_attribute *attr,
1208 			     char *buf)
1209 {
1210 	struct asus_wmi *asus = dev_get_drvdata(dev);
1211 
1212 	return sysfs_emit(buf, "%u\n", asus->ppt_apu_sppt);
1213 }
1214 static DEVICE_ATTR_RW(ppt_apu_sppt);
1215 
1216 /* Tunable: PPT platform SPPT ************************************************/
1217 static ssize_t ppt_platform_sppt_store(struct device *dev,
1218 				    struct device_attribute *attr,
1219 				    const char *buf, size_t count)
1220 {
1221 	struct asus_wmi *asus = dev_get_drvdata(dev);
1222 	int result, err;
1223 	u32 value;
1224 
1225 	result = kstrtou32(buf, 10, &value);
1226 	if (result)
1227 		return result;
1228 
1229 	if (value < PPT_CPU_MIN || value > PPT_CPU_MAX)
1230 		return -EINVAL;
1231 
1232 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PLAT_SPPT, value, &result);
1233 	if (err) {
1234 		pr_warn("Failed to set ppt_platform_sppt: %d\n", err);
1235 		return err;
1236 	}
1237 
1238 	if (result > 1) {
1239 		pr_warn("Failed to set ppt_platform_sppt (result): 0x%x\n", result);
1240 		return -EIO;
1241 	}
1242 
1243 	asus->ppt_platform_sppt = value;
1244 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_platform_sppt");
1245 
1246 	return count;
1247 }
1248 
1249 static ssize_t ppt_platform_sppt_show(struct device *dev,
1250 				 struct device_attribute *attr,
1251 				 char *buf)
1252 {
1253 	struct asus_wmi *asus = dev_get_drvdata(dev);
1254 
1255 	return sysfs_emit(buf, "%u\n", asus->ppt_platform_sppt);
1256 }
1257 static DEVICE_ATTR_RW(ppt_platform_sppt);
1258 
1259 /* Tunable: NVIDIA dynamic boost *********************************************/
1260 static ssize_t nv_dynamic_boost_store(struct device *dev,
1261 				    struct device_attribute *attr,
1262 				    const char *buf, size_t count)
1263 {
1264 	struct asus_wmi *asus = dev_get_drvdata(dev);
1265 	int result, err;
1266 	u32 value;
1267 
1268 	result = kstrtou32(buf, 10, &value);
1269 	if (result)
1270 		return result;
1271 
1272 	if (value < NVIDIA_BOOST_MIN || value > NVIDIA_BOOST_MAX)
1273 		return -EINVAL;
1274 
1275 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_NV_DYN_BOOST, value, &result);
1276 	if (err) {
1277 		pr_warn("Failed to set nv_dynamic_boost: %d\n", err);
1278 		return err;
1279 	}
1280 
1281 	if (result > 1) {
1282 		pr_warn("Failed to set nv_dynamic_boost (result): 0x%x\n", result);
1283 		return -EIO;
1284 	}
1285 
1286 	asus->nv_dynamic_boost = value;
1287 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "nv_dynamic_boost");
1288 
1289 	return count;
1290 }
1291 
1292 static ssize_t nv_dynamic_boost_show(struct device *dev,
1293 				      struct device_attribute *attr,
1294 				      char *buf)
1295 {
1296 	struct asus_wmi *asus = dev_get_drvdata(dev);
1297 
1298 	return sysfs_emit(buf, "%u\n", asus->nv_dynamic_boost);
1299 }
1300 static DEVICE_ATTR_RW(nv_dynamic_boost);
1301 
1302 /* Tunable: NVIDIA temperature target ****************************************/
1303 static ssize_t nv_temp_target_store(struct device *dev,
1304 				    struct device_attribute *attr,
1305 				    const char *buf, size_t count)
1306 {
1307 	struct asus_wmi *asus = dev_get_drvdata(dev);
1308 	int result, err;
1309 	u32 value;
1310 
1311 	result = kstrtou32(buf, 10, &value);
1312 	if (result)
1313 		return result;
1314 
1315 	if (value < NVIDIA_TEMP_MIN || value > NVIDIA_TEMP_MAX)
1316 		return -EINVAL;
1317 
1318 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_NV_THERM_TARGET, value, &result);
1319 	if (err) {
1320 		pr_warn("Failed to set nv_temp_target: %d\n", err);
1321 		return err;
1322 	}
1323 
1324 	if (result > 1) {
1325 		pr_warn("Failed to set nv_temp_target (result): 0x%x\n", result);
1326 		return -EIO;
1327 	}
1328 
1329 	asus->nv_temp_target = value;
1330 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "nv_temp_target");
1331 
1332 	return count;
1333 }
1334 
1335 static ssize_t nv_temp_target_show(struct device *dev,
1336 				     struct device_attribute *attr,
1337 				     char *buf)
1338 {
1339 	struct asus_wmi *asus = dev_get_drvdata(dev);
1340 
1341 	return sysfs_emit(buf, "%u\n", asus->nv_temp_target);
1342 }
1343 static DEVICE_ATTR_RW(nv_temp_target);
1344 
1345 /* Ally MCU Powersave ********************************************************/
1346 static ssize_t mcu_powersave_show(struct device *dev,
1347 				   struct device_attribute *attr, char *buf)
1348 {
1349 	struct asus_wmi *asus = dev_get_drvdata(dev);
1350 	int result;
1351 
1352 	result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_MCU_POWERSAVE);
1353 	if (result < 0)
1354 		return result;
1355 
1356 	return sysfs_emit(buf, "%d\n", result);
1357 }
1358 
1359 static ssize_t mcu_powersave_store(struct device *dev,
1360 				    struct device_attribute *attr,
1361 				    const char *buf, size_t count)
1362 {
1363 	int result, err;
1364 	u32 enable;
1365 
1366 	struct asus_wmi *asus = dev_get_drvdata(dev);
1367 
1368 	result = kstrtou32(buf, 10, &enable);
1369 	if (result)
1370 		return result;
1371 
1372 	if (enable > 1)
1373 		return -EINVAL;
1374 
1375 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MCU_POWERSAVE, enable, &result);
1376 	if (err) {
1377 		pr_warn("Failed to set MCU powersave: %d\n", err);
1378 		return err;
1379 	}
1380 
1381 	if (result > 1) {
1382 		pr_warn("Failed to set MCU powersave (result): 0x%x\n", result);
1383 		return -EIO;
1384 	}
1385 
1386 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "mcu_powersave");
1387 
1388 	return count;
1389 }
1390 static DEVICE_ATTR_RW(mcu_powersave);
1391 
1392 /* Battery ********************************************************************/
1393 
1394 /* The battery maximum charging percentage */
1395 static int charge_end_threshold;
1396 
1397 static ssize_t charge_control_end_threshold_store(struct device *dev,
1398 						  struct device_attribute *attr,
1399 						  const char *buf, size_t count)
1400 {
1401 	int value, ret, rv;
1402 
1403 	ret = kstrtouint(buf, 10, &value);
1404 	if (ret)
1405 		return ret;
1406 
1407 	if (value < 0 || value > 100)
1408 		return -EINVAL;
1409 
1410 	ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
1411 	if (ret)
1412 		return ret;
1413 
1414 	if (rv != 1)
1415 		return -EIO;
1416 
1417 	/* There isn't any method in the DSDT to read the threshold, so we
1418 	 * save the threshold.
1419 	 */
1420 	charge_end_threshold = value;
1421 	return count;
1422 }
1423 
1424 static ssize_t charge_control_end_threshold_show(struct device *device,
1425 						 struct device_attribute *attr,
1426 						 char *buf)
1427 {
1428 	return sysfs_emit(buf, "%d\n", charge_end_threshold);
1429 }
1430 
1431 static DEVICE_ATTR_RW(charge_control_end_threshold);
1432 
1433 static int asus_wmi_battery_add(struct power_supply *battery, struct acpi_battery_hook *hook)
1434 {
1435 	/* The WMI method does not provide a way to specific a battery, so we
1436 	 * just assume it is the first battery.
1437 	 * Note: On some newer ASUS laptops (Zenbook UM431DA), the primary/first
1438 	 * battery is named BATT.
1439 	 */
1440 	if (strcmp(battery->desc->name, "BAT0") != 0 &&
1441 	    strcmp(battery->desc->name, "BAT1") != 0 &&
1442 	    strcmp(battery->desc->name, "BATC") != 0 &&
1443 	    strcmp(battery->desc->name, "BATT") != 0)
1444 		return -ENODEV;
1445 
1446 	if (device_create_file(&battery->dev,
1447 	    &dev_attr_charge_control_end_threshold))
1448 		return -ENODEV;
1449 
1450 	/* The charge threshold is only reset when the system is power cycled,
1451 	 * and we can't get the current threshold so let set it to 100% when
1452 	 * a battery is added.
1453 	 */
1454 	asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
1455 	charge_end_threshold = 100;
1456 
1457 	return 0;
1458 }
1459 
1460 static int asus_wmi_battery_remove(struct power_supply *battery, struct acpi_battery_hook *hook)
1461 {
1462 	device_remove_file(&battery->dev,
1463 			   &dev_attr_charge_control_end_threshold);
1464 	return 0;
1465 }
1466 
1467 static struct acpi_battery_hook battery_hook = {
1468 	.add_battery = asus_wmi_battery_add,
1469 	.remove_battery = asus_wmi_battery_remove,
1470 	.name = "ASUS Battery Extension",
1471 };
1472 
1473 static void asus_wmi_battery_init(struct asus_wmi *asus)
1474 {
1475 	asus->battery_rsoc_available = false;
1476 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
1477 		asus->battery_rsoc_available = true;
1478 		battery_hook_register(&battery_hook);
1479 	}
1480 }
1481 
1482 static void asus_wmi_battery_exit(struct asus_wmi *asus)
1483 {
1484 	if (asus->battery_rsoc_available)
1485 		battery_hook_unregister(&battery_hook);
1486 }
1487 
1488 /* LEDs ***********************************************************************/
1489 
1490 /*
1491  * These functions actually update the LED's, and are called from a
1492  * workqueue. By doing this as separate work rather than when the LED
1493  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
1494  * potentially bad time, such as a timer interrupt.
1495  */
1496 static void tpd_led_update(struct work_struct *work)
1497 {
1498 	int ctrl_param;
1499 	struct asus_wmi *asus;
1500 
1501 	asus = container_of(work, struct asus_wmi, tpd_led_work);
1502 
1503 	ctrl_param = asus->tpd_led_wk;
1504 	asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
1505 }
1506 
1507 static void tpd_led_set(struct led_classdev *led_cdev,
1508 			enum led_brightness value)
1509 {
1510 	struct asus_wmi *asus;
1511 
1512 	asus = container_of(led_cdev, struct asus_wmi, tpd_led);
1513 
1514 	asus->tpd_led_wk = !!value;
1515 	queue_work(asus->led_workqueue, &asus->tpd_led_work);
1516 }
1517 
1518 static int read_tpd_led_state(struct asus_wmi *asus)
1519 {
1520 	return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
1521 }
1522 
1523 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
1524 {
1525 	struct asus_wmi *asus;
1526 
1527 	asus = container_of(led_cdev, struct asus_wmi, tpd_led);
1528 
1529 	return read_tpd_led_state(asus);
1530 }
1531 
1532 static void kbd_led_update(struct asus_wmi *asus)
1533 {
1534 	int ctrl_param = 0;
1535 
1536 	ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
1537 	asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
1538 }
1539 
1540 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
1541 {
1542 	int retval;
1543 
1544 	/*
1545 	 * bits 0-2: level
1546 	 * bit 7: light on/off
1547 	 * bit 8-10: environment (0: dark, 1: normal, 2: light)
1548 	 * bit 17: status unknown
1549 	 */
1550 	retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
1551 					    0xFFFF);
1552 
1553 	/* Unknown status is considered as off */
1554 	if (retval == 0x8000)
1555 		retval = 0;
1556 
1557 	if (retval < 0)
1558 		return retval;
1559 
1560 	if (level)
1561 		*level = retval & 0x7F;
1562 	if (env)
1563 		*env = (retval >> 8) & 0x7F;
1564 	return 0;
1565 }
1566 
1567 static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
1568 {
1569 	struct asus_wmi *asus;
1570 	int max_level;
1571 
1572 	asus = container_of(led_cdev, struct asus_wmi, kbd_led);
1573 	max_level = asus->kbd_led.max_brightness;
1574 
1575 	asus->kbd_led_wk = clamp_val(value, 0, max_level);
1576 	kbd_led_update(asus);
1577 }
1578 
1579 static void kbd_led_set(struct led_classdev *led_cdev,
1580 			enum led_brightness value)
1581 {
1582 	/* Prevent disabling keyboard backlight on module unregister */
1583 	if (led_cdev->flags & LED_UNREGISTERING)
1584 		return;
1585 
1586 	do_kbd_led_set(led_cdev, value);
1587 }
1588 
1589 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
1590 {
1591 	struct led_classdev *led_cdev = &asus->kbd_led;
1592 
1593 	do_kbd_led_set(led_cdev, value);
1594 	led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
1595 }
1596 
1597 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
1598 {
1599 	struct asus_wmi *asus;
1600 	int retval, value;
1601 
1602 	asus = container_of(led_cdev, struct asus_wmi, kbd_led);
1603 
1604 	retval = kbd_led_read(asus, &value, NULL);
1605 	if (retval < 0)
1606 		return retval;
1607 
1608 	return value;
1609 }
1610 
1611 static int wlan_led_unknown_state(struct asus_wmi *asus)
1612 {
1613 	u32 result;
1614 
1615 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
1616 
1617 	return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
1618 }
1619 
1620 static void wlan_led_update(struct work_struct *work)
1621 {
1622 	int ctrl_param;
1623 	struct asus_wmi *asus;
1624 
1625 	asus = container_of(work, struct asus_wmi, wlan_led_work);
1626 
1627 	ctrl_param = asus->wlan_led_wk;
1628 	asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
1629 }
1630 
1631 static void wlan_led_set(struct led_classdev *led_cdev,
1632 			 enum led_brightness value)
1633 {
1634 	struct asus_wmi *asus;
1635 
1636 	asus = container_of(led_cdev, struct asus_wmi, wlan_led);
1637 
1638 	asus->wlan_led_wk = !!value;
1639 	queue_work(asus->led_workqueue, &asus->wlan_led_work);
1640 }
1641 
1642 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
1643 {
1644 	struct asus_wmi *asus;
1645 	u32 result;
1646 
1647 	asus = container_of(led_cdev, struct asus_wmi, wlan_led);
1648 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
1649 
1650 	return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1651 }
1652 
1653 static void lightbar_led_update(struct work_struct *work)
1654 {
1655 	struct asus_wmi *asus;
1656 	int ctrl_param;
1657 
1658 	asus = container_of(work, struct asus_wmi, lightbar_led_work);
1659 
1660 	ctrl_param = asus->lightbar_led_wk;
1661 	asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
1662 }
1663 
1664 static void lightbar_led_set(struct led_classdev *led_cdev,
1665 			     enum led_brightness value)
1666 {
1667 	struct asus_wmi *asus;
1668 
1669 	asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1670 
1671 	asus->lightbar_led_wk = !!value;
1672 	queue_work(asus->led_workqueue, &asus->lightbar_led_work);
1673 }
1674 
1675 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
1676 {
1677 	struct asus_wmi *asus;
1678 	u32 result;
1679 
1680 	asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1681 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
1682 
1683 	return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
1684 }
1685 
1686 static int micmute_led_set(struct led_classdev *led_cdev,
1687 			   enum led_brightness brightness)
1688 {
1689 	int state = brightness != LED_OFF;
1690 	int err;
1691 
1692 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MICMUTE_LED, state, NULL);
1693 	return err < 0 ? err : 0;
1694 }
1695 
1696 static enum led_brightness camera_led_get(struct led_classdev *led_cdev)
1697 {
1698 	struct asus_wmi *asus;
1699 	u32 result;
1700 
1701 	asus = container_of(led_cdev, struct asus_wmi, camera_led);
1702 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CAMERA_LED, &result);
1703 
1704 	return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1705 }
1706 
1707 static int camera_led_set(struct led_classdev *led_cdev,
1708 			   enum led_brightness brightness)
1709 {
1710 	int state = brightness != LED_OFF;
1711 	int err;
1712 
1713 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CAMERA_LED, state, NULL);
1714 	return err < 0 ? err : 0;
1715 }
1716 
1717 static void asus_wmi_led_exit(struct asus_wmi *asus)
1718 {
1719 	led_classdev_unregister(&asus->kbd_led);
1720 	led_classdev_unregister(&asus->tpd_led);
1721 	led_classdev_unregister(&asus->wlan_led);
1722 	led_classdev_unregister(&asus->lightbar_led);
1723 	led_classdev_unregister(&asus->micmute_led);
1724 	led_classdev_unregister(&asus->camera_led);
1725 
1726 	if (asus->led_workqueue)
1727 		destroy_workqueue(asus->led_workqueue);
1728 }
1729 
1730 static int asus_wmi_led_init(struct asus_wmi *asus)
1731 {
1732 	int rv = 0, num_rgb_groups = 0, led_val;
1733 
1734 	if (asus->kbd_rgb_dev)
1735 		kbd_rgb_mode_groups[num_rgb_groups++] = &kbd_rgb_mode_group;
1736 	if (asus->kbd_rgb_state_available)
1737 		kbd_rgb_mode_groups[num_rgb_groups++] = &kbd_rgb_state_group;
1738 
1739 	asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
1740 	if (!asus->led_workqueue)
1741 		return -ENOMEM;
1742 
1743 	if (read_tpd_led_state(asus) >= 0) {
1744 		INIT_WORK(&asus->tpd_led_work, tpd_led_update);
1745 
1746 		asus->tpd_led.name = "asus::touchpad";
1747 		asus->tpd_led.brightness_set = tpd_led_set;
1748 		asus->tpd_led.brightness_get = tpd_led_get;
1749 		asus->tpd_led.max_brightness = 1;
1750 
1751 		rv = led_classdev_register(&asus->platform_device->dev,
1752 					   &asus->tpd_led);
1753 		if (rv)
1754 			goto error;
1755 	}
1756 
1757 	if (!kbd_led_read(asus, &led_val, NULL) && !dmi_check_system(asus_use_hid_led_dmi_ids)) {
1758 		pr_info("using asus-wmi for asus::kbd_backlight\n");
1759 		asus->kbd_led_wk = led_val;
1760 		asus->kbd_led.name = "asus::kbd_backlight";
1761 		asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
1762 		asus->kbd_led.brightness_set = kbd_led_set;
1763 		asus->kbd_led.brightness_get = kbd_led_get;
1764 		asus->kbd_led.max_brightness = 3;
1765 
1766 		if (num_rgb_groups != 0)
1767 			asus->kbd_led.groups = kbd_rgb_mode_groups;
1768 
1769 		rv = led_classdev_register(&asus->platform_device->dev,
1770 					   &asus->kbd_led);
1771 		if (rv)
1772 			goto error;
1773 	}
1774 
1775 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
1776 			&& (asus->driver->quirks->wapf > 0)) {
1777 		INIT_WORK(&asus->wlan_led_work, wlan_led_update);
1778 
1779 		asus->wlan_led.name = "asus::wlan";
1780 		asus->wlan_led.brightness_set = wlan_led_set;
1781 		if (!wlan_led_unknown_state(asus))
1782 			asus->wlan_led.brightness_get = wlan_led_get;
1783 		asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
1784 		asus->wlan_led.max_brightness = 1;
1785 		asus->wlan_led.default_trigger = "asus-wlan";
1786 
1787 		rv = led_classdev_register(&asus->platform_device->dev,
1788 					   &asus->wlan_led);
1789 		if (rv)
1790 			goto error;
1791 	}
1792 
1793 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
1794 		INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
1795 
1796 		asus->lightbar_led.name = "asus::lightbar";
1797 		asus->lightbar_led.brightness_set = lightbar_led_set;
1798 		asus->lightbar_led.brightness_get = lightbar_led_get;
1799 		asus->lightbar_led.max_brightness = 1;
1800 
1801 		rv = led_classdev_register(&asus->platform_device->dev,
1802 					   &asus->lightbar_led);
1803 	}
1804 
1805 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MICMUTE_LED)) {
1806 		asus->micmute_led.name = "platform::micmute";
1807 		asus->micmute_led.max_brightness = 1;
1808 		asus->micmute_led.brightness_set_blocking = micmute_led_set;
1809 		asus->micmute_led.default_trigger = "audio-micmute";
1810 
1811 		rv = led_classdev_register(&asus->platform_device->dev,
1812 						&asus->micmute_led);
1813 		if (rv)
1814 			goto error;
1815 	}
1816 
1817 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CAMERA_LED)) {
1818 		asus->camera_led.name = "asus::camera";
1819 		asus->camera_led.max_brightness = 1;
1820 		asus->camera_led.brightness_get = camera_led_get;
1821 		asus->camera_led.brightness_set_blocking = camera_led_set;
1822 
1823 		rv = led_classdev_register(&asus->platform_device->dev,
1824 						&asus->camera_led);
1825 		if (rv)
1826 			goto error;
1827 	}
1828 
1829 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_OOBE)) {
1830 		/*
1831 		 * Disable OOBE state, so that e.g. the keyboard backlight
1832 		 * works.
1833 		 */
1834 		rv = asus_wmi_set_devstate(ASUS_WMI_DEVID_OOBE, 1, NULL);
1835 		if (rv)
1836 			goto error;
1837 	}
1838 
1839 error:
1840 	if (rv)
1841 		asus_wmi_led_exit(asus);
1842 
1843 	return rv;
1844 }
1845 
1846 /* RF *************************************************************************/
1847 
1848 /*
1849  * PCI hotplug (for wlan rfkill)
1850  */
1851 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
1852 {
1853 	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1854 
1855 	if (result < 0)
1856 		return false;
1857 	return !result;
1858 }
1859 
1860 static void asus_rfkill_hotplug(struct asus_wmi *asus)
1861 {
1862 	struct pci_dev *dev;
1863 	struct pci_bus *bus;
1864 	bool blocked;
1865 	bool absent;
1866 	u32 l;
1867 
1868 	mutex_lock(&asus->wmi_lock);
1869 	blocked = asus_wlan_rfkill_blocked(asus);
1870 	mutex_unlock(&asus->wmi_lock);
1871 
1872 	mutex_lock(&asus->hotplug_lock);
1873 	pci_lock_rescan_remove();
1874 
1875 	if (asus->wlan.rfkill)
1876 		rfkill_set_sw_state(asus->wlan.rfkill, blocked);
1877 
1878 	if (asus->hotplug_slot.ops) {
1879 		bus = pci_find_bus(0, 1);
1880 		if (!bus) {
1881 			pr_warn("Unable to find PCI bus 1?\n");
1882 			goto out_unlock;
1883 		}
1884 
1885 		if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
1886 			pr_err("Unable to read PCI config space?\n");
1887 			goto out_unlock;
1888 		}
1889 		absent = (l == 0xffffffff);
1890 
1891 		if (blocked != absent) {
1892 			pr_warn("BIOS says wireless lan is %s, but the pci device is %s\n",
1893 				blocked ? "blocked" : "unblocked",
1894 				absent ? "absent" : "present");
1895 			pr_warn("skipped wireless hotplug as probably inappropriate for this model\n");
1896 			goto out_unlock;
1897 		}
1898 
1899 		if (!blocked) {
1900 			dev = pci_get_slot(bus, 0);
1901 			if (dev) {
1902 				/* Device already present */
1903 				pci_dev_put(dev);
1904 				goto out_unlock;
1905 			}
1906 			dev = pci_scan_single_device(bus, 0);
1907 			if (dev) {
1908 				pci_bus_assign_resources(bus);
1909 				pci_bus_add_device(dev);
1910 			}
1911 		} else {
1912 			dev = pci_get_slot(bus, 0);
1913 			if (dev) {
1914 				pci_stop_and_remove_bus_device(dev);
1915 				pci_dev_put(dev);
1916 			}
1917 		}
1918 	}
1919 
1920 out_unlock:
1921 	pci_unlock_rescan_remove();
1922 	mutex_unlock(&asus->hotplug_lock);
1923 }
1924 
1925 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
1926 {
1927 	struct asus_wmi *asus = data;
1928 
1929 	if (event != ACPI_NOTIFY_BUS_CHECK)
1930 		return;
1931 
1932 	/*
1933 	 * We can't call directly asus_rfkill_hotplug because most
1934 	 * of the time WMBC is still being executed and not reetrant.
1935 	 * There is currently no way to tell ACPICA that  we want this
1936 	 * method to be serialized, we schedule a asus_rfkill_hotplug
1937 	 * call later, in a safer context.
1938 	 */
1939 	queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
1940 }
1941 
1942 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
1943 {
1944 	acpi_status status;
1945 	acpi_handle handle;
1946 
1947 	status = acpi_get_handle(NULL, node, &handle);
1948 	if (ACPI_FAILURE(status))
1949 		return -ENODEV;
1950 
1951 	status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1952 					     asus_rfkill_notify, asus);
1953 	if (ACPI_FAILURE(status))
1954 		pr_warn("Failed to register notify on %s\n", node);
1955 
1956 	return 0;
1957 }
1958 
1959 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
1960 {
1961 	acpi_status status = AE_OK;
1962 	acpi_handle handle;
1963 
1964 	status = acpi_get_handle(NULL, node, &handle);
1965 	if (ACPI_FAILURE(status))
1966 		return;
1967 
1968 	status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1969 					    asus_rfkill_notify);
1970 	if (ACPI_FAILURE(status))
1971 		pr_err("Error removing rfkill notify handler %s\n", node);
1972 }
1973 
1974 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
1975 				   u8 *value)
1976 {
1977 	struct asus_wmi *asus = container_of(hotplug_slot,
1978 					     struct asus_wmi, hotplug_slot);
1979 	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1980 
1981 	if (result < 0)
1982 		return result;
1983 
1984 	*value = !!result;
1985 	return 0;
1986 }
1987 
1988 static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
1989 	.get_adapter_status = asus_get_adapter_status,
1990 	.get_power_status = asus_get_adapter_status,
1991 };
1992 
1993 static void asus_hotplug_work(struct work_struct *work)
1994 {
1995 	struct asus_wmi *asus;
1996 
1997 	asus = container_of(work, struct asus_wmi, hotplug_work);
1998 	asus_rfkill_hotplug(asus);
1999 }
2000 
2001 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
2002 {
2003 	int ret = -ENOMEM;
2004 	struct pci_bus *bus = pci_find_bus(0, 1);
2005 
2006 	if (!bus) {
2007 		pr_err("Unable to find wifi PCI bus\n");
2008 		return -ENODEV;
2009 	}
2010 
2011 	asus->hotplug_workqueue =
2012 	    create_singlethread_workqueue("hotplug_workqueue");
2013 	if (!asus->hotplug_workqueue)
2014 		goto error_workqueue;
2015 
2016 	INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
2017 
2018 	asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
2019 
2020 	ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
2021 	if (ret) {
2022 		pr_err("Unable to register hotplug slot - %d\n", ret);
2023 		goto error_register;
2024 	}
2025 
2026 	return 0;
2027 
2028 error_register:
2029 	asus->hotplug_slot.ops = NULL;
2030 	destroy_workqueue(asus->hotplug_workqueue);
2031 error_workqueue:
2032 	return ret;
2033 }
2034 
2035 /*
2036  * Rfkill devices
2037  */
2038 static int asus_rfkill_set(void *data, bool blocked)
2039 {
2040 	struct asus_rfkill *priv = data;
2041 	u32 ctrl_param = !blocked;
2042 	u32 dev_id = priv->dev_id;
2043 
2044 	/*
2045 	 * If the user bit is set, BIOS can't set and record the wlan status,
2046 	 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
2047 	 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
2048 	 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
2049 	 * while setting the wlan status through WMI.
2050 	 * This is also the behavior that windows app will do.
2051 	 */
2052 	if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
2053 	     priv->asus->driver->wlan_ctrl_by_user)
2054 		dev_id = ASUS_WMI_DEVID_WLAN_LED;
2055 
2056 	return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
2057 }
2058 
2059 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
2060 {
2061 	struct asus_rfkill *priv = data;
2062 	int result;
2063 
2064 	result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
2065 
2066 	if (result < 0)
2067 		return;
2068 
2069 	rfkill_set_sw_state(priv->rfkill, !result);
2070 }
2071 
2072 static int asus_rfkill_wlan_set(void *data, bool blocked)
2073 {
2074 	struct asus_rfkill *priv = data;
2075 	struct asus_wmi *asus = priv->asus;
2076 	int ret;
2077 
2078 	/*
2079 	 * This handler is enabled only if hotplug is enabled.
2080 	 * In this case, the asus_wmi_set_devstate() will
2081 	 * trigger a wmi notification and we need to wait
2082 	 * this call to finish before being able to call
2083 	 * any wmi method
2084 	 */
2085 	mutex_lock(&asus->wmi_lock);
2086 	ret = asus_rfkill_set(data, blocked);
2087 	mutex_unlock(&asus->wmi_lock);
2088 	return ret;
2089 }
2090 
2091 static const struct rfkill_ops asus_rfkill_wlan_ops = {
2092 	.set_block = asus_rfkill_wlan_set,
2093 	.query = asus_rfkill_query,
2094 };
2095 
2096 static const struct rfkill_ops asus_rfkill_ops = {
2097 	.set_block = asus_rfkill_set,
2098 	.query = asus_rfkill_query,
2099 };
2100 
2101 static int asus_new_rfkill(struct asus_wmi *asus,
2102 			   struct asus_rfkill *arfkill,
2103 			   const char *name, enum rfkill_type type, int dev_id)
2104 {
2105 	int result = asus_wmi_get_devstate_simple(asus, dev_id);
2106 	struct rfkill **rfkill = &arfkill->rfkill;
2107 
2108 	if (result < 0)
2109 		return result;
2110 
2111 	arfkill->dev_id = dev_id;
2112 	arfkill->asus = asus;
2113 
2114 	if (dev_id == ASUS_WMI_DEVID_WLAN &&
2115 	    asus->driver->quirks->hotplug_wireless)
2116 		*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
2117 				       &asus_rfkill_wlan_ops, arfkill);
2118 	else
2119 		*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
2120 				       &asus_rfkill_ops, arfkill);
2121 
2122 	if (!*rfkill)
2123 		return -EINVAL;
2124 
2125 	if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
2126 			(asus->driver->quirks->wapf > 0))
2127 		rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
2128 
2129 	rfkill_init_sw_state(*rfkill, !result);
2130 	result = rfkill_register(*rfkill);
2131 	if (result) {
2132 		rfkill_destroy(*rfkill);
2133 		*rfkill = NULL;
2134 		return result;
2135 	}
2136 	return 0;
2137 }
2138 
2139 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
2140 {
2141 	if (asus->driver->wlan_ctrl_by_user && ashs_present())
2142 		return;
2143 
2144 	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
2145 	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
2146 	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
2147 	if (asus->wlan.rfkill) {
2148 		rfkill_unregister(asus->wlan.rfkill);
2149 		rfkill_destroy(asus->wlan.rfkill);
2150 		asus->wlan.rfkill = NULL;
2151 	}
2152 	/*
2153 	 * Refresh pci hotplug in case the rfkill state was changed after
2154 	 * asus_unregister_rfkill_notifier()
2155 	 */
2156 	asus_rfkill_hotplug(asus);
2157 	if (asus->hotplug_slot.ops)
2158 		pci_hp_deregister(&asus->hotplug_slot);
2159 	if (asus->hotplug_workqueue)
2160 		destroy_workqueue(asus->hotplug_workqueue);
2161 
2162 	if (asus->bluetooth.rfkill) {
2163 		rfkill_unregister(asus->bluetooth.rfkill);
2164 		rfkill_destroy(asus->bluetooth.rfkill);
2165 		asus->bluetooth.rfkill = NULL;
2166 	}
2167 	if (asus->wimax.rfkill) {
2168 		rfkill_unregister(asus->wimax.rfkill);
2169 		rfkill_destroy(asus->wimax.rfkill);
2170 		asus->wimax.rfkill = NULL;
2171 	}
2172 	if (asus->wwan3g.rfkill) {
2173 		rfkill_unregister(asus->wwan3g.rfkill);
2174 		rfkill_destroy(asus->wwan3g.rfkill);
2175 		asus->wwan3g.rfkill = NULL;
2176 	}
2177 	if (asus->gps.rfkill) {
2178 		rfkill_unregister(asus->gps.rfkill);
2179 		rfkill_destroy(asus->gps.rfkill);
2180 		asus->gps.rfkill = NULL;
2181 	}
2182 	if (asus->uwb.rfkill) {
2183 		rfkill_unregister(asus->uwb.rfkill);
2184 		rfkill_destroy(asus->uwb.rfkill);
2185 		asus->uwb.rfkill = NULL;
2186 	}
2187 }
2188 
2189 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
2190 {
2191 	int result = 0;
2192 
2193 	mutex_init(&asus->hotplug_lock);
2194 	mutex_init(&asus->wmi_lock);
2195 
2196 	result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
2197 				 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
2198 
2199 	if (result && result != -ENODEV)
2200 		goto exit;
2201 
2202 	result = asus_new_rfkill(asus, &asus->bluetooth,
2203 				 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
2204 				 ASUS_WMI_DEVID_BLUETOOTH);
2205 
2206 	if (result && result != -ENODEV)
2207 		goto exit;
2208 
2209 	result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
2210 				 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
2211 
2212 	if (result && result != -ENODEV)
2213 		goto exit;
2214 
2215 	result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
2216 				 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
2217 
2218 	if (result && result != -ENODEV)
2219 		goto exit;
2220 
2221 	result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
2222 				 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
2223 
2224 	if (result && result != -ENODEV)
2225 		goto exit;
2226 
2227 	result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
2228 				 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
2229 
2230 	if (result && result != -ENODEV)
2231 		goto exit;
2232 
2233 	if (!asus->driver->quirks->hotplug_wireless)
2234 		goto exit;
2235 
2236 	result = asus_setup_pci_hotplug(asus);
2237 	/*
2238 	 * If we get -EBUSY then something else is handling the PCI hotplug -
2239 	 * don't fail in this case
2240 	 */
2241 	if (result == -EBUSY)
2242 		result = 0;
2243 
2244 	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
2245 	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
2246 	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
2247 	/*
2248 	 * Refresh pci hotplug in case the rfkill state was changed during
2249 	 * setup.
2250 	 */
2251 	asus_rfkill_hotplug(asus);
2252 
2253 exit:
2254 	if (result && result != -ENODEV)
2255 		asus_wmi_rfkill_exit(asus);
2256 
2257 	if (result == -ENODEV)
2258 		result = 0;
2259 
2260 	return result;
2261 }
2262 
2263 /* Panel Overdrive ************************************************************/
2264 static ssize_t panel_od_show(struct device *dev,
2265 				   struct device_attribute *attr, char *buf)
2266 {
2267 	struct asus_wmi *asus = dev_get_drvdata(dev);
2268 	int result;
2269 
2270 	result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_PANEL_OD);
2271 	if (result < 0)
2272 		return result;
2273 
2274 	return sysfs_emit(buf, "%d\n", result);
2275 }
2276 
2277 static ssize_t panel_od_store(struct device *dev,
2278 				    struct device_attribute *attr,
2279 				    const char *buf, size_t count)
2280 {
2281 	int result, err;
2282 	u32 overdrive;
2283 
2284 	struct asus_wmi *asus = dev_get_drvdata(dev);
2285 
2286 	result = kstrtou32(buf, 10, &overdrive);
2287 	if (result)
2288 		return result;
2289 
2290 	if (overdrive > 1)
2291 		return -EINVAL;
2292 
2293 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PANEL_OD, overdrive, &result);
2294 
2295 	if (err) {
2296 		pr_warn("Failed to set panel overdrive: %d\n", err);
2297 		return err;
2298 	}
2299 
2300 	if (result > 1) {
2301 		pr_warn("Failed to set panel overdrive (result): 0x%x\n", result);
2302 		return -EIO;
2303 	}
2304 
2305 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "panel_od");
2306 
2307 	return count;
2308 }
2309 static DEVICE_ATTR_RW(panel_od);
2310 
2311 /* Bootup sound ***************************************************************/
2312 
2313 static ssize_t boot_sound_show(struct device *dev,
2314 			     struct device_attribute *attr, char *buf)
2315 {
2316 	struct asus_wmi *asus = dev_get_drvdata(dev);
2317 	int result;
2318 
2319 	result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BOOT_SOUND);
2320 	if (result < 0)
2321 		return result;
2322 
2323 	return sysfs_emit(buf, "%d\n", result);
2324 }
2325 
2326 static ssize_t boot_sound_store(struct device *dev,
2327 			      struct device_attribute *attr,
2328 			      const char *buf, size_t count)
2329 {
2330 	int result, err;
2331 	u32 snd;
2332 
2333 	struct asus_wmi *asus = dev_get_drvdata(dev);
2334 
2335 	result = kstrtou32(buf, 10, &snd);
2336 	if (result)
2337 		return result;
2338 
2339 	if (snd > 1)
2340 		return -EINVAL;
2341 
2342 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BOOT_SOUND, snd, &result);
2343 	if (err) {
2344 		pr_warn("Failed to set boot sound: %d\n", err);
2345 		return err;
2346 	}
2347 
2348 	if (result > 1) {
2349 		pr_warn("Failed to set panel boot sound (result): 0x%x\n", result);
2350 		return -EIO;
2351 	}
2352 
2353 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "boot_sound");
2354 
2355 	return count;
2356 }
2357 static DEVICE_ATTR_RW(boot_sound);
2358 
2359 /* Mini-LED mode **************************************************************/
2360 static ssize_t mini_led_mode_show(struct device *dev,
2361 				   struct device_attribute *attr, char *buf)
2362 {
2363 	struct asus_wmi *asus = dev_get_drvdata(dev);
2364 	u32 value;
2365 	int err;
2366 
2367 	err = asus_wmi_get_devstate(asus, asus->mini_led_dev_id, &value);
2368 	if (err < 0)
2369 		return err;
2370 	value = value & ASUS_MINI_LED_MODE_MASK;
2371 
2372 	/*
2373 	 * Remap the mode values to match previous generation mini-led. The last gen
2374 	 * WMI 0 == off, while on this version WMI 2 ==off (flipped).
2375 	 */
2376 	if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
2377 		switch (value) {
2378 		case ASUS_MINI_LED_2024_WEAK:
2379 			value = ASUS_MINI_LED_ON;
2380 			break;
2381 		case ASUS_MINI_LED_2024_STRONG:
2382 			value = ASUS_MINI_LED_STRONG_MODE;
2383 			break;
2384 		case ASUS_MINI_LED_2024_OFF:
2385 			value = ASUS_MINI_LED_OFF;
2386 			break;
2387 		}
2388 	}
2389 
2390 	return sysfs_emit(buf, "%d\n", value);
2391 }
2392 
2393 static ssize_t mini_led_mode_store(struct device *dev,
2394 				    struct device_attribute *attr,
2395 				    const char *buf, size_t count)
2396 {
2397 	int result, err;
2398 	u32 mode;
2399 
2400 	struct asus_wmi *asus = dev_get_drvdata(dev);
2401 
2402 	result = kstrtou32(buf, 10, &mode);
2403 	if (result)
2404 		return result;
2405 
2406 	if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE &&
2407 	    mode > ASUS_MINI_LED_ON)
2408 		return -EINVAL;
2409 	if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 &&
2410 	    mode > ASUS_MINI_LED_STRONG_MODE)
2411 		return -EINVAL;
2412 
2413 	/*
2414 	 * Remap the mode values so expected behaviour is the same as the last
2415 	 * generation of mini-LED with 0 == off, 1 == on.
2416 	 */
2417 	if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
2418 		switch (mode) {
2419 		case ASUS_MINI_LED_OFF:
2420 			mode = ASUS_MINI_LED_2024_OFF;
2421 			break;
2422 		case ASUS_MINI_LED_ON:
2423 			mode = ASUS_MINI_LED_2024_WEAK;
2424 			break;
2425 		case ASUS_MINI_LED_STRONG_MODE:
2426 			mode = ASUS_MINI_LED_2024_STRONG;
2427 			break;
2428 		}
2429 	}
2430 
2431 	err = asus_wmi_set_devstate(asus->mini_led_dev_id, mode, &result);
2432 	if (err) {
2433 		pr_warn("Failed to set mini-LED: %d\n", err);
2434 		return err;
2435 	}
2436 
2437 	if (result > 1) {
2438 		pr_warn("Failed to set mini-LED mode (result): 0x%x\n", result);
2439 		return -EIO;
2440 	}
2441 
2442 	sysfs_notify(&asus->platform_device->dev.kobj, NULL, "mini_led_mode");
2443 
2444 	return count;
2445 }
2446 static DEVICE_ATTR_RW(mini_led_mode);
2447 
2448 static ssize_t available_mini_led_mode_show(struct device *dev,
2449 				  struct device_attribute *attr, char *buf)
2450 {
2451 	struct asus_wmi *asus = dev_get_drvdata(dev);
2452 
2453 	switch (asus->mini_led_dev_id) {
2454 	case ASUS_WMI_DEVID_MINI_LED_MODE:
2455 		return sysfs_emit(buf, "0 1\n");
2456 	case ASUS_WMI_DEVID_MINI_LED_MODE2:
2457 		return sysfs_emit(buf, "0 1 2\n");
2458 	}
2459 
2460 	return sysfs_emit(buf, "0\n");
2461 }
2462 
2463 static DEVICE_ATTR_RO(available_mini_led_mode);
2464 
2465 /* Quirks *********************************************************************/
2466 
2467 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
2468 {
2469 	struct pci_dev *xhci_pdev;
2470 	u32 orig_ports_available;
2471 	u32 ports_available = asus->driver->quirks->xusb2pr;
2472 
2473 	xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
2474 			PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
2475 			NULL);
2476 
2477 	if (!xhci_pdev)
2478 		return;
2479 
2480 	pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
2481 				&orig_ports_available);
2482 
2483 	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
2484 				cpu_to_le32(ports_available));
2485 
2486 	pci_dev_put(xhci_pdev);
2487 
2488 	pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
2489 			orig_ports_available, ports_available);
2490 }
2491 
2492 /*
2493  * Some devices dont support or have borcken get_als method
2494  * but still support set method.
2495  */
2496 static void asus_wmi_set_als(void)
2497 {
2498 	asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
2499 }
2500 
2501 /* Hwmon device ***************************************************************/
2502 
2503 static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
2504 					  int *speed)
2505 {
2506 	struct agfn_fan_args args = {
2507 		.agfn.len = sizeof(args),
2508 		.agfn.mfun = ASUS_FAN_MFUN,
2509 		.agfn.sfun = ASUS_FAN_SFUN_READ,
2510 		.fan = fan,
2511 		.speed = 0,
2512 	};
2513 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
2514 	int status;
2515 
2516 	if (fan != 1)
2517 		return -EINVAL;
2518 
2519 	status = asus_wmi_evaluate_method_agfn(input);
2520 
2521 	if (status || args.agfn.err)
2522 		return -ENXIO;
2523 
2524 	if (speed)
2525 		*speed = args.speed;
2526 
2527 	return 0;
2528 }
2529 
2530 static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
2531 				     int *speed)
2532 {
2533 	struct agfn_fan_args args = {
2534 		.agfn.len = sizeof(args),
2535 		.agfn.mfun = ASUS_FAN_MFUN,
2536 		.agfn.sfun = ASUS_FAN_SFUN_WRITE,
2537 		.fan = fan,
2538 		.speed = speed ?  *speed : 0,
2539 	};
2540 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
2541 	int status;
2542 
2543 	/* 1: for setting 1st fan's speed 0: setting auto mode */
2544 	if (fan != 1 && fan != 0)
2545 		return -EINVAL;
2546 
2547 	status = asus_wmi_evaluate_method_agfn(input);
2548 
2549 	if (status || args.agfn.err)
2550 		return -ENXIO;
2551 
2552 	if (speed && fan == 1)
2553 		asus->agfn_pwm = *speed;
2554 
2555 	return 0;
2556 }
2557 
2558 /*
2559  * Check if we can read the speed of one fan. If true we assume we can also
2560  * control it.
2561  */
2562 static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
2563 {
2564 	int status;
2565 	int speed;
2566 	u32 value;
2567 
2568 	status = asus_agfn_fan_speed_read(asus, 1, &speed);
2569 	if (status != 0)
2570 		return false;
2571 
2572 	status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
2573 	if (status != 0)
2574 		return false;
2575 
2576 	/*
2577 	 * We need to find a better way, probably using sfun,
2578 	 * bits or spec ...
2579 	 * Currently we disable it if:
2580 	 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
2581 	 * - reverved bits are non-zero
2582 	 * - sfun and presence bit are not set
2583 	 */
2584 	return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
2585 		 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
2586 }
2587 
2588 static int asus_fan_set_auto(struct asus_wmi *asus)
2589 {
2590 	int status;
2591 	u32 retval;
2592 
2593 	switch (asus->fan_type) {
2594 	case FAN_TYPE_SPEC83:
2595 		status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
2596 					       0, &retval);
2597 		if (status)
2598 			return status;
2599 
2600 		if (retval != 1)
2601 			return -EIO;
2602 		break;
2603 
2604 	case FAN_TYPE_AGFN:
2605 		status = asus_agfn_fan_speed_write(asus, 0, NULL);
2606 		if (status)
2607 			return -ENXIO;
2608 		break;
2609 
2610 	default:
2611 		return -ENXIO;
2612 	}
2613 
2614 	/*
2615 	 * Modern models like the G713 also have GPU fan control (this is not AGFN)
2616 	 */
2617 	if (asus->gpu_fan_type == FAN_TYPE_SPEC83) {
2618 		status = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_FAN_CTRL,
2619 					       0, &retval);
2620 		if (status)
2621 			return status;
2622 
2623 		if (retval != 1)
2624 			return -EIO;
2625 	}
2626 
2627 	return 0;
2628 }
2629 
2630 static ssize_t pwm1_show(struct device *dev,
2631 			       struct device_attribute *attr,
2632 			       char *buf)
2633 {
2634 	struct asus_wmi *asus = dev_get_drvdata(dev);
2635 	int err;
2636 	int value;
2637 
2638 	/* If we already set a value then just return it */
2639 	if (asus->agfn_pwm >= 0)
2640 		return sysfs_emit(buf, "%d\n", asus->agfn_pwm);
2641 
2642 	/*
2643 	 * If we haven't set already set a value through the AGFN interface,
2644 	 * we read a current value through the (now-deprecated) FAN_CTRL device.
2645 	 */
2646 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
2647 	if (err < 0)
2648 		return err;
2649 
2650 	value &= 0xFF;
2651 
2652 	if (value == 1) /* Low Speed */
2653 		value = 85;
2654 	else if (value == 2)
2655 		value = 170;
2656 	else if (value == 3)
2657 		value = 255;
2658 	else if (value) {
2659 		pr_err("Unknown fan speed %#x\n", value);
2660 		value = -1;
2661 	}
2662 
2663 	return sysfs_emit(buf, "%d\n", value);
2664 }
2665 
2666 static ssize_t pwm1_store(struct device *dev,
2667 				     struct device_attribute *attr,
2668 				     const char *buf, size_t count) {
2669 	struct asus_wmi *asus = dev_get_drvdata(dev);
2670 	int value;
2671 	int state;
2672 	int ret;
2673 
2674 	ret = kstrtouint(buf, 10, &value);
2675 	if (ret)
2676 		return ret;
2677 
2678 	value = clamp(value, 0, 255);
2679 
2680 	state = asus_agfn_fan_speed_write(asus, 1, &value);
2681 	if (state)
2682 		pr_warn("Setting fan speed failed: %d\n", state);
2683 	else
2684 		asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
2685 
2686 	return count;
2687 }
2688 
2689 static ssize_t fan1_input_show(struct device *dev,
2690 					struct device_attribute *attr,
2691 					char *buf)
2692 {
2693 	struct asus_wmi *asus = dev_get_drvdata(dev);
2694 	int value;
2695 	int ret;
2696 
2697 	switch (asus->fan_type) {
2698 	case FAN_TYPE_SPEC83:
2699 		ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
2700 					    &value);
2701 		if (ret < 0)
2702 			return ret;
2703 
2704 		value &= 0xffff;
2705 		break;
2706 
2707 	case FAN_TYPE_AGFN:
2708 		/* no speed readable on manual mode */
2709 		if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
2710 			return -ENXIO;
2711 
2712 		ret = asus_agfn_fan_speed_read(asus, 1, &value);
2713 		if (ret) {
2714 			pr_warn("reading fan speed failed: %d\n", ret);
2715 			return -ENXIO;
2716 		}
2717 		break;
2718 
2719 	default:
2720 		return -ENXIO;
2721 	}
2722 
2723 	return sysfs_emit(buf, "%d\n", value < 0 ? -1 : value * 100);
2724 }
2725 
2726 static ssize_t pwm1_enable_show(struct device *dev,
2727 						 struct device_attribute *attr,
2728 						 char *buf)
2729 {
2730 	struct asus_wmi *asus = dev_get_drvdata(dev);
2731 
2732 	/*
2733 	 * Just read back the cached pwm mode.
2734 	 *
2735 	 * For the CPU_FAN device, the spec indicates that we should be
2736 	 * able to read the device status and consult bit 19 to see if we
2737 	 * are in Full On or Automatic mode. However, this does not work
2738 	 * in practice on X532FL at least (the bit is always 0) and there's
2739 	 * also nothing in the DSDT to indicate that this behaviour exists.
2740 	 */
2741 	return sysfs_emit(buf, "%d\n", asus->fan_pwm_mode);
2742 }
2743 
2744 static ssize_t pwm1_enable_store(struct device *dev,
2745 						  struct device_attribute *attr,
2746 						  const char *buf, size_t count)
2747 {
2748 	struct asus_wmi *asus = dev_get_drvdata(dev);
2749 	int status = 0;
2750 	int state;
2751 	int value;
2752 	int ret;
2753 	u32 retval;
2754 
2755 	ret = kstrtouint(buf, 10, &state);
2756 	if (ret)
2757 		return ret;
2758 
2759 	if (asus->fan_type == FAN_TYPE_SPEC83) {
2760 		switch (state) { /* standard documented hwmon values */
2761 		case ASUS_FAN_CTRL_FULLSPEED:
2762 			value = 1;
2763 			break;
2764 		case ASUS_FAN_CTRL_AUTO:
2765 			value = 0;
2766 			break;
2767 		default:
2768 			return -EINVAL;
2769 		}
2770 
2771 		ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
2772 					    value, &retval);
2773 		if (ret)
2774 			return ret;
2775 
2776 		if (retval != 1)
2777 			return -EIO;
2778 	} else if (asus->fan_type == FAN_TYPE_AGFN) {
2779 		switch (state) {
2780 		case ASUS_FAN_CTRL_MANUAL:
2781 			break;
2782 
2783 		case ASUS_FAN_CTRL_AUTO:
2784 			status = asus_fan_set_auto(asus);
2785 			if (status)
2786 				return status;
2787 			break;
2788 
2789 		default:
2790 			return -EINVAL;
2791 		}
2792 	}
2793 
2794 	asus->fan_pwm_mode = state;
2795 
2796 	/* Must set to disabled if mode is toggled */
2797 	if (asus->cpu_fan_curve_available)
2798 		asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
2799 	if (asus->gpu_fan_curve_available)
2800 		asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
2801 	if (asus->mid_fan_curve_available)
2802 		asus->custom_fan_curves[FAN_CURVE_DEV_MID].enabled = false;
2803 
2804 	return count;
2805 }
2806 
2807 static ssize_t asus_hwmon_temp1(struct device *dev,
2808 				struct device_attribute *attr,
2809 				char *buf)
2810 {
2811 	struct asus_wmi *asus = dev_get_drvdata(dev);
2812 	u32 value;
2813 	int err;
2814 
2815 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
2816 	if (err < 0)
2817 		return err;
2818 
2819 	return sysfs_emit(buf, "%ld\n",
2820 			  deci_kelvin_to_millicelsius(value & 0xFFFF));
2821 }
2822 
2823 /* GPU fan on modern ROG laptops */
2824 static ssize_t fan2_input_show(struct device *dev,
2825 					struct device_attribute *attr,
2826 					char *buf)
2827 {
2828 	struct asus_wmi *asus = dev_get_drvdata(dev);
2829 	int value;
2830 	int ret;
2831 
2832 	ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_GPU_FAN_CTRL, &value);
2833 	if (ret < 0)
2834 		return ret;
2835 
2836 	value &= 0xffff;
2837 
2838 	return sysfs_emit(buf, "%d\n", value * 100);
2839 }
2840 
2841 /* Middle/Center fan on modern ROG laptops */
2842 static ssize_t fan3_input_show(struct device *dev,
2843 					struct device_attribute *attr,
2844 					char *buf)
2845 {
2846 	struct asus_wmi *asus = dev_get_drvdata(dev);
2847 	int value;
2848 	int ret;
2849 
2850 	ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_MID_FAN_CTRL, &value);
2851 	if (ret < 0)
2852 		return ret;
2853 
2854 	value &= 0xffff;
2855 
2856 	return sysfs_emit(buf, "%d\n", value * 100);
2857 }
2858 
2859 static ssize_t pwm2_enable_show(struct device *dev,
2860 				struct device_attribute *attr,
2861 				char *buf)
2862 {
2863 	struct asus_wmi *asus = dev_get_drvdata(dev);
2864 
2865 	return sysfs_emit(buf, "%d\n", asus->gpu_fan_pwm_mode);
2866 }
2867 
2868 static ssize_t pwm2_enable_store(struct device *dev,
2869 				 struct device_attribute *attr,
2870 				 const char *buf, size_t count)
2871 {
2872 	struct asus_wmi *asus = dev_get_drvdata(dev);
2873 	int state;
2874 	int value;
2875 	int ret;
2876 	u32 retval;
2877 
2878 	ret = kstrtouint(buf, 10, &state);
2879 	if (ret)
2880 		return ret;
2881 
2882 	switch (state) { /* standard documented hwmon values */
2883 	case ASUS_FAN_CTRL_FULLSPEED:
2884 		value = 1;
2885 		break;
2886 	case ASUS_FAN_CTRL_AUTO:
2887 		value = 0;
2888 		break;
2889 	default:
2890 		return -EINVAL;
2891 	}
2892 
2893 	ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_FAN_CTRL,
2894 				    value, &retval);
2895 	if (ret)
2896 		return ret;
2897 
2898 	if (retval != 1)
2899 		return -EIO;
2900 
2901 	asus->gpu_fan_pwm_mode = state;
2902 	return count;
2903 }
2904 
2905 static ssize_t pwm3_enable_show(struct device *dev,
2906 				struct device_attribute *attr,
2907 				char *buf)
2908 {
2909 	struct asus_wmi *asus = dev_get_drvdata(dev);
2910 
2911 	return sysfs_emit(buf, "%d\n", asus->mid_fan_pwm_mode);
2912 }
2913 
2914 static ssize_t pwm3_enable_store(struct device *dev,
2915 				 struct device_attribute *attr,
2916 				 const char *buf, size_t count)
2917 {
2918 	struct asus_wmi *asus = dev_get_drvdata(dev);
2919 	int state;
2920 	int value;
2921 	int ret;
2922 	u32 retval;
2923 
2924 	ret = kstrtouint(buf, 10, &state);
2925 	if (ret)
2926 		return ret;
2927 
2928 	switch (state) { /* standard documented hwmon values */
2929 	case ASUS_FAN_CTRL_FULLSPEED:
2930 		value = 1;
2931 		break;
2932 	case ASUS_FAN_CTRL_AUTO:
2933 		value = 0;
2934 		break;
2935 	default:
2936 		return -EINVAL;
2937 	}
2938 
2939 	ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_MID_FAN_CTRL,
2940 				    value, &retval);
2941 	if (ret)
2942 		return ret;
2943 
2944 	if (retval != 1)
2945 		return -EIO;
2946 
2947 	asus->mid_fan_pwm_mode = state;
2948 	return count;
2949 }
2950 
2951 /* Fan1 */
2952 static DEVICE_ATTR_RW(pwm1);
2953 static DEVICE_ATTR_RW(pwm1_enable);
2954 static DEVICE_ATTR_RO(fan1_input);
2955 static DEVICE_STRING_ATTR_RO(fan1_label, 0444, ASUS_FAN_DESC);
2956 
2957 /* Fan2 - GPU fan */
2958 static DEVICE_ATTR_RW(pwm2_enable);
2959 static DEVICE_ATTR_RO(fan2_input);
2960 static DEVICE_STRING_ATTR_RO(fan2_label, 0444, ASUS_GPU_FAN_DESC);
2961 /* Fan3 - Middle/center fan */
2962 static DEVICE_ATTR_RW(pwm3_enable);
2963 static DEVICE_ATTR_RO(fan3_input);
2964 static DEVICE_STRING_ATTR_RO(fan3_label, 0444, ASUS_MID_FAN_DESC);
2965 
2966 /* Temperature */
2967 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
2968 
2969 static struct attribute *hwmon_attributes[] = {
2970 	&dev_attr_pwm1.attr,
2971 	&dev_attr_pwm1_enable.attr,
2972 	&dev_attr_pwm2_enable.attr,
2973 	&dev_attr_pwm3_enable.attr,
2974 	&dev_attr_fan1_input.attr,
2975 	&dev_attr_fan1_label.attr.attr,
2976 	&dev_attr_fan2_input.attr,
2977 	&dev_attr_fan2_label.attr.attr,
2978 	&dev_attr_fan3_input.attr,
2979 	&dev_attr_fan3_label.attr.attr,
2980 
2981 	&dev_attr_temp1_input.attr,
2982 	NULL
2983 };
2984 
2985 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
2986 					  struct attribute *attr, int idx)
2987 {
2988 	struct device *dev = kobj_to_dev(kobj);
2989 	struct asus_wmi *asus = dev_get_drvdata(dev->parent);
2990 	u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
2991 
2992 	if (attr == &dev_attr_pwm1.attr) {
2993 		if (asus->fan_type != FAN_TYPE_AGFN)
2994 			return 0;
2995 	} else if (attr == &dev_attr_fan1_input.attr
2996 	    || attr == &dev_attr_fan1_label.attr.attr
2997 	    || attr == &dev_attr_pwm1_enable.attr) {
2998 		if (asus->fan_type == FAN_TYPE_NONE)
2999 			return 0;
3000 	} else if (attr == &dev_attr_fan2_input.attr
3001 	    || attr == &dev_attr_fan2_label.attr.attr
3002 	    || attr == &dev_attr_pwm2_enable.attr) {
3003 		if (asus->gpu_fan_type == FAN_TYPE_NONE)
3004 			return 0;
3005 	} else if (attr == &dev_attr_fan3_input.attr
3006 	    || attr == &dev_attr_fan3_label.attr.attr
3007 	    || attr == &dev_attr_pwm3_enable.attr) {
3008 		if (asus->mid_fan_type == FAN_TYPE_NONE)
3009 			return 0;
3010 	} else if (attr == &dev_attr_temp1_input.attr) {
3011 		int err = asus_wmi_get_devstate(asus,
3012 						ASUS_WMI_DEVID_THERMAL_CTRL,
3013 						&value);
3014 
3015 		if (err < 0)
3016 			return 0; /* can't return negative here */
3017 
3018 		/*
3019 		 * If the temperature value in deci-Kelvin is near the absolute
3020 		 * zero temperature, something is clearly wrong
3021 		 */
3022 		if (value == 0 || value == 1)
3023 			return 0;
3024 	}
3025 
3026 	return attr->mode;
3027 }
3028 
3029 static const struct attribute_group hwmon_attribute_group = {
3030 	.is_visible = asus_hwmon_sysfs_is_visible,
3031 	.attrs = hwmon_attributes
3032 };
3033 __ATTRIBUTE_GROUPS(hwmon_attribute);
3034 
3035 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
3036 {
3037 	struct device *dev = &asus->platform_device->dev;
3038 	struct device *hwmon;
3039 
3040 	hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
3041 			hwmon_attribute_groups);
3042 
3043 	if (IS_ERR(hwmon)) {
3044 		pr_err("Could not register asus hwmon device\n");
3045 		return PTR_ERR(hwmon);
3046 	}
3047 	return 0;
3048 }
3049 
3050 static int asus_wmi_fan_init(struct asus_wmi *asus)
3051 {
3052 	asus->gpu_fan_type = FAN_TYPE_NONE;
3053 	asus->mid_fan_type = FAN_TYPE_NONE;
3054 	asus->fan_type = FAN_TYPE_NONE;
3055 	asus->agfn_pwm = -1;
3056 
3057 	if (asus->driver->quirks->wmi_ignore_fan)
3058 		asus->fan_type = FAN_TYPE_NONE;
3059 	else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
3060 		asus->fan_type = FAN_TYPE_SPEC83;
3061 	else if (asus_wmi_has_agfn_fan(asus))
3062 		asus->fan_type = FAN_TYPE_AGFN;
3063 
3064 	/*  Modern models like G713 also have GPU fan control */
3065 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_FAN_CTRL))
3066 		asus->gpu_fan_type = FAN_TYPE_SPEC83;
3067 
3068 	/* Some models also have a center/middle fan */
3069 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MID_FAN_CTRL))
3070 		asus->mid_fan_type = FAN_TYPE_SPEC83;
3071 
3072 	if (asus->fan_type == FAN_TYPE_NONE)
3073 		return -ENODEV;
3074 
3075 	asus_fan_set_auto(asus);
3076 	asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
3077 	return 0;
3078 }
3079 
3080 /* Fan mode *******************************************************************/
3081 
3082 static int fan_boost_mode_check_present(struct asus_wmi *asus)
3083 {
3084 	u32 result;
3085 	int err;
3086 
3087 	asus->fan_boost_mode_available = false;
3088 
3089 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
3090 				    &result);
3091 	if (err) {
3092 		if (err == -ENODEV)
3093 			return 0;
3094 		else
3095 			return err;
3096 	}
3097 
3098 	if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
3099 			(result & ASUS_FAN_BOOST_MODES_MASK)) {
3100 		asus->fan_boost_mode_available = true;
3101 		asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
3102 	}
3103 
3104 	return 0;
3105 }
3106 
3107 static int fan_boost_mode_write(struct asus_wmi *asus)
3108 {
3109 	u32 retval;
3110 	u8 value;
3111 	int err;
3112 
3113 	value = asus->fan_boost_mode;
3114 
3115 	pr_info("Set fan boost mode: %u\n", value);
3116 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
3117 				    &retval);
3118 
3119 	sysfs_notify(&asus->platform_device->dev.kobj, NULL,
3120 			"fan_boost_mode");
3121 
3122 	if (err) {
3123 		pr_warn("Failed to set fan boost mode: %d\n", err);
3124 		return err;
3125 	}
3126 
3127 	if (retval != 1) {
3128 		pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
3129 			retval);
3130 		return -EIO;
3131 	}
3132 
3133 	return 0;
3134 }
3135 
3136 static int fan_boost_mode_switch_next(struct asus_wmi *asus)
3137 {
3138 	u8 mask = asus->fan_boost_mode_mask;
3139 
3140 	if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
3141 		if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
3142 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
3143 		else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
3144 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
3145 	} else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
3146 		if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
3147 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
3148 		else
3149 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
3150 	} else {
3151 		asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
3152 	}
3153 
3154 	return fan_boost_mode_write(asus);
3155 }
3156 
3157 static ssize_t fan_boost_mode_show(struct device *dev,
3158 				   struct device_attribute *attr, char *buf)
3159 {
3160 	struct asus_wmi *asus = dev_get_drvdata(dev);
3161 
3162 	return sysfs_emit(buf, "%d\n", asus->fan_boost_mode);
3163 }
3164 
3165 static ssize_t fan_boost_mode_store(struct device *dev,
3166 				    struct device_attribute *attr,
3167 				    const char *buf, size_t count)
3168 {
3169 	struct asus_wmi *asus = dev_get_drvdata(dev);
3170 	u8 mask = asus->fan_boost_mode_mask;
3171 	u8 new_mode;
3172 	int result;
3173 
3174 	result = kstrtou8(buf, 10, &new_mode);
3175 	if (result < 0) {
3176 		pr_warn("Trying to store invalid value\n");
3177 		return result;
3178 	}
3179 
3180 	if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
3181 		if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
3182 			return -EINVAL;
3183 	} else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
3184 		if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
3185 			return -EINVAL;
3186 	} else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
3187 		return -EINVAL;
3188 	}
3189 
3190 	asus->fan_boost_mode = new_mode;
3191 	fan_boost_mode_write(asus);
3192 
3193 	return count;
3194 }
3195 
3196 // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
3197 static DEVICE_ATTR_RW(fan_boost_mode);
3198 
3199 /* Custom fan curves **********************************************************/
3200 
3201 static void fan_curve_copy_from_buf(struct fan_curve_data *data, u8 *buf)
3202 {
3203 	int i;
3204 
3205 	for (i = 0; i < FAN_CURVE_POINTS; i++) {
3206 		data->temps[i] = buf[i];
3207 	}
3208 
3209 	for (i = 0; i < FAN_CURVE_POINTS; i++) {
3210 		data->percents[i] =
3211 			255 * buf[i + FAN_CURVE_POINTS] / 100;
3212 	}
3213 }
3214 
3215 static int fan_curve_get_factory_default(struct asus_wmi *asus, u32 fan_dev)
3216 {
3217 	struct fan_curve_data *curves;
3218 	u8 buf[FAN_CURVE_BUF_LEN];
3219 	int err, fan_idx;
3220 	u8 mode = 0;
3221 
3222 	if (asus->throttle_thermal_policy_dev)
3223 		mode = asus->throttle_thermal_policy_mode;
3224 	/* DEVID_<C/G>PU_FAN_CURVE is switched for OVERBOOST vs SILENT */
3225 	if (mode == 2)
3226 		mode = 1;
3227 	else if (mode == 1)
3228 		mode = 2;
3229 
3230 	err = asus_wmi_evaluate_method_buf(asus->dsts_id, fan_dev, mode, buf,
3231 					   FAN_CURVE_BUF_LEN);
3232 	if (err) {
3233 		pr_warn("%s (0x%08x) failed: %d\n", __func__, fan_dev, err);
3234 		return err;
3235 	}
3236 
3237 	fan_idx = FAN_CURVE_DEV_CPU;
3238 	if (fan_dev == ASUS_WMI_DEVID_GPU_FAN_CURVE)
3239 		fan_idx = FAN_CURVE_DEV_GPU;
3240 
3241 	if (fan_dev == ASUS_WMI_DEVID_MID_FAN_CURVE)
3242 		fan_idx = FAN_CURVE_DEV_MID;
3243 
3244 	curves = &asus->custom_fan_curves[fan_idx];
3245 	curves->device_id = fan_dev;
3246 
3247 	fan_curve_copy_from_buf(curves, buf);
3248 	return 0;
3249 }
3250 
3251 /* Check if capability exists, and populate defaults */
3252 static int fan_curve_check_present(struct asus_wmi *asus, bool *available,
3253 				   u32 fan_dev)
3254 {
3255 	int err;
3256 
3257 	*available = false;
3258 
3259 	if (asus->fan_type == FAN_TYPE_NONE)
3260 		return 0;
3261 
3262 	err = fan_curve_get_factory_default(asus, fan_dev);
3263 	if (err) {
3264 		return 0;
3265 	}
3266 
3267 	*available = true;
3268 	return 0;
3269 }
3270 
3271 /* Determine which fan the attribute is for if SENSOR_ATTR */
3272 static struct fan_curve_data *fan_curve_attr_select(struct asus_wmi *asus,
3273 					      struct device_attribute *attr)
3274 {
3275 	int index = to_sensor_dev_attr(attr)->index;
3276 
3277 	return &asus->custom_fan_curves[index];
3278 }
3279 
3280 /* Determine which fan the attribute is for if SENSOR_ATTR_2 */
3281 static struct fan_curve_data *fan_curve_attr_2_select(struct asus_wmi *asus,
3282 					    struct device_attribute *attr)
3283 {
3284 	int nr = to_sensor_dev_attr_2(attr)->nr;
3285 
3286 	return &asus->custom_fan_curves[nr & ~FAN_CURVE_PWM_MASK];
3287 }
3288 
3289 static ssize_t fan_curve_show(struct device *dev,
3290 			      struct device_attribute *attr, char *buf)
3291 {
3292 	struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
3293 	struct asus_wmi *asus = dev_get_drvdata(dev);
3294 	struct fan_curve_data *data;
3295 	int value, pwm, index;
3296 
3297 	data = fan_curve_attr_2_select(asus, attr);
3298 	pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;
3299 	index = dev_attr->index;
3300 
3301 	if (pwm)
3302 		value = data->percents[index];
3303 	else
3304 		value = data->temps[index];
3305 
3306 	return sysfs_emit(buf, "%d\n", value);
3307 }
3308 
3309 /*
3310  * "fan_dev" is the related WMI method such as ASUS_WMI_DEVID_CPU_FAN_CURVE.
3311  */
3312 static int fan_curve_write(struct asus_wmi *asus,
3313 			   struct fan_curve_data *data)
3314 {
3315 	u32 arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0;
3316 	u8 *percents = data->percents;
3317 	u8 *temps = data->temps;
3318 	int ret, i, shift = 0;
3319 
3320 	if (!data->enabled)
3321 		return 0;
3322 
3323 	for (i = 0; i < FAN_CURVE_POINTS / 2; i++) {
3324 		arg1 += (temps[i]) << shift;
3325 		arg2 += (temps[i + 4]) << shift;
3326 		/* Scale to percentage for device */
3327 		arg3 += (100 * percents[i] / 255) << shift;
3328 		arg4 += (100 * percents[i + 4] / 255) << shift;
3329 		shift += 8;
3330 	}
3331 
3332 	return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS,
3333 					 data->device_id,
3334 					 arg1, arg2, arg3, arg4, &ret);
3335 }
3336 
3337 static ssize_t fan_curve_store(struct device *dev,
3338 			       struct device_attribute *attr, const char *buf,
3339 			       size_t count)
3340 {
3341 	struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
3342 	struct asus_wmi *asus = dev_get_drvdata(dev);
3343 	struct fan_curve_data *data;
3344 	int err, pwm, index;
3345 	u8 value;
3346 
3347 	data = fan_curve_attr_2_select(asus, attr);
3348 	pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;
3349 	index = dev_attr->index;
3350 
3351 	err = kstrtou8(buf, 10, &value);
3352 	if (err < 0)
3353 		return err;
3354 
3355 	if (pwm)
3356 		data->percents[index] = value;
3357 	else
3358 		data->temps[index] = value;
3359 
3360 	/*
3361 	 * Mark as disabled so the user has to explicitly enable to apply a
3362 	 * changed fan curve. This prevents potential lockups from writing out
3363 	 * many changes as one-write-per-change.
3364 	 */
3365 	data->enabled = false;
3366 
3367 	return count;
3368 }
3369 
3370 static ssize_t fan_curve_enable_show(struct device *dev,
3371 				     struct device_attribute *attr, char *buf)
3372 {
3373 	struct asus_wmi *asus = dev_get_drvdata(dev);
3374 	struct fan_curve_data *data;
3375 	int out = 2;
3376 
3377 	data = fan_curve_attr_select(asus, attr);
3378 
3379 	if (data->enabled)
3380 		out = 1;
3381 
3382 	return sysfs_emit(buf, "%d\n", out);
3383 }
3384 
3385 static ssize_t fan_curve_enable_store(struct device *dev,
3386 				      struct device_attribute *attr,
3387 				      const char *buf, size_t count)
3388 {
3389 	struct asus_wmi *asus = dev_get_drvdata(dev);
3390 	struct fan_curve_data *data;
3391 	int value, err;
3392 
3393 	data = fan_curve_attr_select(asus, attr);
3394 
3395 	err = kstrtoint(buf, 10, &value);
3396 	if (err < 0)
3397 		return err;
3398 
3399 	switch (value) {
3400 	case 1:
3401 		data->enabled = true;
3402 		break;
3403 	case 2:
3404 		data->enabled = false;
3405 		break;
3406 	/*
3407 	 * Auto + reset the fan curve data to defaults. Make it an explicit
3408 	 * option so that users don't accidentally overwrite a set fan curve.
3409 	 */
3410 	case 3:
3411 		err = fan_curve_get_factory_default(asus, data->device_id);
3412 		if (err)
3413 			return err;
3414 		data->enabled = false;
3415 		break;
3416 	default:
3417 		return -EINVAL;
3418 	}
3419 
3420 	if (data->enabled) {
3421 		err = fan_curve_write(asus, data);
3422 		if (err)
3423 			return err;
3424 	} else {
3425 		/*
3426 		 * For machines with throttle this is the only way to reset fans
3427 		 * to default mode of operation (does not erase curve data).
3428 		 */
3429 		if (asus->throttle_thermal_policy_dev) {
3430 			err = throttle_thermal_policy_write(asus);
3431 			if (err)
3432 				return err;
3433 		/* Similar is true for laptops with this fan */
3434 		} else if (asus->fan_type == FAN_TYPE_SPEC83) {
3435 			err = asus_fan_set_auto(asus);
3436 			if (err)
3437 				return err;
3438 		} else {
3439 			/* Safeguard against fautly ACPI tables */
3440 			err = fan_curve_get_factory_default(asus, data->device_id);
3441 			if (err)
3442 				return err;
3443 			err = fan_curve_write(asus, data);
3444 			if (err)
3445 				return err;
3446 		}
3447 	}
3448 	return count;
3449 }
3450 
3451 /* CPU */
3452 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, FAN_CURVE_DEV_CPU);
3453 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, fan_curve,
3454 			       FAN_CURVE_DEV_CPU, 0);
3455 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, fan_curve,
3456 			       FAN_CURVE_DEV_CPU, 1);
3457 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, fan_curve,
3458 			       FAN_CURVE_DEV_CPU, 2);
3459 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, fan_curve,
3460 			       FAN_CURVE_DEV_CPU, 3);
3461 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, fan_curve,
3462 			       FAN_CURVE_DEV_CPU, 4);
3463 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_temp, fan_curve,
3464 			       FAN_CURVE_DEV_CPU, 5);
3465 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_temp, fan_curve,
3466 			       FAN_CURVE_DEV_CPU, 6);
3467 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_temp, fan_curve,
3468 			       FAN_CURVE_DEV_CPU, 7);
3469 
3470 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, fan_curve,
3471 				FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 0);
3472 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, fan_curve,
3473 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 1);
3474 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_pwm, fan_curve,
3475 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 2);
3476 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_pwm, fan_curve,
3477 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 3);
3478 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_pwm, fan_curve,
3479 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 4);
3480 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_pwm, fan_curve,
3481 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 5);
3482 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_pwm, fan_curve,
3483 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 6);
3484 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_pwm, fan_curve,
3485 			       FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 7);
3486 
3487 /* GPU */
3488 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, fan_curve_enable, FAN_CURVE_DEV_GPU);
3489 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, fan_curve,
3490 			       FAN_CURVE_DEV_GPU, 0);
3491 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, fan_curve,
3492 			       FAN_CURVE_DEV_GPU, 1);
3493 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, fan_curve,
3494 			       FAN_CURVE_DEV_GPU, 2);
3495 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, fan_curve,
3496 			       FAN_CURVE_DEV_GPU, 3);
3497 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, fan_curve,
3498 			       FAN_CURVE_DEV_GPU, 4);
3499 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_temp, fan_curve,
3500 			       FAN_CURVE_DEV_GPU, 5);
3501 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_temp, fan_curve,
3502 			       FAN_CURVE_DEV_GPU, 6);
3503 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_temp, fan_curve,
3504 			       FAN_CURVE_DEV_GPU, 7);
3505 
3506 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, fan_curve,
3507 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 0);
3508 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, fan_curve,
3509 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 1);
3510 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_pwm, fan_curve,
3511 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 2);
3512 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_pwm, fan_curve,
3513 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 3);
3514 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_pwm, fan_curve,
3515 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 4);
3516 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_pwm, fan_curve,
3517 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 5);
3518 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_pwm, fan_curve,
3519 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 6);
3520 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_pwm, fan_curve,
3521 			       FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 7);
3522 
3523 /* MID */
3524 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, fan_curve_enable, FAN_CURVE_DEV_MID);
3525 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_temp, fan_curve,
3526 			       FAN_CURVE_DEV_MID, 0);
3527 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_temp, fan_curve,
3528 			       FAN_CURVE_DEV_MID, 1);
3529 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_temp, fan_curve,
3530 			       FAN_CURVE_DEV_MID, 2);
3531 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_temp, fan_curve,
3532 			       FAN_CURVE_DEV_MID, 3);
3533 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_temp, fan_curve,
3534 			       FAN_CURVE_DEV_MID, 4);
3535 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point6_temp, fan_curve,
3536 			       FAN_CURVE_DEV_MID, 5);
3537 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point7_temp, fan_curve,
3538 			       FAN_CURVE_DEV_MID, 6);
3539 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point8_temp, fan_curve,
3540 			       FAN_CURVE_DEV_MID, 7);
3541 
3542 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, fan_curve,
3543 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 0);
3544 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_pwm, fan_curve,
3545 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 1);
3546 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_pwm, fan_curve,
3547 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 2);
3548 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_pwm, fan_curve,
3549 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 3);
3550 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_pwm, fan_curve,
3551 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 4);
3552 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point6_pwm, fan_curve,
3553 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 5);
3554 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point7_pwm, fan_curve,
3555 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 6);
3556 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point8_pwm, fan_curve,
3557 			       FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 7);
3558 
3559 static struct attribute *asus_fan_curve_attr[] = {
3560 	/* CPU */
3561 	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
3562 	&sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
3563 	&sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
3564 	&sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
3565 	&sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
3566 	&sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
3567 	&sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
3568 	&sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr,
3569 	&sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr,
3570 	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
3571 	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
3572 	&sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
3573 	&sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
3574 	&sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
3575 	&sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
3576 	&sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr,
3577 	&sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr,
3578 	/* GPU */
3579 	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
3580 	&sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
3581 	&sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
3582 	&sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
3583 	&sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr,
3584 	&sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr,
3585 	&sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr,
3586 	&sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr,
3587 	&sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr,
3588 	&sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
3589 	&sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
3590 	&sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr,
3591 	&sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr,
3592 	&sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr,
3593 	&sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr,
3594 	&sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr,
3595 	&sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr,
3596 	/* MID */
3597 	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
3598 	&sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
3599 	&sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
3600 	&sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr,
3601 	&sensor_dev_attr_pwm3_auto_point4_temp.dev_attr.attr,
3602 	&sensor_dev_attr_pwm3_auto_point5_temp.dev_attr.attr,
3603 	&sensor_dev_attr_pwm3_auto_point6_temp.dev_attr.attr,
3604 	&sensor_dev_attr_pwm3_auto_point7_temp.dev_attr.attr,
3605 	&sensor_dev_attr_pwm3_auto_point8_temp.dev_attr.attr,
3606 	&sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
3607 	&sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
3608 	&sensor_dev_attr_pwm3_auto_point3_pwm.dev_attr.attr,
3609 	&sensor_dev_attr_pwm3_auto_point4_pwm.dev_attr.attr,
3610 	&sensor_dev_attr_pwm3_auto_point5_pwm.dev_attr.attr,
3611 	&sensor_dev_attr_pwm3_auto_point6_pwm.dev_attr.attr,
3612 	&sensor_dev_attr_pwm3_auto_point7_pwm.dev_attr.attr,
3613 	&sensor_dev_attr_pwm3_auto_point8_pwm.dev_attr.attr,
3614 	NULL
3615 };
3616 
3617 static umode_t asus_fan_curve_is_visible(struct kobject *kobj,
3618 					 struct attribute *attr, int idx)
3619 {
3620 	struct device *dev = kobj_to_dev(kobj);
3621 	struct asus_wmi *asus = dev_get_drvdata(dev->parent);
3622 
3623 	/*
3624 	 * Check the char instead of casting attr as there are two attr types
3625 	 * involved here (attr1 and attr2)
3626 	 */
3627 	if (asus->cpu_fan_curve_available && attr->name[3] == '1')
3628 		return 0644;
3629 
3630 	if (asus->gpu_fan_curve_available && attr->name[3] == '2')
3631 		return 0644;
3632 
3633 	if (asus->mid_fan_curve_available && attr->name[3] == '3')
3634 		return 0644;
3635 
3636 	return 0;
3637 }
3638 
3639 static const struct attribute_group asus_fan_curve_attr_group = {
3640 	.is_visible = asus_fan_curve_is_visible,
3641 	.attrs = asus_fan_curve_attr,
3642 };
3643 __ATTRIBUTE_GROUPS(asus_fan_curve_attr);
3644 
3645 /*
3646  * Must be initialised after throttle_thermal_policy_dev is set as
3647  * we check the status of throttle_thermal_policy_dev during init.
3648  */
3649 static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus)
3650 {
3651 	struct device *dev = &asus->platform_device->dev;
3652 	struct device *hwmon;
3653 	int err;
3654 
3655 	err = fan_curve_check_present(asus, &asus->cpu_fan_curve_available,
3656 				      ASUS_WMI_DEVID_CPU_FAN_CURVE);
3657 	if (err) {
3658 		pr_debug("%s, checked 0x%08x, failed: %d\n",
3659 			__func__, ASUS_WMI_DEVID_CPU_FAN_CURVE, err);
3660 		return err;
3661 	}
3662 
3663 	err = fan_curve_check_present(asus, &asus->gpu_fan_curve_available,
3664 				      ASUS_WMI_DEVID_GPU_FAN_CURVE);
3665 	if (err) {
3666 		pr_debug("%s, checked 0x%08x, failed: %d\n",
3667 			__func__, ASUS_WMI_DEVID_GPU_FAN_CURVE, err);
3668 		return err;
3669 	}
3670 
3671 	err = fan_curve_check_present(asus, &asus->mid_fan_curve_available,
3672 				      ASUS_WMI_DEVID_MID_FAN_CURVE);
3673 	if (err) {
3674 		pr_debug("%s, checked 0x%08x, failed: %d\n",
3675 			__func__, ASUS_WMI_DEVID_MID_FAN_CURVE, err);
3676 		return err;
3677 	}
3678 
3679 	if (!asus->cpu_fan_curve_available
3680 		&& !asus->gpu_fan_curve_available
3681 		&& !asus->mid_fan_curve_available)
3682 		return 0;
3683 
3684 	hwmon = devm_hwmon_device_register_with_groups(
3685 		dev, "asus_custom_fan_curve", asus, asus_fan_curve_attr_groups);
3686 
3687 	if (IS_ERR(hwmon)) {
3688 		dev_err(dev,
3689 			"Could not register asus_custom_fan_curve device\n");
3690 		return PTR_ERR(hwmon);
3691 	}
3692 
3693 	return 0;
3694 }
3695 
3696 /* Throttle thermal policy ****************************************************/
3697 static int throttle_thermal_policy_write(struct asus_wmi *asus)
3698 {
3699 	u8 value = asus->throttle_thermal_policy_mode;
3700 	u32 retval;
3701 	int err;
3702 
3703 	err = asus_wmi_set_devstate(asus->throttle_thermal_policy_dev,
3704 				    value, &retval);
3705 
3706 	sysfs_notify(&asus->platform_device->dev.kobj, NULL,
3707 			"throttle_thermal_policy");
3708 
3709 	if (err) {
3710 		pr_warn("Failed to set throttle thermal policy: %d\n", err);
3711 		return err;
3712 	}
3713 
3714 	if (retval != 1) {
3715 		pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n",
3716 			retval);
3717 		return -EIO;
3718 	}
3719 
3720 	/* Must set to disabled if mode is toggled */
3721 	if (asus->cpu_fan_curve_available)
3722 		asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
3723 	if (asus->gpu_fan_curve_available)
3724 		asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
3725 	if (asus->mid_fan_curve_available)
3726 		asus->custom_fan_curves[FAN_CURVE_DEV_MID].enabled = false;
3727 
3728 	return 0;
3729 }
3730 
3731 static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
3732 {
3733 	if (!asus->throttle_thermal_policy_dev)
3734 		return 0;
3735 
3736 	asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3737 	return throttle_thermal_policy_write(asus);
3738 }
3739 
3740 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus)
3741 {
3742 	u8 new_mode = asus->throttle_thermal_policy_mode + 1;
3743 	int err;
3744 
3745 	if (new_mode > PLATFORM_PROFILE_MAX)
3746 		new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3747 
3748 	asus->throttle_thermal_policy_mode = new_mode;
3749 	err = throttle_thermal_policy_write(asus);
3750 	if (err)
3751 		return err;
3752 
3753 	/*
3754 	 * Ensure that platform_profile updates userspace with the change to ensure
3755 	 * that platform_profile and throttle_thermal_policy_mode are in sync.
3756 	 */
3757 	platform_profile_notify();
3758 
3759 	return 0;
3760 }
3761 
3762 static ssize_t throttle_thermal_policy_show(struct device *dev,
3763 				   struct device_attribute *attr, char *buf)
3764 {
3765 	struct asus_wmi *asus = dev_get_drvdata(dev);
3766 	u8 mode = asus->throttle_thermal_policy_mode;
3767 
3768 	return sysfs_emit(buf, "%d\n", mode);
3769 }
3770 
3771 static ssize_t throttle_thermal_policy_store(struct device *dev,
3772 				    struct device_attribute *attr,
3773 				    const char *buf, size_t count)
3774 {
3775 	struct asus_wmi *asus = dev_get_drvdata(dev);
3776 	u8 new_mode;
3777 	int result;
3778 	int err;
3779 
3780 	result = kstrtou8(buf, 10, &new_mode);
3781 	if (result < 0)
3782 		return result;
3783 
3784 	if (new_mode > PLATFORM_PROFILE_MAX)
3785 		return -EINVAL;
3786 
3787 	asus->throttle_thermal_policy_mode = new_mode;
3788 	err = throttle_thermal_policy_write(asus);
3789 	if (err)
3790 		return err;
3791 
3792 	/*
3793 	 * Ensure that platform_profile updates userspace with the change to ensure
3794 	 * that platform_profile and throttle_thermal_policy_mode are in sync.
3795 	 */
3796 	platform_profile_notify();
3797 
3798 	return count;
3799 }
3800 
3801 /*
3802  * Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
3803  */
3804 static DEVICE_ATTR_RW(throttle_thermal_policy);
3805 
3806 /* Platform profile ***********************************************************/
3807 static int asus_wmi_platform_profile_to_vivo(struct asus_wmi *asus, int mode)
3808 {
3809 	bool vivo;
3810 
3811 	vivo = asus->throttle_thermal_policy_dev == ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO;
3812 
3813 	if (vivo) {
3814 		switch (mode) {
3815 		case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT:
3816 			return ASUS_THROTTLE_THERMAL_POLICY_DEFAULT_VIVO;
3817 		case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST:
3818 			return ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST_VIVO;
3819 		case ASUS_THROTTLE_THERMAL_POLICY_SILENT:
3820 			return ASUS_THROTTLE_THERMAL_POLICY_SILENT_VIVO;
3821 		}
3822 	}
3823 
3824 	return mode;
3825 }
3826 
3827 static int asus_wmi_platform_profile_mode_from_vivo(struct asus_wmi *asus, int mode)
3828 {
3829 	bool vivo;
3830 
3831 	vivo = asus->throttle_thermal_policy_dev == ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO;
3832 
3833 	if (vivo) {
3834 		switch (mode) {
3835 		case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT_VIVO:
3836 			return ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3837 		case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST_VIVO:
3838 			return ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST;
3839 		case ASUS_THROTTLE_THERMAL_POLICY_SILENT_VIVO:
3840 			return ASUS_THROTTLE_THERMAL_POLICY_SILENT;
3841 		}
3842 	}
3843 
3844 	return mode;
3845 }
3846 
3847 static int asus_wmi_platform_profile_get(struct platform_profile_handler *pprof,
3848 					enum platform_profile_option *profile)
3849 {
3850 	struct asus_wmi *asus;
3851 	int tp;
3852 
3853 	asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
3854 	tp = asus->throttle_thermal_policy_mode;
3855 
3856 	switch (asus_wmi_platform_profile_mode_from_vivo(asus, tp)) {
3857 	case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT:
3858 		*profile = PLATFORM_PROFILE_BALANCED;
3859 		break;
3860 	case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST:
3861 		*profile = PLATFORM_PROFILE_PERFORMANCE;
3862 		break;
3863 	case ASUS_THROTTLE_THERMAL_POLICY_SILENT:
3864 		*profile = PLATFORM_PROFILE_QUIET;
3865 		break;
3866 	default:
3867 		return -EINVAL;
3868 	}
3869 
3870 	return 0;
3871 }
3872 
3873 static int asus_wmi_platform_profile_set(struct platform_profile_handler *pprof,
3874 					enum platform_profile_option profile)
3875 {
3876 	struct asus_wmi *asus;
3877 	int tp;
3878 
3879 	asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
3880 
3881 	switch (profile) {
3882 	case PLATFORM_PROFILE_PERFORMANCE:
3883 		tp = ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST;
3884 		break;
3885 	case PLATFORM_PROFILE_BALANCED:
3886 		tp = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3887 		break;
3888 	case PLATFORM_PROFILE_QUIET:
3889 		tp = ASUS_THROTTLE_THERMAL_POLICY_SILENT;
3890 		break;
3891 	default:
3892 		return -EOPNOTSUPP;
3893 	}
3894 
3895 	asus->throttle_thermal_policy_mode = asus_wmi_platform_profile_to_vivo(asus, tp);
3896 	return throttle_thermal_policy_write(asus);
3897 }
3898 
3899 static int platform_profile_setup(struct asus_wmi *asus)
3900 {
3901 	struct device *dev = &asus->platform_device->dev;
3902 	int err;
3903 
3904 	/*
3905 	 * Not an error if a component platform_profile relies on is unavailable
3906 	 * so early return, skipping the setup of platform_profile.
3907 	 */
3908 	if (!asus->throttle_thermal_policy_dev)
3909 		return 0;
3910 
3911 	dev_info(dev, "Using throttle_thermal_policy for platform_profile support\n");
3912 
3913 	asus->platform_profile_handler.profile_get = asus_wmi_platform_profile_get;
3914 	asus->platform_profile_handler.profile_set = asus_wmi_platform_profile_set;
3915 
3916 	set_bit(PLATFORM_PROFILE_QUIET, asus->platform_profile_handler.choices);
3917 	set_bit(PLATFORM_PROFILE_BALANCED,
3918 		asus->platform_profile_handler.choices);
3919 	set_bit(PLATFORM_PROFILE_PERFORMANCE,
3920 		asus->platform_profile_handler.choices);
3921 
3922 	err = platform_profile_register(&asus->platform_profile_handler);
3923 	if (err == -EEXIST) {
3924 		pr_warn("%s, a platform_profile handler is already registered\n", __func__);
3925 		return 0;
3926 	} else if (err) {
3927 		pr_err("%s, failed at platform_profile_register: %d\n", __func__, err);
3928 		return err;
3929 	}
3930 
3931 	asus->platform_profile_support = true;
3932 	return 0;
3933 }
3934 
3935 /* Backlight ******************************************************************/
3936 
3937 static int read_backlight_power(struct asus_wmi *asus)
3938 {
3939 	int ret;
3940 
3941 	if (asus->driver->quirks->store_backlight_power)
3942 		ret = !asus->driver->panel_power;
3943 	else
3944 		ret = asus_wmi_get_devstate_simple(asus,
3945 						   ASUS_WMI_DEVID_BACKLIGHT);
3946 
3947 	if (ret < 0)
3948 		return ret;
3949 
3950 	return ret ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF;
3951 }
3952 
3953 static int read_brightness_max(struct asus_wmi *asus)
3954 {
3955 	u32 retval;
3956 	int err;
3957 
3958 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
3959 	if (err < 0)
3960 		return err;
3961 
3962 	retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
3963 	retval >>= 8;
3964 
3965 	if (!retval)
3966 		return -ENODEV;
3967 
3968 	return retval;
3969 }
3970 
3971 static int read_brightness(struct backlight_device *bd)
3972 {
3973 	struct asus_wmi *asus = bl_get_data(bd);
3974 	u32 retval;
3975 	int err;
3976 
3977 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
3978 	if (err < 0)
3979 		return err;
3980 
3981 	return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
3982 }
3983 
3984 static u32 get_scalar_command(struct backlight_device *bd)
3985 {
3986 	struct asus_wmi *asus = bl_get_data(bd);
3987 	u32 ctrl_param = 0;
3988 
3989 	if ((asus->driver->brightness < bd->props.brightness) ||
3990 	    bd->props.brightness == bd->props.max_brightness)
3991 		ctrl_param = 0x00008001;
3992 	else if ((asus->driver->brightness > bd->props.brightness) ||
3993 		 bd->props.brightness == 0)
3994 		ctrl_param = 0x00008000;
3995 
3996 	asus->driver->brightness = bd->props.brightness;
3997 
3998 	return ctrl_param;
3999 }
4000 
4001 static int update_bl_status(struct backlight_device *bd)
4002 {
4003 	struct asus_wmi *asus = bl_get_data(bd);
4004 	u32 ctrl_param;
4005 	int power, err = 0;
4006 
4007 	power = read_backlight_power(asus);
4008 	if (power != -ENODEV && bd->props.power != power) {
4009 		ctrl_param = !!(bd->props.power == BACKLIGHT_POWER_ON);
4010 		err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
4011 					    ctrl_param, NULL);
4012 		if (asus->driver->quirks->store_backlight_power)
4013 			asus->driver->panel_power = bd->props.power;
4014 
4015 		/* When using scalar brightness, updating the brightness
4016 		 * will mess with the backlight power */
4017 		if (asus->driver->quirks->scalar_panel_brightness)
4018 			return err;
4019 	}
4020 
4021 	if (asus->driver->quirks->scalar_panel_brightness)
4022 		ctrl_param = get_scalar_command(bd);
4023 	else
4024 		ctrl_param = bd->props.brightness;
4025 
4026 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
4027 				    ctrl_param, NULL);
4028 
4029 	return err;
4030 }
4031 
4032 static const struct backlight_ops asus_wmi_bl_ops = {
4033 	.get_brightness = read_brightness,
4034 	.update_status = update_bl_status,
4035 };
4036 
4037 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
4038 {
4039 	struct backlight_device *bd = asus->backlight_device;
4040 	int old = bd->props.brightness;
4041 	int new = old;
4042 
4043 	if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
4044 		new = code - NOTIFY_BRNUP_MIN + 1;
4045 	else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
4046 		new = code - NOTIFY_BRNDOWN_MIN;
4047 
4048 	bd->props.brightness = new;
4049 	backlight_update_status(bd);
4050 	backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
4051 
4052 	return old;
4053 }
4054 
4055 static int asus_wmi_backlight_init(struct asus_wmi *asus)
4056 {
4057 	struct backlight_device *bd;
4058 	struct backlight_properties props;
4059 	int max;
4060 	int power;
4061 
4062 	max = read_brightness_max(asus);
4063 	if (max < 0)
4064 		return max;
4065 
4066 	power = read_backlight_power(asus);
4067 	if (power == -ENODEV)
4068 		power = BACKLIGHT_POWER_ON;
4069 	else if (power < 0)
4070 		return power;
4071 
4072 	memset(&props, 0, sizeof(struct backlight_properties));
4073 	props.type = BACKLIGHT_PLATFORM;
4074 	props.max_brightness = max;
4075 	bd = backlight_device_register(asus->driver->name,
4076 				       &asus->platform_device->dev, asus,
4077 				       &asus_wmi_bl_ops, &props);
4078 	if (IS_ERR(bd)) {
4079 		pr_err("Could not register backlight device\n");
4080 		return PTR_ERR(bd);
4081 	}
4082 
4083 	asus->backlight_device = bd;
4084 
4085 	if (asus->driver->quirks->store_backlight_power)
4086 		asus->driver->panel_power = power;
4087 
4088 	bd->props.brightness = read_brightness(bd);
4089 	bd->props.power = power;
4090 	backlight_update_status(bd);
4091 
4092 	asus->driver->brightness = bd->props.brightness;
4093 
4094 	return 0;
4095 }
4096 
4097 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
4098 {
4099 	backlight_device_unregister(asus->backlight_device);
4100 
4101 	asus->backlight_device = NULL;
4102 }
4103 
4104 static int is_display_toggle(int code)
4105 {
4106 	/* display toggle keys */
4107 	if ((code >= 0x61 && code <= 0x67) ||
4108 	    (code >= 0x8c && code <= 0x93) ||
4109 	    (code >= 0xa0 && code <= 0xa7) ||
4110 	    (code >= 0xd0 && code <= 0xd5))
4111 		return 1;
4112 
4113 	return 0;
4114 }
4115 
4116 /* Screenpad backlight *******************************************************/
4117 
4118 static int read_screenpad_backlight_power(struct asus_wmi *asus)
4119 {
4120 	int ret;
4121 
4122 	ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_SCREENPAD_POWER);
4123 	if (ret < 0)
4124 		return ret;
4125 	/* 1 == powered */
4126 	return ret ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF;
4127 }
4128 
4129 static int read_screenpad_brightness(struct backlight_device *bd)
4130 {
4131 	struct asus_wmi *asus = bl_get_data(bd);
4132 	u32 retval;
4133 	int err;
4134 
4135 	err = read_screenpad_backlight_power(asus);
4136 	if (err < 0)
4137 		return err;
4138 	/* The device brightness can only be read if powered, so return stored */
4139 	if (err == BACKLIGHT_POWER_OFF)
4140 		return asus->driver->screenpad_brightness - ASUS_SCREENPAD_BRIGHT_MIN;
4141 
4142 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_SCREENPAD_LIGHT, &retval);
4143 	if (err < 0)
4144 		return err;
4145 
4146 	return (retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK) - ASUS_SCREENPAD_BRIGHT_MIN;
4147 }
4148 
4149 static int update_screenpad_bl_status(struct backlight_device *bd)
4150 {
4151 	struct asus_wmi *asus = bl_get_data(bd);
4152 	int power, err = 0;
4153 	u32 ctrl_param;
4154 
4155 	power = read_screenpad_backlight_power(asus);
4156 	if (power < 0)
4157 		return power;
4158 
4159 	if (bd->props.power != power) {
4160 		if (power != BACKLIGHT_POWER_ON) {
4161 			/* Only brightness > 0 can power it back on */
4162 			ctrl_param = asus->driver->screenpad_brightness - ASUS_SCREENPAD_BRIGHT_MIN;
4163 			err = asus_wmi_set_devstate(ASUS_WMI_DEVID_SCREENPAD_LIGHT,
4164 						    ctrl_param, NULL);
4165 		} else {
4166 			err = asus_wmi_set_devstate(ASUS_WMI_DEVID_SCREENPAD_POWER, 0, NULL);
4167 		}
4168 	} else if (power == BACKLIGHT_POWER_ON) {
4169 		/* Only set brightness if powered on or we get invalid/unsync state */
4170 		ctrl_param = bd->props.brightness + ASUS_SCREENPAD_BRIGHT_MIN;
4171 		err = asus_wmi_set_devstate(ASUS_WMI_DEVID_SCREENPAD_LIGHT, ctrl_param, NULL);
4172 	}
4173 
4174 	/* Ensure brightness is stored to turn back on with */
4175 	if (err == 0)
4176 		asus->driver->screenpad_brightness = bd->props.brightness + ASUS_SCREENPAD_BRIGHT_MIN;
4177 
4178 	return err;
4179 }
4180 
4181 static const struct backlight_ops asus_screenpad_bl_ops = {
4182 	.get_brightness = read_screenpad_brightness,
4183 	.update_status = update_screenpad_bl_status,
4184 	.options = BL_CORE_SUSPENDRESUME,
4185 };
4186 
4187 static int asus_screenpad_init(struct asus_wmi *asus)
4188 {
4189 	struct backlight_device *bd;
4190 	struct backlight_properties props;
4191 	int err, power;
4192 	int brightness = 0;
4193 
4194 	power = read_screenpad_backlight_power(asus);
4195 	if (power < 0)
4196 		return power;
4197 
4198 	if (power != BACKLIGHT_POWER_OFF) {
4199 		err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_SCREENPAD_LIGHT, &brightness);
4200 		if (err < 0)
4201 			return err;
4202 	}
4203 	/* default to an acceptable min brightness on boot if too low */
4204 	if (brightness < ASUS_SCREENPAD_BRIGHT_MIN)
4205 		brightness = ASUS_SCREENPAD_BRIGHT_DEFAULT;
4206 
4207 	memset(&props, 0, sizeof(struct backlight_properties));
4208 	props.type = BACKLIGHT_RAW; /* ensure this bd is last to be picked */
4209 	props.max_brightness = ASUS_SCREENPAD_BRIGHT_MAX - ASUS_SCREENPAD_BRIGHT_MIN;
4210 	bd = backlight_device_register("asus_screenpad",
4211 				       &asus->platform_device->dev, asus,
4212 				       &asus_screenpad_bl_ops, &props);
4213 	if (IS_ERR(bd)) {
4214 		pr_err("Could not register backlight device\n");
4215 		return PTR_ERR(bd);
4216 	}
4217 
4218 	asus->screenpad_backlight_device = bd;
4219 	asus->driver->screenpad_brightness = brightness;
4220 	bd->props.brightness = brightness - ASUS_SCREENPAD_BRIGHT_MIN;
4221 	bd->props.power = power;
4222 	backlight_update_status(bd);
4223 
4224 	return 0;
4225 }
4226 
4227 static void asus_screenpad_exit(struct asus_wmi *asus)
4228 {
4229 	backlight_device_unregister(asus->screenpad_backlight_device);
4230 
4231 	asus->screenpad_backlight_device = NULL;
4232 }
4233 
4234 /* Fn-lock ********************************************************************/
4235 
4236 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
4237 {
4238 	u32 result;
4239 
4240 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
4241 
4242 	return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
4243 		!(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
4244 }
4245 
4246 static void asus_wmi_fnlock_update(struct asus_wmi *asus)
4247 {
4248 	int mode = asus->fnlock_locked;
4249 
4250 	asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
4251 }
4252 
4253 /* WMI events *****************************************************************/
4254 
4255 static int asus_wmi_get_event_code(union acpi_object *obj)
4256 {
4257 	int code;
4258 
4259 	if (obj && obj->type == ACPI_TYPE_INTEGER)
4260 		code = (int)(obj->integer.value & WMI_EVENT_MASK);
4261 	else
4262 		code = -EIO;
4263 
4264 	return code;
4265 }
4266 
4267 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
4268 {
4269 	unsigned int key_value = 1;
4270 	bool autorelease = 1;
4271 
4272 	if (asus->driver->key_filter) {
4273 		asus->driver->key_filter(asus->driver, &code, &key_value,
4274 					 &autorelease);
4275 		if (code == ASUS_WMI_KEY_IGNORE)
4276 			return;
4277 	}
4278 
4279 	if (acpi_video_get_backlight_type() == acpi_backlight_vendor &&
4280 	    code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNDOWN_MAX) {
4281 		asus_wmi_backlight_notify(asus, code);
4282 		return;
4283 	}
4284 
4285 	if (code == NOTIFY_KBD_BRTUP) {
4286 		kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
4287 		return;
4288 	}
4289 	if (code == NOTIFY_KBD_BRTDWN) {
4290 		kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
4291 		return;
4292 	}
4293 	if (code == NOTIFY_KBD_BRTTOGGLE) {
4294 		if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
4295 			kbd_led_set_by_kbd(asus, 0);
4296 		else
4297 			kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
4298 		return;
4299 	}
4300 
4301 	if (code == NOTIFY_FNLOCK_TOGGLE) {
4302 		asus->fnlock_locked = !asus->fnlock_locked;
4303 		asus_wmi_fnlock_update(asus);
4304 		return;
4305 	}
4306 
4307 	if (code == asus->tablet_switch_event_code) {
4308 		asus_wmi_tablet_mode_get_state(asus);
4309 		return;
4310 	}
4311 
4312 	if (code == NOTIFY_KBD_FBM || code == NOTIFY_KBD_TTP) {
4313 		if (asus->fan_boost_mode_available)
4314 			fan_boost_mode_switch_next(asus);
4315 		if (asus->throttle_thermal_policy_dev)
4316 			throttle_thermal_policy_switch_next(asus);
4317 		return;
4318 
4319 	}
4320 
4321 	if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
4322 		return;
4323 
4324 	if (!sparse_keymap_report_event(asus->inputdev, code,
4325 					key_value, autorelease))
4326 		pr_info("Unknown key code 0x%x\n", code);
4327 }
4328 
4329 static void asus_wmi_notify(union acpi_object *obj, void *context)
4330 {
4331 	struct asus_wmi *asus = context;
4332 	int code = asus_wmi_get_event_code(obj);
4333 
4334 	if (code < 0) {
4335 		pr_warn("Failed to get notify code: %d\n", code);
4336 		return;
4337 	}
4338 
4339 	asus_wmi_handle_event_code(code, asus);
4340 }
4341 
4342 /* Sysfs **********************************************************************/
4343 
4344 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
4345 			     const char *buf, size_t count)
4346 {
4347 	u32 retval;
4348 	int err, value;
4349 
4350 	value = asus_wmi_get_devstate_simple(asus, devid);
4351 	if (value < 0)
4352 		return value;
4353 
4354 	err = kstrtoint(buf, 0, &value);
4355 	if (err)
4356 		return err;
4357 
4358 	err = asus_wmi_set_devstate(devid, value, &retval);
4359 	if (err < 0)
4360 		return err;
4361 
4362 	return count;
4363 }
4364 
4365 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
4366 {
4367 	int value = asus_wmi_get_devstate_simple(asus, devid);
4368 
4369 	if (value < 0)
4370 		return value;
4371 
4372 	return sysfs_emit(buf, "%d\n", value);
4373 }
4374 
4375 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)			\
4376 	static ssize_t show_##_name(struct device *dev,			\
4377 				    struct device_attribute *attr,	\
4378 				    char *buf)				\
4379 	{								\
4380 		struct asus_wmi *asus = dev_get_drvdata(dev);		\
4381 									\
4382 		return show_sys_wmi(asus, _cm, buf);			\
4383 	}								\
4384 	static ssize_t store_##_name(struct device *dev,		\
4385 				     struct device_attribute *attr,	\
4386 				     const char *buf, size_t count)	\
4387 	{								\
4388 		struct asus_wmi *asus = dev_get_drvdata(dev);		\
4389 									\
4390 		return store_sys_wmi(asus, _cm, buf, count);		\
4391 	}								\
4392 	static struct device_attribute dev_attr_##_name = {		\
4393 		.attr = {						\
4394 			.name = __stringify(_name),			\
4395 			.mode = _mode },				\
4396 		.show   = show_##_name,					\
4397 		.store  = store_##_name,				\
4398 	}
4399 
4400 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
4401 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
4402 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
4403 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
4404 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
4405 
4406 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
4407 			   const char *buf, size_t count)
4408 {
4409 	int value, rv;
4410 
4411 	rv = kstrtoint(buf, 0, &value);
4412 	if (rv)
4413 		return rv;
4414 
4415 	if (value < 0 || value > 2)
4416 		return -EINVAL;
4417 
4418 	rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
4419 	if (rv < 0)
4420 		return rv;
4421 
4422 	return count;
4423 }
4424 
4425 static DEVICE_ATTR_WO(cpufv);
4426 
4427 static struct attribute *platform_attributes[] = {
4428 	&dev_attr_cpufv.attr,
4429 	&dev_attr_camera.attr,
4430 	&dev_attr_cardr.attr,
4431 	&dev_attr_touchpad.attr,
4432 	&dev_attr_charge_mode.attr,
4433 	&dev_attr_egpu_enable.attr,
4434 	&dev_attr_egpu_connected.attr,
4435 	&dev_attr_dgpu_disable.attr,
4436 	&dev_attr_gpu_mux_mode.attr,
4437 	&dev_attr_lid_resume.attr,
4438 	&dev_attr_als_enable.attr,
4439 	&dev_attr_fan_boost_mode.attr,
4440 	&dev_attr_throttle_thermal_policy.attr,
4441 	&dev_attr_ppt_pl2_sppt.attr,
4442 	&dev_attr_ppt_pl1_spl.attr,
4443 	&dev_attr_ppt_fppt.attr,
4444 	&dev_attr_ppt_apu_sppt.attr,
4445 	&dev_attr_ppt_platform_sppt.attr,
4446 	&dev_attr_nv_dynamic_boost.attr,
4447 	&dev_attr_nv_temp_target.attr,
4448 	&dev_attr_mcu_powersave.attr,
4449 	&dev_attr_boot_sound.attr,
4450 	&dev_attr_panel_od.attr,
4451 	&dev_attr_mini_led_mode.attr,
4452 	&dev_attr_available_mini_led_mode.attr,
4453 	NULL
4454 };
4455 
4456 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
4457 				    struct attribute *attr, int idx)
4458 {
4459 	struct device *dev = kobj_to_dev(kobj);
4460 	struct asus_wmi *asus = dev_get_drvdata(dev);
4461 	bool ok = true;
4462 	int devid = -1;
4463 
4464 	if (attr == &dev_attr_camera.attr)
4465 		devid = ASUS_WMI_DEVID_CAMERA;
4466 	else if (attr == &dev_attr_cardr.attr)
4467 		devid = ASUS_WMI_DEVID_CARDREADER;
4468 	else if (attr == &dev_attr_touchpad.attr)
4469 		devid = ASUS_WMI_DEVID_TOUCHPAD;
4470 	else if (attr == &dev_attr_lid_resume.attr)
4471 		devid = ASUS_WMI_DEVID_LID_RESUME;
4472 	else if (attr == &dev_attr_als_enable.attr)
4473 		devid = ASUS_WMI_DEVID_ALS_ENABLE;
4474 	else if (attr == &dev_attr_charge_mode.attr)
4475 		devid = ASUS_WMI_DEVID_CHARGE_MODE;
4476 	else if (attr == &dev_attr_egpu_enable.attr)
4477 		ok = asus->egpu_enable_available;
4478 	else if (attr == &dev_attr_egpu_connected.attr)
4479 		devid = ASUS_WMI_DEVID_EGPU_CONNECTED;
4480 	else if (attr == &dev_attr_dgpu_disable.attr)
4481 		ok = asus->dgpu_disable_available;
4482 	else if (attr == &dev_attr_gpu_mux_mode.attr)
4483 		ok = asus->gpu_mux_dev != 0;
4484 	else if (attr == &dev_attr_fan_boost_mode.attr)
4485 		ok = asus->fan_boost_mode_available;
4486 	else if (attr == &dev_attr_throttle_thermal_policy.attr)
4487 		ok = asus->throttle_thermal_policy_dev != 0;
4488 	else if (attr == &dev_attr_ppt_pl2_sppt.attr)
4489 		devid = ASUS_WMI_DEVID_PPT_PL2_SPPT;
4490 	else if (attr == &dev_attr_ppt_pl1_spl.attr)
4491 		devid = ASUS_WMI_DEVID_PPT_PL1_SPL;
4492 	else if (attr == &dev_attr_ppt_fppt.attr)
4493 		devid = ASUS_WMI_DEVID_PPT_FPPT;
4494 	else if (attr == &dev_attr_ppt_apu_sppt.attr)
4495 		devid = ASUS_WMI_DEVID_PPT_APU_SPPT;
4496 	else if (attr == &dev_attr_ppt_platform_sppt.attr)
4497 		devid = ASUS_WMI_DEVID_PPT_PLAT_SPPT;
4498 	else if (attr == &dev_attr_nv_dynamic_boost.attr)
4499 		devid = ASUS_WMI_DEVID_NV_DYN_BOOST;
4500 	else if (attr == &dev_attr_nv_temp_target.attr)
4501 		devid = ASUS_WMI_DEVID_NV_THERM_TARGET;
4502 	else if (attr == &dev_attr_mcu_powersave.attr)
4503 		devid = ASUS_WMI_DEVID_MCU_POWERSAVE;
4504 	else if (attr == &dev_attr_boot_sound.attr)
4505 		devid = ASUS_WMI_DEVID_BOOT_SOUND;
4506 	else if (attr == &dev_attr_panel_od.attr)
4507 		devid = ASUS_WMI_DEVID_PANEL_OD;
4508 	else if (attr == &dev_attr_mini_led_mode.attr)
4509 		ok = asus->mini_led_dev_id != 0;
4510 	else if (attr == &dev_attr_available_mini_led_mode.attr)
4511 		ok = asus->mini_led_dev_id != 0;
4512 
4513 	if (devid != -1) {
4514 		ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
4515 		pr_debug("%s called 0x%08x, ok: %x\n", __func__, devid, ok);
4516 	}
4517 
4518 	return ok ? attr->mode : 0;
4519 }
4520 
4521 static const struct attribute_group platform_attribute_group = {
4522 	.is_visible = asus_sysfs_is_visible,
4523 	.attrs = platform_attributes
4524 };
4525 
4526 static void asus_wmi_sysfs_exit(struct platform_device *device)
4527 {
4528 	sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
4529 }
4530 
4531 static int asus_wmi_sysfs_init(struct platform_device *device)
4532 {
4533 	return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
4534 }
4535 
4536 /* Platform device ************************************************************/
4537 
4538 static int asus_wmi_platform_init(struct asus_wmi *asus)
4539 {
4540 	struct device *dev = &asus->platform_device->dev;
4541 	char *wmi_uid;
4542 	int rv;
4543 
4544 	/* INIT enable hotkeys on some models */
4545 	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
4546 		pr_info("Initialization: %#x\n", rv);
4547 
4548 	/* We don't know yet what to do with this version... */
4549 	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
4550 		pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
4551 		asus->spec = rv;
4552 	}
4553 
4554 	/*
4555 	 * The SFUN method probably allows the original driver to get the list
4556 	 * of features supported by a given model. For now, 0x0100 or 0x0800
4557 	 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
4558 	 * The significance of others is yet to be found.
4559 	 */
4560 	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
4561 		pr_info("SFUN value: %#x\n", rv);
4562 		asus->sfun = rv;
4563 	}
4564 
4565 	/*
4566 	 * Eee PC and Notebooks seems to have different method_id for DSTS,
4567 	 * but it may also be related to the BIOS's SPEC.
4568 	 * Note, on most Eeepc, there is no way to check if a method exist
4569 	 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
4570 	 * but once again, SPEC may probably be used for that kind of things.
4571 	 *
4572 	 * Additionally at least TUF Gaming series laptops return nothing for
4573 	 * unknown methods, so the detection in this way is not possible.
4574 	 *
4575 	 * There is strong indication that only ACPI WMI devices that have _UID
4576 	 * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
4577 	 */
4578 	wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
4579 	if (!wmi_uid)
4580 		return -ENODEV;
4581 
4582 	if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
4583 		dev_info(dev, "Detected ASUSWMI, use DCTS\n");
4584 		asus->dsts_id = ASUS_WMI_METHODID_DCTS;
4585 	} else {
4586 		dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
4587 		asus->dsts_id = ASUS_WMI_METHODID_DSTS;
4588 	}
4589 
4590 	/* CWAP allow to define the behavior of the Fn+F2 key,
4591 	 * this method doesn't seems to be present on Eee PCs */
4592 	if (asus->driver->quirks->wapf >= 0)
4593 		asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
4594 				      asus->driver->quirks->wapf, NULL);
4595 
4596 	return 0;
4597 }
4598 
4599 /* debugfs ********************************************************************/
4600 
4601 struct asus_wmi_debugfs_node {
4602 	struct asus_wmi *asus;
4603 	char *name;
4604 	int (*show) (struct seq_file *m, void *data);
4605 };
4606 
4607 static int show_dsts(struct seq_file *m, void *data)
4608 {
4609 	struct asus_wmi *asus = m->private;
4610 	int err;
4611 	u32 retval = -1;
4612 
4613 	err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
4614 	if (err < 0)
4615 		return err;
4616 
4617 	seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
4618 
4619 	return 0;
4620 }
4621 
4622 static int show_devs(struct seq_file *m, void *data)
4623 {
4624 	struct asus_wmi *asus = m->private;
4625 	int err;
4626 	u32 retval = -1;
4627 
4628 	err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
4629 				    &retval);
4630 	if (err < 0)
4631 		return err;
4632 
4633 	seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
4634 		   asus->debug.ctrl_param, retval);
4635 
4636 	return 0;
4637 }
4638 
4639 static int show_call(struct seq_file *m, void *data)
4640 {
4641 	struct asus_wmi *asus = m->private;
4642 	struct bios_args args = {
4643 		.arg0 = asus->debug.dev_id,
4644 		.arg1 = asus->debug.ctrl_param,
4645 	};
4646 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
4647 	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
4648 	union acpi_object *obj;
4649 	acpi_status status;
4650 
4651 	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
4652 				     0, asus->debug.method_id,
4653 				     &input, &output);
4654 
4655 	if (ACPI_FAILURE(status))
4656 		return -EIO;
4657 
4658 	obj = (union acpi_object *)output.pointer;
4659 	if (obj && obj->type == ACPI_TYPE_INTEGER)
4660 		seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
4661 			   asus->debug.dev_id, asus->debug.ctrl_param,
4662 			   (u32) obj->integer.value);
4663 	else
4664 		seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
4665 			   asus->debug.dev_id, asus->debug.ctrl_param,
4666 			   obj ? obj->type : -1);
4667 
4668 	kfree(obj);
4669 
4670 	return 0;
4671 }
4672 
4673 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
4674 	{NULL, "devs", show_devs},
4675 	{NULL, "dsts", show_dsts},
4676 	{NULL, "call", show_call},
4677 };
4678 
4679 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
4680 {
4681 	struct asus_wmi_debugfs_node *node = inode->i_private;
4682 
4683 	return single_open(file, node->show, node->asus);
4684 }
4685 
4686 static const struct file_operations asus_wmi_debugfs_io_ops = {
4687 	.owner = THIS_MODULE,
4688 	.open = asus_wmi_debugfs_open,
4689 	.read = seq_read,
4690 	.llseek = seq_lseek,
4691 	.release = single_release,
4692 };
4693 
4694 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
4695 {
4696 	debugfs_remove_recursive(asus->debug.root);
4697 }
4698 
4699 static void asus_wmi_debugfs_init(struct asus_wmi *asus)
4700 {
4701 	int i;
4702 
4703 	asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
4704 
4705 	debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
4706 			   &asus->debug.method_id);
4707 
4708 	debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
4709 			   &asus->debug.dev_id);
4710 
4711 	debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
4712 			   &asus->debug.ctrl_param);
4713 
4714 	for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
4715 		struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
4716 
4717 		node->asus = asus;
4718 		debugfs_create_file(node->name, S_IFREG | S_IRUGO,
4719 				    asus->debug.root, node,
4720 				    &asus_wmi_debugfs_io_ops);
4721 	}
4722 }
4723 
4724 /* Init / exit ****************************************************************/
4725 
4726 static int asus_wmi_add(struct platform_device *pdev)
4727 {
4728 	struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
4729 	struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
4730 	struct asus_wmi *asus;
4731 	acpi_status status;
4732 	int err;
4733 	u32 result;
4734 
4735 	asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
4736 	if (!asus)
4737 		return -ENOMEM;
4738 
4739 	asus->driver = wdrv;
4740 	asus->platform_device = pdev;
4741 	wdrv->platform_device = pdev;
4742 	platform_set_drvdata(asus->platform_device, asus);
4743 
4744 	if (wdrv->detect_quirks)
4745 		wdrv->detect_quirks(asus->driver);
4746 
4747 	err = asus_wmi_platform_init(asus);
4748 	if (err)
4749 		goto fail_platform;
4750 
4751 	/* ensure defaults for tunables */
4752 	asus->ppt_pl2_sppt = 5;
4753 	asus->ppt_pl1_spl = 5;
4754 	asus->ppt_apu_sppt = 5;
4755 	asus->ppt_platform_sppt = 5;
4756 	asus->ppt_fppt = 5;
4757 	asus->nv_dynamic_boost = 5;
4758 	asus->nv_temp_target = 75;
4759 
4760 	asus->egpu_enable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU);
4761 	asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU);
4762 	asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE);
4763 	asus->ally_mcu_usb_switch = acpi_has_method(NULL, ASUS_USB0_PWR_EC0_CSEE)
4764 						&& dmi_check_system(asus_ally_mcu_quirk);
4765 
4766 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE))
4767 		asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
4768 	else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE2))
4769 		asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2;
4770 
4771 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX))
4772 		asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX;
4773 	else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX_VIVO))
4774 		asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX_VIVO;
4775 
4776 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE))
4777 		asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE;
4778 	else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2))
4779 		asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2;
4780 
4781 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY))
4782 		asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY;
4783 	else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO))
4784 		asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO;
4785 
4786 	err = fan_boost_mode_check_present(asus);
4787 	if (err)
4788 		goto fail_fan_boost_mode;
4789 
4790 	err = platform_profile_setup(asus);
4791 	if (err)
4792 		goto fail_platform_profile_setup;
4793 
4794 	err = asus_wmi_sysfs_init(asus->platform_device);
4795 	if (err)
4796 		goto fail_sysfs;
4797 
4798 	err = asus_wmi_input_init(asus);
4799 	if (err)
4800 		goto fail_input;
4801 
4802 	err = asus_wmi_fan_init(asus); /* probably no problems on error */
4803 
4804 	err = asus_wmi_hwmon_init(asus);
4805 	if (err)
4806 		goto fail_hwmon;
4807 
4808 	err = asus_wmi_custom_fan_curve_init(asus);
4809 	if (err)
4810 		goto fail_custom_fan_curve;
4811 
4812 	err = asus_wmi_led_init(asus);
4813 	if (err)
4814 		goto fail_leds;
4815 
4816 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
4817 	if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
4818 		asus->driver->wlan_ctrl_by_user = 1;
4819 
4820 	if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
4821 		err = asus_wmi_rfkill_init(asus);
4822 		if (err)
4823 			goto fail_rfkill;
4824 	}
4825 
4826 	if (asus->driver->quirks->wmi_force_als_set)
4827 		asus_wmi_set_als();
4828 
4829 	if (asus->driver->quirks->xusb2pr)
4830 		asus_wmi_set_xusb2pr(asus);
4831 
4832 	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
4833 		err = asus_wmi_backlight_init(asus);
4834 		if (err && err != -ENODEV)
4835 			goto fail_backlight;
4836 	} else if (asus->driver->quirks->wmi_backlight_set_devstate)
4837 		err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
4838 
4839 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_SCREENPAD_LIGHT)) {
4840 		err = asus_screenpad_init(asus);
4841 		if (err && err != -ENODEV)
4842 			goto fail_screenpad;
4843 	}
4844 
4845 	if (asus_wmi_has_fnlock_key(asus)) {
4846 		asus->fnlock_locked = fnlock_default;
4847 		asus_wmi_fnlock_update(asus);
4848 	}
4849 
4850 	status = wmi_install_notify_handler(asus->driver->event_guid,
4851 					    asus_wmi_notify, asus);
4852 	if (ACPI_FAILURE(status)) {
4853 		pr_err("Unable to register notify handler - %d\n", status);
4854 		err = -ENODEV;
4855 		goto fail_wmi_handler;
4856 	}
4857 
4858 	if (asus->driver->i8042_filter) {
4859 		err = i8042_install_filter(asus->driver->i8042_filter);
4860 		if (err)
4861 			pr_warn("Unable to install key filter - %d\n", err);
4862 	}
4863 
4864 	asus_wmi_battery_init(asus);
4865 
4866 	asus_wmi_debugfs_init(asus);
4867 
4868 	return 0;
4869 
4870 fail_wmi_handler:
4871 	asus_wmi_backlight_exit(asus);
4872 fail_backlight:
4873 	asus_wmi_rfkill_exit(asus);
4874 fail_screenpad:
4875 	asus_screenpad_exit(asus);
4876 fail_rfkill:
4877 	asus_wmi_led_exit(asus);
4878 fail_leds:
4879 fail_hwmon:
4880 	asus_wmi_input_exit(asus);
4881 fail_input:
4882 	asus_wmi_sysfs_exit(asus->platform_device);
4883 fail_sysfs:
4884 fail_custom_fan_curve:
4885 fail_platform_profile_setup:
4886 	if (asus->platform_profile_support)
4887 		platform_profile_remove();
4888 fail_fan_boost_mode:
4889 fail_platform:
4890 	kfree(asus);
4891 	return err;
4892 }
4893 
4894 static void asus_wmi_remove(struct platform_device *device)
4895 {
4896 	struct asus_wmi *asus;
4897 
4898 	asus = platform_get_drvdata(device);
4899 	if (asus->driver->i8042_filter)
4900 		i8042_remove_filter(asus->driver->i8042_filter);
4901 	wmi_remove_notify_handler(asus->driver->event_guid);
4902 	asus_wmi_backlight_exit(asus);
4903 	asus_screenpad_exit(asus);
4904 	asus_wmi_input_exit(asus);
4905 	asus_wmi_led_exit(asus);
4906 	asus_wmi_rfkill_exit(asus);
4907 	asus_wmi_debugfs_exit(asus);
4908 	asus_wmi_sysfs_exit(asus->platform_device);
4909 	asus_fan_set_auto(asus);
4910 	throttle_thermal_policy_set_default(asus);
4911 	asus_wmi_battery_exit(asus);
4912 
4913 	if (asus->platform_profile_support)
4914 		platform_profile_remove();
4915 
4916 	kfree(asus);
4917 }
4918 
4919 /* Platform driver - hibernate/resume callbacks *******************************/
4920 
4921 static int asus_hotk_thaw(struct device *device)
4922 {
4923 	struct asus_wmi *asus = dev_get_drvdata(device);
4924 
4925 	if (asus->wlan.rfkill) {
4926 		bool wlan;
4927 
4928 		/*
4929 		 * Work around bios bug - acpi _PTS turns off the wireless led
4930 		 * during suspend.  Normally it restores it on resume, but
4931 		 * we should kick it ourselves in case hibernation is aborted.
4932 		 */
4933 		wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
4934 		asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
4935 	}
4936 
4937 	return 0;
4938 }
4939 
4940 static int asus_hotk_resume(struct device *device)
4941 {
4942 	struct asus_wmi *asus = dev_get_drvdata(device);
4943 
4944 	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
4945 		kbd_led_update(asus);
4946 
4947 	if (asus_wmi_has_fnlock_key(asus))
4948 		asus_wmi_fnlock_update(asus);
4949 
4950 	asus_wmi_tablet_mode_get_state(asus);
4951 
4952 	return 0;
4953 }
4954 
4955 static int asus_hotk_resume_early(struct device *device)
4956 {
4957 	struct asus_wmi *asus = dev_get_drvdata(device);
4958 
4959 	if (asus->ally_mcu_usb_switch) {
4960 		/* sleep required to prevent USB0 being yanked then reappearing rapidly */
4961 		if (ACPI_FAILURE(acpi_execute_simple_method(NULL, ASUS_USB0_PWR_EC0_CSEE, 0xB8)))
4962 			dev_err(device, "ROG Ally MCU failed to connect USB dev\n");
4963 		else
4964 			msleep(ASUS_USB0_PWR_EC0_CSEE_WAIT);
4965 	}
4966 	return 0;
4967 }
4968 
4969 static int asus_hotk_prepare(struct device *device)
4970 {
4971 	struct asus_wmi *asus = dev_get_drvdata(device);
4972 
4973 	if (asus->ally_mcu_usb_switch) {
4974 		/* sleep required to ensure USB0 is disabled before sleep continues */
4975 		if (ACPI_FAILURE(acpi_execute_simple_method(NULL, ASUS_USB0_PWR_EC0_CSEE, 0xB7)))
4976 			dev_err(device, "ROG Ally MCU failed to disconnect USB dev\n");
4977 		else
4978 			msleep(ASUS_USB0_PWR_EC0_CSEE_WAIT);
4979 	}
4980 	return 0;
4981 }
4982 
4983 static int asus_hotk_restore(struct device *device)
4984 {
4985 	struct asus_wmi *asus = dev_get_drvdata(device);
4986 	int bl;
4987 
4988 	/* Refresh both wlan rfkill state and pci hotplug */
4989 	if (asus->wlan.rfkill)
4990 		asus_rfkill_hotplug(asus);
4991 
4992 	if (asus->bluetooth.rfkill) {
4993 		bl = !asus_wmi_get_devstate_simple(asus,
4994 						   ASUS_WMI_DEVID_BLUETOOTH);
4995 		rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
4996 	}
4997 	if (asus->wimax.rfkill) {
4998 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
4999 		rfkill_set_sw_state(asus->wimax.rfkill, bl);
5000 	}
5001 	if (asus->wwan3g.rfkill) {
5002 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
5003 		rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
5004 	}
5005 	if (asus->gps.rfkill) {
5006 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
5007 		rfkill_set_sw_state(asus->gps.rfkill, bl);
5008 	}
5009 	if (asus->uwb.rfkill) {
5010 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
5011 		rfkill_set_sw_state(asus->uwb.rfkill, bl);
5012 	}
5013 	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
5014 		kbd_led_update(asus);
5015 
5016 	if (asus_wmi_has_fnlock_key(asus))
5017 		asus_wmi_fnlock_update(asus);
5018 
5019 	asus_wmi_tablet_mode_get_state(asus);
5020 	return 0;
5021 }
5022 
5023 static const struct dev_pm_ops asus_pm_ops = {
5024 	.thaw = asus_hotk_thaw,
5025 	.restore = asus_hotk_restore,
5026 	.resume = asus_hotk_resume,
5027 	.resume_early = asus_hotk_resume_early,
5028 	.prepare = asus_hotk_prepare,
5029 };
5030 
5031 /* Registration ***************************************************************/
5032 
5033 static int asus_wmi_probe(struct platform_device *pdev)
5034 {
5035 	struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
5036 	struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
5037 	int ret;
5038 
5039 	if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
5040 		pr_warn("ASUS Management GUID not found\n");
5041 		return -ENODEV;
5042 	}
5043 
5044 	if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
5045 		pr_warn("ASUS Event GUID not found\n");
5046 		return -ENODEV;
5047 	}
5048 
5049 	if (wdrv->probe) {
5050 		ret = wdrv->probe(pdev);
5051 		if (ret)
5052 			return ret;
5053 	}
5054 
5055 	return asus_wmi_add(pdev);
5056 }
5057 
5058 static bool used;
5059 
5060 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
5061 {
5062 	struct platform_driver *platform_driver;
5063 	struct platform_device *platform_device;
5064 
5065 	if (used)
5066 		return -EBUSY;
5067 
5068 	platform_driver = &driver->platform_driver;
5069 	platform_driver->remove_new = asus_wmi_remove;
5070 	platform_driver->driver.owner = driver->owner;
5071 	platform_driver->driver.name = driver->name;
5072 	platform_driver->driver.pm = &asus_pm_ops;
5073 
5074 	platform_device = platform_create_bundle(platform_driver,
5075 						 asus_wmi_probe,
5076 						 NULL, 0, NULL, 0);
5077 	if (IS_ERR(platform_device))
5078 		return PTR_ERR(platform_device);
5079 
5080 	used = true;
5081 	return 0;
5082 }
5083 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
5084 
5085 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
5086 {
5087 	platform_device_unregister(driver->platform_device);
5088 	platform_driver_unregister(&driver->platform_driver);
5089 	used = false;
5090 }
5091 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
5092 
5093 static int __init asus_wmi_init(void)
5094 {
5095 	pr_info("ASUS WMI generic driver loaded\n");
5096 	return 0;
5097 }
5098 
5099 static void __exit asus_wmi_exit(void)
5100 {
5101 	pr_info("ASUS WMI generic driver unloaded\n");
5102 }
5103 
5104 module_init(asus_wmi_init);
5105 module_exit(asus_wmi_exit);
5106