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