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 */
get_n_events_by_type(int type)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 */
get_bm_events_by_type(struct input_dev * dev,int type)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
gpio_keys_quiesce_key(void * data)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(&bdata->release_timer);
136 else if (bdata->debounce_use_hrtimer)
137 hrtimer_cancel(&bdata->debounce_timer);
138 else
139 cancel_delayed_work_sync(&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 */
gpio_keys_disable_button(struct gpio_button_data * bdata)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(bdata->irq);
162 gpio_keys_quiesce_key(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 */
gpio_keys_enable_button(struct gpio_button_data * bdata)177 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
178 {
179 if (bdata->disabled) {
180 enable_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 */
gpio_keys_attr_show_helper(struct gpio_keys_drvdata * ddata,char * buf,unsigned int type,bool only_disabled)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(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, "%*pbl", n_events, bits);
225 buf[ret++] = '\n';
226 buf[ret] = '\0';
227
228 bitmap_free(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 */
gpio_keys_attr_store_helper(struct gpio_keys_drvdata * ddata,const char * buf,unsigned int type)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(ddata->input, type);
248 ssize_t error;
249 int i;
250
251 unsigned long *bits __free(bitmap) = bitmap_alloc(n_events, GFP_KERNEL);
252 if (!bits)
253 return -ENOMEM;
254
255 error = bitmap_parselist(buf, bits, n_events);
256 if (error)
257 return error;
258
259 /* First validate */
260 if (!bitmap_subset(bits, bitmap, n_events))
261 return -EINVAL;
262
263 for (i = 0; i < ddata->pdata->nbuttons; i++) {
264 struct gpio_button_data *bdata = &ddata->data[i];
265
266 if (bdata->button->type != type)
267 continue;
268
269 if (test_bit(*bdata->code, bits) &&
270 !bdata->button->can_disable) {
271 return -EINVAL;
272 }
273 }
274
275 guard(mutex)(&ddata->disable_lock);
276
277 for (i = 0; i < ddata->pdata->nbuttons; i++) {
278 struct gpio_button_data *bdata = &ddata->data[i];
279
280 if (bdata->button->type != type)
281 continue;
282
283 if (test_bit(*bdata->code, bits))
284 gpio_keys_disable_button(bdata);
285 else
286 gpio_keys_enable_button(bdata);
287 }
288
289 return 0;
290 }
291
292 #define ATTR_SHOW_FN(name, type, only_disabled) \
293 static ssize_t gpio_keys_show_##name(struct device *dev, \
294 struct device_attribute *attr, \
295 char *buf) \
296 { \
297 struct platform_device *pdev = to_platform_device(dev); \
298 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
299 \
300 return gpio_keys_attr_show_helper(ddata, buf, \
301 type, only_disabled); \
302 }
303
304 ATTR_SHOW_FN(keys, EV_KEY, false);
305 ATTR_SHOW_FN(switches, EV_SW, false);
306 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
307 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
308
309 /*
310 * ATTRIBUTES:
311 *
312 * /sys/devices/platform/gpio-keys/keys [ro]
313 * /sys/devices/platform/gpio-keys/switches [ro]
314 */
315 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
316 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
317
318 #define ATTR_STORE_FN(name, type) \
319 static ssize_t gpio_keys_store_##name(struct device *dev, \
320 struct device_attribute *attr, \
321 const char *buf, \
322 size_t count) \
323 { \
324 struct platform_device *pdev = to_platform_device(dev); \
325 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
326 ssize_t error; \
327 \
328 error = gpio_keys_attr_store_helper(ddata, buf, type); \
329 if (error) \
330 return error; \
331 \
332 return count; \
333 }
334
335 ATTR_STORE_FN(disabled_keys, EV_KEY);
336 ATTR_STORE_FN(disabled_switches, EV_SW);
337
338 /*
339 * ATTRIBUTES:
340 *
341 * /sys/devices/platform/gpio-keys/disabled_keys [rw]
342 * /sys/devices/platform/gpio-keys/disables_switches [rw]
343 */
344 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
345 gpio_keys_show_disabled_keys,
346 gpio_keys_store_disabled_keys);
347 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
348 gpio_keys_show_disabled_switches,
349 gpio_keys_store_disabled_switches);
350
351 static struct attribute *gpio_keys_attrs[] = {
352 &dev_attr_keys.attr,
353 &dev_attr_switches.attr,
354 &dev_attr_disabled_keys.attr,
355 &dev_attr_disabled_switches.attr,
356 NULL,
357 };
358 ATTRIBUTE_GROUPS(gpio_keys);
359
gpio_keys_gpio_report_event(struct gpio_button_data * bdata)360 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
361 {
362 const struct gpio_keys_button *button = bdata->button;
363 struct input_dev *input = bdata->input;
364 unsigned int type = button->type ?: EV_KEY;
365 int state;
366
367 state = bdata->debounce_use_hrtimer ?
368 gpiod_get_value(bdata->gpiod) :
369 gpiod_get_value_cansleep(bdata->gpiod);
370 if (state < 0) {
371 dev_err(input->dev.parent,
372 "failed to get gpio state: %d\n", state);
373 return;
374 }
375
376 if (type == EV_ABS) {
377 if (state)
378 input_event(input, type, button->code, button->value);
379 } else {
380 input_event(input, type, *bdata->code, state);
381 }
382 }
383
gpio_keys_debounce_event(struct gpio_button_data * bdata)384 static void gpio_keys_debounce_event(struct gpio_button_data *bdata)
385 {
386 gpio_keys_gpio_report_event(bdata);
387 input_sync(bdata->input);
388
389 if (bdata->button->wakeup)
390 pm_relax(bdata->input->dev.parent);
391 }
392
gpio_keys_gpio_work_func(struct work_struct * work)393 static void gpio_keys_gpio_work_func(struct work_struct *work)
394 {
395 struct gpio_button_data *bdata =
396 container_of(work, struct gpio_button_data, work.work);
397
398 gpio_keys_debounce_event(bdata);
399 }
400
gpio_keys_debounce_timer(struct hrtimer * t)401 static enum hrtimer_restart gpio_keys_debounce_timer(struct hrtimer *t)
402 {
403 struct gpio_button_data *bdata =
404 container_of(t, struct gpio_button_data, debounce_timer);
405
406 gpio_keys_debounce_event(bdata);
407
408 return HRTIMER_NORESTART;
409 }
410
gpio_keys_gpio_isr(int irq,void * dev_id)411 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
412 {
413 struct gpio_button_data *bdata = dev_id;
414
415 BUG_ON(irq != bdata->irq);
416
417 if (bdata->button->wakeup) {
418 const struct gpio_keys_button *button = bdata->button;
419
420 pm_stay_awake(bdata->input->dev.parent);
421 if (bdata->suspended &&
422 (button->type == 0 || button->type == EV_KEY)) {
423 /*
424 * Simulate wakeup key press in case the key has
425 * already released by the time we got interrupt
426 * handler to run.
427 */
428 input_report_key(bdata->input, button->code, 1);
429 }
430 }
431
432 if (bdata->debounce_use_hrtimer) {
433 hrtimer_start(&bdata->debounce_timer,
434 ms_to_ktime(bdata->software_debounce),
435 HRTIMER_MODE_REL);
436 } else {
437 mod_delayed_work(system_wq,
438 &bdata->work,
439 msecs_to_jiffies(bdata->software_debounce));
440 }
441
442 return IRQ_HANDLED;
443 }
444
gpio_keys_irq_timer(struct hrtimer * t)445 static enum hrtimer_restart gpio_keys_irq_timer(struct hrtimer *t)
446 {
447 struct gpio_button_data *bdata = container_of(t,
448 struct gpio_button_data,
449 release_timer);
450 struct input_dev *input = bdata->input;
451
452 guard(spinlock_irqsave)(&bdata->lock);
453
454 if (bdata->key_pressed) {
455 input_report_key(input, *bdata->code, 0);
456 input_sync(input);
457 bdata->key_pressed = false;
458 }
459
460 return HRTIMER_NORESTART;
461 }
462
gpio_keys_irq_isr(int irq,void * dev_id)463 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
464 {
465 struct gpio_button_data *bdata = dev_id;
466 struct input_dev *input = bdata->input;
467
468 BUG_ON(irq != bdata->irq);
469
470 guard(spinlock_irqsave)(&bdata->lock);
471
472 if (!bdata->key_pressed) {
473 if (bdata->button->wakeup)
474 pm_wakeup_event(bdata->input->dev.parent, 0);
475
476 input_report_key(input, *bdata->code, 1);
477 input_sync(input);
478
479 if (!bdata->release_delay) {
480 input_report_key(input, *bdata->code, 0);
481 input_sync(input);
482 goto out;
483 }
484
485 bdata->key_pressed = true;
486 }
487
488 if (bdata->release_delay)
489 hrtimer_start(&bdata->release_timer,
490 ms_to_ktime(bdata->release_delay),
491 HRTIMER_MODE_REL);
492 out:
493 return IRQ_HANDLED;
494 }
495
gpio_keys_setup_key(struct platform_device * pdev,struct input_dev * input,struct gpio_keys_drvdata * ddata,const struct gpio_keys_button * button,int idx,struct fwnode_handle * child)496 static int gpio_keys_setup_key(struct platform_device *pdev,
497 struct input_dev *input,
498 struct gpio_keys_drvdata *ddata,
499 const struct gpio_keys_button *button,
500 int idx,
501 struct fwnode_handle *child)
502 {
503 const char *desc = button->desc ? button->desc : "gpio_keys";
504 struct device *dev = &pdev->dev;
505 struct gpio_button_data *bdata = &ddata->data[idx];
506 irq_handler_t isr;
507 unsigned long irqflags;
508 const char *wakedesc;
509 int irq;
510 int error;
511
512 bdata->input = input;
513 bdata->button = button;
514 spin_lock_init(&bdata->lock);
515
516 if (child) {
517 bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
518 NULL, GPIOD_IN, desc);
519 if (IS_ERR(bdata->gpiod)) {
520 error = PTR_ERR(bdata->gpiod);
521 if (error != -ENOENT)
522 return dev_err_probe(dev, error,
523 "failed to get gpio\n");
524
525 /*
526 * GPIO is optional, we may be dealing with
527 * purely interrupt-driven setup.
528 */
529 bdata->gpiod = NULL;
530 }
531 } else if (gpio_is_valid(button->gpio)) {
532 /*
533 * Legacy GPIO number, so request the GPIO here and
534 * convert it to descriptor.
535 */
536 unsigned flags = GPIOF_IN;
537
538 if (button->active_low)
539 flags |= GPIOF_ACTIVE_LOW;
540
541 error = devm_gpio_request_one(dev, button->gpio, flags, desc);
542 if (error < 0) {
543 dev_err(dev, "Failed to request GPIO %d, error %d\n",
544 button->gpio, error);
545 return error;
546 }
547
548 bdata->gpiod = gpio_to_desc(button->gpio);
549 if (!bdata->gpiod)
550 return -EINVAL;
551 }
552
553 if (bdata->gpiod) {
554 bool active_low = gpiod_is_active_low(bdata->gpiod);
555
556 if (button->debounce_interval) {
557 error = gpiod_set_debounce(bdata->gpiod,
558 button->debounce_interval * 1000);
559 /* use timer if gpiolib doesn't provide debounce */
560 if (error < 0)
561 bdata->software_debounce =
562 button->debounce_interval;
563
564 /*
565 * If reading the GPIO won't sleep, we can use a
566 * hrtimer instead of a standard timer for the software
567 * debounce, to reduce the latency as much as possible.
568 */
569 bdata->debounce_use_hrtimer =
570 !gpiod_cansleep(bdata->gpiod);
571 }
572
573 /*
574 * If an interrupt was specified, use it instead of the gpio
575 * interrupt and use the gpio for reading the state. A separate
576 * interrupt may be used as the main button interrupt for
577 * runtime PM to detect events also in deeper idle states. If a
578 * dedicated wakeirq is used for system suspend only, see below
579 * for bdata->wakeirq setup.
580 */
581 if (button->irq) {
582 bdata->irq = button->irq;
583 } else {
584 irq = gpiod_to_irq(bdata->gpiod);
585 if (irq < 0) {
586 error = irq;
587 dev_err_probe(dev, error,
588 "Unable to get irq number for GPIO %d\n",
589 button->gpio);
590 return error;
591 }
592 bdata->irq = irq;
593 }
594
595 INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
596
597 hrtimer_init(&bdata->debounce_timer,
598 CLOCK_REALTIME, HRTIMER_MODE_REL);
599 bdata->debounce_timer.function = gpio_keys_debounce_timer;
600
601 isr = gpio_keys_gpio_isr;
602 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
603
604 switch (button->wakeup_event_action) {
605 case EV_ACT_ASSERTED:
606 bdata->wakeup_trigger_type = active_low ?
607 IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
608 break;
609 case EV_ACT_DEASSERTED:
610 bdata->wakeup_trigger_type = active_low ?
611 IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING;
612 break;
613 case EV_ACT_ANY:
614 default:
615 /*
616 * For other cases, we are OK letting suspend/resume
617 * not reconfigure the trigger type.
618 */
619 break;
620 }
621 } else {
622 if (!button->irq) {
623 dev_err(dev, "Found button without gpio or irq\n");
624 return -EINVAL;
625 }
626
627 bdata->irq = button->irq;
628
629 if (button->type && button->type != EV_KEY) {
630 dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
631 return -EINVAL;
632 }
633
634 bdata->release_delay = button->debounce_interval;
635 hrtimer_init(&bdata->release_timer,
636 CLOCK_REALTIME, HRTIMER_MODE_REL);
637 bdata->release_timer.function = gpio_keys_irq_timer;
638
639 isr = gpio_keys_irq_isr;
640 irqflags = 0;
641
642 /*
643 * For IRQ buttons, there is no interrupt for release.
644 * So we don't need to reconfigure the trigger type for wakeup.
645 */
646 }
647
648 bdata->code = &ddata->keymap[idx];
649 *bdata->code = button->code;
650 input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
651
652 /*
653 * Install custom action to cancel release timer and
654 * workqueue item.
655 */
656 error = devm_add_action(dev, gpio_keys_quiesce_key, bdata);
657 if (error) {
658 dev_err(dev, "failed to register quiesce action, error: %d\n",
659 error);
660 return error;
661 }
662
663 /*
664 * If platform has specified that the button can be disabled,
665 * we don't want it to share the interrupt line.
666 */
667 if (!button->can_disable)
668 irqflags |= IRQF_SHARED;
669
670 error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags,
671 desc, bdata);
672 if (error < 0) {
673 dev_err(dev, "Unable to claim irq %d; error %d\n",
674 bdata->irq, error);
675 return error;
676 }
677
678 if (!button->wakeirq)
679 return 0;
680
681 /* Use :wakeup suffix like drivers/base/power/wakeirq.c does */
682 wakedesc = devm_kasprintf(dev, GFP_KERNEL, "%s:wakeup", desc);
683 if (!wakedesc)
684 return -ENOMEM;
685
686 bdata->wakeirq = button->wakeirq;
687 irqflags |= IRQF_NO_SUSPEND;
688
689 /*
690 * Wakeirq shares the handler with the main interrupt, it's only
691 * active during system suspend. See gpio_keys_button_enable_wakeup()
692 * and gpio_keys_button_disable_wakeup().
693 */
694 error = devm_request_any_context_irq(dev, bdata->wakeirq, isr,
695 irqflags, wakedesc, bdata);
696 if (error < 0) {
697 dev_err(dev, "Unable to claim wakeirq %d; error %d\n",
698 bdata->irq, error);
699 return error;
700 }
701
702 /*
703 * Disable wakeirq until suspend. IRQF_NO_AUTOEN won't work if
704 * IRQF_SHARED was set based on !button->can_disable.
705 */
706 disable_irq(bdata->wakeirq);
707
708 return 0;
709 }
710
gpio_keys_report_state(struct gpio_keys_drvdata * ddata)711 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
712 {
713 struct input_dev *input = ddata->input;
714 int i;
715
716 for (i = 0; i < ddata->pdata->nbuttons; i++) {
717 struct gpio_button_data *bdata = &ddata->data[i];
718 if (bdata->gpiod)
719 gpio_keys_gpio_report_event(bdata);
720 }
721 input_sync(input);
722 }
723
gpio_keys_open(struct input_dev * input)724 static int gpio_keys_open(struct input_dev *input)
725 {
726 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
727 const struct gpio_keys_platform_data *pdata = ddata->pdata;
728 int error;
729
730 if (pdata->enable) {
731 error = pdata->enable(input->dev.parent);
732 if (error)
733 return error;
734 }
735
736 /* Report current state of buttons that are connected to GPIOs */
737 gpio_keys_report_state(ddata);
738
739 return 0;
740 }
741
gpio_keys_close(struct input_dev * input)742 static void gpio_keys_close(struct input_dev *input)
743 {
744 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
745 const struct gpio_keys_platform_data *pdata = ddata->pdata;
746
747 if (pdata->disable)
748 pdata->disable(input->dev.parent);
749 }
750
751 /*
752 * Handlers for alternative sources of platform_data
753 */
754
755 /*
756 * Translate properties into platform_data
757 */
758 static struct gpio_keys_platform_data *
gpio_keys_get_devtree_pdata(struct device * dev)759 gpio_keys_get_devtree_pdata(struct device *dev)
760 {
761 struct gpio_keys_platform_data *pdata;
762 struct gpio_keys_button *button;
763 int nbuttons, irq;
764
765 nbuttons = device_get_child_node_count(dev);
766 if (nbuttons == 0)
767 return ERR_PTR(-ENODEV);
768
769 pdata = devm_kzalloc(dev,
770 sizeof(*pdata) + nbuttons * sizeof(*button),
771 GFP_KERNEL);
772 if (!pdata)
773 return ERR_PTR(-ENOMEM);
774
775 button = (struct gpio_keys_button *)(pdata + 1);
776
777 pdata->buttons = button;
778 pdata->nbuttons = nbuttons;
779
780 pdata->rep = device_property_read_bool(dev, "autorepeat");
781
782 device_property_read_string(dev, "label", &pdata->name);
783
784 device_for_each_child_node_scoped(dev, child) {
785 if (is_of_node(child)) {
786 irq = of_irq_get_byname(to_of_node(child), "irq");
787 if (irq > 0)
788 button->irq = irq;
789
790 irq = of_irq_get_byname(to_of_node(child), "wakeup");
791 if (irq > 0)
792 button->wakeirq = irq;
793
794 if (!button->irq && !button->wakeirq)
795 button->irq =
796 irq_of_parse_and_map(to_of_node(child), 0);
797 }
798
799 if (fwnode_property_read_u32(child, "linux,code",
800 &button->code)) {
801 dev_err(dev, "Button without keycode\n");
802 return ERR_PTR(-EINVAL);
803 }
804
805 fwnode_property_read_string(child, "label", &button->desc);
806
807 if (fwnode_property_read_u32(child, "linux,input-type",
808 &button->type))
809 button->type = EV_KEY;
810
811 fwnode_property_read_u32(child, "linux,input-value",
812 (u32 *)&button->value);
813
814 button->wakeup =
815 fwnode_property_read_bool(child, "wakeup-source") ||
816 /* legacy name */
817 fwnode_property_read_bool(child, "gpio-key,wakeup");
818
819 fwnode_property_read_u32(child, "wakeup-event-action",
820 &button->wakeup_event_action);
821
822 button->can_disable =
823 fwnode_property_read_bool(child, "linux,can-disable");
824
825 if (fwnode_property_read_u32(child, "debounce-interval",
826 &button->debounce_interval))
827 button->debounce_interval = 5;
828
829 button++;
830 }
831
832 return pdata;
833 }
834
835 static const struct of_device_id gpio_keys_of_match[] = {
836 { .compatible = "gpio-keys", },
837 { },
838 };
839 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
840
gpio_keys_probe(struct platform_device * pdev)841 static int gpio_keys_probe(struct platform_device *pdev)
842 {
843 struct device *dev = &pdev->dev;
844 const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
845 struct fwnode_handle *child = NULL;
846 struct gpio_keys_drvdata *ddata;
847 struct input_dev *input;
848 int i, error;
849 int wakeup = 0;
850
851 if (!pdata) {
852 pdata = gpio_keys_get_devtree_pdata(dev);
853 if (IS_ERR(pdata))
854 return PTR_ERR(pdata);
855 }
856
857 ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons),
858 GFP_KERNEL);
859 if (!ddata) {
860 dev_err(dev, "failed to allocate state\n");
861 return -ENOMEM;
862 }
863
864 ddata->keymap = devm_kcalloc(dev,
865 pdata->nbuttons, sizeof(ddata->keymap[0]),
866 GFP_KERNEL);
867 if (!ddata->keymap)
868 return -ENOMEM;
869
870 input = devm_input_allocate_device(dev);
871 if (!input) {
872 dev_err(dev, "failed to allocate input device\n");
873 return -ENOMEM;
874 }
875
876 ddata->pdata = pdata;
877 ddata->input = input;
878 mutex_init(&ddata->disable_lock);
879
880 platform_set_drvdata(pdev, ddata);
881 input_set_drvdata(input, ddata);
882
883 input->name = pdata->name ? : pdev->name;
884 input->phys = "gpio-keys/input0";
885 input->dev.parent = dev;
886 input->open = gpio_keys_open;
887 input->close = gpio_keys_close;
888
889 input->id.bustype = BUS_HOST;
890 input->id.vendor = 0x0001;
891 input->id.product = 0x0001;
892 input->id.version = 0x0100;
893
894 input->keycode = ddata->keymap;
895 input->keycodesize = sizeof(ddata->keymap[0]);
896 input->keycodemax = pdata->nbuttons;
897
898 /* Enable auto repeat feature of Linux input subsystem */
899 if (pdata->rep)
900 __set_bit(EV_REP, input->evbit);
901
902 for (i = 0; i < pdata->nbuttons; i++) {
903 const struct gpio_keys_button *button = &pdata->buttons[i];
904
905 if (!dev_get_platdata(dev)) {
906 child = device_get_next_child_node(dev, child);
907 if (!child) {
908 dev_err(dev,
909 "missing child device node for entry %d\n",
910 i);
911 return -EINVAL;
912 }
913 }
914
915 error = gpio_keys_setup_key(pdev, input, ddata,
916 button, i, child);
917 if (error) {
918 fwnode_handle_put(child);
919 return error;
920 }
921
922 if (button->wakeup)
923 wakeup = 1;
924 }
925
926 fwnode_handle_put(child);
927
928 error = input_register_device(input);
929 if (error) {
930 dev_err(dev, "Unable to register input device, error: %d\n",
931 error);
932 return error;
933 }
934
935 device_init_wakeup(dev, wakeup);
936
937 return 0;
938 }
939
940 static int __maybe_unused
gpio_keys_button_enable_wakeup(struct gpio_button_data * bdata)941 gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata)
942 {
943 int error;
944
945 error = enable_irq_wake(bdata->irq);
946 if (error) {
947 dev_err(bdata->input->dev.parent,
948 "failed to configure IRQ %d as wakeup source: %d\n",
949 bdata->irq, error);
950 return error;
951 }
952
953 if (bdata->wakeup_trigger_type) {
954 error = irq_set_irq_type(bdata->irq,
955 bdata->wakeup_trigger_type);
956 if (error) {
957 dev_err(bdata->input->dev.parent,
958 "failed to set wakeup trigger %08x for IRQ %d: %d\n",
959 bdata->wakeup_trigger_type, bdata->irq, error);
960 disable_irq_wake(bdata->irq);
961 return error;
962 }
963 }
964
965 if (bdata->wakeirq) {
966 enable_irq(bdata->wakeirq);
967 disable_irq(bdata->irq);
968 }
969
970 return 0;
971 }
972
973 static void __maybe_unused
gpio_keys_button_disable_wakeup(struct gpio_button_data * bdata)974 gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata)
975 {
976 int error;
977
978 if (bdata->wakeirq) {
979 enable_irq(bdata->irq);
980 disable_irq(bdata->wakeirq);
981 }
982
983 /*
984 * The trigger type is always both edges for gpio-based keys and we do
985 * not support changing wakeup trigger for interrupt-based keys.
986 */
987 if (bdata->wakeup_trigger_type) {
988 error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH);
989 if (error)
990 dev_warn(bdata->input->dev.parent,
991 "failed to restore interrupt trigger for IRQ %d: %d\n",
992 bdata->irq, error);
993 }
994
995 error = disable_irq_wake(bdata->irq);
996 if (error)
997 dev_warn(bdata->input->dev.parent,
998 "failed to disable IRQ %d as wake source: %d\n",
999 bdata->irq, error);
1000 }
1001
1002 static int __maybe_unused
gpio_keys_enable_wakeup(struct gpio_keys_drvdata * ddata)1003 gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata)
1004 {
1005 struct gpio_button_data *bdata;
1006 int error;
1007 int i;
1008
1009 for (i = 0; i < ddata->pdata->nbuttons; i++) {
1010 bdata = &ddata->data[i];
1011 if (bdata->button->wakeup) {
1012 error = gpio_keys_button_enable_wakeup(bdata);
1013 if (error)
1014 goto err_out;
1015 }
1016 bdata->suspended = true;
1017 }
1018
1019 return 0;
1020
1021 err_out:
1022 while (i--) {
1023 bdata = &ddata->data[i];
1024 if (bdata->button->wakeup)
1025 gpio_keys_button_disable_wakeup(bdata);
1026 bdata->suspended = false;
1027 }
1028
1029 return error;
1030 }
1031
1032 static void __maybe_unused
gpio_keys_disable_wakeup(struct gpio_keys_drvdata * ddata)1033 gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata)
1034 {
1035 struct gpio_button_data *bdata;
1036 int i;
1037
1038 for (i = 0; i < ddata->pdata->nbuttons; i++) {
1039 bdata = &ddata->data[i];
1040 bdata->suspended = false;
1041 if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq)))
1042 gpio_keys_button_disable_wakeup(bdata);
1043 }
1044 }
1045
gpio_keys_suspend(struct device * dev)1046 static int gpio_keys_suspend(struct device *dev)
1047 {
1048 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
1049 struct input_dev *input = ddata->input;
1050 int error;
1051
1052 if (device_may_wakeup(dev)) {
1053 error = gpio_keys_enable_wakeup(ddata);
1054 if (error)
1055 return error;
1056 } else {
1057 guard(mutex)(&input->mutex);
1058
1059 if (input_device_enabled(input))
1060 gpio_keys_close(input);
1061 }
1062
1063 return 0;
1064 }
1065
gpio_keys_resume(struct device * dev)1066 static int gpio_keys_resume(struct device *dev)
1067 {
1068 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
1069 struct input_dev *input = ddata->input;
1070 int error;
1071
1072 if (device_may_wakeup(dev)) {
1073 gpio_keys_disable_wakeup(ddata);
1074 } else {
1075 guard(mutex)(&input->mutex);
1076
1077 if (input_device_enabled(input)) {
1078 error = gpio_keys_open(input);
1079 if (error)
1080 return error;
1081 }
1082 }
1083
1084 gpio_keys_report_state(ddata);
1085 return 0;
1086 }
1087
1088 static DEFINE_SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
1089
gpio_keys_shutdown(struct platform_device * pdev)1090 static void gpio_keys_shutdown(struct platform_device *pdev)
1091 {
1092 int ret;
1093
1094 ret = gpio_keys_suspend(&pdev->dev);
1095 if (ret)
1096 dev_err(&pdev->dev, "failed to shutdown\n");
1097 }
1098
1099 static struct platform_driver gpio_keys_device_driver = {
1100 .probe = gpio_keys_probe,
1101 .shutdown = gpio_keys_shutdown,
1102 .driver = {
1103 .name = "gpio-keys",
1104 .pm = pm_sleep_ptr(&gpio_keys_pm_ops),
1105 .of_match_table = gpio_keys_of_match,
1106 .dev_groups = gpio_keys_groups,
1107 }
1108 };
1109
gpio_keys_init(void)1110 static int __init gpio_keys_init(void)
1111 {
1112 return platform_driver_register(&gpio_keys_device_driver);
1113 }
1114
gpio_keys_exit(void)1115 static void __exit gpio_keys_exit(void)
1116 {
1117 platform_driver_unregister(&gpio_keys_device_driver);
1118 }
1119
1120 late_initcall(gpio_keys_init);
1121 module_exit(gpio_keys_exit);
1122
1123 MODULE_LICENSE("GPL");
1124 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
1125 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
1126 MODULE_ALIAS("platform:gpio-keys");
1127