2
* Asus PC WMI hotkey driver
4
* Copyright(C) 2010 Intel Corporation.
5
* Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
7
* Portions based on wistron_btns.c:
8
* Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
9
* Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
10
* Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
12
* This program is free software; you can redistribute it and/or modify
13
* it under the terms of the GNU General Public License as published by
14
* the Free Software Foundation; either version 2 of the License, or
15
* (at your option) any later version.
17
* This program is distributed in the hope that it will be useful,
18
* but WITHOUT ANY WARRANTY; without even the implied warranty of
19
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20
* GNU General Public License for more details.
22
* You should have received a copy of the GNU General Public License
23
* along with this program; if not, write to the Free Software
24
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
#include <linux/kernel.h>
30
#include <linux/module.h>
31
#include <linux/init.h>
32
#include <linux/types.h>
33
#include <linux/slab.h>
34
#include <linux/input.h>
35
#include <linux/input/sparse-keymap.h>
37
#include <linux/backlight.h>
38
#include <linux/leds.h>
39
#include <linux/rfkill.h>
40
#include <linux/pci.h>
41
#include <linux/pci_hotplug.h>
42
#include <linux/hwmon.h>
43
#include <linux/hwmon-sysfs.h>
44
#include <linux/debugfs.h>
45
#include <linux/seq_file.h>
46
#include <linux/platform_device.h>
47
#include <acpi/acpi_bus.h>
48
#include <acpi/acpi_drivers.h>
52
MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
53
"Yong Wang <yong.y.wang@intel.com>");
54
MODULE_DESCRIPTION("Asus Generic WMI Driver");
55
MODULE_LICENSE("GPL");
57
#define to_platform_driver(drv) \
58
(container_of((drv), struct platform_driver, driver))
60
#define to_asus_wmi_driver(pdrv) \
61
(container_of((pdrv), struct asus_wmi_driver, platform_driver))
63
#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
65
#define NOTIFY_BRNUP_MIN 0x11
66
#define NOTIFY_BRNUP_MAX 0x1f
67
#define NOTIFY_BRNDOWN_MIN 0x20
68
#define NOTIFY_BRNDOWN_MAX 0x2e
71
#define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
72
#define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
73
#define ASUS_WMI_METHODID_GLCD 0x44434C47 /* Get LCD status */
74
#define ASUS_WMI_METHODID_GPID 0x44495047 /* Get Panel ID?? (Resol) */
75
#define ASUS_WMI_METHODID_QMOD 0x444F4D51 /* Quiet MODe */
76
#define ASUS_WMI_METHODID_SPLV 0x4C425053 /* Set Panel Light Value */
77
#define ASUS_WMI_METHODID_SFUN 0x4E554653 /* FUNCtionalities */
78
#define ASUS_WMI_METHODID_SDSP 0x50534453 /* Set DiSPlay output */
79
#define ASUS_WMI_METHODID_GDSP 0x50534447 /* Get DiSPlay output */
80
#define ASUS_WMI_METHODID_DEVP 0x50564544 /* DEVice Policy */
81
#define ASUS_WMI_METHODID_OSVR 0x5256534F /* OS VeRsion */
82
#define ASUS_WMI_METHODID_DSTS 0x53544344 /* Device STatuS */
83
#define ASUS_WMI_METHODID_DSTS2 0x53545344 /* Device STatuS #2*/
84
#define ASUS_WMI_METHODID_BSTS 0x53545342 /* Bios STatuS ? */
85
#define ASUS_WMI_METHODID_DEVS 0x53564544 /* DEVice Set */
86
#define ASUS_WMI_METHODID_CFVS 0x53564643 /* CPU Frequency Volt Set */
87
#define ASUS_WMI_METHODID_KBFT 0x5446424B /* KeyBoard FilTer */
88
#define ASUS_WMI_METHODID_INIT 0x54494E49 /* INITialize */
89
#define ASUS_WMI_METHODID_HKEY 0x59454B48 /* Hot KEY ?? */
91
#define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
94
#define ASUS_WMI_DEVID_HW_SWITCH 0x00010001
95
#define ASUS_WMI_DEVID_WIRELESS_LED 0x00010002
96
#define ASUS_WMI_DEVID_WLAN 0x00010011
97
#define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
98
#define ASUS_WMI_DEVID_GPS 0x00010015
99
#define ASUS_WMI_DEVID_WIMAX 0x00010017
100
#define ASUS_WMI_DEVID_WWAN3G 0x00010019
101
#define ASUS_WMI_DEVID_UWB 0x00010021
104
/* 0x000200XX and 0x000400XX */
106
/* Backlight and Brightness */
107
#define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
108
#define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
109
#define ASUS_WMI_DEVID_KBD_BACKLIGHT 0x00050021
110
#define ASUS_WMI_DEVID_LIGHT_SENSOR 0x00050022 /* ?? */
113
#define ASUS_WMI_DEVID_CAMERA 0x00060013
116
#define ASUS_WMI_DEVID_CARDREADER 0x00080013
119
#define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
120
#define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
123
#define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011
124
#define ASUS_WMI_DEVID_FAN_CTRL 0x00110012
127
#define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012
130
#define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
131
#define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
132
#define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
133
#define ASUS_WMI_DSTS_USER_BIT 0x00020000
134
#define ASUS_WMI_DSTS_BIOS_BIT 0x00040000
135
#define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
136
#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
144
* <platform>/ - debugfs root directory
145
* dev_id - current dev_id
146
* ctrl_param - current ctrl_param
147
* method_id - current method_id
148
* devs - call DEVS(dev_id, ctrl_param) and print result
149
* dsts - call DSTS(dev_id) and print result
150
* call - call method_id(dev_id, ctrl_param) and print result
152
struct asus_wmi_debug {
160
struct asus_wmi *asus;
161
struct rfkill *rfkill;
170
struct input_dev *inputdev;
171
struct backlight_device *backlight_device;
172
struct device *hwmon_device;
173
struct platform_device *platform_device;
175
struct led_classdev tpd_led;
177
struct workqueue_struct *led_workqueue;
178
struct work_struct tpd_led_work;
180
struct asus_rfkill wlan;
181
struct asus_rfkill bluetooth;
182
struct asus_rfkill wimax;
183
struct asus_rfkill wwan3g;
185
struct hotplug_slot *hotplug_slot;
186
struct mutex hotplug_lock;
187
struct mutex wmi_lock;
188
struct workqueue_struct *hotplug_workqueue;
189
struct work_struct hotplug_work;
191
struct asus_wmi_debug debug;
193
struct asus_wmi_driver *driver;
196
static int asus_wmi_input_init(struct asus_wmi *asus)
200
asus->inputdev = input_allocate_device();
204
asus->inputdev->name = asus->driver->input_name;
205
asus->inputdev->phys = asus->driver->input_phys;
206
asus->inputdev->id.bustype = BUS_HOST;
207
asus->inputdev->dev.parent = &asus->platform_device->dev;
208
set_bit(EV_REP, asus->inputdev->evbit);
210
err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
214
err = input_register_device(asus->inputdev);
216
goto err_free_keymap;
221
sparse_keymap_free(asus->inputdev);
223
input_free_device(asus->inputdev);
227
static void asus_wmi_input_exit(struct asus_wmi *asus)
229
if (asus->inputdev) {
230
sparse_keymap_free(asus->inputdev);
231
input_unregister_device(asus->inputdev);
234
asus->inputdev = NULL;
237
static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
240
struct bios_args args = {
244
struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
245
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
247
union acpi_object *obj;
250
status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
253
if (ACPI_FAILURE(status))
256
obj = (union acpi_object *)output.pointer;
257
if (obj && obj->type == ACPI_TYPE_INTEGER)
258
tmp = (u32) obj->integer.value;
268
if (ACPI_FAILURE(status))
271
if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
277
static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
279
return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
282
static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
285
return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
289
/* Helper for special devices with magic return codes */
290
static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
291
u32 dev_id, u32 mask)
296
err = asus_wmi_get_devstate(asus, dev_id, &retval);
301
if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
304
if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
305
if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
309
return retval & mask;
312
static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
314
return asus_wmi_get_devstate_bits(asus, dev_id,
315
ASUS_WMI_DSTS_STATUS_BIT);
322
* These functions actually update the LED's, and are called from a
323
* workqueue. By doing this as separate work rather than when the LED
324
* subsystem asks, we avoid messing with the Asus ACPI stuff during a
325
* potentially bad time, such as a timer interrupt.
327
static void tpd_led_update(struct work_struct *work)
330
struct asus_wmi *asus;
332
asus = container_of(work, struct asus_wmi, tpd_led_work);
334
ctrl_param = asus->tpd_led_wk;
335
asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
338
static void tpd_led_set(struct led_classdev *led_cdev,
339
enum led_brightness value)
341
struct asus_wmi *asus;
343
asus = container_of(led_cdev, struct asus_wmi, tpd_led);
345
asus->tpd_led_wk = !!value;
346
queue_work(asus->led_workqueue, &asus->tpd_led_work);
349
static int read_tpd_led_state(struct asus_wmi *asus)
351
return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
354
static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
356
struct asus_wmi *asus;
358
asus = container_of(led_cdev, struct asus_wmi, tpd_led);
360
return read_tpd_led_state(asus);
363
static int asus_wmi_led_init(struct asus_wmi *asus)
367
if (read_tpd_led_state(asus) < 0)
370
asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
371
if (!asus->led_workqueue)
373
INIT_WORK(&asus->tpd_led_work, tpd_led_update);
375
asus->tpd_led.name = "asus::touchpad";
376
asus->tpd_led.brightness_set = tpd_led_set;
377
asus->tpd_led.brightness_get = tpd_led_get;
378
asus->tpd_led.max_brightness = 1;
380
rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
382
destroy_workqueue(asus->led_workqueue);
389
static void asus_wmi_led_exit(struct asus_wmi *asus)
391
if (asus->tpd_led.dev)
392
led_classdev_unregister(&asus->tpd_led);
393
if (asus->led_workqueue)
394
destroy_workqueue(asus->led_workqueue);
398
* PCI hotplug (for wlan rfkill)
400
static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
402
int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
409
static void asus_rfkill_hotplug(struct asus_wmi *asus)
417
mutex_lock(&asus->wmi_lock);
418
blocked = asus_wlan_rfkill_blocked(asus);
419
mutex_unlock(&asus->wmi_lock);
421
mutex_lock(&asus->hotplug_lock);
423
if (asus->wlan.rfkill)
424
rfkill_set_sw_state(asus->wlan.rfkill, blocked);
426
if (asus->hotplug_slot) {
427
bus = pci_find_bus(0, 1);
429
pr_warn("Unable to find PCI bus 1?\n");
433
if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
434
pr_err("Unable to read PCI config space?\n");
437
absent = (l == 0xffffffff);
439
if (blocked != absent) {
440
pr_warn("BIOS says wireless lan is %s, "
441
"but the pci device is %s\n",
442
blocked ? "blocked" : "unblocked",
443
absent ? "absent" : "present");
444
pr_warn("skipped wireless hotplug as probably "
445
"inappropriate for this model\n");
450
dev = pci_get_slot(bus, 0);
452
/* Device already present */
456
dev = pci_scan_single_device(bus, 0);
458
pci_bus_assign_resources(bus);
459
if (pci_bus_add_device(dev))
460
pr_err("Unable to hotplug wifi\n");
463
dev = pci_get_slot(bus, 0);
465
pci_remove_bus_device(dev);
472
mutex_unlock(&asus->hotplug_lock);
475
static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
477
struct asus_wmi *asus = data;
479
if (event != ACPI_NOTIFY_BUS_CHECK)
483
* We can't call directly asus_rfkill_hotplug because most
484
* of the time WMBC is still being executed and not reetrant.
485
* There is currently no way to tell ACPICA that we want this
486
* method to be serialized, we schedule a asus_rfkill_hotplug
487
* call later, in a safer context.
489
queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
492
static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
497
status = acpi_get_handle(NULL, node, &handle);
499
if (ACPI_SUCCESS(status)) {
500
status = acpi_install_notify_handler(handle,
502
asus_rfkill_notify, asus);
503
if (ACPI_FAILURE(status))
504
pr_warn("Failed to register notify on %s\n", node);
511
static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
513
acpi_status status = AE_OK;
516
status = acpi_get_handle(NULL, node, &handle);
518
if (ACPI_SUCCESS(status)) {
519
status = acpi_remove_notify_handler(handle,
522
if (ACPI_FAILURE(status))
523
pr_err("Error removing rfkill notify handler %s\n",
528
static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
531
struct asus_wmi *asus = hotplug_slot->private;
532
int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
541
static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
543
kfree(hotplug_slot->info);
547
static struct hotplug_slot_ops asus_hotplug_slot_ops = {
548
.owner = THIS_MODULE,
549
.get_adapter_status = asus_get_adapter_status,
550
.get_power_status = asus_get_adapter_status,
553
static void asus_hotplug_work(struct work_struct *work)
555
struct asus_wmi *asus;
557
asus = container_of(work, struct asus_wmi, hotplug_work);
558
asus_rfkill_hotplug(asus);
561
static int asus_setup_pci_hotplug(struct asus_wmi *asus)
564
struct pci_bus *bus = pci_find_bus(0, 1);
567
pr_err("Unable to find wifi PCI bus\n");
571
asus->hotplug_workqueue =
572
create_singlethread_workqueue("hotplug_workqueue");
573
if (!asus->hotplug_workqueue)
574
goto error_workqueue;
576
INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
578
asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
579
if (!asus->hotplug_slot)
582
asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
584
if (!asus->hotplug_slot->info)
587
asus->hotplug_slot->private = asus;
588
asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
589
asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
590
asus_get_adapter_status(asus->hotplug_slot,
591
&asus->hotplug_slot->info->adapter_status);
593
ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
595
pr_err("Unable to register hotplug slot - %d\n", ret);
602
kfree(asus->hotplug_slot->info);
604
kfree(asus->hotplug_slot);
605
asus->hotplug_slot = NULL;
607
destroy_workqueue(asus->hotplug_workqueue);
615
static int asus_rfkill_set(void *data, bool blocked)
617
struct asus_rfkill *priv = data;
618
u32 ctrl_param = !blocked;
620
return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
623
static void asus_rfkill_query(struct rfkill *rfkill, void *data)
625
struct asus_rfkill *priv = data;
628
result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
633
rfkill_set_sw_state(priv->rfkill, !result);
636
static int asus_rfkill_wlan_set(void *data, bool blocked)
638
struct asus_rfkill *priv = data;
639
struct asus_wmi *asus = priv->asus;
643
* This handler is enabled only if hotplug is enabled.
644
* In this case, the asus_wmi_set_devstate() will
645
* trigger a wmi notification and we need to wait
646
* this call to finish before being able to call
649
mutex_lock(&asus->wmi_lock);
650
ret = asus_rfkill_set(data, blocked);
651
mutex_unlock(&asus->wmi_lock);
655
static const struct rfkill_ops asus_rfkill_wlan_ops = {
656
.set_block = asus_rfkill_wlan_set,
657
.query = asus_rfkill_query,
660
static const struct rfkill_ops asus_rfkill_ops = {
661
.set_block = asus_rfkill_set,
662
.query = asus_rfkill_query,
665
static int asus_new_rfkill(struct asus_wmi *asus,
666
struct asus_rfkill *arfkill,
667
const char *name, enum rfkill_type type, int dev_id)
669
int result = asus_wmi_get_devstate_simple(asus, dev_id);
670
struct rfkill **rfkill = &arfkill->rfkill;
675
arfkill->dev_id = dev_id;
676
arfkill->asus = asus;
678
if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
679
*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
680
&asus_rfkill_wlan_ops, arfkill);
682
*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
683
&asus_rfkill_ops, arfkill);
688
rfkill_init_sw_state(*rfkill, !result);
689
result = rfkill_register(*rfkill);
691
rfkill_destroy(*rfkill);
698
static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
700
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
701
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
702
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
703
if (asus->wlan.rfkill) {
704
rfkill_unregister(asus->wlan.rfkill);
705
rfkill_destroy(asus->wlan.rfkill);
706
asus->wlan.rfkill = NULL;
709
* Refresh pci hotplug in case the rfkill state was changed after
710
* asus_unregister_rfkill_notifier()
712
asus_rfkill_hotplug(asus);
713
if (asus->hotplug_slot)
714
pci_hp_deregister(asus->hotplug_slot);
715
if (asus->hotplug_workqueue)
716
destroy_workqueue(asus->hotplug_workqueue);
718
if (asus->bluetooth.rfkill) {
719
rfkill_unregister(asus->bluetooth.rfkill);
720
rfkill_destroy(asus->bluetooth.rfkill);
721
asus->bluetooth.rfkill = NULL;
723
if (asus->wimax.rfkill) {
724
rfkill_unregister(asus->wimax.rfkill);
725
rfkill_destroy(asus->wimax.rfkill);
726
asus->wimax.rfkill = NULL;
728
if (asus->wwan3g.rfkill) {
729
rfkill_unregister(asus->wwan3g.rfkill);
730
rfkill_destroy(asus->wwan3g.rfkill);
731
asus->wwan3g.rfkill = NULL;
735
static int asus_wmi_rfkill_init(struct asus_wmi *asus)
739
mutex_init(&asus->hotplug_lock);
740
mutex_init(&asus->wmi_lock);
742
result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
743
RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
745
if (result && result != -ENODEV)
748
result = asus_new_rfkill(asus, &asus->bluetooth,
749
"asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
750
ASUS_WMI_DEVID_BLUETOOTH);
752
if (result && result != -ENODEV)
755
result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
756
RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
758
if (result && result != -ENODEV)
761
result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
762
RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
764
if (result && result != -ENODEV)
767
if (!asus->driver->hotplug_wireless)
770
result = asus_setup_pci_hotplug(asus);
772
* If we get -EBUSY then something else is handling the PCI hotplug -
773
* don't fail in this case
775
if (result == -EBUSY)
778
asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
779
asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
780
asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
782
* Refresh pci hotplug in case the rfkill state was changed during
785
asus_rfkill_hotplug(asus);
788
if (result && result != -ENODEV)
789
asus_wmi_rfkill_exit(asus);
791
if (result == -ENODEV)
800
static ssize_t asus_hwmon_pwm1(struct device *dev,
801
struct device_attribute *attr,
804
struct asus_wmi *asus = dev_get_drvdata(dev);
808
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
815
if (value == 1) /* Low Speed */
821
else if (value != 0) {
822
pr_err("Unknown fan speed %#x", value);
826
return sprintf(buf, "%d\n", value);
829
static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
832
show_name(struct device *dev, struct device_attribute *attr, char *buf)
834
return sprintf(buf, "asus\n");
836
static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
838
static struct attribute *hwmon_attributes[] = {
839
&sensor_dev_attr_pwm1.dev_attr.attr,
840
&sensor_dev_attr_name.dev_attr.attr,
844
static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
845
struct attribute *attr, int idx)
847
struct device *dev = container_of(kobj, struct device, kobj);
848
struct platform_device *pdev = to_platform_device(dev->parent);
849
struct asus_wmi *asus = platform_get_drvdata(pdev);
852
u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
854
if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
855
dev_id = ASUS_WMI_DEVID_FAN_CTRL;
858
int err = asus_wmi_get_devstate(asus, dev_id, &value);
864
if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
866
* We need to find a better way, probably using sfun,
868
* Currently we disable it if:
869
* - ASUS_WMI_UNSUPPORTED_METHOD is returned
870
* - reverved bits are non-zero
871
* - sfun and presence bit are not set
873
if (value != ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
874
|| (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
878
return ok ? attr->mode : 0;
881
static struct attribute_group hwmon_attribute_group = {
882
.is_visible = asus_hwmon_sysfs_is_visible,
883
.attrs = hwmon_attributes
886
static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
888
struct device *hwmon;
890
hwmon = asus->hwmon_device;
893
sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
894
hwmon_device_unregister(hwmon);
895
asus->hwmon_device = NULL;
898
static int asus_wmi_hwmon_init(struct asus_wmi *asus)
900
struct device *hwmon;
903
hwmon = hwmon_device_register(&asus->platform_device->dev);
905
pr_err("Could not register asus hwmon device\n");
906
return PTR_ERR(hwmon);
908
asus->hwmon_device = hwmon;
909
result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
911
asus_wmi_hwmon_exit(asus);
918
static int read_backlight_power(struct asus_wmi *asus)
920
int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
925
return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
928
static int read_brightness_max(struct asus_wmi *asus)
933
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
938
retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
947
static int read_brightness(struct backlight_device *bd)
949
struct asus_wmi *asus = bl_get_data(bd);
953
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
958
return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
961
static int update_bl_status(struct backlight_device *bd)
963
struct asus_wmi *asus = bl_get_data(bd);
967
ctrl_param = bd->props.brightness;
969
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
975
power = read_backlight_power(asus);
976
if (power != -ENODEV && bd->props.power != power) {
977
ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
978
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
984
static const struct backlight_ops asus_wmi_bl_ops = {
985
.get_brightness = read_brightness,
986
.update_status = update_bl_status,
989
static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
991
struct backlight_device *bd = asus->backlight_device;
992
int old = bd->props.brightness;
995
if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
996
new = code - NOTIFY_BRNUP_MIN + 1;
997
else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
998
new = code - NOTIFY_BRNDOWN_MIN;
1000
bd->props.brightness = new;
1001
backlight_update_status(bd);
1002
backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1007
static int asus_wmi_backlight_init(struct asus_wmi *asus)
1009
struct backlight_device *bd;
1010
struct backlight_properties props;
1014
max = read_brightness_max(asus);
1021
power = read_backlight_power(asus);
1023
if (power == -ENODEV)
1024
power = FB_BLANK_UNBLANK;
1028
memset(&props, 0, sizeof(struct backlight_properties));
1029
props.type = BACKLIGHT_PLATFORM;
1030
props.max_brightness = max;
1031
bd = backlight_device_register(asus->driver->name,
1032
&asus->platform_device->dev, asus,
1033
&asus_wmi_bl_ops, &props);
1035
pr_err("Could not register backlight device\n");
1039
asus->backlight_device = bd;
1041
bd->props.brightness = read_brightness(bd);
1042
bd->props.power = power;
1043
backlight_update_status(bd);
1048
static void asus_wmi_backlight_exit(struct asus_wmi *asus)
1050
if (asus->backlight_device)
1051
backlight_device_unregister(asus->backlight_device);
1053
asus->backlight_device = NULL;
1056
static void asus_wmi_notify(u32 value, void *context)
1058
struct asus_wmi *asus = context;
1059
struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1060
union acpi_object *obj;
1064
unsigned int key_value = 1;
1065
bool autorelease = 1;
1067
status = wmi_get_event_data(value, &response);
1068
if (status != AE_OK) {
1069
pr_err("bad event status 0x%x\n", status);
1073
obj = (union acpi_object *)response.pointer;
1075
if (!obj || obj->type != ACPI_TYPE_INTEGER)
1078
code = obj->integer.value;
1081
if (asus->driver->key_filter) {
1082
asus->driver->key_filter(asus->driver, &code, &key_value,
1084
if (code == ASUS_WMI_KEY_IGNORE)
1088
if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1089
code = NOTIFY_BRNUP_MIN;
1090
else if (code >= NOTIFY_BRNDOWN_MIN &&
1091
code <= NOTIFY_BRNDOWN_MAX)
1092
code = NOTIFY_BRNDOWN_MIN;
1094
if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
1095
if (!acpi_video_backlight_support())
1096
asus_wmi_backlight_notify(asus, orig_code);
1097
} else if (!sparse_keymap_report_event(asus->inputdev, code,
1098
key_value, autorelease))
1099
pr_info("Unknown key %x pressed\n", code);
1108
static int parse_arg(const char *buf, unsigned long count, int *val)
1112
if (sscanf(buf, "%i", val) != 1)
1117
static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1118
const char *buf, size_t count)
1123
value = asus_wmi_get_devstate_simple(asus, devid);
1124
if (value == -ENODEV) /* Check device presence */
1127
rv = parse_arg(buf, count, &value);
1128
err = asus_wmi_set_devstate(devid, value, &retval);
1136
static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
1138
int value = asus_wmi_get_devstate_simple(asus, devid);
1143
return sprintf(buf, "%d\n", value);
1146
#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
1147
static ssize_t show_##_name(struct device *dev, \
1148
struct device_attribute *attr, \
1151
struct asus_wmi *asus = dev_get_drvdata(dev); \
1153
return show_sys_wmi(asus, _cm, buf); \
1155
static ssize_t store_##_name(struct device *dev, \
1156
struct device_attribute *attr, \
1157
const char *buf, size_t count) \
1159
struct asus_wmi *asus = dev_get_drvdata(dev); \
1161
return store_sys_wmi(asus, _cm, buf, count); \
1163
static struct device_attribute dev_attr_##_name = { \
1165
.name = __stringify(_name), \
1167
.show = show_##_name, \
1168
.store = store_##_name, \
1171
ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1172
ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1173
ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
1175
static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1176
const char *buf, size_t count)
1180
if (!count || sscanf(buf, "%i", &value) != 1)
1182
if (value < 0 || value > 2)
1185
return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1188
static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1190
static struct attribute *platform_attributes[] = {
1191
&dev_attr_cpufv.attr,
1192
&dev_attr_camera.attr,
1193
&dev_attr_cardr.attr,
1194
&dev_attr_touchpad.attr,
1198
static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1199
struct attribute *attr, int idx)
1201
struct device *dev = container_of(kobj, struct device, kobj);
1202
struct platform_device *pdev = to_platform_device(dev);
1203
struct asus_wmi *asus = platform_get_drvdata(pdev);
1207
if (attr == &dev_attr_camera.attr)
1208
devid = ASUS_WMI_DEVID_CAMERA;
1209
else if (attr == &dev_attr_cardr.attr)
1210
devid = ASUS_WMI_DEVID_CARDREADER;
1211
else if (attr == &dev_attr_touchpad.attr)
1212
devid = ASUS_WMI_DEVID_TOUCHPAD;
1215
ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
1217
return ok ? attr->mode : 0;
1220
static struct attribute_group platform_attribute_group = {
1221
.is_visible = asus_sysfs_is_visible,
1222
.attrs = platform_attributes
1225
static void asus_wmi_sysfs_exit(struct platform_device *device)
1227
sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1230
static int asus_wmi_sysfs_init(struct platform_device *device)
1232
return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1238
static int asus_wmi_platform_init(struct asus_wmi *asus)
1242
/* INIT enable hotkeys on some models */
1243
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
1244
pr_info("Initialization: %#x", rv);
1246
/* We don't know yet what to do with this version... */
1247
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
1248
pr_info("BIOS WMI version: %d.%d", rv >> 8, rv & 0xFF);
1253
* The SFUN method probably allows the original driver to get the list
1254
* of features supported by a given model. For now, 0x0100 or 0x0800
1255
* bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1256
* The significance of others is yet to be found.
1258
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
1259
pr_info("SFUN value: %#x", rv);
1264
* Eee PC and Notebooks seems to have different method_id for DSTS,
1265
* but it may also be related to the BIOS's SPEC.
1266
* Note, on most Eeepc, there is no way to check if a method exist
1267
* or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1268
* but once again, SPEC may probably be used for that kind of things.
1270
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1271
asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1272
else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
1273
asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1275
if (!asus->dsts_id) {
1276
pr_err("Can't find DSTS");
1280
return asus_wmi_sysfs_init(asus->platform_device);
1283
static void asus_wmi_platform_exit(struct asus_wmi *asus)
1285
asus_wmi_sysfs_exit(asus->platform_device);
1291
struct asus_wmi_debugfs_node {
1292
struct asus_wmi *asus;
1294
int (*show) (struct seq_file *m, void *data);
1297
static int show_dsts(struct seq_file *m, void *data)
1299
struct asus_wmi *asus = m->private;
1303
err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
1308
seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
1313
static int show_devs(struct seq_file *m, void *data)
1315
struct asus_wmi *asus = m->private;
1319
err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1325
seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
1326
asus->debug.ctrl_param, retval);
1331
static int show_call(struct seq_file *m, void *data)
1333
struct asus_wmi *asus = m->private;
1334
struct bios_args args = {
1335
.arg0 = asus->debug.dev_id,
1336
.arg1 = asus->debug.ctrl_param,
1338
struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1339
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1340
union acpi_object *obj;
1343
status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1344
1, asus->debug.method_id,
1347
if (ACPI_FAILURE(status))
1350
obj = (union acpi_object *)output.pointer;
1351
if (obj && obj->type == ACPI_TYPE_INTEGER)
1352
seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1353
asus->debug.dev_id, asus->debug.ctrl_param,
1354
(u32) obj->integer.value);
1356
seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1357
asus->debug.dev_id, asus->debug.ctrl_param,
1358
obj ? obj->type : -1);
1365
static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1366
{NULL, "devs", show_devs},
1367
{NULL, "dsts", show_dsts},
1368
{NULL, "call", show_call},
1371
static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1373
struct asus_wmi_debugfs_node *node = inode->i_private;
1375
return single_open(file, node->show, node->asus);
1378
static const struct file_operations asus_wmi_debugfs_io_ops = {
1379
.owner = THIS_MODULE,
1380
.open = asus_wmi_debugfs_open,
1382
.llseek = seq_lseek,
1383
.release = single_release,
1386
static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1388
debugfs_remove_recursive(asus->debug.root);
1391
static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1393
struct dentry *dent;
1396
asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1397
if (!asus->debug.root) {
1398
pr_err("failed to create debugfs directory");
1402
dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
1403
asus->debug.root, &asus->debug.method_id);
1407
dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1408
asus->debug.root, &asus->debug.dev_id);
1412
dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1413
asus->debug.root, &asus->debug.ctrl_param);
1417
for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1418
struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
1421
dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
1422
asus->debug.root, node,
1423
&asus_wmi_debugfs_io_ops);
1425
pr_err("failed to create debug file: %s\n", node->name);
1433
asus_wmi_debugfs_exit(asus);
1440
static int asus_wmi_add(struct platform_device *pdev)
1442
struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1443
struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1444
struct asus_wmi *asus;
1448
asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
1452
asus->driver = wdrv;
1453
asus->platform_device = pdev;
1454
wdrv->platform_device = pdev;
1455
platform_set_drvdata(asus->platform_device, asus);
1458
wdrv->quirks(asus->driver);
1460
err = asus_wmi_platform_init(asus);
1464
err = asus_wmi_input_init(asus);
1468
err = asus_wmi_hwmon_init(asus);
1472
err = asus_wmi_led_init(asus);
1476
err = asus_wmi_rfkill_init(asus);
1480
if (!acpi_video_backlight_support()) {
1481
err = asus_wmi_backlight_init(asus);
1482
if (err && err != -ENODEV)
1483
goto fail_backlight;
1485
pr_info("Backlight controlled by ACPI video driver\n");
1487
status = wmi_install_notify_handler(asus->driver->event_guid,
1488
asus_wmi_notify, asus);
1489
if (ACPI_FAILURE(status)) {
1490
pr_err("Unable to register notify handler - %d\n", status);
1492
goto fail_wmi_handler;
1495
err = asus_wmi_debugfs_init(asus);
1502
wmi_remove_notify_handler(asus->driver->event_guid);
1504
asus_wmi_backlight_exit(asus);
1506
asus_wmi_rfkill_exit(asus);
1508
asus_wmi_led_exit(asus);
1510
asus_wmi_hwmon_exit(asus);
1512
asus_wmi_input_exit(asus);
1514
asus_wmi_platform_exit(asus);
1520
static int asus_wmi_remove(struct platform_device *device)
1522
struct asus_wmi *asus;
1524
asus = platform_get_drvdata(device);
1525
wmi_remove_notify_handler(asus->driver->event_guid);
1526
asus_wmi_backlight_exit(asus);
1527
asus_wmi_input_exit(asus);
1528
asus_wmi_hwmon_exit(asus);
1529
asus_wmi_led_exit(asus);
1530
asus_wmi_rfkill_exit(asus);
1531
asus_wmi_debugfs_exit(asus);
1532
asus_wmi_platform_exit(asus);
1539
* Platform driver - hibernate/resume callbacks
1541
static int asus_hotk_thaw(struct device *device)
1543
struct asus_wmi *asus = dev_get_drvdata(device);
1545
if (asus->wlan.rfkill) {
1549
* Work around bios bug - acpi _PTS turns off the wireless led
1550
* during suspend. Normally it restores it on resume, but
1551
* we should kick it ourselves in case hibernation is aborted.
1553
wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1554
asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
1560
static int asus_hotk_restore(struct device *device)
1562
struct asus_wmi *asus = dev_get_drvdata(device);
1565
/* Refresh both wlan rfkill state and pci hotplug */
1566
if (asus->wlan.rfkill)
1567
asus_rfkill_hotplug(asus);
1569
if (asus->bluetooth.rfkill) {
1570
bl = !asus_wmi_get_devstate_simple(asus,
1571
ASUS_WMI_DEVID_BLUETOOTH);
1572
rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
1574
if (asus->wimax.rfkill) {
1575
bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
1576
rfkill_set_sw_state(asus->wimax.rfkill, bl);
1578
if (asus->wwan3g.rfkill) {
1579
bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
1580
rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
1586
static const struct dev_pm_ops asus_pm_ops = {
1587
.thaw = asus_hotk_thaw,
1588
.restore = asus_hotk_restore,
1591
static int asus_wmi_probe(struct platform_device *pdev)
1593
struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1594
struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1597
if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1598
pr_warn("Management GUID not found\n");
1602
if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
1603
pr_warn("Event GUID not found\n");
1608
ret = wdrv->probe(pdev);
1613
return asus_wmi_add(pdev);
1618
int asus_wmi_register_driver(struct asus_wmi_driver *driver)
1620
struct platform_driver *platform_driver;
1621
struct platform_device *platform_device;
1626
platform_driver = &driver->platform_driver;
1627
platform_driver->remove = asus_wmi_remove;
1628
platform_driver->driver.owner = driver->owner;
1629
platform_driver->driver.name = driver->name;
1630
platform_driver->driver.pm = &asus_pm_ops;
1632
platform_device = platform_create_bundle(platform_driver,
1635
if (IS_ERR(platform_device))
1636
return PTR_ERR(platform_device);
1641
EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
1643
void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
1645
platform_device_unregister(driver->platform_device);
1646
platform_driver_unregister(&driver->platform_driver);
1649
EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
1651
static int __init asus_wmi_init(void)
1653
if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1654
pr_info("Asus Management GUID not found");
1658
pr_info("ASUS WMI generic driver loaded");
1662
static void __exit asus_wmi_exit(void)
1664
pr_info("ASUS WMI generic driver unloaded");
1667
module_init(asus_wmi_init);
1668
module_exit(asus_wmi_exit);
added
removed
drivers/platform/x86/asus-wmi.c
