1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | Dell Airplane Mode Switch driver |
4 | Copyright (C) 2014-2015 Pali Rohár <pali@kernel.org> |
5 | |
6 | */ |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/acpi.h> |
10 | #include <linux/rfkill.h> |
11 | #include <linux/input.h> |
12 | |
13 | #include "dell-rbtn.h" |
14 | |
15 | enum rbtn_type { |
16 | RBTN_UNKNOWN, |
17 | RBTN_TOGGLE, |
18 | RBTN_SLIDER, |
19 | }; |
20 | |
21 | struct rbtn_data { |
22 | enum rbtn_type type; |
23 | struct rfkill *rfkill; |
24 | struct input_dev *input_dev; |
25 | bool suspended; |
26 | }; |
27 | |
28 | |
29 | /* |
30 | * acpi functions |
31 | */ |
32 | |
33 | static enum rbtn_type rbtn_check(struct acpi_device *device) |
34 | { |
35 | unsigned long long output; |
36 | acpi_status status; |
37 | |
38 | status = acpi_evaluate_integer(handle: device->handle, pathname: "CRBT" , NULL, data: &output); |
39 | if (ACPI_FAILURE(status)) |
40 | return RBTN_UNKNOWN; |
41 | |
42 | switch (output) { |
43 | case 0: |
44 | case 1: |
45 | return RBTN_TOGGLE; |
46 | case 2: |
47 | case 3: |
48 | return RBTN_SLIDER; |
49 | default: |
50 | return RBTN_UNKNOWN; |
51 | } |
52 | } |
53 | |
54 | static int rbtn_get(struct acpi_device *device) |
55 | { |
56 | unsigned long long output; |
57 | acpi_status status; |
58 | |
59 | status = acpi_evaluate_integer(handle: device->handle, pathname: "GRBT" , NULL, data: &output); |
60 | if (ACPI_FAILURE(status)) |
61 | return -EINVAL; |
62 | |
63 | return !output; |
64 | } |
65 | |
66 | static int rbtn_acquire(struct acpi_device *device, bool enable) |
67 | { |
68 | struct acpi_object_list input; |
69 | union acpi_object param; |
70 | acpi_status status; |
71 | |
72 | param.type = ACPI_TYPE_INTEGER; |
73 | param.integer.value = enable; |
74 | input.count = 1; |
75 | input.pointer = ¶m; |
76 | |
77 | status = acpi_evaluate_object(object: device->handle, pathname: "ARBT" , parameter_objects: &input, NULL); |
78 | if (ACPI_FAILURE(status)) |
79 | return -EINVAL; |
80 | |
81 | return 0; |
82 | } |
83 | |
84 | |
85 | /* |
86 | * rfkill device |
87 | */ |
88 | |
89 | static void rbtn_rfkill_query(struct rfkill *rfkill, void *data) |
90 | { |
91 | struct acpi_device *device = data; |
92 | int state; |
93 | |
94 | state = rbtn_get(device); |
95 | if (state < 0) |
96 | return; |
97 | |
98 | rfkill_set_states(rfkill, sw: state, hw: state); |
99 | } |
100 | |
101 | static int rbtn_rfkill_set_block(void *data, bool blocked) |
102 | { |
103 | /* NOTE: setting soft rfkill state is not supported */ |
104 | return -EINVAL; |
105 | } |
106 | |
107 | static const struct rfkill_ops rbtn_ops = { |
108 | .query = rbtn_rfkill_query, |
109 | .set_block = rbtn_rfkill_set_block, |
110 | }; |
111 | |
112 | static int rbtn_rfkill_init(struct acpi_device *device) |
113 | { |
114 | struct rbtn_data *rbtn_data = device->driver_data; |
115 | int ret; |
116 | |
117 | if (rbtn_data->rfkill) |
118 | return 0; |
119 | |
120 | /* |
121 | * NOTE: rbtn controls all radio devices, not only WLAN |
122 | * but rfkill interface does not support "ANY" type |
123 | * so "WLAN" type is used |
124 | */ |
125 | rbtn_data->rfkill = rfkill_alloc(name: "dell-rbtn" , parent: &device->dev, |
126 | type: RFKILL_TYPE_WLAN, ops: &rbtn_ops, ops_data: device); |
127 | if (!rbtn_data->rfkill) |
128 | return -ENOMEM; |
129 | |
130 | ret = rfkill_register(rfkill: rbtn_data->rfkill); |
131 | if (ret) { |
132 | rfkill_destroy(rfkill: rbtn_data->rfkill); |
133 | rbtn_data->rfkill = NULL; |
134 | return ret; |
135 | } |
136 | |
137 | return 0; |
138 | } |
139 | |
140 | static void rbtn_rfkill_exit(struct acpi_device *device) |
141 | { |
142 | struct rbtn_data *rbtn_data = device->driver_data; |
143 | |
144 | if (!rbtn_data->rfkill) |
145 | return; |
146 | |
147 | rfkill_unregister(rfkill: rbtn_data->rfkill); |
148 | rfkill_destroy(rfkill: rbtn_data->rfkill); |
149 | rbtn_data->rfkill = NULL; |
150 | } |
151 | |
152 | static void rbtn_rfkill_event(struct acpi_device *device) |
153 | { |
154 | struct rbtn_data *rbtn_data = device->driver_data; |
155 | |
156 | if (rbtn_data->rfkill) |
157 | rbtn_rfkill_query(rfkill: rbtn_data->rfkill, data: device); |
158 | } |
159 | |
160 | |
161 | /* |
162 | * input device |
163 | */ |
164 | |
165 | static int rbtn_input_init(struct rbtn_data *rbtn_data) |
166 | { |
167 | int ret; |
168 | |
169 | rbtn_data->input_dev = input_allocate_device(); |
170 | if (!rbtn_data->input_dev) |
171 | return -ENOMEM; |
172 | |
173 | rbtn_data->input_dev->name = "DELL Wireless hotkeys" ; |
174 | rbtn_data->input_dev->phys = "dellabce/input0" ; |
175 | rbtn_data->input_dev->id.bustype = BUS_HOST; |
176 | rbtn_data->input_dev->evbit[0] = BIT(EV_KEY); |
177 | set_bit(KEY_RFKILL, addr: rbtn_data->input_dev->keybit); |
178 | |
179 | ret = input_register_device(rbtn_data->input_dev); |
180 | if (ret) { |
181 | input_free_device(dev: rbtn_data->input_dev); |
182 | rbtn_data->input_dev = NULL; |
183 | return ret; |
184 | } |
185 | |
186 | return 0; |
187 | } |
188 | |
189 | static void rbtn_input_exit(struct rbtn_data *rbtn_data) |
190 | { |
191 | input_unregister_device(rbtn_data->input_dev); |
192 | rbtn_data->input_dev = NULL; |
193 | } |
194 | |
195 | static void rbtn_input_event(struct rbtn_data *rbtn_data) |
196 | { |
197 | input_report_key(dev: rbtn_data->input_dev, KEY_RFKILL, value: 1); |
198 | input_sync(dev: rbtn_data->input_dev); |
199 | input_report_key(dev: rbtn_data->input_dev, KEY_RFKILL, value: 0); |
200 | input_sync(dev: rbtn_data->input_dev); |
201 | } |
202 | |
203 | |
204 | /* |
205 | * acpi driver |
206 | */ |
207 | |
208 | static int rbtn_add(struct acpi_device *device); |
209 | static void rbtn_remove(struct acpi_device *device); |
210 | static void rbtn_notify(struct acpi_device *device, u32 event); |
211 | |
212 | static const struct acpi_device_id rbtn_ids[] = { |
213 | { "DELRBTN" , 0 }, |
214 | { "DELLABCE" , 0 }, |
215 | |
216 | /* |
217 | * This driver can also handle the "DELLABC6" device that |
218 | * appears on the XPS 13 9350, but that device is disabled by |
219 | * the DSDT unless booted with acpi_osi="!Windows 2012" |
220 | * acpi_osi="!Windows 2013". |
221 | * |
222 | * According to Mario at Dell: |
223 | * |
224 | * DELLABC6 is a custom interface that was created solely to |
225 | * have airplane mode support for Windows 7. For Windows 10 |
226 | * the proper interface is to use that which is handled by |
227 | * intel-hid. A OEM airplane mode driver is not used. |
228 | * |
229 | * Since the kernel doesn't identify as Windows 7 it would be |
230 | * incorrect to do attempt to use that interface. |
231 | * |
232 | * Even if we override _OSI and bind to DELLABC6, we end up with |
233 | * inconsistent behavior in which userspace can get out of sync |
234 | * with the rfkill state as it conflicts with events from |
235 | * intel-hid. |
236 | * |
237 | * The upshot is that it is better to just ignore DELLABC6 |
238 | * devices. |
239 | */ |
240 | |
241 | { "" , 0 }, |
242 | }; |
243 | |
244 | #ifdef CONFIG_PM_SLEEP |
245 | static void ACPI_SYSTEM_XFACE rbtn_clear_suspended_flag(void *context) |
246 | { |
247 | struct rbtn_data *rbtn_data = context; |
248 | |
249 | rbtn_data->suspended = false; |
250 | } |
251 | |
252 | static int rbtn_suspend(struct device *dev) |
253 | { |
254 | struct acpi_device *device = to_acpi_device(dev); |
255 | struct rbtn_data *rbtn_data = acpi_driver_data(d: device); |
256 | |
257 | rbtn_data->suspended = true; |
258 | |
259 | return 0; |
260 | } |
261 | |
262 | static int rbtn_resume(struct device *dev) |
263 | { |
264 | struct acpi_device *device = to_acpi_device(dev); |
265 | struct rbtn_data *rbtn_data = acpi_driver_data(d: device); |
266 | acpi_status status; |
267 | |
268 | /* |
269 | * Upon resume, some BIOSes send an ACPI notification thet triggers |
270 | * an unwanted input event. In order to ignore it, we use a flag |
271 | * that we set at suspend and clear once we have received the extra |
272 | * ACPI notification. Since ACPI notifications are delivered |
273 | * asynchronously to drivers, we clear the flag from the workqueue |
274 | * used to deliver the notifications. This should be enough |
275 | * to have the flag cleared only after we received the extra |
276 | * notification, if any. |
277 | */ |
278 | status = acpi_os_execute(type: OSL_NOTIFY_HANDLER, |
279 | function: rbtn_clear_suspended_flag, context: rbtn_data); |
280 | if (ACPI_FAILURE(status)) |
281 | rbtn_clear_suspended_flag(context: rbtn_data); |
282 | |
283 | return 0; |
284 | } |
285 | #endif |
286 | |
287 | static SIMPLE_DEV_PM_OPS(rbtn_pm_ops, rbtn_suspend, rbtn_resume); |
288 | |
289 | static struct acpi_driver rbtn_driver = { |
290 | .name = "dell-rbtn" , |
291 | .ids = rbtn_ids, |
292 | .drv.pm = &rbtn_pm_ops, |
293 | .ops = { |
294 | .add = rbtn_add, |
295 | .remove = rbtn_remove, |
296 | .notify = rbtn_notify, |
297 | }, |
298 | .owner = THIS_MODULE, |
299 | }; |
300 | |
301 | |
302 | /* |
303 | * notifier export functions |
304 | */ |
305 | |
306 | static bool auto_remove_rfkill = true; |
307 | |
308 | static ATOMIC_NOTIFIER_HEAD(rbtn_chain_head); |
309 | |
310 | static int rbtn_inc_count(struct device *dev, void *data) |
311 | { |
312 | struct acpi_device *device = to_acpi_device(dev); |
313 | struct rbtn_data *rbtn_data = device->driver_data; |
314 | int *count = data; |
315 | |
316 | if (rbtn_data->type == RBTN_SLIDER) |
317 | (*count)++; |
318 | |
319 | return 0; |
320 | } |
321 | |
322 | static int rbtn_switch_dev(struct device *dev, void *data) |
323 | { |
324 | struct acpi_device *device = to_acpi_device(dev); |
325 | struct rbtn_data *rbtn_data = device->driver_data; |
326 | bool enable = data; |
327 | |
328 | if (rbtn_data->type != RBTN_SLIDER) |
329 | return 0; |
330 | |
331 | if (enable) |
332 | rbtn_rfkill_init(device); |
333 | else |
334 | rbtn_rfkill_exit(device); |
335 | |
336 | return 0; |
337 | } |
338 | |
339 | int dell_rbtn_notifier_register(struct notifier_block *nb) |
340 | { |
341 | bool first; |
342 | int count; |
343 | int ret; |
344 | |
345 | count = 0; |
346 | ret = driver_for_each_device(drv: &rbtn_driver.drv, NULL, data: &count, |
347 | fn: rbtn_inc_count); |
348 | if (ret || count == 0) |
349 | return -ENODEV; |
350 | |
351 | first = !rbtn_chain_head.head; |
352 | |
353 | ret = atomic_notifier_chain_register(nh: &rbtn_chain_head, nb); |
354 | if (ret != 0) |
355 | return ret; |
356 | |
357 | if (auto_remove_rfkill && first) |
358 | ret = driver_for_each_device(drv: &rbtn_driver.drv, NULL, |
359 | data: (void *)false, fn: rbtn_switch_dev); |
360 | |
361 | return ret; |
362 | } |
363 | EXPORT_SYMBOL_GPL(dell_rbtn_notifier_register); |
364 | |
365 | int dell_rbtn_notifier_unregister(struct notifier_block *nb) |
366 | { |
367 | int ret; |
368 | |
369 | ret = atomic_notifier_chain_unregister(nh: &rbtn_chain_head, nb); |
370 | if (ret != 0) |
371 | return ret; |
372 | |
373 | if (auto_remove_rfkill && !rbtn_chain_head.head) |
374 | ret = driver_for_each_device(drv: &rbtn_driver.drv, NULL, |
375 | data: (void *)true, fn: rbtn_switch_dev); |
376 | |
377 | return ret; |
378 | } |
379 | EXPORT_SYMBOL_GPL(dell_rbtn_notifier_unregister); |
380 | |
381 | |
382 | /* |
383 | * acpi driver functions |
384 | */ |
385 | |
386 | static int rbtn_add(struct acpi_device *device) |
387 | { |
388 | struct rbtn_data *rbtn_data; |
389 | enum rbtn_type type; |
390 | int ret = 0; |
391 | |
392 | type = rbtn_check(device); |
393 | if (type == RBTN_UNKNOWN) { |
394 | dev_info(&device->dev, "Unknown device type\n" ); |
395 | return -EINVAL; |
396 | } |
397 | |
398 | rbtn_data = devm_kzalloc(dev: &device->dev, size: sizeof(*rbtn_data), GFP_KERNEL); |
399 | if (!rbtn_data) |
400 | return -ENOMEM; |
401 | |
402 | ret = rbtn_acquire(device, enable: true); |
403 | if (ret < 0) { |
404 | dev_err(&device->dev, "Cannot enable device\n" ); |
405 | return ret; |
406 | } |
407 | |
408 | rbtn_data->type = type; |
409 | device->driver_data = rbtn_data; |
410 | |
411 | switch (rbtn_data->type) { |
412 | case RBTN_TOGGLE: |
413 | ret = rbtn_input_init(rbtn_data); |
414 | break; |
415 | case RBTN_SLIDER: |
416 | if (auto_remove_rfkill && rbtn_chain_head.head) |
417 | ret = 0; |
418 | else |
419 | ret = rbtn_rfkill_init(device); |
420 | break; |
421 | default: |
422 | ret = -EINVAL; |
423 | break; |
424 | } |
425 | if (ret) |
426 | rbtn_acquire(device, enable: false); |
427 | |
428 | return ret; |
429 | } |
430 | |
431 | static void rbtn_remove(struct acpi_device *device) |
432 | { |
433 | struct rbtn_data *rbtn_data = device->driver_data; |
434 | |
435 | switch (rbtn_data->type) { |
436 | case RBTN_TOGGLE: |
437 | rbtn_input_exit(rbtn_data); |
438 | break; |
439 | case RBTN_SLIDER: |
440 | rbtn_rfkill_exit(device); |
441 | break; |
442 | default: |
443 | break; |
444 | } |
445 | |
446 | rbtn_acquire(device, enable: false); |
447 | } |
448 | |
449 | static void rbtn_notify(struct acpi_device *device, u32 event) |
450 | { |
451 | struct rbtn_data *rbtn_data = device->driver_data; |
452 | |
453 | /* |
454 | * Some BIOSes send a notification at resume. |
455 | * Ignore it to prevent unwanted input events. |
456 | */ |
457 | if (rbtn_data->suspended) { |
458 | dev_dbg(&device->dev, "ACPI notification ignored\n" ); |
459 | return; |
460 | } |
461 | |
462 | if (event != 0x80) { |
463 | dev_info(&device->dev, "Received unknown event (0x%x)\n" , |
464 | event); |
465 | return; |
466 | } |
467 | |
468 | switch (rbtn_data->type) { |
469 | case RBTN_TOGGLE: |
470 | rbtn_input_event(rbtn_data); |
471 | break; |
472 | case RBTN_SLIDER: |
473 | rbtn_rfkill_event(device); |
474 | atomic_notifier_call_chain(nh: &rbtn_chain_head, val: event, v: device); |
475 | break; |
476 | default: |
477 | break; |
478 | } |
479 | } |
480 | |
481 | |
482 | /* |
483 | * module functions |
484 | */ |
485 | |
486 | module_acpi_driver(rbtn_driver); |
487 | |
488 | module_param(auto_remove_rfkill, bool, 0444); |
489 | |
490 | MODULE_PARM_DESC(auto_remove_rfkill, "Automatically remove rfkill devices when " |
491 | "other modules start receiving events " |
492 | "from this module and re-add them when " |
493 | "the last module stops receiving events " |
494 | "(default true)" ); |
495 | MODULE_DEVICE_TABLE(acpi, rbtn_ids); |
496 | MODULE_DESCRIPTION("Dell Airplane Mode Switch driver" ); |
497 | MODULE_AUTHOR("Pali Rohár <pali@kernel.org>" ); |
498 | MODULE_LICENSE("GPL" ); |
499 | |