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