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