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