1 /*
2 * Asus Wireless Radio Control Driver
3 *
4 * Copyright (C) 2015-2016 Endless Mobile, Inc.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/types.h>
15 #include <linux/acpi.h>
16 #include <linux/input.h>
17 #include <linux/pci_ids.h>
18 #include <linux/leds.h>
19
20 struct hswc_params {
21 u8 on;
22 u8 off;
23 u8 status;
24 };
25
26 struct asus_wireless_data {
27 struct input_dev *idev;
28 struct acpi_device *adev;
29 const struct hswc_params *hswc_params;
30 struct workqueue_struct *wq;
31 struct work_struct led_work;
32 struct led_classdev led;
33 int led_state;
34 };
35
36 static const struct hswc_params atk4001_id_params = {
37 .on = 0x0,
38 .off = 0x1,
39 .status = 0x2,
40 };
41
42 static const struct hswc_params atk4002_id_params = {
43 .on = 0x5,
44 .off = 0x4,
45 .status = 0x2,
46 };
47
48 static const struct acpi_device_id device_ids[] = {
49 {"ATK4001", (kernel_ulong_t)&atk4001_id_params},
50 {"ATK4002", (kernel_ulong_t)&atk4002_id_params},
51 {"", 0},
52 };
53 MODULE_DEVICE_TABLE(acpi, device_ids);
54
asus_wireless_method(acpi_handle handle,const char * method,int param,u64 * ret)55 static acpi_status asus_wireless_method(acpi_handle handle, const char *method,
56 int param, u64 *ret)
57 {
58 struct acpi_object_list p;
59 union acpi_object obj;
60 acpi_status s;
61
62 acpi_handle_debug(handle, "Evaluating method %s, parameter %#x\n",
63 method, param);
64 obj.type = ACPI_TYPE_INTEGER;
65 obj.integer.value = param;
66 p.count = 1;
67 p.pointer = &obj;
68
69 s = acpi_evaluate_integer(handle, (acpi_string) method, &p, ret);
70 if (ACPI_FAILURE(s))
71 acpi_handle_err(handle,
72 "Failed to eval method %s, param %#x (%d)\n",
73 method, param, s);
74 else
75 acpi_handle_debug(handle, "%s returned %#llx\n", method, *ret);
76
77 return s;
78 }
79
led_state_get(struct led_classdev * led)80 static enum led_brightness led_state_get(struct led_classdev *led)
81 {
82 struct asus_wireless_data *data;
83 acpi_status s;
84 u64 ret;
85
86 data = container_of(led, struct asus_wireless_data, led);
87 s = asus_wireless_method(acpi_device_handle(data->adev), "HSWC",
88 data->hswc_params->status, &ret);
89 if (ACPI_SUCCESS(s) && ret == data->hswc_params->on)
90 return LED_FULL;
91 return LED_OFF;
92 }
93
led_state_update(struct work_struct * work)94 static void led_state_update(struct work_struct *work)
95 {
96 struct asus_wireless_data *data;
97 u64 ret;
98
99 data = container_of(work, struct asus_wireless_data, led_work);
100 asus_wireless_method(acpi_device_handle(data->adev), "HSWC",
101 data->led_state, &ret);
102 }
103
led_state_set(struct led_classdev * led,enum led_brightness value)104 static void led_state_set(struct led_classdev *led, enum led_brightness value)
105 {
106 struct asus_wireless_data *data;
107
108 data = container_of(led, struct asus_wireless_data, led);
109 data->led_state = value == LED_OFF ? data->hswc_params->off :
110 data->hswc_params->on;
111 queue_work(data->wq, &data->led_work);
112 }
113
asus_wireless_notify(struct acpi_device * adev,u32 event)114 static void asus_wireless_notify(struct acpi_device *adev, u32 event)
115 {
116 struct asus_wireless_data *data = acpi_driver_data(adev);
117
118 dev_dbg(&adev->dev, "event=%#x\n", event);
119 if (event != 0x88) {
120 dev_notice(&adev->dev, "Unknown ASHS event: %#x\n", event);
121 return;
122 }
123 input_report_key(data->idev, KEY_RFKILL, 1);
124 input_sync(data->idev);
125 input_report_key(data->idev, KEY_RFKILL, 0);
126 input_sync(data->idev);
127 }
128
asus_wireless_add(struct acpi_device * adev)129 static int asus_wireless_add(struct acpi_device *adev)
130 {
131 struct asus_wireless_data *data;
132 const struct acpi_device_id *id;
133 int err;
134
135 data = devm_kzalloc(&adev->dev, sizeof(*data), GFP_KERNEL);
136 if (!data)
137 return -ENOMEM;
138 adev->driver_data = data;
139 data->adev = adev;
140
141 data->idev = devm_input_allocate_device(&adev->dev);
142 if (!data->idev)
143 return -ENOMEM;
144 data->idev->name = "Asus Wireless Radio Control";
145 data->idev->phys = "asus-wireless/input0";
146 data->idev->id.bustype = BUS_HOST;
147 data->idev->id.vendor = PCI_VENDOR_ID_ASUSTEK;
148 set_bit(EV_KEY, data->idev->evbit);
149 set_bit(KEY_RFKILL, data->idev->keybit);
150 err = input_register_device(data->idev);
151 if (err)
152 return err;
153
154 for (id = device_ids; id->id[0]; id++) {
155 if (!strcmp((char *) id->id, acpi_device_hid(adev))) {
156 data->hswc_params =
157 (const struct hswc_params *)id->driver_data;
158 break;
159 }
160 }
161 if (!data->hswc_params)
162 return 0;
163
164 data->wq = create_singlethread_workqueue("asus_wireless_workqueue");
165 if (!data->wq)
166 return -ENOMEM;
167 INIT_WORK(&data->led_work, led_state_update);
168 data->led.name = "asus-wireless::airplane";
169 data->led.brightness_set = led_state_set;
170 data->led.brightness_get = led_state_get;
171 data->led.flags = LED_CORE_SUSPENDRESUME;
172 data->led.max_brightness = 1;
173 data->led.default_trigger = "rfkill-none";
174 err = devm_led_classdev_register(&adev->dev, &data->led);
175 if (err)
176 destroy_workqueue(data->wq);
177
178 return err;
179 }
180
asus_wireless_remove(struct acpi_device * adev)181 static int asus_wireless_remove(struct acpi_device *adev)
182 {
183 struct asus_wireless_data *data = acpi_driver_data(adev);
184
185 if (data->wq) {
186 devm_led_classdev_unregister(&adev->dev, &data->led);
187 destroy_workqueue(data->wq);
188 }
189 return 0;
190 }
191
192 static struct acpi_driver asus_wireless_driver = {
193 .name = "Asus Wireless Radio Control Driver",
194 .class = "hotkey",
195 .ids = device_ids,
196 .ops = {
197 .add = asus_wireless_add,
198 .remove = asus_wireless_remove,
199 .notify = asus_wireless_notify,
200 },
201 };
202 module_acpi_driver(asus_wireless_driver);
203
204 MODULE_DESCRIPTION("Asus Wireless Radio Control Driver");
205 MODULE_AUTHOR("João Paulo Rechi Vita <jprvita@gmail.com>");
206 MODULE_LICENSE("GPL");
207
