xref: /linux/drivers/platform/x86/asus-wmi.c (revision 26fbb4c8c7c3ee9a4c3b4de555a8587b5a19154e)
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/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/types.h>
20 #include <linux/slab.h>
21 #include <linux/input.h>
22 #include <linux/input/sparse-keymap.h>
23 #include <linux/fb.h>
24 #include <linux/backlight.h>
25 #include <linux/leds.h>
26 #include <linux/rfkill.h>
27 #include <linux/pci.h>
28 #include <linux/pci_hotplug.h>
29 #include <linux/power_supply.h>
30 #include <linux/hwmon.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/debugfs.h>
33 #include <linux/seq_file.h>
34 #include <linux/platform_data/x86/asus-wmi.h>
35 #include <linux/platform_device.h>
36 #include <linux/acpi.h>
37 #include <linux/dmi.h>
38 #include <linux/units.h>
39 
40 #include <acpi/battery.h>
41 #include <acpi/video.h>
42 
43 #include "asus-wmi.h"
44 
45 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
46 	      "Yong Wang <yong.y.wang@intel.com>");
47 MODULE_DESCRIPTION("Asus Generic WMI Driver");
48 MODULE_LICENSE("GPL");
49 
50 #define to_asus_wmi_driver(pdrv)					\
51 	(container_of((pdrv), struct asus_wmi_driver, platform_driver))
52 
53 #define ASUS_WMI_MGMT_GUID	"97845ED0-4E6D-11DE-8A39-0800200C9A66"
54 
55 #define NOTIFY_BRNUP_MIN		0x11
56 #define NOTIFY_BRNUP_MAX		0x1f
57 #define NOTIFY_BRNDOWN_MIN		0x20
58 #define NOTIFY_BRNDOWN_MAX		0x2e
59 #define NOTIFY_FNLOCK_TOGGLE		0x4e
60 #define NOTIFY_KBD_DOCK_CHANGE		0x75
61 #define NOTIFY_KBD_BRTUP		0xc4
62 #define NOTIFY_KBD_BRTDWN		0xc5
63 #define NOTIFY_KBD_BRTTOGGLE		0xc7
64 #define NOTIFY_KBD_FBM			0x99
65 #define NOTIFY_KBD_TTP			0xae
66 #define NOTIFY_LID_FLIP			0xfa
67 
68 #define ASUS_WMI_FNLOCK_BIOS_DISABLED	BIT(0)
69 
70 #define ASUS_FAN_DESC			"cpu_fan"
71 #define ASUS_FAN_MFUN			0x13
72 #define ASUS_FAN_SFUN_READ		0x06
73 #define ASUS_FAN_SFUN_WRITE		0x07
74 
75 /* Based on standard hwmon pwmX_enable values */
76 #define ASUS_FAN_CTRL_FULLSPEED		0
77 #define ASUS_FAN_CTRL_MANUAL		1
78 #define ASUS_FAN_CTRL_AUTO		2
79 
80 #define ASUS_FAN_BOOST_MODE_NORMAL		0
81 #define ASUS_FAN_BOOST_MODE_OVERBOOST		1
82 #define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK	0x01
83 #define ASUS_FAN_BOOST_MODE_SILENT		2
84 #define ASUS_FAN_BOOST_MODE_SILENT_MASK		0x02
85 #define ASUS_FAN_BOOST_MODES_MASK		0x03
86 
87 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT	0
88 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST	1
89 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT	2
90 
91 #define USB_INTEL_XUSB2PR		0xD0
92 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI	0x9c31
93 
94 #define ASUS_ACPI_UID_ASUSWMI		"ASUSWMI"
95 #define ASUS_ACPI_UID_ATK		"ATK"
96 
97 #define WMI_EVENT_QUEUE_SIZE		0x10
98 #define WMI_EVENT_QUEUE_END		0x1
99 #define WMI_EVENT_MASK			0xFFFF
100 /* The WMI hotkey event value is always the same. */
101 #define WMI_EVENT_VALUE_ATK		0xFF
102 
103 #define WMI_EVENT_MASK			0xFFFF
104 
105 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
106 
107 static bool ashs_present(void)
108 {
109 	int i = 0;
110 	while (ashs_ids[i]) {
111 		if (acpi_dev_found(ashs_ids[i++]))
112 			return true;
113 	}
114 	return false;
115 }
116 
117 struct bios_args {
118 	u32 arg0;
119 	u32 arg1;
120 	u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
121 	u32 arg4;
122 	u32 arg5;
123 } __packed;
124 
125 /*
126  * Struct that's used for all methods called via AGFN. Naming is
127  * identically to the AML code.
128  */
129 struct agfn_args {
130 	u16 mfun; /* probably "Multi-function" to be called */
131 	u16 sfun; /* probably "Sub-function" to be called */
132 	u16 len;  /* size of the hole struct, including subfunction fields */
133 	u8 stas;  /* not used by now */
134 	u8 err;   /* zero on success */
135 } __packed;
136 
137 /* struct used for calling fan read and write methods */
138 struct agfn_fan_args {
139 	struct agfn_args agfn;	/* common fields */
140 	u8 fan;			/* fan number: 0: set auto mode 1: 1st fan */
141 	u32 speed;		/* read: RPM/100 - write: 0-255 */
142 } __packed;
143 
144 /*
145  * <platform>/    - debugfs root directory
146  *   dev_id      - current dev_id
147  *   ctrl_param  - current ctrl_param
148  *   method_id   - current method_id
149  *   devs        - call DEVS(dev_id, ctrl_param) and print result
150  *   dsts        - call DSTS(dev_id)  and print result
151  *   call        - call method_id(dev_id, ctrl_param) and print result
152  */
153 struct asus_wmi_debug {
154 	struct dentry *root;
155 	u32 method_id;
156 	u32 dev_id;
157 	u32 ctrl_param;
158 };
159 
160 struct asus_rfkill {
161 	struct asus_wmi *asus;
162 	struct rfkill *rfkill;
163 	u32 dev_id;
164 };
165 
166 enum fan_type {
167 	FAN_TYPE_NONE = 0,
168 	FAN_TYPE_AGFN,		/* deprecated on newer platforms */
169 	FAN_TYPE_SPEC83,	/* starting in Spec 8.3, use CPU_FAN_CTRL */
170 };
171 
172 struct asus_wmi {
173 	int dsts_id;
174 	int spec;
175 	int sfun;
176 	bool wmi_event_queue;
177 
178 	struct input_dev *inputdev;
179 	struct backlight_device *backlight_device;
180 	struct platform_device *platform_device;
181 
182 	struct led_classdev wlan_led;
183 	int wlan_led_wk;
184 	struct led_classdev tpd_led;
185 	int tpd_led_wk;
186 	struct led_classdev kbd_led;
187 	int kbd_led_wk;
188 	struct led_classdev lightbar_led;
189 	int lightbar_led_wk;
190 	struct workqueue_struct *led_workqueue;
191 	struct work_struct tpd_led_work;
192 	struct work_struct wlan_led_work;
193 	struct work_struct lightbar_led_work;
194 
195 	struct asus_rfkill wlan;
196 	struct asus_rfkill bluetooth;
197 	struct asus_rfkill wimax;
198 	struct asus_rfkill wwan3g;
199 	struct asus_rfkill gps;
200 	struct asus_rfkill uwb;
201 
202 	enum fan_type fan_type;
203 	int fan_pwm_mode;
204 	int agfn_pwm;
205 
206 	bool fan_boost_mode_available;
207 	u8 fan_boost_mode_mask;
208 	u8 fan_boost_mode;
209 
210 	bool throttle_thermal_policy_available;
211 	u8 throttle_thermal_policy_mode;
212 
213 	// The RSOC controls the maximum charging percentage.
214 	bool battery_rsoc_available;
215 
216 	struct hotplug_slot hotplug_slot;
217 	struct mutex hotplug_lock;
218 	struct mutex wmi_lock;
219 	struct workqueue_struct *hotplug_workqueue;
220 	struct work_struct hotplug_work;
221 
222 	bool fnlock_locked;
223 
224 	struct asus_wmi_debug debug;
225 
226 	struct asus_wmi_driver *driver;
227 };
228 
229 /* WMI ************************************************************************/
230 
231 static int asus_wmi_evaluate_method3(u32 method_id,
232 		u32 arg0, u32 arg1, u32 arg2, u32 *retval)
233 {
234 	struct bios_args args = {
235 		.arg0 = arg0,
236 		.arg1 = arg1,
237 		.arg2 = arg2,
238 	};
239 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
240 	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
241 	acpi_status status;
242 	union acpi_object *obj;
243 	u32 tmp = 0;
244 
245 	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
246 				     &input, &output);
247 
248 	if (ACPI_FAILURE(status))
249 		return -EIO;
250 
251 	obj = (union acpi_object *)output.pointer;
252 	if (obj && obj->type == ACPI_TYPE_INTEGER)
253 		tmp = (u32) obj->integer.value;
254 
255 	if (retval)
256 		*retval = tmp;
257 
258 	kfree(obj);
259 
260 	if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
261 		return -ENODEV;
262 
263 	return 0;
264 }
265 
266 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
267 {
268 	return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
269 }
270 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
271 
272 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
273 {
274 	struct acpi_buffer input;
275 	u64 phys_addr;
276 	u32 retval;
277 	u32 status;
278 
279 	/*
280 	 * Copy to dma capable address otherwise memory corruption occurs as
281 	 * bios has to be able to access it.
282 	 */
283 	input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
284 	input.length = args.length;
285 	if (!input.pointer)
286 		return -ENOMEM;
287 	phys_addr = virt_to_phys(input.pointer);
288 
289 	status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
290 					phys_addr, 0, &retval);
291 	if (!status)
292 		memcpy(args.pointer, input.pointer, args.length);
293 
294 	kfree(input.pointer);
295 	if (status)
296 		return -ENXIO;
297 
298 	return retval;
299 }
300 
301 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
302 {
303 	return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
304 }
305 
306 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
307 				 u32 *retval)
308 {
309 	return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
310 					ctrl_param, retval);
311 }
312 
313 /* Helper for special devices with magic return codes */
314 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
315 				      u32 dev_id, u32 mask)
316 {
317 	u32 retval = 0;
318 	int err;
319 
320 	err = asus_wmi_get_devstate(asus, dev_id, &retval);
321 	if (err < 0)
322 		return err;
323 
324 	if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
325 		return -ENODEV;
326 
327 	if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
328 		if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
329 			return -ENODEV;
330 	}
331 
332 	return retval & mask;
333 }
334 
335 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
336 {
337 	return asus_wmi_get_devstate_bits(asus, dev_id,
338 					  ASUS_WMI_DSTS_STATUS_BIT);
339 }
340 
341 static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
342 {
343 	u32 retval;
344 	int status = asus_wmi_get_devstate(asus, dev_id, &retval);
345 
346 	return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
347 }
348 
349 /* Input **********************************************************************/
350 
351 static int asus_wmi_input_init(struct asus_wmi *asus)
352 {
353 	int err, result;
354 
355 	asus->inputdev = input_allocate_device();
356 	if (!asus->inputdev)
357 		return -ENOMEM;
358 
359 	asus->inputdev->name = asus->driver->input_name;
360 	asus->inputdev->phys = asus->driver->input_phys;
361 	asus->inputdev->id.bustype = BUS_HOST;
362 	asus->inputdev->dev.parent = &asus->platform_device->dev;
363 	set_bit(EV_REP, asus->inputdev->evbit);
364 
365 	err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
366 	if (err)
367 		goto err_free_dev;
368 
369 	if (asus->driver->quirks->use_kbd_dock_devid) {
370 		result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_KBD_DOCK);
371 		if (result >= 0) {
372 			input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
373 			input_report_switch(asus->inputdev, SW_TABLET_MODE, !result);
374 		} else if (result != -ENODEV) {
375 			pr_err("Error checking for keyboard-dock: %d\n", result);
376 		}
377 	}
378 
379 	if (asus->driver->quirks->use_lid_flip_devid) {
380 		result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
381 		if (result < 0)
382 			asus->driver->quirks->use_lid_flip_devid = 0;
383 		if (result >= 0) {
384 			input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
385 			input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
386 		} else if (result == -ENODEV) {
387 			pr_err("This device has lid_flip quirk but got ENODEV checking it. This is a bug.");
388 		} else {
389 			pr_err("Error checking for lid-flip: %d\n", result);
390 		}
391 	}
392 
393 	err = input_register_device(asus->inputdev);
394 	if (err)
395 		goto err_free_dev;
396 
397 	return 0;
398 
399 err_free_dev:
400 	input_free_device(asus->inputdev);
401 	return err;
402 }
403 
404 static void asus_wmi_input_exit(struct asus_wmi *asus)
405 {
406 	if (asus->inputdev)
407 		input_unregister_device(asus->inputdev);
408 
409 	asus->inputdev = NULL;
410 }
411 
412 /* Tablet mode ****************************************************************/
413 
414 static void lid_flip_tablet_mode_get_state(struct asus_wmi *asus)
415 {
416 	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
417 
418 	if (result >= 0) {
419 		input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
420 		input_sync(asus->inputdev);
421 	}
422 }
423 
424 /* Battery ********************************************************************/
425 
426 /* The battery maximum charging percentage */
427 static int charge_end_threshold;
428 
429 static ssize_t charge_control_end_threshold_store(struct device *dev,
430 						  struct device_attribute *attr,
431 						  const char *buf, size_t count)
432 {
433 	int value, ret, rv;
434 
435 	ret = kstrtouint(buf, 10, &value);
436 	if (ret)
437 		return ret;
438 
439 	if (value < 0 || value > 100)
440 		return -EINVAL;
441 
442 	ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
443 	if (ret)
444 		return ret;
445 
446 	if (rv != 1)
447 		return -EIO;
448 
449 	/* There isn't any method in the DSDT to read the threshold, so we
450 	 * save the threshold.
451 	 */
452 	charge_end_threshold = value;
453 	return count;
454 }
455 
456 static ssize_t charge_control_end_threshold_show(struct device *device,
457 						 struct device_attribute *attr,
458 						 char *buf)
459 {
460 	return sprintf(buf, "%d\n", charge_end_threshold);
461 }
462 
463 static DEVICE_ATTR_RW(charge_control_end_threshold);
464 
465 static int asus_wmi_battery_add(struct power_supply *battery)
466 {
467 	/* The WMI method does not provide a way to specific a battery, so we
468 	 * just assume it is the first battery.
469 	 * Note: On some newer ASUS laptops (Zenbook UM431DA), the primary/first
470 	 * battery is named BATT.
471 	 */
472 	if (strcmp(battery->desc->name, "BAT0") != 0 &&
473 	    strcmp(battery->desc->name, "BAT1") != 0 &&
474 	    strcmp(battery->desc->name, "BATC") != 0 &&
475 	    strcmp(battery->desc->name, "BATT") != 0)
476 		return -ENODEV;
477 
478 	if (device_create_file(&battery->dev,
479 	    &dev_attr_charge_control_end_threshold))
480 		return -ENODEV;
481 
482 	/* The charge threshold is only reset when the system is power cycled,
483 	 * and we can't get the current threshold so let set it to 100% when
484 	 * a battery is added.
485 	 */
486 	asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
487 	charge_end_threshold = 100;
488 
489 	return 0;
490 }
491 
492 static int asus_wmi_battery_remove(struct power_supply *battery)
493 {
494 	device_remove_file(&battery->dev,
495 			   &dev_attr_charge_control_end_threshold);
496 	return 0;
497 }
498 
499 static struct acpi_battery_hook battery_hook = {
500 	.add_battery = asus_wmi_battery_add,
501 	.remove_battery = asus_wmi_battery_remove,
502 	.name = "ASUS Battery Extension",
503 };
504 
505 static void asus_wmi_battery_init(struct asus_wmi *asus)
506 {
507 	asus->battery_rsoc_available = false;
508 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
509 		asus->battery_rsoc_available = true;
510 		battery_hook_register(&battery_hook);
511 	}
512 }
513 
514 static void asus_wmi_battery_exit(struct asus_wmi *asus)
515 {
516 	if (asus->battery_rsoc_available)
517 		battery_hook_unregister(&battery_hook);
518 }
519 
520 /* LEDs ***********************************************************************/
521 
522 /*
523  * These functions actually update the LED's, and are called from a
524  * workqueue. By doing this as separate work rather than when the LED
525  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
526  * potentially bad time, such as a timer interrupt.
527  */
528 static void tpd_led_update(struct work_struct *work)
529 {
530 	int ctrl_param;
531 	struct asus_wmi *asus;
532 
533 	asus = container_of(work, struct asus_wmi, tpd_led_work);
534 
535 	ctrl_param = asus->tpd_led_wk;
536 	asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
537 }
538 
539 static void tpd_led_set(struct led_classdev *led_cdev,
540 			enum led_brightness value)
541 {
542 	struct asus_wmi *asus;
543 
544 	asus = container_of(led_cdev, struct asus_wmi, tpd_led);
545 
546 	asus->tpd_led_wk = !!value;
547 	queue_work(asus->led_workqueue, &asus->tpd_led_work);
548 }
549 
550 static int read_tpd_led_state(struct asus_wmi *asus)
551 {
552 	return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
553 }
554 
555 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
556 {
557 	struct asus_wmi *asus;
558 
559 	asus = container_of(led_cdev, struct asus_wmi, tpd_led);
560 
561 	return read_tpd_led_state(asus);
562 }
563 
564 static void kbd_led_update(struct asus_wmi *asus)
565 {
566 	int ctrl_param = 0;
567 
568 	ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
569 	asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
570 }
571 
572 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
573 {
574 	int retval;
575 
576 	/*
577 	 * bits 0-2: level
578 	 * bit 7: light on/off
579 	 * bit 8-10: environment (0: dark, 1: normal, 2: light)
580 	 * bit 17: status unknown
581 	 */
582 	retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
583 					    0xFFFF);
584 
585 	/* Unknown status is considered as off */
586 	if (retval == 0x8000)
587 		retval = 0;
588 
589 	if (retval < 0)
590 		return retval;
591 
592 	if (level)
593 		*level = retval & 0x7F;
594 	if (env)
595 		*env = (retval >> 8) & 0x7F;
596 	return 0;
597 }
598 
599 static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
600 {
601 	struct asus_wmi *asus;
602 	int max_level;
603 
604 	asus = container_of(led_cdev, struct asus_wmi, kbd_led);
605 	max_level = asus->kbd_led.max_brightness;
606 
607 	asus->kbd_led_wk = clamp_val(value, 0, max_level);
608 	kbd_led_update(asus);
609 }
610 
611 static void kbd_led_set(struct led_classdev *led_cdev,
612 			enum led_brightness value)
613 {
614 	/* Prevent disabling keyboard backlight on module unregister */
615 	if (led_cdev->flags & LED_UNREGISTERING)
616 		return;
617 
618 	do_kbd_led_set(led_cdev, value);
619 }
620 
621 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
622 {
623 	struct led_classdev *led_cdev = &asus->kbd_led;
624 
625 	do_kbd_led_set(led_cdev, value);
626 	led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
627 }
628 
629 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
630 {
631 	struct asus_wmi *asus;
632 	int retval, value;
633 
634 	asus = container_of(led_cdev, struct asus_wmi, kbd_led);
635 
636 	retval = kbd_led_read(asus, &value, NULL);
637 	if (retval < 0)
638 		return retval;
639 
640 	return value;
641 }
642 
643 static int wlan_led_unknown_state(struct asus_wmi *asus)
644 {
645 	u32 result;
646 
647 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
648 
649 	return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
650 }
651 
652 static void wlan_led_update(struct work_struct *work)
653 {
654 	int ctrl_param;
655 	struct asus_wmi *asus;
656 
657 	asus = container_of(work, struct asus_wmi, wlan_led_work);
658 
659 	ctrl_param = asus->wlan_led_wk;
660 	asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
661 }
662 
663 static void wlan_led_set(struct led_classdev *led_cdev,
664 			 enum led_brightness value)
665 {
666 	struct asus_wmi *asus;
667 
668 	asus = container_of(led_cdev, struct asus_wmi, wlan_led);
669 
670 	asus->wlan_led_wk = !!value;
671 	queue_work(asus->led_workqueue, &asus->wlan_led_work);
672 }
673 
674 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
675 {
676 	struct asus_wmi *asus;
677 	u32 result;
678 
679 	asus = container_of(led_cdev, struct asus_wmi, wlan_led);
680 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
681 
682 	return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
683 }
684 
685 static void lightbar_led_update(struct work_struct *work)
686 {
687 	struct asus_wmi *asus;
688 	int ctrl_param;
689 
690 	asus = container_of(work, struct asus_wmi, lightbar_led_work);
691 
692 	ctrl_param = asus->lightbar_led_wk;
693 	asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
694 }
695 
696 static void lightbar_led_set(struct led_classdev *led_cdev,
697 			     enum led_brightness value)
698 {
699 	struct asus_wmi *asus;
700 
701 	asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
702 
703 	asus->lightbar_led_wk = !!value;
704 	queue_work(asus->led_workqueue, &asus->lightbar_led_work);
705 }
706 
707 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
708 {
709 	struct asus_wmi *asus;
710 	u32 result;
711 
712 	asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
713 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
714 
715 	return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
716 }
717 
718 static void asus_wmi_led_exit(struct asus_wmi *asus)
719 {
720 	led_classdev_unregister(&asus->kbd_led);
721 	led_classdev_unregister(&asus->tpd_led);
722 	led_classdev_unregister(&asus->wlan_led);
723 	led_classdev_unregister(&asus->lightbar_led);
724 
725 	if (asus->led_workqueue)
726 		destroy_workqueue(asus->led_workqueue);
727 }
728 
729 static int asus_wmi_led_init(struct asus_wmi *asus)
730 {
731 	int rv = 0, led_val;
732 
733 	asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
734 	if (!asus->led_workqueue)
735 		return -ENOMEM;
736 
737 	if (read_tpd_led_state(asus) >= 0) {
738 		INIT_WORK(&asus->tpd_led_work, tpd_led_update);
739 
740 		asus->tpd_led.name = "asus::touchpad";
741 		asus->tpd_led.brightness_set = tpd_led_set;
742 		asus->tpd_led.brightness_get = tpd_led_get;
743 		asus->tpd_led.max_brightness = 1;
744 
745 		rv = led_classdev_register(&asus->platform_device->dev,
746 					   &asus->tpd_led);
747 		if (rv)
748 			goto error;
749 	}
750 
751 	if (!kbd_led_read(asus, &led_val, NULL)) {
752 		asus->kbd_led_wk = led_val;
753 		asus->kbd_led.name = "asus::kbd_backlight";
754 		asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
755 		asus->kbd_led.brightness_set = kbd_led_set;
756 		asus->kbd_led.brightness_get = kbd_led_get;
757 		asus->kbd_led.max_brightness = 3;
758 
759 		rv = led_classdev_register(&asus->platform_device->dev,
760 					   &asus->kbd_led);
761 		if (rv)
762 			goto error;
763 	}
764 
765 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
766 			&& (asus->driver->quirks->wapf > 0)) {
767 		INIT_WORK(&asus->wlan_led_work, wlan_led_update);
768 
769 		asus->wlan_led.name = "asus::wlan";
770 		asus->wlan_led.brightness_set = wlan_led_set;
771 		if (!wlan_led_unknown_state(asus))
772 			asus->wlan_led.brightness_get = wlan_led_get;
773 		asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
774 		asus->wlan_led.max_brightness = 1;
775 		asus->wlan_led.default_trigger = "asus-wlan";
776 
777 		rv = led_classdev_register(&asus->platform_device->dev,
778 					   &asus->wlan_led);
779 		if (rv)
780 			goto error;
781 	}
782 
783 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
784 		INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
785 
786 		asus->lightbar_led.name = "asus::lightbar";
787 		asus->lightbar_led.brightness_set = lightbar_led_set;
788 		asus->lightbar_led.brightness_get = lightbar_led_get;
789 		asus->lightbar_led.max_brightness = 1;
790 
791 		rv = led_classdev_register(&asus->platform_device->dev,
792 					   &asus->lightbar_led);
793 	}
794 
795 error:
796 	if (rv)
797 		asus_wmi_led_exit(asus);
798 
799 	return rv;
800 }
801 
802 /* RF *************************************************************************/
803 
804 /*
805  * PCI hotplug (for wlan rfkill)
806  */
807 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
808 {
809 	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
810 
811 	if (result < 0)
812 		return false;
813 	return !result;
814 }
815 
816 static void asus_rfkill_hotplug(struct asus_wmi *asus)
817 {
818 	struct pci_dev *dev;
819 	struct pci_bus *bus;
820 	bool blocked;
821 	bool absent;
822 	u32 l;
823 
824 	mutex_lock(&asus->wmi_lock);
825 	blocked = asus_wlan_rfkill_blocked(asus);
826 	mutex_unlock(&asus->wmi_lock);
827 
828 	mutex_lock(&asus->hotplug_lock);
829 	pci_lock_rescan_remove();
830 
831 	if (asus->wlan.rfkill)
832 		rfkill_set_sw_state(asus->wlan.rfkill, blocked);
833 
834 	if (asus->hotplug_slot.ops) {
835 		bus = pci_find_bus(0, 1);
836 		if (!bus) {
837 			pr_warn("Unable to find PCI bus 1?\n");
838 			goto out_unlock;
839 		}
840 
841 		if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
842 			pr_err("Unable to read PCI config space?\n");
843 			goto out_unlock;
844 		}
845 		absent = (l == 0xffffffff);
846 
847 		if (blocked != absent) {
848 			pr_warn("BIOS says wireless lan is %s, "
849 				"but the pci device is %s\n",
850 				blocked ? "blocked" : "unblocked",
851 				absent ? "absent" : "present");
852 			pr_warn("skipped wireless hotplug as probably "
853 				"inappropriate for this model\n");
854 			goto out_unlock;
855 		}
856 
857 		if (!blocked) {
858 			dev = pci_get_slot(bus, 0);
859 			if (dev) {
860 				/* Device already present */
861 				pci_dev_put(dev);
862 				goto out_unlock;
863 			}
864 			dev = pci_scan_single_device(bus, 0);
865 			if (dev) {
866 				pci_bus_assign_resources(bus);
867 				pci_bus_add_device(dev);
868 			}
869 		} else {
870 			dev = pci_get_slot(bus, 0);
871 			if (dev) {
872 				pci_stop_and_remove_bus_device(dev);
873 				pci_dev_put(dev);
874 			}
875 		}
876 	}
877 
878 out_unlock:
879 	pci_unlock_rescan_remove();
880 	mutex_unlock(&asus->hotplug_lock);
881 }
882 
883 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
884 {
885 	struct asus_wmi *asus = data;
886 
887 	if (event != ACPI_NOTIFY_BUS_CHECK)
888 		return;
889 
890 	/*
891 	 * We can't call directly asus_rfkill_hotplug because most
892 	 * of the time WMBC is still being executed and not reetrant.
893 	 * There is currently no way to tell ACPICA that  we want this
894 	 * method to be serialized, we schedule a asus_rfkill_hotplug
895 	 * call later, in a safer context.
896 	 */
897 	queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
898 }
899 
900 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
901 {
902 	acpi_status status;
903 	acpi_handle handle;
904 
905 	status = acpi_get_handle(NULL, node, &handle);
906 	if (ACPI_FAILURE(status))
907 		return -ENODEV;
908 
909 	status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
910 					     asus_rfkill_notify, asus);
911 	if (ACPI_FAILURE(status))
912 		pr_warn("Failed to register notify on %s\n", node);
913 
914 	return 0;
915 }
916 
917 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
918 {
919 	acpi_status status = AE_OK;
920 	acpi_handle handle;
921 
922 	status = acpi_get_handle(NULL, node, &handle);
923 	if (ACPI_FAILURE(status))
924 		return;
925 
926 	status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
927 					    asus_rfkill_notify);
928 	if (ACPI_FAILURE(status))
929 		pr_err("Error removing rfkill notify handler %s\n", node);
930 }
931 
932 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
933 				   u8 *value)
934 {
935 	struct asus_wmi *asus = container_of(hotplug_slot,
936 					     struct asus_wmi, hotplug_slot);
937 	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
938 
939 	if (result < 0)
940 		return result;
941 
942 	*value = !!result;
943 	return 0;
944 }
945 
946 static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
947 	.get_adapter_status = asus_get_adapter_status,
948 	.get_power_status = asus_get_adapter_status,
949 };
950 
951 static void asus_hotplug_work(struct work_struct *work)
952 {
953 	struct asus_wmi *asus;
954 
955 	asus = container_of(work, struct asus_wmi, hotplug_work);
956 	asus_rfkill_hotplug(asus);
957 }
958 
959 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
960 {
961 	int ret = -ENOMEM;
962 	struct pci_bus *bus = pci_find_bus(0, 1);
963 
964 	if (!bus) {
965 		pr_err("Unable to find wifi PCI bus\n");
966 		return -ENODEV;
967 	}
968 
969 	asus->hotplug_workqueue =
970 	    create_singlethread_workqueue("hotplug_workqueue");
971 	if (!asus->hotplug_workqueue)
972 		goto error_workqueue;
973 
974 	INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
975 
976 	asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
977 
978 	ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
979 	if (ret) {
980 		pr_err("Unable to register hotplug slot - %d\n", ret);
981 		goto error_register;
982 	}
983 
984 	return 0;
985 
986 error_register:
987 	asus->hotplug_slot.ops = NULL;
988 	destroy_workqueue(asus->hotplug_workqueue);
989 error_workqueue:
990 	return ret;
991 }
992 
993 /*
994  * Rfkill devices
995  */
996 static int asus_rfkill_set(void *data, bool blocked)
997 {
998 	struct asus_rfkill *priv = data;
999 	u32 ctrl_param = !blocked;
1000 	u32 dev_id = priv->dev_id;
1001 
1002 	/*
1003 	 * If the user bit is set, BIOS can't set and record the wlan status,
1004 	 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
1005 	 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
1006 	 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
1007 	 * while setting the wlan status through WMI.
1008 	 * This is also the behavior that windows app will do.
1009 	 */
1010 	if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1011 	     priv->asus->driver->wlan_ctrl_by_user)
1012 		dev_id = ASUS_WMI_DEVID_WLAN_LED;
1013 
1014 	return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
1015 }
1016 
1017 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
1018 {
1019 	struct asus_rfkill *priv = data;
1020 	int result;
1021 
1022 	result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
1023 
1024 	if (result < 0)
1025 		return;
1026 
1027 	rfkill_set_sw_state(priv->rfkill, !result);
1028 }
1029 
1030 static int asus_rfkill_wlan_set(void *data, bool blocked)
1031 {
1032 	struct asus_rfkill *priv = data;
1033 	struct asus_wmi *asus = priv->asus;
1034 	int ret;
1035 
1036 	/*
1037 	 * This handler is enabled only if hotplug is enabled.
1038 	 * In this case, the asus_wmi_set_devstate() will
1039 	 * trigger a wmi notification and we need to wait
1040 	 * this call to finish before being able to call
1041 	 * any wmi method
1042 	 */
1043 	mutex_lock(&asus->wmi_lock);
1044 	ret = asus_rfkill_set(data, blocked);
1045 	mutex_unlock(&asus->wmi_lock);
1046 	return ret;
1047 }
1048 
1049 static const struct rfkill_ops asus_rfkill_wlan_ops = {
1050 	.set_block = asus_rfkill_wlan_set,
1051 	.query = asus_rfkill_query,
1052 };
1053 
1054 static const struct rfkill_ops asus_rfkill_ops = {
1055 	.set_block = asus_rfkill_set,
1056 	.query = asus_rfkill_query,
1057 };
1058 
1059 static int asus_new_rfkill(struct asus_wmi *asus,
1060 			   struct asus_rfkill *arfkill,
1061 			   const char *name, enum rfkill_type type, int dev_id)
1062 {
1063 	int result = asus_wmi_get_devstate_simple(asus, dev_id);
1064 	struct rfkill **rfkill = &arfkill->rfkill;
1065 
1066 	if (result < 0)
1067 		return result;
1068 
1069 	arfkill->dev_id = dev_id;
1070 	arfkill->asus = asus;
1071 
1072 	if (dev_id == ASUS_WMI_DEVID_WLAN &&
1073 	    asus->driver->quirks->hotplug_wireless)
1074 		*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1075 				       &asus_rfkill_wlan_ops, arfkill);
1076 	else
1077 		*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1078 				       &asus_rfkill_ops, arfkill);
1079 
1080 	if (!*rfkill)
1081 		return -EINVAL;
1082 
1083 	if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1084 			(asus->driver->quirks->wapf > 0))
1085 		rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
1086 
1087 	rfkill_init_sw_state(*rfkill, !result);
1088 	result = rfkill_register(*rfkill);
1089 	if (result) {
1090 		rfkill_destroy(*rfkill);
1091 		*rfkill = NULL;
1092 		return result;
1093 	}
1094 	return 0;
1095 }
1096 
1097 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
1098 {
1099 	if (asus->driver->wlan_ctrl_by_user && ashs_present())
1100 		return;
1101 
1102 	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1103 	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1104 	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1105 	if (asus->wlan.rfkill) {
1106 		rfkill_unregister(asus->wlan.rfkill);
1107 		rfkill_destroy(asus->wlan.rfkill);
1108 		asus->wlan.rfkill = NULL;
1109 	}
1110 	/*
1111 	 * Refresh pci hotplug in case the rfkill state was changed after
1112 	 * asus_unregister_rfkill_notifier()
1113 	 */
1114 	asus_rfkill_hotplug(asus);
1115 	if (asus->hotplug_slot.ops)
1116 		pci_hp_deregister(&asus->hotplug_slot);
1117 	if (asus->hotplug_workqueue)
1118 		destroy_workqueue(asus->hotplug_workqueue);
1119 
1120 	if (asus->bluetooth.rfkill) {
1121 		rfkill_unregister(asus->bluetooth.rfkill);
1122 		rfkill_destroy(asus->bluetooth.rfkill);
1123 		asus->bluetooth.rfkill = NULL;
1124 	}
1125 	if (asus->wimax.rfkill) {
1126 		rfkill_unregister(asus->wimax.rfkill);
1127 		rfkill_destroy(asus->wimax.rfkill);
1128 		asus->wimax.rfkill = NULL;
1129 	}
1130 	if (asus->wwan3g.rfkill) {
1131 		rfkill_unregister(asus->wwan3g.rfkill);
1132 		rfkill_destroy(asus->wwan3g.rfkill);
1133 		asus->wwan3g.rfkill = NULL;
1134 	}
1135 	if (asus->gps.rfkill) {
1136 		rfkill_unregister(asus->gps.rfkill);
1137 		rfkill_destroy(asus->gps.rfkill);
1138 		asus->gps.rfkill = NULL;
1139 	}
1140 	if (asus->uwb.rfkill) {
1141 		rfkill_unregister(asus->uwb.rfkill);
1142 		rfkill_destroy(asus->uwb.rfkill);
1143 		asus->uwb.rfkill = NULL;
1144 	}
1145 }
1146 
1147 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1148 {
1149 	int result = 0;
1150 
1151 	mutex_init(&asus->hotplug_lock);
1152 	mutex_init(&asus->wmi_lock);
1153 
1154 	result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1155 				 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1156 
1157 	if (result && result != -ENODEV)
1158 		goto exit;
1159 
1160 	result = asus_new_rfkill(asus, &asus->bluetooth,
1161 				 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1162 				 ASUS_WMI_DEVID_BLUETOOTH);
1163 
1164 	if (result && result != -ENODEV)
1165 		goto exit;
1166 
1167 	result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1168 				 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1169 
1170 	if (result && result != -ENODEV)
1171 		goto exit;
1172 
1173 	result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1174 				 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1175 
1176 	if (result && result != -ENODEV)
1177 		goto exit;
1178 
1179 	result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1180 				 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1181 
1182 	if (result && result != -ENODEV)
1183 		goto exit;
1184 
1185 	result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1186 				 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1187 
1188 	if (result && result != -ENODEV)
1189 		goto exit;
1190 
1191 	if (!asus->driver->quirks->hotplug_wireless)
1192 		goto exit;
1193 
1194 	result = asus_setup_pci_hotplug(asus);
1195 	/*
1196 	 * If we get -EBUSY then something else is handling the PCI hotplug -
1197 	 * don't fail in this case
1198 	 */
1199 	if (result == -EBUSY)
1200 		result = 0;
1201 
1202 	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1203 	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1204 	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1205 	/*
1206 	 * Refresh pci hotplug in case the rfkill state was changed during
1207 	 * setup.
1208 	 */
1209 	asus_rfkill_hotplug(asus);
1210 
1211 exit:
1212 	if (result && result != -ENODEV)
1213 		asus_wmi_rfkill_exit(asus);
1214 
1215 	if (result == -ENODEV)
1216 		result = 0;
1217 
1218 	return result;
1219 }
1220 
1221 /* Quirks *********************************************************************/
1222 
1223 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
1224 {
1225 	struct pci_dev *xhci_pdev;
1226 	u32 orig_ports_available;
1227 	u32 ports_available = asus->driver->quirks->xusb2pr;
1228 
1229 	xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1230 			PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
1231 			NULL);
1232 
1233 	if (!xhci_pdev)
1234 		return;
1235 
1236 	pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1237 				&orig_ports_available);
1238 
1239 	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1240 				cpu_to_le32(ports_available));
1241 
1242 	pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
1243 			orig_ports_available, ports_available);
1244 }
1245 
1246 /*
1247  * Some devices dont support or have borcken get_als method
1248  * but still support set method.
1249  */
1250 static void asus_wmi_set_als(void)
1251 {
1252 	asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
1253 }
1254 
1255 /* Hwmon device ***************************************************************/
1256 
1257 static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
1258 					  int *speed)
1259 {
1260 	struct agfn_fan_args args = {
1261 		.agfn.len = sizeof(args),
1262 		.agfn.mfun = ASUS_FAN_MFUN,
1263 		.agfn.sfun = ASUS_FAN_SFUN_READ,
1264 		.fan = fan,
1265 		.speed = 0,
1266 	};
1267 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1268 	int status;
1269 
1270 	if (fan != 1)
1271 		return -EINVAL;
1272 
1273 	status = asus_wmi_evaluate_method_agfn(input);
1274 
1275 	if (status || args.agfn.err)
1276 		return -ENXIO;
1277 
1278 	if (speed)
1279 		*speed = args.speed;
1280 
1281 	return 0;
1282 }
1283 
1284 static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1285 				     int *speed)
1286 {
1287 	struct agfn_fan_args args = {
1288 		.agfn.len = sizeof(args),
1289 		.agfn.mfun = ASUS_FAN_MFUN,
1290 		.agfn.sfun = ASUS_FAN_SFUN_WRITE,
1291 		.fan = fan,
1292 		.speed = speed ?  *speed : 0,
1293 	};
1294 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1295 	int status;
1296 
1297 	/* 1: for setting 1st fan's speed 0: setting auto mode */
1298 	if (fan != 1 && fan != 0)
1299 		return -EINVAL;
1300 
1301 	status = asus_wmi_evaluate_method_agfn(input);
1302 
1303 	if (status || args.agfn.err)
1304 		return -ENXIO;
1305 
1306 	if (speed && fan == 1)
1307 		asus->agfn_pwm = *speed;
1308 
1309 	return 0;
1310 }
1311 
1312 /*
1313  * Check if we can read the speed of one fan. If true we assume we can also
1314  * control it.
1315  */
1316 static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
1317 {
1318 	int status;
1319 	int speed;
1320 	u32 value;
1321 
1322 	status = asus_agfn_fan_speed_read(asus, 1, &speed);
1323 	if (status != 0)
1324 		return false;
1325 
1326 	status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1327 	if (status != 0)
1328 		return false;
1329 
1330 	/*
1331 	 * We need to find a better way, probably using sfun,
1332 	 * bits or spec ...
1333 	 * Currently we disable it if:
1334 	 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1335 	 * - reverved bits are non-zero
1336 	 * - sfun and presence bit are not set
1337 	 */
1338 	return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
1339 		 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
1340 }
1341 
1342 static int asus_fan_set_auto(struct asus_wmi *asus)
1343 {
1344 	int status;
1345 	u32 retval;
1346 
1347 	switch (asus->fan_type) {
1348 	case FAN_TYPE_SPEC83:
1349 		status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1350 					       0, &retval);
1351 		if (status)
1352 			return status;
1353 
1354 		if (retval != 1)
1355 			return -EIO;
1356 		break;
1357 
1358 	case FAN_TYPE_AGFN:
1359 		status = asus_agfn_fan_speed_write(asus, 0, NULL);
1360 		if (status)
1361 			return -ENXIO;
1362 		break;
1363 
1364 	default:
1365 		return -ENXIO;
1366 	}
1367 
1368 
1369 	return 0;
1370 }
1371 
1372 static ssize_t pwm1_show(struct device *dev,
1373 			       struct device_attribute *attr,
1374 			       char *buf)
1375 {
1376 	struct asus_wmi *asus = dev_get_drvdata(dev);
1377 	int err;
1378 	int value;
1379 
1380 	/* If we already set a value then just return it */
1381 	if (asus->agfn_pwm >= 0)
1382 		return sprintf(buf, "%d\n", asus->agfn_pwm);
1383 
1384 	/*
1385 	 * If we haven't set already set a value through the AGFN interface,
1386 	 * we read a current value through the (now-deprecated) FAN_CTRL device.
1387 	 */
1388 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1389 	if (err < 0)
1390 		return err;
1391 
1392 	value &= 0xFF;
1393 
1394 	if (value == 1) /* Low Speed */
1395 		value = 85;
1396 	else if (value == 2)
1397 		value = 170;
1398 	else if (value == 3)
1399 		value = 255;
1400 	else if (value) {
1401 		pr_err("Unknown fan speed %#x\n", value);
1402 		value = -1;
1403 	}
1404 
1405 	return sprintf(buf, "%d\n", value);
1406 }
1407 
1408 static ssize_t pwm1_store(struct device *dev,
1409 				     struct device_attribute *attr,
1410 				     const char *buf, size_t count) {
1411 	struct asus_wmi *asus = dev_get_drvdata(dev);
1412 	int value;
1413 	int state;
1414 	int ret;
1415 
1416 	ret = kstrtouint(buf, 10, &value);
1417 	if (ret)
1418 		return ret;
1419 
1420 	value = clamp(value, 0, 255);
1421 
1422 	state = asus_agfn_fan_speed_write(asus, 1, &value);
1423 	if (state)
1424 		pr_warn("Setting fan speed failed: %d\n", state);
1425 	else
1426 		asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
1427 
1428 	return count;
1429 }
1430 
1431 static ssize_t fan1_input_show(struct device *dev,
1432 					struct device_attribute *attr,
1433 					char *buf)
1434 {
1435 	struct asus_wmi *asus = dev_get_drvdata(dev);
1436 	int value;
1437 	int ret;
1438 
1439 	switch (asus->fan_type) {
1440 	case FAN_TYPE_SPEC83:
1441 		ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
1442 					    &value);
1443 		if (ret < 0)
1444 			return ret;
1445 
1446 		value &= 0xffff;
1447 		break;
1448 
1449 	case FAN_TYPE_AGFN:
1450 		/* no speed readable on manual mode */
1451 		if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
1452 			return -ENXIO;
1453 
1454 		ret = asus_agfn_fan_speed_read(asus, 1, &value);
1455 		if (ret) {
1456 			pr_warn("reading fan speed failed: %d\n", ret);
1457 			return -ENXIO;
1458 		}
1459 		break;
1460 
1461 	default:
1462 		return -ENXIO;
1463 	}
1464 
1465 	return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
1466 }
1467 
1468 static ssize_t pwm1_enable_show(struct device *dev,
1469 						 struct device_attribute *attr,
1470 						 char *buf)
1471 {
1472 	struct asus_wmi *asus = dev_get_drvdata(dev);
1473 
1474 	/*
1475 	 * Just read back the cached pwm mode.
1476 	 *
1477 	 * For the CPU_FAN device, the spec indicates that we should be
1478 	 * able to read the device status and consult bit 19 to see if we
1479 	 * are in Full On or Automatic mode. However, this does not work
1480 	 * in practice on X532FL at least (the bit is always 0) and there's
1481 	 * also nothing in the DSDT to indicate that this behaviour exists.
1482 	 */
1483 	return sprintf(buf, "%d\n", asus->fan_pwm_mode);
1484 }
1485 
1486 static ssize_t pwm1_enable_store(struct device *dev,
1487 						  struct device_attribute *attr,
1488 						  const char *buf, size_t count)
1489 {
1490 	struct asus_wmi *asus = dev_get_drvdata(dev);
1491 	int status = 0;
1492 	int state;
1493 	int value;
1494 	int ret;
1495 	u32 retval;
1496 
1497 	ret = kstrtouint(buf, 10, &state);
1498 	if (ret)
1499 		return ret;
1500 
1501 	if (asus->fan_type == FAN_TYPE_SPEC83) {
1502 		switch (state) { /* standard documented hwmon values */
1503 		case ASUS_FAN_CTRL_FULLSPEED:
1504 			value = 1;
1505 			break;
1506 		case ASUS_FAN_CTRL_AUTO:
1507 			value = 0;
1508 			break;
1509 		default:
1510 			return -EINVAL;
1511 		}
1512 
1513 		ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1514 					    value, &retval);
1515 		if (ret)
1516 			return ret;
1517 
1518 		if (retval != 1)
1519 			return -EIO;
1520 	} else if (asus->fan_type == FAN_TYPE_AGFN) {
1521 		switch (state) {
1522 		case ASUS_FAN_CTRL_MANUAL:
1523 			break;
1524 
1525 		case ASUS_FAN_CTRL_AUTO:
1526 			status = asus_fan_set_auto(asus);
1527 			if (status)
1528 				return status;
1529 			break;
1530 
1531 		default:
1532 			return -EINVAL;
1533 		}
1534 	}
1535 
1536 	asus->fan_pwm_mode = state;
1537 	return count;
1538 }
1539 
1540 static ssize_t fan1_label_show(struct device *dev,
1541 					  struct device_attribute *attr,
1542 					  char *buf)
1543 {
1544 	return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1545 }
1546 
1547 static ssize_t asus_hwmon_temp1(struct device *dev,
1548 				struct device_attribute *attr,
1549 				char *buf)
1550 {
1551 	struct asus_wmi *asus = dev_get_drvdata(dev);
1552 	u32 value;
1553 	int err;
1554 
1555 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1556 	if (err < 0)
1557 		return err;
1558 
1559 	return sprintf(buf, "%ld\n",
1560 		       deci_kelvin_to_millicelsius(value & 0xFFFF));
1561 }
1562 
1563 /* Fan1 */
1564 static DEVICE_ATTR_RW(pwm1);
1565 static DEVICE_ATTR_RW(pwm1_enable);
1566 static DEVICE_ATTR_RO(fan1_input);
1567 static DEVICE_ATTR_RO(fan1_label);
1568 
1569 /* Temperature */
1570 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
1571 
1572 static struct attribute *hwmon_attributes[] = {
1573 	&dev_attr_pwm1.attr,
1574 	&dev_attr_pwm1_enable.attr,
1575 	&dev_attr_fan1_input.attr,
1576 	&dev_attr_fan1_label.attr,
1577 
1578 	&dev_attr_temp1_input.attr,
1579 	NULL
1580 };
1581 
1582 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
1583 					  struct attribute *attr, int idx)
1584 {
1585 	struct device *dev = container_of(kobj, struct device, kobj);
1586 	struct asus_wmi *asus = dev_get_drvdata(dev->parent);
1587 	u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
1588 
1589 	if (attr == &dev_attr_pwm1.attr) {
1590 		if (asus->fan_type != FAN_TYPE_AGFN)
1591 			return 0;
1592 	} else if (attr == &dev_attr_fan1_input.attr
1593 	    || attr == &dev_attr_fan1_label.attr
1594 	    || attr == &dev_attr_pwm1_enable.attr) {
1595 		if (asus->fan_type == FAN_TYPE_NONE)
1596 			return 0;
1597 	} else if (attr == &dev_attr_temp1_input.attr) {
1598 		int err = asus_wmi_get_devstate(asus,
1599 						ASUS_WMI_DEVID_THERMAL_CTRL,
1600 						&value);
1601 
1602 		if (err < 0)
1603 			return 0; /* can't return negative here */
1604 
1605 		/*
1606 		 * If the temperature value in deci-Kelvin is near the absolute
1607 		 * zero temperature, something is clearly wrong
1608 		 */
1609 		if (value == 0 || value == 1)
1610 			return 0;
1611 	}
1612 
1613 	return attr->mode;
1614 }
1615 
1616 static const struct attribute_group hwmon_attribute_group = {
1617 	.is_visible = asus_hwmon_sysfs_is_visible,
1618 	.attrs = hwmon_attributes
1619 };
1620 __ATTRIBUTE_GROUPS(hwmon_attribute);
1621 
1622 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1623 {
1624 	struct device *dev = &asus->platform_device->dev;
1625 	struct device *hwmon;
1626 
1627 	hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
1628 			hwmon_attribute_groups);
1629 
1630 	if (IS_ERR(hwmon)) {
1631 		pr_err("Could not register asus hwmon device\n");
1632 		return PTR_ERR(hwmon);
1633 	}
1634 	return 0;
1635 }
1636 
1637 static int asus_wmi_fan_init(struct asus_wmi *asus)
1638 {
1639 	asus->fan_type = FAN_TYPE_NONE;
1640 	asus->agfn_pwm = -1;
1641 
1642 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
1643 		asus->fan_type = FAN_TYPE_SPEC83;
1644 	else if (asus_wmi_has_agfn_fan(asus))
1645 		asus->fan_type = FAN_TYPE_AGFN;
1646 
1647 	if (asus->fan_type == FAN_TYPE_NONE)
1648 		return -ENODEV;
1649 
1650 	asus_fan_set_auto(asus);
1651 	asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
1652 	return 0;
1653 }
1654 
1655 /* Fan mode *******************************************************************/
1656 
1657 static int fan_boost_mode_check_present(struct asus_wmi *asus)
1658 {
1659 	u32 result;
1660 	int err;
1661 
1662 	asus->fan_boost_mode_available = false;
1663 
1664 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
1665 				    &result);
1666 	if (err) {
1667 		if (err == -ENODEV)
1668 			return 0;
1669 		else
1670 			return err;
1671 	}
1672 
1673 	if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
1674 			(result & ASUS_FAN_BOOST_MODES_MASK)) {
1675 		asus->fan_boost_mode_available = true;
1676 		asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
1677 	}
1678 
1679 	return 0;
1680 }
1681 
1682 static int fan_boost_mode_write(struct asus_wmi *asus)
1683 {
1684 	int err;
1685 	u8 value;
1686 	u32 retval;
1687 
1688 	value = asus->fan_boost_mode;
1689 
1690 	pr_info("Set fan boost mode: %u\n", value);
1691 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
1692 				    &retval);
1693 
1694 	sysfs_notify(&asus->platform_device->dev.kobj, NULL,
1695 			"fan_boost_mode");
1696 
1697 	if (err) {
1698 		pr_warn("Failed to set fan boost mode: %d\n", err);
1699 		return err;
1700 	}
1701 
1702 	if (retval != 1) {
1703 		pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
1704 			retval);
1705 		return -EIO;
1706 	}
1707 
1708 	return 0;
1709 }
1710 
1711 static int fan_boost_mode_switch_next(struct asus_wmi *asus)
1712 {
1713 	u8 mask = asus->fan_boost_mode_mask;
1714 
1715 	if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
1716 		if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
1717 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
1718 		else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
1719 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
1720 	} else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
1721 		if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
1722 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
1723 		else
1724 			asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
1725 	} else {
1726 		asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
1727 	}
1728 
1729 	return fan_boost_mode_write(asus);
1730 }
1731 
1732 static ssize_t fan_boost_mode_show(struct device *dev,
1733 				   struct device_attribute *attr, char *buf)
1734 {
1735 	struct asus_wmi *asus = dev_get_drvdata(dev);
1736 
1737 	return scnprintf(buf, PAGE_SIZE, "%d\n", asus->fan_boost_mode);
1738 }
1739 
1740 static ssize_t fan_boost_mode_store(struct device *dev,
1741 				    struct device_attribute *attr,
1742 				    const char *buf, size_t count)
1743 {
1744 	int result;
1745 	u8 new_mode;
1746 	struct asus_wmi *asus = dev_get_drvdata(dev);
1747 	u8 mask = asus->fan_boost_mode_mask;
1748 
1749 	result = kstrtou8(buf, 10, &new_mode);
1750 	if (result < 0) {
1751 		pr_warn("Trying to store invalid value\n");
1752 		return result;
1753 	}
1754 
1755 	if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
1756 		if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
1757 			return -EINVAL;
1758 	} else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
1759 		if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
1760 			return -EINVAL;
1761 	} else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
1762 		return -EINVAL;
1763 	}
1764 
1765 	asus->fan_boost_mode = new_mode;
1766 	fan_boost_mode_write(asus);
1767 
1768 	return count;
1769 }
1770 
1771 // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
1772 static DEVICE_ATTR_RW(fan_boost_mode);
1773 
1774 /* Throttle thermal policy ****************************************************/
1775 
1776 static int throttle_thermal_policy_check_present(struct asus_wmi *asus)
1777 {
1778 	u32 result;
1779 	int err;
1780 
1781 	asus->throttle_thermal_policy_available = false;
1782 
1783 	err = asus_wmi_get_devstate(asus,
1784 				    ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
1785 				    &result);
1786 	if (err) {
1787 		if (err == -ENODEV)
1788 			return 0;
1789 		return err;
1790 	}
1791 
1792 	if (result & ASUS_WMI_DSTS_PRESENCE_BIT)
1793 		asus->throttle_thermal_policy_available = true;
1794 
1795 	return 0;
1796 }
1797 
1798 static int throttle_thermal_policy_write(struct asus_wmi *asus)
1799 {
1800 	int err;
1801 	u8 value;
1802 	u32 retval;
1803 
1804 	value = asus->throttle_thermal_policy_mode;
1805 
1806 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
1807 				    value, &retval);
1808 
1809 	sysfs_notify(&asus->platform_device->dev.kobj, NULL,
1810 			"throttle_thermal_policy");
1811 
1812 	if (err) {
1813 		pr_warn("Failed to set throttle thermal policy: %d\n", err);
1814 		return err;
1815 	}
1816 
1817 	if (retval != 1) {
1818 		pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n",
1819 			retval);
1820 		return -EIO;
1821 	}
1822 
1823 	return 0;
1824 }
1825 
1826 static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
1827 {
1828 	if (!asus->throttle_thermal_policy_available)
1829 		return 0;
1830 
1831 	asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
1832 	return throttle_thermal_policy_write(asus);
1833 }
1834 
1835 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus)
1836 {
1837 	u8 new_mode = asus->throttle_thermal_policy_mode + 1;
1838 
1839 	if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
1840 		new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
1841 
1842 	asus->throttle_thermal_policy_mode = new_mode;
1843 	return throttle_thermal_policy_write(asus);
1844 }
1845 
1846 static ssize_t throttle_thermal_policy_show(struct device *dev,
1847 				   struct device_attribute *attr, char *buf)
1848 {
1849 	struct asus_wmi *asus = dev_get_drvdata(dev);
1850 	u8 mode = asus->throttle_thermal_policy_mode;
1851 
1852 	return scnprintf(buf, PAGE_SIZE, "%d\n", mode);
1853 }
1854 
1855 static ssize_t throttle_thermal_policy_store(struct device *dev,
1856 				    struct device_attribute *attr,
1857 				    const char *buf, size_t count)
1858 {
1859 	int result;
1860 	u8 new_mode;
1861 	struct asus_wmi *asus = dev_get_drvdata(dev);
1862 
1863 	result = kstrtou8(buf, 10, &new_mode);
1864 	if (result < 0)
1865 		return result;
1866 
1867 	if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
1868 		return -EINVAL;
1869 
1870 	asus->throttle_thermal_policy_mode = new_mode;
1871 	throttle_thermal_policy_write(asus);
1872 
1873 	return count;
1874 }
1875 
1876 // Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
1877 static DEVICE_ATTR_RW(throttle_thermal_policy);
1878 
1879 /* Backlight ******************************************************************/
1880 
1881 static int read_backlight_power(struct asus_wmi *asus)
1882 {
1883 	int ret;
1884 
1885 	if (asus->driver->quirks->store_backlight_power)
1886 		ret = !asus->driver->panel_power;
1887 	else
1888 		ret = asus_wmi_get_devstate_simple(asus,
1889 						   ASUS_WMI_DEVID_BACKLIGHT);
1890 
1891 	if (ret < 0)
1892 		return ret;
1893 
1894 	return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1895 }
1896 
1897 static int read_brightness_max(struct asus_wmi *asus)
1898 {
1899 	u32 retval;
1900 	int err;
1901 
1902 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1903 	if (err < 0)
1904 		return err;
1905 
1906 	retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1907 	retval >>= 8;
1908 
1909 	if (!retval)
1910 		return -ENODEV;
1911 
1912 	return retval;
1913 }
1914 
1915 static int read_brightness(struct backlight_device *bd)
1916 {
1917 	struct asus_wmi *asus = bl_get_data(bd);
1918 	u32 retval;
1919 	int err;
1920 
1921 	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1922 	if (err < 0)
1923 		return err;
1924 
1925 	return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1926 }
1927 
1928 static u32 get_scalar_command(struct backlight_device *bd)
1929 {
1930 	struct asus_wmi *asus = bl_get_data(bd);
1931 	u32 ctrl_param = 0;
1932 
1933 	if ((asus->driver->brightness < bd->props.brightness) ||
1934 	    bd->props.brightness == bd->props.max_brightness)
1935 		ctrl_param = 0x00008001;
1936 	else if ((asus->driver->brightness > bd->props.brightness) ||
1937 		 bd->props.brightness == 0)
1938 		ctrl_param = 0x00008000;
1939 
1940 	asus->driver->brightness = bd->props.brightness;
1941 
1942 	return ctrl_param;
1943 }
1944 
1945 static int update_bl_status(struct backlight_device *bd)
1946 {
1947 	struct asus_wmi *asus = bl_get_data(bd);
1948 	u32 ctrl_param;
1949 	int power, err = 0;
1950 
1951 	power = read_backlight_power(asus);
1952 	if (power != -ENODEV && bd->props.power != power) {
1953 		ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
1954 		err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1955 					    ctrl_param, NULL);
1956 		if (asus->driver->quirks->store_backlight_power)
1957 			asus->driver->panel_power = bd->props.power;
1958 
1959 		/* When using scalar brightness, updating the brightness
1960 		 * will mess with the backlight power */
1961 		if (asus->driver->quirks->scalar_panel_brightness)
1962 			return err;
1963 	}
1964 
1965 	if (asus->driver->quirks->scalar_panel_brightness)
1966 		ctrl_param = get_scalar_command(bd);
1967 	else
1968 		ctrl_param = bd->props.brightness;
1969 
1970 	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1971 				    ctrl_param, NULL);
1972 
1973 	return err;
1974 }
1975 
1976 static const struct backlight_ops asus_wmi_bl_ops = {
1977 	.get_brightness = read_brightness,
1978 	.update_status = update_bl_status,
1979 };
1980 
1981 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
1982 {
1983 	struct backlight_device *bd = asus->backlight_device;
1984 	int old = bd->props.brightness;
1985 	int new = old;
1986 
1987 	if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1988 		new = code - NOTIFY_BRNUP_MIN + 1;
1989 	else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1990 		new = code - NOTIFY_BRNDOWN_MIN;
1991 
1992 	bd->props.brightness = new;
1993 	backlight_update_status(bd);
1994 	backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1995 
1996 	return old;
1997 }
1998 
1999 static int asus_wmi_backlight_init(struct asus_wmi *asus)
2000 {
2001 	struct backlight_device *bd;
2002 	struct backlight_properties props;
2003 	int max;
2004 	int power;
2005 
2006 	max = read_brightness_max(asus);
2007 	if (max < 0)
2008 		return max;
2009 
2010 	power = read_backlight_power(asus);
2011 	if (power == -ENODEV)
2012 		power = FB_BLANK_UNBLANK;
2013 	else if (power < 0)
2014 		return power;
2015 
2016 	memset(&props, 0, sizeof(struct backlight_properties));
2017 	props.type = BACKLIGHT_PLATFORM;
2018 	props.max_brightness = max;
2019 	bd = backlight_device_register(asus->driver->name,
2020 				       &asus->platform_device->dev, asus,
2021 				       &asus_wmi_bl_ops, &props);
2022 	if (IS_ERR(bd)) {
2023 		pr_err("Could not register backlight device\n");
2024 		return PTR_ERR(bd);
2025 	}
2026 
2027 	asus->backlight_device = bd;
2028 
2029 	if (asus->driver->quirks->store_backlight_power)
2030 		asus->driver->panel_power = power;
2031 
2032 	bd->props.brightness = read_brightness(bd);
2033 	bd->props.power = power;
2034 	backlight_update_status(bd);
2035 
2036 	asus->driver->brightness = bd->props.brightness;
2037 
2038 	return 0;
2039 }
2040 
2041 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
2042 {
2043 	backlight_device_unregister(asus->backlight_device);
2044 
2045 	asus->backlight_device = NULL;
2046 }
2047 
2048 static int is_display_toggle(int code)
2049 {
2050 	/* display toggle keys */
2051 	if ((code >= 0x61 && code <= 0x67) ||
2052 	    (code >= 0x8c && code <= 0x93) ||
2053 	    (code >= 0xa0 && code <= 0xa7) ||
2054 	    (code >= 0xd0 && code <= 0xd5))
2055 		return 1;
2056 
2057 	return 0;
2058 }
2059 
2060 /* Fn-lock ********************************************************************/
2061 
2062 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
2063 {
2064 	u32 result;
2065 
2066 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
2067 
2068 	return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
2069 		!(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
2070 }
2071 
2072 static void asus_wmi_fnlock_update(struct asus_wmi *asus)
2073 {
2074 	int mode = asus->fnlock_locked;
2075 
2076 	asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
2077 }
2078 
2079 /* WMI events *****************************************************************/
2080 
2081 static int asus_wmi_get_event_code(u32 value)
2082 {
2083 	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
2084 	union acpi_object *obj;
2085 	acpi_status status;
2086 	int code;
2087 
2088 	status = wmi_get_event_data(value, &response);
2089 	if (ACPI_FAILURE(status)) {
2090 		pr_warn("Failed to get WMI notify code: %s\n",
2091 				acpi_format_exception(status));
2092 		return -EIO;
2093 	}
2094 
2095 	obj = (union acpi_object *)response.pointer;
2096 
2097 	if (obj && obj->type == ACPI_TYPE_INTEGER)
2098 		code = (int)(obj->integer.value & WMI_EVENT_MASK);
2099 	else
2100 		code = -EIO;
2101 
2102 	kfree(obj);
2103 	return code;
2104 }
2105 
2106 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
2107 {
2108 	unsigned int key_value = 1;
2109 	bool autorelease = 1;
2110 	int result, orig_code;
2111 
2112 	orig_code = code;
2113 
2114 	if (asus->driver->key_filter) {
2115 		asus->driver->key_filter(asus->driver, &code, &key_value,
2116 					 &autorelease);
2117 		if (code == ASUS_WMI_KEY_IGNORE)
2118 			return;
2119 	}
2120 
2121 	if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
2122 		code = ASUS_WMI_BRN_UP;
2123 	else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
2124 		code = ASUS_WMI_BRN_DOWN;
2125 
2126 	if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
2127 		if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
2128 			asus_wmi_backlight_notify(asus, orig_code);
2129 			return;
2130 		}
2131 	}
2132 
2133 	if (code == NOTIFY_KBD_BRTUP) {
2134 		kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
2135 		return;
2136 	}
2137 	if (code == NOTIFY_KBD_BRTDWN) {
2138 		kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
2139 		return;
2140 	}
2141 	if (code == NOTIFY_KBD_BRTTOGGLE) {
2142 		if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
2143 			kbd_led_set_by_kbd(asus, 0);
2144 		else
2145 			kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
2146 		return;
2147 	}
2148 
2149 	if (code == NOTIFY_FNLOCK_TOGGLE) {
2150 		asus->fnlock_locked = !asus->fnlock_locked;
2151 		asus_wmi_fnlock_update(asus);
2152 		return;
2153 	}
2154 
2155 	if (asus->driver->quirks->use_kbd_dock_devid && code == NOTIFY_KBD_DOCK_CHANGE) {
2156 		result = asus_wmi_get_devstate_simple(asus,
2157 						      ASUS_WMI_DEVID_KBD_DOCK);
2158 		if (result >= 0) {
2159 			input_report_switch(asus->inputdev, SW_TABLET_MODE,
2160 					    !result);
2161 			input_sync(asus->inputdev);
2162 		}
2163 		return;
2164 	}
2165 
2166 	if (asus->driver->quirks->use_lid_flip_devid && code == NOTIFY_LID_FLIP) {
2167 		lid_flip_tablet_mode_get_state(asus);
2168 		return;
2169 	}
2170 
2171 	if (asus->fan_boost_mode_available && code == NOTIFY_KBD_FBM) {
2172 		fan_boost_mode_switch_next(asus);
2173 		return;
2174 	}
2175 
2176 	if (asus->throttle_thermal_policy_available && code == NOTIFY_KBD_TTP) {
2177 		throttle_thermal_policy_switch_next(asus);
2178 		return;
2179 	}
2180 
2181 	if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
2182 		return;
2183 
2184 	if (!sparse_keymap_report_event(asus->inputdev, code,
2185 					key_value, autorelease))
2186 		pr_info("Unknown key %x pressed\n", code);
2187 }
2188 
2189 static void asus_wmi_notify(u32 value, void *context)
2190 {
2191 	struct asus_wmi *asus = context;
2192 	int code;
2193 	int i;
2194 
2195 	for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
2196 		code = asus_wmi_get_event_code(value);
2197 		if (code < 0) {
2198 			pr_warn("Failed to get notify code: %d\n", code);
2199 			return;
2200 		}
2201 
2202 		if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
2203 			return;
2204 
2205 		asus_wmi_handle_event_code(code, asus);
2206 
2207 		/*
2208 		 * Double check that queue is present:
2209 		 * ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2.
2210 		 */
2211 		if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK)
2212 			return;
2213 	}
2214 
2215 	pr_warn("Failed to process event queue, last code: 0x%x\n", code);
2216 }
2217 
2218 static int asus_wmi_notify_queue_flush(struct asus_wmi *asus)
2219 {
2220 	int code;
2221 	int i;
2222 
2223 	for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
2224 		code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK);
2225 		if (code < 0) {
2226 			pr_warn("Failed to get event during flush: %d\n", code);
2227 			return code;
2228 		}
2229 
2230 		if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
2231 			return 0;
2232 	}
2233 
2234 	pr_warn("Failed to flush event queue\n");
2235 	return -EIO;
2236 }
2237 
2238 /* Sysfs **********************************************************************/
2239 
2240 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
2241 			     const char *buf, size_t count)
2242 {
2243 	u32 retval;
2244 	int err, value;
2245 
2246 	value = asus_wmi_get_devstate_simple(asus, devid);
2247 	if (value < 0)
2248 		return value;
2249 
2250 	err = kstrtoint(buf, 0, &value);
2251 	if (err)
2252 		return err;
2253 
2254 	err = asus_wmi_set_devstate(devid, value, &retval);
2255 	if (err < 0)
2256 		return err;
2257 
2258 	return count;
2259 }
2260 
2261 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
2262 {
2263 	int value = asus_wmi_get_devstate_simple(asus, devid);
2264 
2265 	if (value < 0)
2266 		return value;
2267 
2268 	return sprintf(buf, "%d\n", value);
2269 }
2270 
2271 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)			\
2272 	static ssize_t show_##_name(struct device *dev,			\
2273 				    struct device_attribute *attr,	\
2274 				    char *buf)				\
2275 	{								\
2276 		struct asus_wmi *asus = dev_get_drvdata(dev);		\
2277 									\
2278 		return show_sys_wmi(asus, _cm, buf);			\
2279 	}								\
2280 	static ssize_t store_##_name(struct device *dev,		\
2281 				     struct device_attribute *attr,	\
2282 				     const char *buf, size_t count)	\
2283 	{								\
2284 		struct asus_wmi *asus = dev_get_drvdata(dev);		\
2285 									\
2286 		return store_sys_wmi(asus, _cm, buf, count);		\
2287 	}								\
2288 	static struct device_attribute dev_attr_##_name = {		\
2289 		.attr = {						\
2290 			.name = __stringify(_name),			\
2291 			.mode = _mode },				\
2292 		.show   = show_##_name,					\
2293 		.store  = store_##_name,				\
2294 	}
2295 
2296 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
2297 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
2298 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
2299 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
2300 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
2301 
2302 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
2303 			   const char *buf, size_t count)
2304 {
2305 	int value, rv;
2306 
2307 	rv = kstrtoint(buf, 0, &value);
2308 	if (rv)
2309 		return rv;
2310 
2311 	if (value < 0 || value > 2)
2312 		return -EINVAL;
2313 
2314 	rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
2315 	if (rv < 0)
2316 		return rv;
2317 
2318 	return count;
2319 }
2320 
2321 static DEVICE_ATTR_WO(cpufv);
2322 
2323 static struct attribute *platform_attributes[] = {
2324 	&dev_attr_cpufv.attr,
2325 	&dev_attr_camera.attr,
2326 	&dev_attr_cardr.attr,
2327 	&dev_attr_touchpad.attr,
2328 	&dev_attr_lid_resume.attr,
2329 	&dev_attr_als_enable.attr,
2330 	&dev_attr_fan_boost_mode.attr,
2331 	&dev_attr_throttle_thermal_policy.attr,
2332 	NULL
2333 };
2334 
2335 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
2336 				    struct attribute *attr, int idx)
2337 {
2338 	struct device *dev = container_of(kobj, struct device, kobj);
2339 	struct asus_wmi *asus = dev_get_drvdata(dev);
2340 	bool ok = true;
2341 	int devid = -1;
2342 
2343 	if (attr == &dev_attr_camera.attr)
2344 		devid = ASUS_WMI_DEVID_CAMERA;
2345 	else if (attr == &dev_attr_cardr.attr)
2346 		devid = ASUS_WMI_DEVID_CARDREADER;
2347 	else if (attr == &dev_attr_touchpad.attr)
2348 		devid = ASUS_WMI_DEVID_TOUCHPAD;
2349 	else if (attr == &dev_attr_lid_resume.attr)
2350 		devid = ASUS_WMI_DEVID_LID_RESUME;
2351 	else if (attr == &dev_attr_als_enable.attr)
2352 		devid = ASUS_WMI_DEVID_ALS_ENABLE;
2353 	else if (attr == &dev_attr_fan_boost_mode.attr)
2354 		ok = asus->fan_boost_mode_available;
2355 	else if (attr == &dev_attr_throttle_thermal_policy.attr)
2356 		ok = asus->throttle_thermal_policy_available;
2357 
2358 	if (devid != -1)
2359 		ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
2360 
2361 	return ok ? attr->mode : 0;
2362 }
2363 
2364 static const struct attribute_group platform_attribute_group = {
2365 	.is_visible = asus_sysfs_is_visible,
2366 	.attrs = platform_attributes
2367 };
2368 
2369 static void asus_wmi_sysfs_exit(struct platform_device *device)
2370 {
2371 	sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
2372 }
2373 
2374 static int asus_wmi_sysfs_init(struct platform_device *device)
2375 {
2376 	return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
2377 }
2378 
2379 /* Platform device ************************************************************/
2380 
2381 static int asus_wmi_platform_init(struct asus_wmi *asus)
2382 {
2383 	struct device *dev = &asus->platform_device->dev;
2384 	char *wmi_uid;
2385 	int rv;
2386 
2387 	/* INIT enable hotkeys on some models */
2388 	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
2389 		pr_info("Initialization: %#x\n", rv);
2390 
2391 	/* We don't know yet what to do with this version... */
2392 	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
2393 		pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
2394 		asus->spec = rv;
2395 	}
2396 
2397 	/*
2398 	 * The SFUN method probably allows the original driver to get the list
2399 	 * of features supported by a given model. For now, 0x0100 or 0x0800
2400 	 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
2401 	 * The significance of others is yet to be found.
2402 	 */
2403 	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
2404 		pr_info("SFUN value: %#x\n", rv);
2405 		asus->sfun = rv;
2406 	}
2407 
2408 	/*
2409 	 * Eee PC and Notebooks seems to have different method_id for DSTS,
2410 	 * but it may also be related to the BIOS's SPEC.
2411 	 * Note, on most Eeepc, there is no way to check if a method exist
2412 	 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
2413 	 * but once again, SPEC may probably be used for that kind of things.
2414 	 *
2415 	 * Additionally at least TUF Gaming series laptops return nothing for
2416 	 * unknown methods, so the detection in this way is not possible.
2417 	 *
2418 	 * There is strong indication that only ACPI WMI devices that have _UID
2419 	 * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
2420 	 */
2421 	wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
2422 	if (!wmi_uid)
2423 		return -ENODEV;
2424 
2425 	if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
2426 		dev_info(dev, "Detected ASUSWMI, use DCTS\n");
2427 		asus->dsts_id = ASUS_WMI_METHODID_DCTS;
2428 	} else {
2429 		dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
2430 		asus->dsts_id = ASUS_WMI_METHODID_DSTS;
2431 	}
2432 
2433 	/*
2434 	 * Some devices can have multiple event codes stored in a queue before
2435 	 * the module load if it was unloaded intermittently after calling
2436 	 * the INIT method (enables event handling). The WMI notify handler is
2437 	 * expected to retrieve all event codes until a retrieved code equals
2438 	 * queue end marker (One or Ones). Old codes are flushed from the queue
2439 	 * upon module load. Not enabling this when it should be has minimal
2440 	 * visible impact so fall back if anything goes wrong.
2441 	 */
2442 	wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid);
2443 	if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) {
2444 		dev_info(dev, "Detected ATK, enable event queue\n");
2445 
2446 		if (!asus_wmi_notify_queue_flush(asus))
2447 			asus->wmi_event_queue = true;
2448 	}
2449 
2450 	/* CWAP allow to define the behavior of the Fn+F2 key,
2451 	 * this method doesn't seems to be present on Eee PCs */
2452 	if (asus->driver->quirks->wapf >= 0)
2453 		asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
2454 				      asus->driver->quirks->wapf, NULL);
2455 
2456 	return 0;
2457 }
2458 
2459 /* debugfs ********************************************************************/
2460 
2461 struct asus_wmi_debugfs_node {
2462 	struct asus_wmi *asus;
2463 	char *name;
2464 	int (*show) (struct seq_file *m, void *data);
2465 };
2466 
2467 static int show_dsts(struct seq_file *m, void *data)
2468 {
2469 	struct asus_wmi *asus = m->private;
2470 	int err;
2471 	u32 retval = -1;
2472 
2473 	err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
2474 	if (err < 0)
2475 		return err;
2476 
2477 	seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
2478 
2479 	return 0;
2480 }
2481 
2482 static int show_devs(struct seq_file *m, void *data)
2483 {
2484 	struct asus_wmi *asus = m->private;
2485 	int err;
2486 	u32 retval = -1;
2487 
2488 	err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
2489 				    &retval);
2490 	if (err < 0)
2491 		return err;
2492 
2493 	seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
2494 		   asus->debug.ctrl_param, retval);
2495 
2496 	return 0;
2497 }
2498 
2499 static int show_call(struct seq_file *m, void *data)
2500 {
2501 	struct asus_wmi *asus = m->private;
2502 	struct bios_args args = {
2503 		.arg0 = asus->debug.dev_id,
2504 		.arg1 = asus->debug.ctrl_param,
2505 	};
2506 	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
2507 	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
2508 	union acpi_object *obj;
2509 	acpi_status status;
2510 
2511 	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
2512 				     0, asus->debug.method_id,
2513 				     &input, &output);
2514 
2515 	if (ACPI_FAILURE(status))
2516 		return -EIO;
2517 
2518 	obj = (union acpi_object *)output.pointer;
2519 	if (obj && obj->type == ACPI_TYPE_INTEGER)
2520 		seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
2521 			   asus->debug.dev_id, asus->debug.ctrl_param,
2522 			   (u32) obj->integer.value);
2523 	else
2524 		seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
2525 			   asus->debug.dev_id, asus->debug.ctrl_param,
2526 			   obj ? obj->type : -1);
2527 
2528 	kfree(obj);
2529 
2530 	return 0;
2531 }
2532 
2533 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
2534 	{NULL, "devs", show_devs},
2535 	{NULL, "dsts", show_dsts},
2536 	{NULL, "call", show_call},
2537 };
2538 
2539 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
2540 {
2541 	struct asus_wmi_debugfs_node *node = inode->i_private;
2542 
2543 	return single_open(file, node->show, node->asus);
2544 }
2545 
2546 static const struct file_operations asus_wmi_debugfs_io_ops = {
2547 	.owner = THIS_MODULE,
2548 	.open = asus_wmi_debugfs_open,
2549 	.read = seq_read,
2550 	.llseek = seq_lseek,
2551 	.release = single_release,
2552 };
2553 
2554 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
2555 {
2556 	debugfs_remove_recursive(asus->debug.root);
2557 }
2558 
2559 static void asus_wmi_debugfs_init(struct asus_wmi *asus)
2560 {
2561 	int i;
2562 
2563 	asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
2564 
2565 	debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
2566 			   &asus->debug.method_id);
2567 
2568 	debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
2569 			   &asus->debug.dev_id);
2570 
2571 	debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
2572 			   &asus->debug.ctrl_param);
2573 
2574 	for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
2575 		struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
2576 
2577 		node->asus = asus;
2578 		debugfs_create_file(node->name, S_IFREG | S_IRUGO,
2579 				    asus->debug.root, node,
2580 				    &asus_wmi_debugfs_io_ops);
2581 	}
2582 }
2583 
2584 /* Init / exit ****************************************************************/
2585 
2586 static int asus_wmi_add(struct platform_device *pdev)
2587 {
2588 	struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2589 	struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2590 	struct asus_wmi *asus;
2591 	const char *chassis_type;
2592 	acpi_status status;
2593 	int err;
2594 	u32 result;
2595 
2596 	asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
2597 	if (!asus)
2598 		return -ENOMEM;
2599 
2600 	asus->driver = wdrv;
2601 	asus->platform_device = pdev;
2602 	wdrv->platform_device = pdev;
2603 	platform_set_drvdata(asus->platform_device, asus);
2604 
2605 	if (wdrv->detect_quirks)
2606 		wdrv->detect_quirks(asus->driver);
2607 
2608 	err = asus_wmi_platform_init(asus);
2609 	if (err)
2610 		goto fail_platform;
2611 
2612 	err = fan_boost_mode_check_present(asus);
2613 	if (err)
2614 		goto fail_fan_boost_mode;
2615 
2616 	err = throttle_thermal_policy_check_present(asus);
2617 	if (err)
2618 		goto fail_throttle_thermal_policy;
2619 	else
2620 		throttle_thermal_policy_set_default(asus);
2621 
2622 	err = asus_wmi_sysfs_init(asus->platform_device);
2623 	if (err)
2624 		goto fail_sysfs;
2625 
2626 	err = asus_wmi_input_init(asus);
2627 	if (err)
2628 		goto fail_input;
2629 
2630 	err = asus_wmi_fan_init(asus); /* probably no problems on error */
2631 
2632 	err = asus_wmi_hwmon_init(asus);
2633 	if (err)
2634 		goto fail_hwmon;
2635 
2636 	err = asus_wmi_led_init(asus);
2637 	if (err)
2638 		goto fail_leds;
2639 
2640 	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
2641 	if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
2642 		asus->driver->wlan_ctrl_by_user = 1;
2643 
2644 	if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
2645 		err = asus_wmi_rfkill_init(asus);
2646 		if (err)
2647 			goto fail_rfkill;
2648 	}
2649 
2650 	if (asus->driver->quirks->wmi_force_als_set)
2651 		asus_wmi_set_als();
2652 
2653 	/* Some Asus desktop boards export an acpi-video backlight interface,
2654 	   stop this from showing up */
2655 	chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2656 	if (chassis_type && !strcmp(chassis_type, "3"))
2657 		acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2658 
2659 	if (asus->driver->quirks->wmi_backlight_power)
2660 		acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2661 
2662 	if (asus->driver->quirks->wmi_backlight_native)
2663 		acpi_video_set_dmi_backlight_type(acpi_backlight_native);
2664 
2665 	if (asus->driver->quirks->xusb2pr)
2666 		asus_wmi_set_xusb2pr(asus);
2667 
2668 	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
2669 		err = asus_wmi_backlight_init(asus);
2670 		if (err && err != -ENODEV)
2671 			goto fail_backlight;
2672 	} else if (asus->driver->quirks->wmi_backlight_set_devstate)
2673 		err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
2674 
2675 	if (asus_wmi_has_fnlock_key(asus)) {
2676 		asus->fnlock_locked = true;
2677 		asus_wmi_fnlock_update(asus);
2678 	}
2679 
2680 	status = wmi_install_notify_handler(asus->driver->event_guid,
2681 					    asus_wmi_notify, asus);
2682 	if (ACPI_FAILURE(status)) {
2683 		pr_err("Unable to register notify handler - %d\n", status);
2684 		err = -ENODEV;
2685 		goto fail_wmi_handler;
2686 	}
2687 
2688 	asus_wmi_battery_init(asus);
2689 
2690 	asus_wmi_debugfs_init(asus);
2691 
2692 	return 0;
2693 
2694 fail_wmi_handler:
2695 	asus_wmi_backlight_exit(asus);
2696 fail_backlight:
2697 	asus_wmi_rfkill_exit(asus);
2698 fail_rfkill:
2699 	asus_wmi_led_exit(asus);
2700 fail_leds:
2701 fail_hwmon:
2702 	asus_wmi_input_exit(asus);
2703 fail_input:
2704 	asus_wmi_sysfs_exit(asus->platform_device);
2705 fail_sysfs:
2706 fail_throttle_thermal_policy:
2707 fail_fan_boost_mode:
2708 fail_platform:
2709 	kfree(asus);
2710 	return err;
2711 }
2712 
2713 static int asus_wmi_remove(struct platform_device *device)
2714 {
2715 	struct asus_wmi *asus;
2716 
2717 	asus = platform_get_drvdata(device);
2718 	wmi_remove_notify_handler(asus->driver->event_guid);
2719 	asus_wmi_backlight_exit(asus);
2720 	asus_wmi_input_exit(asus);
2721 	asus_wmi_led_exit(asus);
2722 	asus_wmi_rfkill_exit(asus);
2723 	asus_wmi_debugfs_exit(asus);
2724 	asus_wmi_sysfs_exit(asus->platform_device);
2725 	asus_fan_set_auto(asus);
2726 	asus_wmi_battery_exit(asus);
2727 
2728 	kfree(asus);
2729 	return 0;
2730 }
2731 
2732 /* Platform driver - hibernate/resume callbacks *******************************/
2733 
2734 static int asus_hotk_thaw(struct device *device)
2735 {
2736 	struct asus_wmi *asus = dev_get_drvdata(device);
2737 
2738 	if (asus->wlan.rfkill) {
2739 		bool wlan;
2740 
2741 		/*
2742 		 * Work around bios bug - acpi _PTS turns off the wireless led
2743 		 * during suspend.  Normally it restores it on resume, but
2744 		 * we should kick it ourselves in case hibernation is aborted.
2745 		 */
2746 		wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
2747 		asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
2748 	}
2749 
2750 	return 0;
2751 }
2752 
2753 static int asus_hotk_resume(struct device *device)
2754 {
2755 	struct asus_wmi *asus = dev_get_drvdata(device);
2756 
2757 	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2758 		kbd_led_update(asus);
2759 
2760 	if (asus_wmi_has_fnlock_key(asus))
2761 		asus_wmi_fnlock_update(asus);
2762 
2763 	if (asus->driver->quirks->use_lid_flip_devid)
2764 		lid_flip_tablet_mode_get_state(asus);
2765 
2766 	return 0;
2767 }
2768 
2769 static int asus_hotk_restore(struct device *device)
2770 {
2771 	struct asus_wmi *asus = dev_get_drvdata(device);
2772 	int bl;
2773 
2774 	/* Refresh both wlan rfkill state and pci hotplug */
2775 	if (asus->wlan.rfkill)
2776 		asus_rfkill_hotplug(asus);
2777 
2778 	if (asus->bluetooth.rfkill) {
2779 		bl = !asus_wmi_get_devstate_simple(asus,
2780 						   ASUS_WMI_DEVID_BLUETOOTH);
2781 		rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
2782 	}
2783 	if (asus->wimax.rfkill) {
2784 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
2785 		rfkill_set_sw_state(asus->wimax.rfkill, bl);
2786 	}
2787 	if (asus->wwan3g.rfkill) {
2788 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
2789 		rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
2790 	}
2791 	if (asus->gps.rfkill) {
2792 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
2793 		rfkill_set_sw_state(asus->gps.rfkill, bl);
2794 	}
2795 	if (asus->uwb.rfkill) {
2796 		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
2797 		rfkill_set_sw_state(asus->uwb.rfkill, bl);
2798 	}
2799 	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2800 		kbd_led_update(asus);
2801 
2802 	if (asus_wmi_has_fnlock_key(asus))
2803 		asus_wmi_fnlock_update(asus);
2804 
2805 	if (asus->driver->quirks->use_lid_flip_devid)
2806 		lid_flip_tablet_mode_get_state(asus);
2807 
2808 	return 0;
2809 }
2810 
2811 static const struct dev_pm_ops asus_pm_ops = {
2812 	.thaw = asus_hotk_thaw,
2813 	.restore = asus_hotk_restore,
2814 	.resume = asus_hotk_resume,
2815 };
2816 
2817 /* Registration ***************************************************************/
2818 
2819 static int asus_wmi_probe(struct platform_device *pdev)
2820 {
2821 	struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2822 	struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2823 	int ret;
2824 
2825 	if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
2826 		pr_warn("ASUS Management GUID not found\n");
2827 		return -ENODEV;
2828 	}
2829 
2830 	if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
2831 		pr_warn("ASUS Event GUID not found\n");
2832 		return -ENODEV;
2833 	}
2834 
2835 	if (wdrv->probe) {
2836 		ret = wdrv->probe(pdev);
2837 		if (ret)
2838 			return ret;
2839 	}
2840 
2841 	return asus_wmi_add(pdev);
2842 }
2843 
2844 static bool used;
2845 
2846 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
2847 {
2848 	struct platform_driver *platform_driver;
2849 	struct platform_device *platform_device;
2850 
2851 	if (used)
2852 		return -EBUSY;
2853 
2854 	platform_driver = &driver->platform_driver;
2855 	platform_driver->remove = asus_wmi_remove;
2856 	platform_driver->driver.owner = driver->owner;
2857 	platform_driver->driver.name = driver->name;
2858 	platform_driver->driver.pm = &asus_pm_ops;
2859 
2860 	platform_device = platform_create_bundle(platform_driver,
2861 						 asus_wmi_probe,
2862 						 NULL, 0, NULL, 0);
2863 	if (IS_ERR(platform_device))
2864 		return PTR_ERR(platform_device);
2865 
2866 	used = true;
2867 	return 0;
2868 }
2869 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
2870 
2871 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
2872 {
2873 	platform_device_unregister(driver->platform_device);
2874 	platform_driver_unregister(&driver->platform_driver);
2875 	used = false;
2876 }
2877 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
2878 
2879 static int __init asus_wmi_init(void)
2880 {
2881 	pr_info("ASUS WMI generic driver loaded\n");
2882 	return 0;
2883 }
2884 
2885 static void __exit asus_wmi_exit(void)
2886 {
2887 	pr_info("ASUS WMI generic driver unloaded\n");
2888 }
2889 
2890 module_init(asus_wmi_init);
2891 module_exit(asus_wmi_exit);
2892