1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Driver for keys on GPIO lines capable of generating interrupts. |
4 | * |
5 | * Copyright 2005 Phil Blundell |
6 | * Copyright 2010, 2011 David Jander <david@protonic.nl> |
7 | */ |
8 | |
9 | #include <linux/module.h> |
10 | |
11 | #include <linux/hrtimer.h> |
12 | #include <linux/init.h> |
13 | #include <linux/fs.h> |
14 | #include <linux/interrupt.h> |
15 | #include <linux/irq.h> |
16 | #include <linux/sched.h> |
17 | #include <linux/pm.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/sysctl.h> |
20 | #include <linux/proc_fs.h> |
21 | #include <linux/delay.h> |
22 | #include <linux/platform_device.h> |
23 | #include <linux/input.h> |
24 | #include <linux/gpio_keys.h> |
25 | #include <linux/workqueue.h> |
26 | #include <linux/gpio.h> |
27 | #include <linux/gpio/consumer.h> |
28 | #include <linux/of.h> |
29 | #include <linux/of_irq.h> |
30 | #include <linux/spinlock.h> |
31 | #include <dt-bindings/input/gpio-keys.h> |
32 | |
33 | struct gpio_button_data { |
34 | const struct gpio_keys_button *button; |
35 | struct input_dev *input; |
36 | struct gpio_desc *gpiod; |
37 | |
38 | unsigned short *code; |
39 | |
40 | struct hrtimer release_timer; |
41 | unsigned int release_delay; /* in msecs, for IRQ-only buttons */ |
42 | |
43 | struct delayed_work work; |
44 | struct hrtimer debounce_timer; |
45 | unsigned int software_debounce; /* in msecs, for GPIO-driven buttons */ |
46 | |
47 | unsigned int irq; |
48 | unsigned int wakeirq; |
49 | unsigned int wakeup_trigger_type; |
50 | |
51 | spinlock_t lock; |
52 | bool disabled; |
53 | bool key_pressed; |
54 | bool suspended; |
55 | bool debounce_use_hrtimer; |
56 | }; |
57 | |
58 | struct gpio_keys_drvdata { |
59 | const struct gpio_keys_platform_data *pdata; |
60 | struct input_dev *input; |
61 | struct mutex disable_lock; |
62 | unsigned short *keymap; |
63 | struct gpio_button_data data[]; |
64 | }; |
65 | |
66 | /* |
67 | * SYSFS interface for enabling/disabling keys and switches: |
68 | * |
69 | * There are 4 attributes under /sys/devices/platform/gpio-keys/ |
70 | * keys [ro] - bitmap of keys (EV_KEY) which can be |
71 | * disabled |
72 | * switches [ro] - bitmap of switches (EV_SW) which can be |
73 | * disabled |
74 | * disabled_keys [rw] - bitmap of keys currently disabled |
75 | * disabled_switches [rw] - bitmap of switches currently disabled |
76 | * |
77 | * Userland can change these values and hence disable event generation |
78 | * for each key (or switch). Disabling a key means its interrupt line |
79 | * is disabled. |
80 | * |
81 | * For example, if we have following switches set up as gpio-keys: |
82 | * SW_DOCK = 5 |
83 | * SW_CAMERA_LENS_COVER = 9 |
84 | * SW_KEYPAD_SLIDE = 10 |
85 | * SW_FRONT_PROXIMITY = 11 |
86 | * This is read from switches: |
87 | * 11-9,5 |
88 | * Next we want to disable proximity (11) and dock (5), we write: |
89 | * 11,5 |
90 | * to file disabled_switches. Now proximity and dock IRQs are disabled. |
91 | * This can be verified by reading the file disabled_switches: |
92 | * 11,5 |
93 | * If we now want to enable proximity (11) switch we write: |
94 | * 5 |
95 | * to disabled_switches. |
96 | * |
97 | * We can disable only those keys which don't allow sharing the irq. |
98 | */ |
99 | |
100 | /** |
101 | * get_n_events_by_type() - returns maximum number of events per @type |
102 | * @type: type of button (%EV_KEY, %EV_SW) |
103 | * |
104 | * Return value of this function can be used to allocate bitmap |
105 | * large enough to hold all bits for given type. |
106 | */ |
107 | static int get_n_events_by_type(int type) |
108 | { |
109 | BUG_ON(type != EV_SW && type != EV_KEY); |
110 | |
111 | return (type == EV_KEY) ? KEY_CNT : SW_CNT; |
112 | } |
113 | |
114 | /** |
115 | * get_bm_events_by_type() - returns bitmap of supported events per @type |
116 | * @dev: input device from which bitmap is retrieved |
117 | * @type: type of button (%EV_KEY, %EV_SW) |
118 | * |
119 | * Return value of this function can be used to allocate bitmap |
120 | * large enough to hold all bits for given type. |
121 | */ |
122 | static const unsigned long *get_bm_events_by_type(struct input_dev *dev, |
123 | int type) |
124 | { |
125 | BUG_ON(type != EV_SW && type != EV_KEY); |
126 | |
127 | return (type == EV_KEY) ? dev->keybit : dev->swbit; |
128 | } |
129 | |
130 | static void gpio_keys_quiesce_key(void *data) |
131 | { |
132 | struct gpio_button_data *bdata = data; |
133 | |
134 | if (!bdata->gpiod) |
135 | hrtimer_cancel(timer: &bdata->release_timer); |
136 | else if (bdata->debounce_use_hrtimer) |
137 | hrtimer_cancel(timer: &bdata->debounce_timer); |
138 | else |
139 | cancel_delayed_work_sync(dwork: &bdata->work); |
140 | } |
141 | |
142 | /** |
143 | * gpio_keys_disable_button() - disables given GPIO button |
144 | * @bdata: button data for button to be disabled |
145 | * |
146 | * Disables button pointed by @bdata. This is done by masking |
147 | * IRQ line. After this function is called, button won't generate |
148 | * input events anymore. Note that one can only disable buttons |
149 | * that don't share IRQs. |
150 | * |
151 | * Make sure that @bdata->disable_lock is locked when entering |
152 | * this function to avoid races when concurrent threads are |
153 | * disabling buttons at the same time. |
154 | */ |
155 | static void gpio_keys_disable_button(struct gpio_button_data *bdata) |
156 | { |
157 | if (!bdata->disabled) { |
158 | /* |
159 | * Disable IRQ and associated timer/work structure. |
160 | */ |
161 | disable_irq(irq: bdata->irq); |
162 | gpio_keys_quiesce_key(data: bdata); |
163 | bdata->disabled = true; |
164 | } |
165 | } |
166 | |
167 | /** |
168 | * gpio_keys_enable_button() - enables given GPIO button |
169 | * @bdata: button data for button to be disabled |
170 | * |
171 | * Enables given button pointed by @bdata. |
172 | * |
173 | * Make sure that @bdata->disable_lock is locked when entering |
174 | * this function to avoid races with concurrent threads trying |
175 | * to enable the same button at the same time. |
176 | */ |
177 | static void gpio_keys_enable_button(struct gpio_button_data *bdata) |
178 | { |
179 | if (bdata->disabled) { |
180 | enable_irq(irq: bdata->irq); |
181 | bdata->disabled = false; |
182 | } |
183 | } |
184 | |
185 | /** |
186 | * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons |
187 | * @ddata: pointer to drvdata |
188 | * @buf: buffer where stringified bitmap is written |
189 | * @type: button type (%EV_KEY, %EV_SW) |
190 | * @only_disabled: does caller want only those buttons that are |
191 | * currently disabled or all buttons that can be |
192 | * disabled |
193 | * |
194 | * This function writes buttons that can be disabled to @buf. If |
195 | * @only_disabled is true, then @buf contains only those buttons |
196 | * that are currently disabled. Returns 0 on success or negative |
197 | * errno on failure. |
198 | */ |
199 | static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata, |
200 | char *buf, unsigned int type, |
201 | bool only_disabled) |
202 | { |
203 | int n_events = get_n_events_by_type(type); |
204 | unsigned long *bits; |
205 | ssize_t ret; |
206 | int i; |
207 | |
208 | bits = bitmap_zalloc(nbits: n_events, GFP_KERNEL); |
209 | if (!bits) |
210 | return -ENOMEM; |
211 | |
212 | for (i = 0; i < ddata->pdata->nbuttons; i++) { |
213 | struct gpio_button_data *bdata = &ddata->data[i]; |
214 | |
215 | if (bdata->button->type != type) |
216 | continue; |
217 | |
218 | if (only_disabled && !bdata->disabled) |
219 | continue; |
220 | |
221 | __set_bit(*bdata->code, bits); |
222 | } |
223 | |
224 | ret = scnprintf(buf, PAGE_SIZE - 1, fmt: "%*pbl" , n_events, bits); |
225 | buf[ret++] = '\n'; |
226 | buf[ret] = '\0'; |
227 | |
228 | bitmap_free(bitmap: bits); |
229 | |
230 | return ret; |
231 | } |
232 | |
233 | /** |
234 | * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap |
235 | * @ddata: pointer to drvdata |
236 | * @buf: buffer from userspace that contains stringified bitmap |
237 | * @type: button type (%EV_KEY, %EV_SW) |
238 | * |
239 | * This function parses stringified bitmap from @buf and disables/enables |
240 | * GPIO buttons accordingly. Returns 0 on success and negative error |
241 | * on failure. |
242 | */ |
243 | static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata, |
244 | const char *buf, unsigned int type) |
245 | { |
246 | int n_events = get_n_events_by_type(type); |
247 | const unsigned long *bitmap = get_bm_events_by_type(dev: ddata->input, type); |
248 | unsigned long *bits; |
249 | ssize_t error; |
250 | int i; |
251 | |
252 | bits = bitmap_alloc(nbits: n_events, GFP_KERNEL); |
253 | if (!bits) |
254 | return -ENOMEM; |
255 | |
256 | error = bitmap_parselist(buf, maskp: bits, nmaskbits: n_events); |
257 | if (error) |
258 | goto out; |
259 | |
260 | /* First validate */ |
261 | if (!bitmap_subset(src1: bits, src2: bitmap, nbits: n_events)) { |
262 | error = -EINVAL; |
263 | goto out; |
264 | } |
265 | |
266 | for (i = 0; i < ddata->pdata->nbuttons; i++) { |
267 | struct gpio_button_data *bdata = &ddata->data[i]; |
268 | |
269 | if (bdata->button->type != type) |
270 | continue; |
271 | |
272 | if (test_bit(*bdata->code, bits) && |
273 | !bdata->button->can_disable) { |
274 | error = -EINVAL; |
275 | goto out; |
276 | } |
277 | } |
278 | |
279 | mutex_lock(&ddata->disable_lock); |
280 | |
281 | for (i = 0; i < ddata->pdata->nbuttons; i++) { |
282 | struct gpio_button_data *bdata = &ddata->data[i]; |
283 | |
284 | if (bdata->button->type != type) |
285 | continue; |
286 | |
287 | if (test_bit(*bdata->code, bits)) |
288 | gpio_keys_disable_button(bdata); |
289 | else |
290 | gpio_keys_enable_button(bdata); |
291 | } |
292 | |
293 | mutex_unlock(lock: &ddata->disable_lock); |
294 | |
295 | out: |
296 | bitmap_free(bitmap: bits); |
297 | return error; |
298 | } |
299 | |
300 | #define ATTR_SHOW_FN(name, type, only_disabled) \ |
301 | static ssize_t gpio_keys_show_##name(struct device *dev, \ |
302 | struct device_attribute *attr, \ |
303 | char *buf) \ |
304 | { \ |
305 | struct platform_device *pdev = to_platform_device(dev); \ |
306 | struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \ |
307 | \ |
308 | return gpio_keys_attr_show_helper(ddata, buf, \ |
309 | type, only_disabled); \ |
310 | } |
311 | |
312 | ATTR_SHOW_FN(keys, EV_KEY, false); |
313 | ATTR_SHOW_FN(switches, EV_SW, false); |
314 | ATTR_SHOW_FN(disabled_keys, EV_KEY, true); |
315 | ATTR_SHOW_FN(disabled_switches, EV_SW, true); |
316 | |
317 | /* |
318 | * ATTRIBUTES: |
319 | * |
320 | * /sys/devices/platform/gpio-keys/keys [ro] |
321 | * /sys/devices/platform/gpio-keys/switches [ro] |
322 | */ |
323 | static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL); |
324 | static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL); |
325 | |
326 | #define ATTR_STORE_FN(name, type) \ |
327 | static ssize_t gpio_keys_store_##name(struct device *dev, \ |
328 | struct device_attribute *attr, \ |
329 | const char *buf, \ |
330 | size_t count) \ |
331 | { \ |
332 | struct platform_device *pdev = to_platform_device(dev); \ |
333 | struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \ |
334 | ssize_t error; \ |
335 | \ |
336 | error = gpio_keys_attr_store_helper(ddata, buf, type); \ |
337 | if (error) \ |
338 | return error; \ |
339 | \ |
340 | return count; \ |
341 | } |
342 | |
343 | ATTR_STORE_FN(disabled_keys, EV_KEY); |
344 | ATTR_STORE_FN(disabled_switches, EV_SW); |
345 | |
346 | /* |
347 | * ATTRIBUTES: |
348 | * |
349 | * /sys/devices/platform/gpio-keys/disabled_keys [rw] |
350 | * /sys/devices/platform/gpio-keys/disables_switches [rw] |
351 | */ |
352 | static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO, |
353 | gpio_keys_show_disabled_keys, |
354 | gpio_keys_store_disabled_keys); |
355 | static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO, |
356 | gpio_keys_show_disabled_switches, |
357 | gpio_keys_store_disabled_switches); |
358 | |
359 | static struct attribute *gpio_keys_attrs[] = { |
360 | &dev_attr_keys.attr, |
361 | &dev_attr_switches.attr, |
362 | &dev_attr_disabled_keys.attr, |
363 | &dev_attr_disabled_switches.attr, |
364 | NULL, |
365 | }; |
366 | ATTRIBUTE_GROUPS(gpio_keys); |
367 | |
368 | static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata) |
369 | { |
370 | const struct gpio_keys_button *button = bdata->button; |
371 | struct input_dev *input = bdata->input; |
372 | unsigned int type = button->type ?: EV_KEY; |
373 | int state; |
374 | |
375 | state = bdata->debounce_use_hrtimer ? |
376 | gpiod_get_value(desc: bdata->gpiod) : |
377 | gpiod_get_value_cansleep(desc: bdata->gpiod); |
378 | if (state < 0) { |
379 | dev_err(input->dev.parent, |
380 | "failed to get gpio state: %d\n" , state); |
381 | return; |
382 | } |
383 | |
384 | if (type == EV_ABS) { |
385 | if (state) |
386 | input_event(dev: input, type, code: button->code, value: button->value); |
387 | } else { |
388 | input_event(dev: input, type, code: *bdata->code, value: state); |
389 | } |
390 | } |
391 | |
392 | static void gpio_keys_debounce_event(struct gpio_button_data *bdata) |
393 | { |
394 | gpio_keys_gpio_report_event(bdata); |
395 | input_sync(dev: bdata->input); |
396 | |
397 | if (bdata->button->wakeup) |
398 | pm_relax(dev: bdata->input->dev.parent); |
399 | } |
400 | |
401 | static void gpio_keys_gpio_work_func(struct work_struct *work) |
402 | { |
403 | struct gpio_button_data *bdata = |
404 | container_of(work, struct gpio_button_data, work.work); |
405 | |
406 | gpio_keys_debounce_event(bdata); |
407 | } |
408 | |
409 | static enum hrtimer_restart gpio_keys_debounce_timer(struct hrtimer *t) |
410 | { |
411 | struct gpio_button_data *bdata = |
412 | container_of(t, struct gpio_button_data, debounce_timer); |
413 | |
414 | gpio_keys_debounce_event(bdata); |
415 | |
416 | return HRTIMER_NORESTART; |
417 | } |
418 | |
419 | static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id) |
420 | { |
421 | struct gpio_button_data *bdata = dev_id; |
422 | |
423 | BUG_ON(irq != bdata->irq); |
424 | |
425 | if (bdata->button->wakeup) { |
426 | const struct gpio_keys_button *button = bdata->button; |
427 | |
428 | pm_stay_awake(dev: bdata->input->dev.parent); |
429 | if (bdata->suspended && |
430 | (button->type == 0 || button->type == EV_KEY)) { |
431 | /* |
432 | * Simulate wakeup key press in case the key has |
433 | * already released by the time we got interrupt |
434 | * handler to run. |
435 | */ |
436 | input_report_key(dev: bdata->input, code: button->code, value: 1); |
437 | } |
438 | } |
439 | |
440 | if (bdata->debounce_use_hrtimer) { |
441 | hrtimer_start(timer: &bdata->debounce_timer, |
442 | tim: ms_to_ktime(ms: bdata->software_debounce), |
443 | mode: HRTIMER_MODE_REL); |
444 | } else { |
445 | mod_delayed_work(wq: system_wq, |
446 | dwork: &bdata->work, |
447 | delay: msecs_to_jiffies(m: bdata->software_debounce)); |
448 | } |
449 | |
450 | return IRQ_HANDLED; |
451 | } |
452 | |
453 | static enum hrtimer_restart gpio_keys_irq_timer(struct hrtimer *t) |
454 | { |
455 | struct gpio_button_data *bdata = container_of(t, |
456 | struct gpio_button_data, |
457 | release_timer); |
458 | struct input_dev *input = bdata->input; |
459 | |
460 | if (bdata->key_pressed) { |
461 | input_report_key(dev: input, code: *bdata->code, value: 0); |
462 | input_sync(dev: input); |
463 | bdata->key_pressed = false; |
464 | } |
465 | |
466 | return HRTIMER_NORESTART; |
467 | } |
468 | |
469 | static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id) |
470 | { |
471 | struct gpio_button_data *bdata = dev_id; |
472 | struct input_dev *input = bdata->input; |
473 | unsigned long flags; |
474 | |
475 | BUG_ON(irq != bdata->irq); |
476 | |
477 | spin_lock_irqsave(&bdata->lock, flags); |
478 | |
479 | if (!bdata->key_pressed) { |
480 | if (bdata->button->wakeup) |
481 | pm_wakeup_event(dev: bdata->input->dev.parent, msec: 0); |
482 | |
483 | input_report_key(dev: input, code: *bdata->code, value: 1); |
484 | input_sync(dev: input); |
485 | |
486 | if (!bdata->release_delay) { |
487 | input_report_key(dev: input, code: *bdata->code, value: 0); |
488 | input_sync(dev: input); |
489 | goto out; |
490 | } |
491 | |
492 | bdata->key_pressed = true; |
493 | } |
494 | |
495 | if (bdata->release_delay) |
496 | hrtimer_start(timer: &bdata->release_timer, |
497 | tim: ms_to_ktime(ms: bdata->release_delay), |
498 | mode: HRTIMER_MODE_REL_HARD); |
499 | out: |
500 | spin_unlock_irqrestore(lock: &bdata->lock, flags); |
501 | return IRQ_HANDLED; |
502 | } |
503 | |
504 | static int gpio_keys_setup_key(struct platform_device *pdev, |
505 | struct input_dev *input, |
506 | struct gpio_keys_drvdata *ddata, |
507 | const struct gpio_keys_button *button, |
508 | int idx, |
509 | struct fwnode_handle *child) |
510 | { |
511 | const char *desc = button->desc ? button->desc : "gpio_keys" ; |
512 | struct device *dev = &pdev->dev; |
513 | struct gpio_button_data *bdata = &ddata->data[idx]; |
514 | irq_handler_t isr; |
515 | unsigned long irqflags; |
516 | const char *wakedesc; |
517 | int irq; |
518 | int error; |
519 | |
520 | bdata->input = input; |
521 | bdata->button = button; |
522 | spin_lock_init(&bdata->lock); |
523 | |
524 | if (child) { |
525 | bdata->gpiod = devm_fwnode_gpiod_get(dev, fwnode: child, |
526 | NULL, flags: GPIOD_IN, label: desc); |
527 | if (IS_ERR(ptr: bdata->gpiod)) { |
528 | error = PTR_ERR(ptr: bdata->gpiod); |
529 | if (error != -ENOENT) |
530 | return dev_err_probe(dev, err: error, |
531 | fmt: "failed to get gpio\n" ); |
532 | |
533 | /* |
534 | * GPIO is optional, we may be dealing with |
535 | * purely interrupt-driven setup. |
536 | */ |
537 | bdata->gpiod = NULL; |
538 | } |
539 | } else if (gpio_is_valid(number: button->gpio)) { |
540 | /* |
541 | * Legacy GPIO number, so request the GPIO here and |
542 | * convert it to descriptor. |
543 | */ |
544 | unsigned flags = GPIOF_IN; |
545 | |
546 | if (button->active_low) |
547 | flags |= GPIOF_ACTIVE_LOW; |
548 | |
549 | error = devm_gpio_request_one(dev, gpio: button->gpio, flags, label: desc); |
550 | if (error < 0) { |
551 | dev_err(dev, "Failed to request GPIO %d, error %d\n" , |
552 | button->gpio, error); |
553 | return error; |
554 | } |
555 | |
556 | bdata->gpiod = gpio_to_desc(gpio: button->gpio); |
557 | if (!bdata->gpiod) |
558 | return -EINVAL; |
559 | } |
560 | |
561 | if (bdata->gpiod) { |
562 | bool active_low = gpiod_is_active_low(desc: bdata->gpiod); |
563 | |
564 | if (button->debounce_interval) { |
565 | error = gpiod_set_debounce(desc: bdata->gpiod, |
566 | debounce: button->debounce_interval * 1000); |
567 | /* use timer if gpiolib doesn't provide debounce */ |
568 | if (error < 0) |
569 | bdata->software_debounce = |
570 | button->debounce_interval; |
571 | |
572 | /* |
573 | * If reading the GPIO won't sleep, we can use a |
574 | * hrtimer instead of a standard timer for the software |
575 | * debounce, to reduce the latency as much as possible. |
576 | */ |
577 | bdata->debounce_use_hrtimer = |
578 | !gpiod_cansleep(desc: bdata->gpiod); |
579 | } |
580 | |
581 | /* |
582 | * If an interrupt was specified, use it instead of the gpio |
583 | * interrupt and use the gpio for reading the state. A separate |
584 | * interrupt may be used as the main button interrupt for |
585 | * runtime PM to detect events also in deeper idle states. If a |
586 | * dedicated wakeirq is used for system suspend only, see below |
587 | * for bdata->wakeirq setup. |
588 | */ |
589 | if (button->irq) { |
590 | bdata->irq = button->irq; |
591 | } else { |
592 | irq = gpiod_to_irq(desc: bdata->gpiod); |
593 | if (irq < 0) { |
594 | error = irq; |
595 | dev_err_probe(dev, err: error, |
596 | fmt: "Unable to get irq number for GPIO %d\n" , |
597 | button->gpio); |
598 | return error; |
599 | } |
600 | bdata->irq = irq; |
601 | } |
602 | |
603 | INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func); |
604 | |
605 | hrtimer_init(timer: &bdata->debounce_timer, |
606 | CLOCK_REALTIME, mode: HRTIMER_MODE_REL); |
607 | bdata->debounce_timer.function = gpio_keys_debounce_timer; |
608 | |
609 | isr = gpio_keys_gpio_isr; |
610 | irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; |
611 | |
612 | switch (button->wakeup_event_action) { |
613 | case EV_ACT_ASSERTED: |
614 | bdata->wakeup_trigger_type = active_low ? |
615 | IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING; |
616 | break; |
617 | case EV_ACT_DEASSERTED: |
618 | bdata->wakeup_trigger_type = active_low ? |
619 | IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING; |
620 | break; |
621 | case EV_ACT_ANY: |
622 | default: |
623 | /* |
624 | * For other cases, we are OK letting suspend/resume |
625 | * not reconfigure the trigger type. |
626 | */ |
627 | break; |
628 | } |
629 | } else { |
630 | if (!button->irq) { |
631 | dev_err(dev, "Found button without gpio or irq\n" ); |
632 | return -EINVAL; |
633 | } |
634 | |
635 | bdata->irq = button->irq; |
636 | |
637 | if (button->type && button->type != EV_KEY) { |
638 | dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n" ); |
639 | return -EINVAL; |
640 | } |
641 | |
642 | bdata->release_delay = button->debounce_interval; |
643 | hrtimer_init(timer: &bdata->release_timer, |
644 | CLOCK_REALTIME, mode: HRTIMER_MODE_REL_HARD); |
645 | bdata->release_timer.function = gpio_keys_irq_timer; |
646 | |
647 | isr = gpio_keys_irq_isr; |
648 | irqflags = 0; |
649 | |
650 | /* |
651 | * For IRQ buttons, there is no interrupt for release. |
652 | * So we don't need to reconfigure the trigger type for wakeup. |
653 | */ |
654 | } |
655 | |
656 | bdata->code = &ddata->keymap[idx]; |
657 | *bdata->code = button->code; |
658 | input_set_capability(dev: input, type: button->type ?: EV_KEY, code: *bdata->code); |
659 | |
660 | /* |
661 | * Install custom action to cancel release timer and |
662 | * workqueue item. |
663 | */ |
664 | error = devm_add_action(dev, gpio_keys_quiesce_key, bdata); |
665 | if (error) { |
666 | dev_err(dev, "failed to register quiesce action, error: %d\n" , |
667 | error); |
668 | return error; |
669 | } |
670 | |
671 | /* |
672 | * If platform has specified that the button can be disabled, |
673 | * we don't want it to share the interrupt line. |
674 | */ |
675 | if (!button->can_disable) |
676 | irqflags |= IRQF_SHARED; |
677 | |
678 | error = devm_request_any_context_irq(dev, irq: bdata->irq, handler: isr, irqflags, |
679 | devname: desc, dev_id: bdata); |
680 | if (error < 0) { |
681 | dev_err(dev, "Unable to claim irq %d; error %d\n" , |
682 | bdata->irq, error); |
683 | return error; |
684 | } |
685 | |
686 | if (!button->wakeirq) |
687 | return 0; |
688 | |
689 | /* Use :wakeup suffix like drivers/base/power/wakeirq.c does */ |
690 | wakedesc = devm_kasprintf(dev, GFP_KERNEL, fmt: "%s:wakeup" , desc); |
691 | if (!wakedesc) |
692 | return -ENOMEM; |
693 | |
694 | bdata->wakeirq = button->wakeirq; |
695 | irqflags |= IRQF_NO_SUSPEND; |
696 | |
697 | /* |
698 | * Wakeirq shares the handler with the main interrupt, it's only |
699 | * active during system suspend. See gpio_keys_button_enable_wakeup() |
700 | * and gpio_keys_button_disable_wakeup(). |
701 | */ |
702 | error = devm_request_any_context_irq(dev, irq: bdata->wakeirq, handler: isr, |
703 | irqflags, devname: wakedesc, dev_id: bdata); |
704 | if (error < 0) { |
705 | dev_err(dev, "Unable to claim wakeirq %d; error %d\n" , |
706 | bdata->irq, error); |
707 | return error; |
708 | } |
709 | |
710 | /* |
711 | * Disable wakeirq until suspend. IRQF_NO_AUTOEN won't work if |
712 | * IRQF_SHARED was set based on !button->can_disable. |
713 | */ |
714 | disable_irq(irq: bdata->wakeirq); |
715 | |
716 | return 0; |
717 | } |
718 | |
719 | static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata) |
720 | { |
721 | struct input_dev *input = ddata->input; |
722 | int i; |
723 | |
724 | for (i = 0; i < ddata->pdata->nbuttons; i++) { |
725 | struct gpio_button_data *bdata = &ddata->data[i]; |
726 | if (bdata->gpiod) |
727 | gpio_keys_gpio_report_event(bdata); |
728 | } |
729 | input_sync(dev: input); |
730 | } |
731 | |
732 | static int gpio_keys_open(struct input_dev *input) |
733 | { |
734 | struct gpio_keys_drvdata *ddata = input_get_drvdata(dev: input); |
735 | const struct gpio_keys_platform_data *pdata = ddata->pdata; |
736 | int error; |
737 | |
738 | if (pdata->enable) { |
739 | error = pdata->enable(input->dev.parent); |
740 | if (error) |
741 | return error; |
742 | } |
743 | |
744 | /* Report current state of buttons that are connected to GPIOs */ |
745 | gpio_keys_report_state(ddata); |
746 | |
747 | return 0; |
748 | } |
749 | |
750 | static void gpio_keys_close(struct input_dev *input) |
751 | { |
752 | struct gpio_keys_drvdata *ddata = input_get_drvdata(dev: input); |
753 | const struct gpio_keys_platform_data *pdata = ddata->pdata; |
754 | |
755 | if (pdata->disable) |
756 | pdata->disable(input->dev.parent); |
757 | } |
758 | |
759 | /* |
760 | * Handlers for alternative sources of platform_data |
761 | */ |
762 | |
763 | /* |
764 | * Translate properties into platform_data |
765 | */ |
766 | static struct gpio_keys_platform_data * |
767 | gpio_keys_get_devtree_pdata(struct device *dev) |
768 | { |
769 | struct gpio_keys_platform_data *pdata; |
770 | struct gpio_keys_button *button; |
771 | struct fwnode_handle *child; |
772 | int nbuttons, irq; |
773 | |
774 | nbuttons = device_get_child_node_count(dev); |
775 | if (nbuttons == 0) |
776 | return ERR_PTR(error: -ENODEV); |
777 | |
778 | pdata = devm_kzalloc(dev, |
779 | size: sizeof(*pdata) + nbuttons * sizeof(*button), |
780 | GFP_KERNEL); |
781 | if (!pdata) |
782 | return ERR_PTR(error: -ENOMEM); |
783 | |
784 | button = (struct gpio_keys_button *)(pdata + 1); |
785 | |
786 | pdata->buttons = button; |
787 | pdata->nbuttons = nbuttons; |
788 | |
789 | pdata->rep = device_property_read_bool(dev, propname: "autorepeat" ); |
790 | |
791 | device_property_read_string(dev, propname: "label" , val: &pdata->name); |
792 | |
793 | device_for_each_child_node(dev, child) { |
794 | if (is_of_node(fwnode: child)) { |
795 | irq = of_irq_get_byname(to_of_node(child), name: "irq" ); |
796 | if (irq > 0) |
797 | button->irq = irq; |
798 | |
799 | irq = of_irq_get_byname(to_of_node(child), name: "wakeup" ); |
800 | if (irq > 0) |
801 | button->wakeirq = irq; |
802 | |
803 | if (!button->irq && !button->wakeirq) |
804 | button->irq = |
805 | irq_of_parse_and_map(to_of_node(child), index: 0); |
806 | } |
807 | |
808 | if (fwnode_property_read_u32(fwnode: child, propname: "linux,code" , |
809 | val: &button->code)) { |
810 | dev_err(dev, "Button without keycode\n" ); |
811 | fwnode_handle_put(fwnode: child); |
812 | return ERR_PTR(error: -EINVAL); |
813 | } |
814 | |
815 | fwnode_property_read_string(fwnode: child, propname: "label" , val: &button->desc); |
816 | |
817 | if (fwnode_property_read_u32(fwnode: child, propname: "linux,input-type" , |
818 | val: &button->type)) |
819 | button->type = EV_KEY; |
820 | |
821 | fwnode_property_read_u32(fwnode: child, propname: "linux,input-value" , |
822 | val: (u32 *)&button->value); |
823 | |
824 | button->wakeup = |
825 | fwnode_property_read_bool(fwnode: child, propname: "wakeup-source" ) || |
826 | /* legacy name */ |
827 | fwnode_property_read_bool(fwnode: child, propname: "gpio-key,wakeup" ); |
828 | |
829 | fwnode_property_read_u32(fwnode: child, propname: "wakeup-event-action" , |
830 | val: &button->wakeup_event_action); |
831 | |
832 | button->can_disable = |
833 | fwnode_property_read_bool(fwnode: child, propname: "linux,can-disable" ); |
834 | |
835 | if (fwnode_property_read_u32(fwnode: child, propname: "debounce-interval" , |
836 | val: &button->debounce_interval)) |
837 | button->debounce_interval = 5; |
838 | |
839 | button++; |
840 | } |
841 | |
842 | return pdata; |
843 | } |
844 | |
845 | static const struct of_device_id gpio_keys_of_match[] = { |
846 | { .compatible = "gpio-keys" , }, |
847 | { }, |
848 | }; |
849 | MODULE_DEVICE_TABLE(of, gpio_keys_of_match); |
850 | |
851 | static int gpio_keys_probe(struct platform_device *pdev) |
852 | { |
853 | struct device *dev = &pdev->dev; |
854 | const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev); |
855 | struct fwnode_handle *child = NULL; |
856 | struct gpio_keys_drvdata *ddata; |
857 | struct input_dev *input; |
858 | int i, error; |
859 | int wakeup = 0; |
860 | |
861 | if (!pdata) { |
862 | pdata = gpio_keys_get_devtree_pdata(dev); |
863 | if (IS_ERR(ptr: pdata)) |
864 | return PTR_ERR(ptr: pdata); |
865 | } |
866 | |
867 | ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons), |
868 | GFP_KERNEL); |
869 | if (!ddata) { |
870 | dev_err(dev, "failed to allocate state\n" ); |
871 | return -ENOMEM; |
872 | } |
873 | |
874 | ddata->keymap = devm_kcalloc(dev, |
875 | n: pdata->nbuttons, size: sizeof(ddata->keymap[0]), |
876 | GFP_KERNEL); |
877 | if (!ddata->keymap) |
878 | return -ENOMEM; |
879 | |
880 | input = devm_input_allocate_device(dev); |
881 | if (!input) { |
882 | dev_err(dev, "failed to allocate input device\n" ); |
883 | return -ENOMEM; |
884 | } |
885 | |
886 | ddata->pdata = pdata; |
887 | ddata->input = input; |
888 | mutex_init(&ddata->disable_lock); |
889 | |
890 | platform_set_drvdata(pdev, data: ddata); |
891 | input_set_drvdata(dev: input, data: ddata); |
892 | |
893 | input->name = pdata->name ? : pdev->name; |
894 | input->phys = "gpio-keys/input0" ; |
895 | input->dev.parent = dev; |
896 | input->open = gpio_keys_open; |
897 | input->close = gpio_keys_close; |
898 | |
899 | input->id.bustype = BUS_HOST; |
900 | input->id.vendor = 0x0001; |
901 | input->id.product = 0x0001; |
902 | input->id.version = 0x0100; |
903 | |
904 | input->keycode = ddata->keymap; |
905 | input->keycodesize = sizeof(ddata->keymap[0]); |
906 | input->keycodemax = pdata->nbuttons; |
907 | |
908 | /* Enable auto repeat feature of Linux input subsystem */ |
909 | if (pdata->rep) |
910 | __set_bit(EV_REP, input->evbit); |
911 | |
912 | for (i = 0; i < pdata->nbuttons; i++) { |
913 | const struct gpio_keys_button *button = &pdata->buttons[i]; |
914 | |
915 | if (!dev_get_platdata(dev)) { |
916 | child = device_get_next_child_node(dev, child); |
917 | if (!child) { |
918 | dev_err(dev, |
919 | "missing child device node for entry %d\n" , |
920 | i); |
921 | return -EINVAL; |
922 | } |
923 | } |
924 | |
925 | error = gpio_keys_setup_key(pdev, input, ddata, |
926 | button, idx: i, child); |
927 | if (error) { |
928 | fwnode_handle_put(fwnode: child); |
929 | return error; |
930 | } |
931 | |
932 | if (button->wakeup) |
933 | wakeup = 1; |
934 | } |
935 | |
936 | fwnode_handle_put(fwnode: child); |
937 | |
938 | error = input_register_device(input); |
939 | if (error) { |
940 | dev_err(dev, "Unable to register input device, error: %d\n" , |
941 | error); |
942 | return error; |
943 | } |
944 | |
945 | device_init_wakeup(dev, enable: wakeup); |
946 | |
947 | return 0; |
948 | } |
949 | |
950 | static int __maybe_unused |
951 | gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata) |
952 | { |
953 | int error; |
954 | |
955 | error = enable_irq_wake(irq: bdata->irq); |
956 | if (error) { |
957 | dev_err(bdata->input->dev.parent, |
958 | "failed to configure IRQ %d as wakeup source: %d\n" , |
959 | bdata->irq, error); |
960 | return error; |
961 | } |
962 | |
963 | if (bdata->wakeup_trigger_type) { |
964 | error = irq_set_irq_type(irq: bdata->irq, |
965 | type: bdata->wakeup_trigger_type); |
966 | if (error) { |
967 | dev_err(bdata->input->dev.parent, |
968 | "failed to set wakeup trigger %08x for IRQ %d: %d\n" , |
969 | bdata->wakeup_trigger_type, bdata->irq, error); |
970 | disable_irq_wake(irq: bdata->irq); |
971 | return error; |
972 | } |
973 | } |
974 | |
975 | if (bdata->wakeirq) { |
976 | enable_irq(irq: bdata->wakeirq); |
977 | disable_irq(irq: bdata->irq); |
978 | } |
979 | |
980 | return 0; |
981 | } |
982 | |
983 | static void __maybe_unused |
984 | gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata) |
985 | { |
986 | int error; |
987 | |
988 | if (bdata->wakeirq) { |
989 | enable_irq(irq: bdata->irq); |
990 | disable_irq(irq: bdata->wakeirq); |
991 | } |
992 | |
993 | /* |
994 | * The trigger type is always both edges for gpio-based keys and we do |
995 | * not support changing wakeup trigger for interrupt-based keys. |
996 | */ |
997 | if (bdata->wakeup_trigger_type) { |
998 | error = irq_set_irq_type(irq: bdata->irq, type: IRQ_TYPE_EDGE_BOTH); |
999 | if (error) |
1000 | dev_warn(bdata->input->dev.parent, |
1001 | "failed to restore interrupt trigger for IRQ %d: %d\n" , |
1002 | bdata->irq, error); |
1003 | } |
1004 | |
1005 | error = disable_irq_wake(irq: bdata->irq); |
1006 | if (error) |
1007 | dev_warn(bdata->input->dev.parent, |
1008 | "failed to disable IRQ %d as wake source: %d\n" , |
1009 | bdata->irq, error); |
1010 | } |
1011 | |
1012 | static int __maybe_unused |
1013 | gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata) |
1014 | { |
1015 | struct gpio_button_data *bdata; |
1016 | int error; |
1017 | int i; |
1018 | |
1019 | for (i = 0; i < ddata->pdata->nbuttons; i++) { |
1020 | bdata = &ddata->data[i]; |
1021 | if (bdata->button->wakeup) { |
1022 | error = gpio_keys_button_enable_wakeup(bdata); |
1023 | if (error) |
1024 | goto err_out; |
1025 | } |
1026 | bdata->suspended = true; |
1027 | } |
1028 | |
1029 | return 0; |
1030 | |
1031 | err_out: |
1032 | while (i--) { |
1033 | bdata = &ddata->data[i]; |
1034 | if (bdata->button->wakeup) |
1035 | gpio_keys_button_disable_wakeup(bdata); |
1036 | bdata->suspended = false; |
1037 | } |
1038 | |
1039 | return error; |
1040 | } |
1041 | |
1042 | static void __maybe_unused |
1043 | gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata) |
1044 | { |
1045 | struct gpio_button_data *bdata; |
1046 | int i; |
1047 | |
1048 | for (i = 0; i < ddata->pdata->nbuttons; i++) { |
1049 | bdata = &ddata->data[i]; |
1050 | bdata->suspended = false; |
1051 | if (irqd_is_wakeup_set(d: irq_get_irq_data(irq: bdata->irq))) |
1052 | gpio_keys_button_disable_wakeup(bdata); |
1053 | } |
1054 | } |
1055 | |
1056 | static int gpio_keys_suspend(struct device *dev) |
1057 | { |
1058 | struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); |
1059 | struct input_dev *input = ddata->input; |
1060 | int error; |
1061 | |
1062 | if (device_may_wakeup(dev)) { |
1063 | error = gpio_keys_enable_wakeup(ddata); |
1064 | if (error) |
1065 | return error; |
1066 | } else { |
1067 | mutex_lock(&input->mutex); |
1068 | if (input_device_enabled(dev: input)) |
1069 | gpio_keys_close(input); |
1070 | mutex_unlock(lock: &input->mutex); |
1071 | } |
1072 | |
1073 | return 0; |
1074 | } |
1075 | |
1076 | static int gpio_keys_resume(struct device *dev) |
1077 | { |
1078 | struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); |
1079 | struct input_dev *input = ddata->input; |
1080 | int error = 0; |
1081 | |
1082 | if (device_may_wakeup(dev)) { |
1083 | gpio_keys_disable_wakeup(ddata); |
1084 | } else { |
1085 | mutex_lock(&input->mutex); |
1086 | if (input_device_enabled(dev: input)) |
1087 | error = gpio_keys_open(input); |
1088 | mutex_unlock(lock: &input->mutex); |
1089 | } |
1090 | |
1091 | if (error) |
1092 | return error; |
1093 | |
1094 | gpio_keys_report_state(ddata); |
1095 | return 0; |
1096 | } |
1097 | |
1098 | static DEFINE_SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume); |
1099 | |
1100 | static void gpio_keys_shutdown(struct platform_device *pdev) |
1101 | { |
1102 | int ret; |
1103 | |
1104 | ret = gpio_keys_suspend(dev: &pdev->dev); |
1105 | if (ret) |
1106 | dev_err(&pdev->dev, "failed to shutdown\n" ); |
1107 | } |
1108 | |
1109 | static struct platform_driver gpio_keys_device_driver = { |
1110 | .probe = gpio_keys_probe, |
1111 | .shutdown = gpio_keys_shutdown, |
1112 | .driver = { |
1113 | .name = "gpio-keys" , |
1114 | .pm = pm_sleep_ptr(&gpio_keys_pm_ops), |
1115 | .of_match_table = gpio_keys_of_match, |
1116 | .dev_groups = gpio_keys_groups, |
1117 | } |
1118 | }; |
1119 | |
1120 | static int __init gpio_keys_init(void) |
1121 | { |
1122 | return platform_driver_register(&gpio_keys_device_driver); |
1123 | } |
1124 | |
1125 | static void __exit gpio_keys_exit(void) |
1126 | { |
1127 | platform_driver_unregister(&gpio_keys_device_driver); |
1128 | } |
1129 | |
1130 | late_initcall(gpio_keys_init); |
1131 | module_exit(gpio_keys_exit); |
1132 | |
1133 | MODULE_LICENSE("GPL" ); |
1134 | MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>" ); |
1135 | MODULE_DESCRIPTION("Keyboard driver for GPIOs" ); |
1136 | MODULE_ALIAS("platform:gpio-keys" ); |
1137 | |