1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13
14#include <linux/init.h>
15#include <linux/fs.h>
16#include <linux/interrupt.h>
17#include <linux/irq.h>
18#include <linux/sched.h>
19#include <linux/pm.h>
20#include <linux/slab.h>
21#include <linux/sysctl.h>
22#include <linux/proc_fs.h>
23#include <linux/delay.h>
24#include <linux/platform_device.h>
25#include <linux/input.h>
26#include <linux/gpio_keys.h>
27#include <linux/workqueue.h>
28#include <linux/gpio.h>
29#include <linux/of_platform.h>
30#include <linux/of_gpio.h>
31#include <linux/spinlock.h>
32
33struct gpio_button_data {
34 const struct gpio_keys_button *button;
35 struct input_dev *input;
36 struct timer_list timer;
37 struct work_struct work;
38 unsigned int timer_debounce;
39 unsigned int irq;
40 spinlock_t lock;
41 bool disabled;
42 bool key_pressed;
43};
44
45struct gpio_keys_drvdata {
46 const struct gpio_keys_platform_data *pdata;
47 struct input_dev *input;
48 struct mutex disable_lock;
49 struct gpio_button_data data[0];
50};
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93static inline int get_n_events_by_type(int type)
94{
95 BUG_ON(type != EV_SW && type != EV_KEY);
96
97 return (type == EV_KEY) ? KEY_CNT : SW_CNT;
98}
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113static void gpio_keys_disable_button(struct gpio_button_data *bdata)
114{
115 if (!bdata->disabled) {
116
117
118
119 disable_irq(bdata->irq);
120 if (bdata->timer_debounce)
121 del_timer_sync(&bdata->timer);
122
123 bdata->disabled = true;
124 }
125}
126
127
128
129
130
131
132
133
134
135
136
137static void gpio_keys_enable_button(struct gpio_button_data *bdata)
138{
139 if (bdata->disabled) {
140 enable_irq(bdata->irq);
141 bdata->disabled = false;
142 }
143}
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
160 char *buf, unsigned int type,
161 bool only_disabled)
162{
163 int n_events = get_n_events_by_type(type);
164 unsigned long *bits;
165 ssize_t ret;
166 int i;
167
168 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
169 if (!bits)
170 return -ENOMEM;
171
172 for (i = 0; i < ddata->pdata->nbuttons; i++) {
173 struct gpio_button_data *bdata = &ddata->data[i];
174
175 if (bdata->button->type != type)
176 continue;
177
178 if (only_disabled && !bdata->disabled)
179 continue;
180
181 __set_bit(bdata->button->code, bits);
182 }
183
184 ret = bitmap_scnlistprintf(buf, PAGE_SIZE - 2, bits, n_events);
185 buf[ret++] = '\n';
186 buf[ret] = '\0';
187
188 kfree(bits);
189
190 return ret;
191}
192
193
194
195
196
197
198
199
200
201
202
203static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
204 const char *buf, unsigned int type)
205{
206 int n_events = get_n_events_by_type(type);
207 unsigned long *bits;
208 ssize_t error;
209 int i;
210
211 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
212 if (!bits)
213 return -ENOMEM;
214
215 error = bitmap_parselist(buf, bits, n_events);
216 if (error)
217 goto out;
218
219
220 for (i = 0; i < ddata->pdata->nbuttons; i++) {
221 struct gpio_button_data *bdata = &ddata->data[i];
222
223 if (bdata->button->type != type)
224 continue;
225
226 if (test_bit(bdata->button->code, bits) &&
227 !bdata->button->can_disable) {
228 error = -EINVAL;
229 goto out;
230 }
231 }
232
233 mutex_lock(&ddata->disable_lock);
234
235 for (i = 0; i < ddata->pdata->nbuttons; i++) {
236 struct gpio_button_data *bdata = &ddata->data[i];
237
238 if (bdata->button->type != type)
239 continue;
240
241 if (test_bit(bdata->button->code, bits))
242 gpio_keys_disable_button(bdata);
243 else
244 gpio_keys_enable_button(bdata);
245 }
246
247 mutex_unlock(&ddata->disable_lock);
248
249out:
250 kfree(bits);
251 return error;
252}
253
254#define ATTR_SHOW_FN(name, type, only_disabled) \
255static ssize_t gpio_keys_show_##name(struct device *dev, \
256 struct device_attribute *attr, \
257 char *buf) \
258{ \
259 struct platform_device *pdev = to_platform_device(dev); \
260 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
261 \
262 return gpio_keys_attr_show_helper(ddata, buf, \
263 type, only_disabled); \
264}
265
266ATTR_SHOW_FN(keys, EV_KEY, false);
267ATTR_SHOW_FN(switches, EV_SW, false);
268ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
269ATTR_SHOW_FN(disabled_switches, EV_SW, true);
270
271
272
273
274
275
276
277static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
278static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
279
280#define ATTR_STORE_FN(name, type) \
281static ssize_t gpio_keys_store_##name(struct device *dev, \
282 struct device_attribute *attr, \
283 const char *buf, \
284 size_t count) \
285{ \
286 struct platform_device *pdev = to_platform_device(dev); \
287 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
288 ssize_t error; \
289 \
290 error = gpio_keys_attr_store_helper(ddata, buf, type); \
291 if (error) \
292 return error; \
293 \
294 return count; \
295}
296
297ATTR_STORE_FN(disabled_keys, EV_KEY);
298ATTR_STORE_FN(disabled_switches, EV_SW);
299
300
301
302
303
304
305
306static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
307 gpio_keys_show_disabled_keys,
308 gpio_keys_store_disabled_keys);
309static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
310 gpio_keys_show_disabled_switches,
311 gpio_keys_store_disabled_switches);
312
313static struct attribute *gpio_keys_attrs[] = {
314 &dev_attr_keys.attr,
315 &dev_attr_switches.attr,
316 &dev_attr_disabled_keys.attr,
317 &dev_attr_disabled_switches.attr,
318 NULL,
319};
320
321static struct attribute_group gpio_keys_attr_group = {
322 .attrs = gpio_keys_attrs,
323};
324
325static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
326{
327 const struct gpio_keys_button *button = bdata->button;
328 struct input_dev *input = bdata->input;
329 unsigned int type = button->type ?: EV_KEY;
330 int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
331
332 if (type == EV_ABS) {
333 if (state)
334 input_event(input, type, button->code, button->value);
335 } else {
336 input_event(input, type, button->code, !!state);
337 }
338 input_sync(input);
339}
340
341static void gpio_keys_gpio_work_func(struct work_struct *work)
342{
343 struct gpio_button_data *bdata =
344 container_of(work, struct gpio_button_data, work);
345
346 gpio_keys_gpio_report_event(bdata);
347
348 if (bdata->button->wakeup)
349 pm_relax(bdata->input->dev.parent);
350}
351
352static void gpio_keys_gpio_timer(unsigned long _data)
353{
354 struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
355
356 schedule_work(&bdata->work);
357}
358
359static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
360{
361 struct gpio_button_data *bdata = dev_id;
362
363 BUG_ON(irq != bdata->irq);
364
365 if (bdata->button->wakeup)
366 pm_stay_awake(bdata->input->dev.parent);
367 if (bdata->timer_debounce)
368 mod_timer(&bdata->timer,
369 jiffies + msecs_to_jiffies(bdata->timer_debounce));
370 else
371 schedule_work(&bdata->work);
372
373 return IRQ_HANDLED;
374}
375
376static void gpio_keys_irq_timer(unsigned long _data)
377{
378 struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
379 struct input_dev *input = bdata->input;
380 unsigned long flags;
381
382 spin_lock_irqsave(&bdata->lock, flags);
383 if (bdata->key_pressed) {
384 input_event(input, EV_KEY, bdata->button->code, 0);
385 input_sync(input);
386 bdata->key_pressed = false;
387 }
388 spin_unlock_irqrestore(&bdata->lock, flags);
389}
390
391static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
392{
393 struct gpio_button_data *bdata = dev_id;
394 const struct gpio_keys_button *button = bdata->button;
395 struct input_dev *input = bdata->input;
396 unsigned long flags;
397
398 BUG_ON(irq != bdata->irq);
399
400 spin_lock_irqsave(&bdata->lock, flags);
401
402 if (!bdata->key_pressed) {
403 if (bdata->button->wakeup)
404 pm_wakeup_event(bdata->input->dev.parent, 0);
405
406 input_event(input, EV_KEY, button->code, 1);
407 input_sync(input);
408
409 if (!bdata->timer_debounce) {
410 input_event(input, EV_KEY, button->code, 0);
411 input_sync(input);
412 goto out;
413 }
414
415 bdata->key_pressed = true;
416 }
417
418 if (bdata->timer_debounce)
419 mod_timer(&bdata->timer,
420 jiffies + msecs_to_jiffies(bdata->timer_debounce));
421out:
422 spin_unlock_irqrestore(&bdata->lock, flags);
423 return IRQ_HANDLED;
424}
425
426static int gpio_keys_setup_key(struct platform_device *pdev,
427 struct input_dev *input,
428 struct gpio_button_data *bdata,
429 const struct gpio_keys_button *button)
430{
431 const char *desc = button->desc ? button->desc : "gpio_keys";
432 struct device *dev = &pdev->dev;
433 irq_handler_t isr;
434 unsigned long irqflags;
435 int irq, error;
436
437 bdata->input = input;
438 bdata->button = button;
439 spin_lock_init(&bdata->lock);
440
441 if (gpio_is_valid(button->gpio)) {
442
443 error = gpio_request_one(button->gpio, GPIOF_IN, desc);
444 if (error < 0) {
445 dev_err(dev, "Failed to request GPIO %d, error %d\n",
446 button->gpio, error);
447 return error;
448 }
449
450 if (button->debounce_interval) {
451 error = gpio_set_debounce(button->gpio,
452 button->debounce_interval * 1000);
453
454 if (error < 0)
455 bdata->timer_debounce =
456 button->debounce_interval;
457 }
458
459 irq = gpio_to_irq(button->gpio);
460 if (irq < 0) {
461 error = irq;
462 dev_err(dev,
463 "Unable to get irq number for GPIO %d, error %d\n",
464 button->gpio, error);
465 goto fail;
466 }
467 bdata->irq = irq;
468
469 INIT_WORK(&bdata->work, gpio_keys_gpio_work_func);
470 setup_timer(&bdata->timer,
471 gpio_keys_gpio_timer, (unsigned long)bdata);
472
473 isr = gpio_keys_gpio_isr;
474 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
475
476 } else {
477 if (!button->irq) {
478 dev_err(dev, "No IRQ specified\n");
479 return -EINVAL;
480 }
481 bdata->irq = button->irq;
482
483 if (button->type && button->type != EV_KEY) {
484 dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
485 return -EINVAL;
486 }
487
488 bdata->timer_debounce = button->debounce_interval;
489 setup_timer(&bdata->timer,
490 gpio_keys_irq_timer, (unsigned long)bdata);
491
492 isr = gpio_keys_irq_isr;
493 irqflags = 0;
494 }
495
496 input_set_capability(input, button->type ?: EV_KEY, button->code);
497
498
499
500
501
502 if (!button->can_disable)
503 irqflags |= IRQF_SHARED;
504
505 error = request_any_context_irq(bdata->irq, isr, irqflags, desc, bdata);
506 if (error < 0) {
507 dev_err(dev, "Unable to claim irq %d; error %d\n",
508 bdata->irq, error);
509 goto fail;
510 }
511
512 return 0;
513
514fail:
515 if (gpio_is_valid(button->gpio))
516 gpio_free(button->gpio);
517
518 return error;
519}
520
521static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
522{
523 struct input_dev *input = ddata->input;
524 int i;
525
526 for (i = 0; i < ddata->pdata->nbuttons; i++) {
527 struct gpio_button_data *bdata = &ddata->data[i];
528 if (gpio_is_valid(bdata->button->gpio))
529 gpio_keys_gpio_report_event(bdata);
530 }
531 input_sync(input);
532}
533
534static int gpio_keys_open(struct input_dev *input)
535{
536 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
537 const struct gpio_keys_platform_data *pdata = ddata->pdata;
538 int error;
539
540 if (pdata->enable) {
541 error = pdata->enable(input->dev.parent);
542 if (error)
543 return error;
544 }
545
546
547 gpio_keys_report_state(ddata);
548
549 return 0;
550}
551
552static void gpio_keys_close(struct input_dev *input)
553{
554 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
555 const struct gpio_keys_platform_data *pdata = ddata->pdata;
556
557 if (pdata->disable)
558 pdata->disable(input->dev.parent);
559}
560
561
562
563
564
565#ifdef CONFIG_OF
566
567
568
569static struct gpio_keys_platform_data *
570gpio_keys_get_devtree_pdata(struct device *dev)
571{
572 struct device_node *node, *pp;
573 struct gpio_keys_platform_data *pdata;
574 struct gpio_keys_button *button;
575 int error;
576 int nbuttons;
577 int i;
578
579 node = dev->of_node;
580 if (!node) {
581 error = -ENODEV;
582 goto err_out;
583 }
584
585 nbuttons = of_get_child_count(node);
586 if (nbuttons == 0) {
587 error = -ENODEV;
588 goto err_out;
589 }
590
591 pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button),
592 GFP_KERNEL);
593 if (!pdata) {
594 error = -ENOMEM;
595 goto err_out;
596 }
597
598 pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
599 pdata->nbuttons = nbuttons;
600
601 pdata->rep = !!of_get_property(node, "autorepeat", NULL);
602
603 i = 0;
604 for_each_child_of_node(node, pp) {
605 int gpio;
606 enum of_gpio_flags flags;
607
608 if (!of_find_property(pp, "gpios", NULL)) {
609 pdata->nbuttons--;
610 dev_warn(dev, "Found button without gpios\n");
611 continue;
612 }
613
614 gpio = of_get_gpio_flags(pp, 0, &flags);
615 if (gpio < 0) {
616 error = gpio;
617 if (error != -EPROBE_DEFER)
618 dev_err(dev,
619 "Failed to get gpio flags, error: %d\n",
620 error);
621 goto err_free_pdata;
622 }
623
624 button = &pdata->buttons[i++];
625
626 button->gpio = gpio;
627 button->active_low = flags & OF_GPIO_ACTIVE_LOW;
628
629 if (of_property_read_u32(pp, "linux,code", &button->code)) {
630 dev_err(dev, "Button without keycode: 0x%x\n",
631 button->gpio);
632 error = -EINVAL;
633 goto err_free_pdata;
634 }
635
636 button->desc = of_get_property(pp, "label", NULL);
637
638 if (of_property_read_u32(pp, "linux,input-type", &button->type))
639 button->type = EV_KEY;
640
641 button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
642
643 if (of_property_read_u32(pp, "debounce-interval",
644 &button->debounce_interval))
645 button->debounce_interval = 5;
646 }
647
648 if (pdata->nbuttons == 0) {
649 error = -EINVAL;
650 goto err_free_pdata;
651 }
652
653 return pdata;
654
655err_free_pdata:
656 kfree(pdata);
657err_out:
658 return ERR_PTR(error);
659}
660
661static struct of_device_id gpio_keys_of_match[] = {
662 { .compatible = "gpio-keys", },
663 { },
664};
665MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
666
667#else
668
669static inline struct gpio_keys_platform_data *
670gpio_keys_get_devtree_pdata(struct device *dev)
671{
672 return ERR_PTR(-ENODEV);
673}
674
675#endif
676
677static void gpio_remove_key(struct gpio_button_data *bdata)
678{
679 free_irq(bdata->irq, bdata);
680 if (bdata->timer_debounce)
681 del_timer_sync(&bdata->timer);
682 cancel_work_sync(&bdata->work);
683 if (gpio_is_valid(bdata->button->gpio))
684 gpio_free(bdata->button->gpio);
685}
686
687static int gpio_keys_probe(struct platform_device *pdev)
688{
689 struct device *dev = &pdev->dev;
690 const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
691 struct gpio_keys_drvdata *ddata;
692 struct input_dev *input;
693 int i, error;
694 int wakeup = 0;
695
696 if (!pdata) {
697 pdata = gpio_keys_get_devtree_pdata(dev);
698 if (IS_ERR(pdata))
699 return PTR_ERR(pdata);
700 }
701
702 ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
703 pdata->nbuttons * sizeof(struct gpio_button_data),
704 GFP_KERNEL);
705 input = input_allocate_device();
706 if (!ddata || !input) {
707 dev_err(dev, "failed to allocate state\n");
708 error = -ENOMEM;
709 goto fail1;
710 }
711
712 ddata->pdata = pdata;
713 ddata->input = input;
714 mutex_init(&ddata->disable_lock);
715
716 platform_set_drvdata(pdev, ddata);
717 input_set_drvdata(input, ddata);
718
719 input->name = pdata->name ? : pdev->name;
720 input->phys = "gpio-keys/input0";
721 input->dev.parent = &pdev->dev;
722 input->open = gpio_keys_open;
723 input->close = gpio_keys_close;
724
725 input->id.bustype = BUS_HOST;
726 input->id.vendor = 0x0001;
727 input->id.product = 0x0001;
728 input->id.version = 0x0100;
729
730
731 if (pdata->rep)
732 __set_bit(EV_REP, input->evbit);
733
734 for (i = 0; i < pdata->nbuttons; i++) {
735 const struct gpio_keys_button *button = &pdata->buttons[i];
736 struct gpio_button_data *bdata = &ddata->data[i];
737
738 error = gpio_keys_setup_key(pdev, input, bdata, button);
739 if (error)
740 goto fail2;
741
742 if (button->wakeup)
743 wakeup = 1;
744 }
745
746 error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
747 if (error) {
748 dev_err(dev, "Unable to export keys/switches, error: %d\n",
749 error);
750 goto fail2;
751 }
752
753 error = input_register_device(input);
754 if (error) {
755 dev_err(dev, "Unable to register input device, error: %d\n",
756 error);
757 goto fail3;
758 }
759
760 device_init_wakeup(&pdev->dev, wakeup);
761
762 return 0;
763
764 fail3:
765 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
766 fail2:
767 while (--i >= 0)
768 gpio_remove_key(&ddata->data[i]);
769
770 fail1:
771 input_free_device(input);
772 kfree(ddata);
773
774 if (!dev_get_platdata(&pdev->dev))
775 kfree(pdata);
776
777 return error;
778}
779
780static int gpio_keys_remove(struct platform_device *pdev)
781{
782 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
783 struct input_dev *input = ddata->input;
784 int i;
785
786 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
787
788 device_init_wakeup(&pdev->dev, 0);
789
790 for (i = 0; i < ddata->pdata->nbuttons; i++)
791 gpio_remove_key(&ddata->data[i]);
792
793 input_unregister_device(input);
794
795
796 if (!dev_get_platdata(&pdev->dev))
797 kfree(ddata->pdata);
798
799 kfree(ddata);
800
801 return 0;
802}
803
804#ifdef CONFIG_PM_SLEEP
805static int gpio_keys_suspend(struct device *dev)
806{
807 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
808 struct input_dev *input = ddata->input;
809 int i;
810
811 if (device_may_wakeup(dev)) {
812 for (i = 0; i < ddata->pdata->nbuttons; i++) {
813 struct gpio_button_data *bdata = &ddata->data[i];
814 if (bdata->button->wakeup)
815 enable_irq_wake(bdata->irq);
816 }
817 } else {
818 mutex_lock(&input->mutex);
819 if (input->users)
820 gpio_keys_close(input);
821 mutex_unlock(&input->mutex);
822 }
823
824 return 0;
825}
826
827static int gpio_keys_resume(struct device *dev)
828{
829 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
830 struct input_dev *input = ddata->input;
831 int error = 0;
832 int i;
833
834 if (device_may_wakeup(dev)) {
835 for (i = 0; i < ddata->pdata->nbuttons; i++) {
836 struct gpio_button_data *bdata = &ddata->data[i];
837 if (bdata->button->wakeup)
838 disable_irq_wake(bdata->irq);
839 }
840 } else {
841 mutex_lock(&input->mutex);
842 if (input->users)
843 error = gpio_keys_open(input);
844 mutex_unlock(&input->mutex);
845 }
846
847 if (error)
848 return error;
849
850 gpio_keys_report_state(ddata);
851 return 0;
852}
853#endif
854
855static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
856
857static struct platform_driver gpio_keys_device_driver = {
858 .probe = gpio_keys_probe,
859 .remove = gpio_keys_remove,
860 .driver = {
861 .name = "gpio-keys",
862 .owner = THIS_MODULE,
863 .pm = &gpio_keys_pm_ops,
864 .of_match_table = of_match_ptr(gpio_keys_of_match),
865 }
866};
867
868static int __init gpio_keys_init(void)
869{
870 return platform_driver_register(&gpio_keys_device_driver);
871}
872
873static void __exit gpio_keys_exit(void)
874{
875 platform_driver_unregister(&gpio_keys_device_driver);
876}
877
878late_initcall(gpio_keys_init);
879module_exit(gpio_keys_exit);
880
881MODULE_LICENSE("GPL");
882MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
883MODULE_DESCRIPTION("Keyboard driver for GPIOs");
884MODULE_ALIAS("platform:gpio-keys");
885