2 * Driver for keys on GPIO lines capable of generating interrupts.
4 * Copyright 2005 Phil Blundell
5 * Copyright 2010, 2011 David Jander <david@protonic.nl>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/module.h>
14 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/irq.h>
18 #include <linux/sched.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>
30 #include <linux/of_platform.h>
31 #include <linux/of_gpio.h>
32 #include <linux/of_irq.h>
33 #include <linux/spinlock.h>
35 struct gpio_button_data {
36 const struct gpio_keys_button *button;
37 struct input_dev *input;
39 struct timer_list release_timer;
40 unsigned int release_delay; /* in msecs, for IRQ-only buttons */
42 struct delayed_work work;
43 unsigned int software_debounce; /* in msecs, for GPIO-driven buttons */
51 struct gpio_keys_drvdata {
52 const struct gpio_keys_platform_data *pdata;
53 struct input_dev *input;
54 struct mutex disable_lock;
55 struct gpio_button_data data[0];
59 * SYSFS interface for enabling/disabling keys and switches:
61 * There are 4 attributes under /sys/devices/platform/gpio-keys/
62 * keys [ro] - bitmap of keys (EV_KEY) which can be
64 * switches [ro] - bitmap of switches (EV_SW) which can be
66 * disabled_keys [rw] - bitmap of keys currently disabled
67 * disabled_switches [rw] - bitmap of switches currently disabled
69 * Userland can change these values and hence disable event generation
70 * for each key (or switch). Disabling a key means its interrupt line
73 * For example, if we have following switches set up as gpio-keys:
75 * SW_CAMERA_LENS_COVER = 9
76 * SW_KEYPAD_SLIDE = 10
77 * SW_FRONT_PROXIMITY = 11
78 * This is read from switches:
80 * Next we want to disable proximity (11) and dock (5), we write:
82 * to file disabled_switches. Now proximity and dock IRQs are disabled.
83 * This can be verified by reading the file disabled_switches:
85 * If we now want to enable proximity (11) switch we write:
87 * to disabled_switches.
89 * We can disable only those keys which don't allow sharing the irq.
93 * get_n_events_by_type() - returns maximum number of events per @type
94 * @type: type of button (%EV_KEY, %EV_SW)
96 * Return value of this function can be used to allocate bitmap
97 * large enough to hold all bits for given type.
99 static int get_n_events_by_type(int type)
101 BUG_ON(type != EV_SW && type != EV_KEY);
103 return (type == EV_KEY) ? KEY_CNT : SW_CNT;
107 * get_bm_events_by_type() - returns bitmap of supported events per @type
108 * @input: input device from which bitmap is retrieved
109 * @type: type of button (%EV_KEY, %EV_SW)
111 * Return value of this function can be used to allocate bitmap
112 * large enough to hold all bits for given type.
114 static const unsigned long *get_bm_events_by_type(struct input_dev *dev,
117 BUG_ON(type != EV_SW && type != EV_KEY);
119 return (type == EV_KEY) ? dev->keybit : dev->swbit;
123 * gpio_keys_disable_button() - disables given GPIO button
124 * @bdata: button data for button to be disabled
126 * Disables button pointed by @bdata. This is done by masking
127 * IRQ line. After this function is called, button won't generate
128 * input events anymore. Note that one can only disable buttons
129 * that don't share IRQs.
131 * Make sure that @bdata->disable_lock is locked when entering
132 * this function to avoid races when concurrent threads are
133 * disabling buttons at the same time.
135 static void gpio_keys_disable_button(struct gpio_button_data *bdata)
137 if (!bdata->disabled) {
139 * Disable IRQ and associated timer/work structure.
141 disable_irq(bdata->irq);
143 if (gpio_is_valid(bdata->button->gpio))
144 cancel_delayed_work_sync(&bdata->work);
146 del_timer_sync(&bdata->release_timer);
148 bdata->disabled = true;
153 * gpio_keys_enable_button() - enables given GPIO button
154 * @bdata: button data for button to be disabled
156 * Enables given button pointed by @bdata.
158 * Make sure that @bdata->disable_lock is locked when entering
159 * this function to avoid races with concurrent threads trying
160 * to enable the same button at the same time.
162 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
164 if (bdata->disabled) {
165 enable_irq(bdata->irq);
166 bdata->disabled = false;
171 * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
172 * @ddata: pointer to drvdata
173 * @buf: buffer where stringified bitmap is written
174 * @type: button type (%EV_KEY, %EV_SW)
175 * @only_disabled: does caller want only those buttons that are
176 * currently disabled or all buttons that can be
179 * This function writes buttons that can be disabled to @buf. If
180 * @only_disabled is true, then @buf contains only those buttons
181 * that are currently disabled. Returns 0 on success or negative
184 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
185 char *buf, unsigned int type,
188 int n_events = get_n_events_by_type(type);
193 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
197 for (i = 0; i < ddata->pdata->nbuttons; i++) {
198 struct gpio_button_data *bdata = &ddata->data[i];
200 if (bdata->button->type != type)
203 if (only_disabled && !bdata->disabled)
206 __set_bit(bdata->button->code, bits);
209 ret = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", n_events, bits);
219 * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
220 * @ddata: pointer to drvdata
221 * @buf: buffer from userspace that contains stringified bitmap
222 * @type: button type (%EV_KEY, %EV_SW)
224 * This function parses stringified bitmap from @buf and disables/enables
225 * GPIO buttons accordingly. Returns 0 on success and negative error
228 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
229 const char *buf, unsigned int type)
231 int n_events = get_n_events_by_type(type);
232 const unsigned long *bitmap = get_bm_events_by_type(ddata->input, type);
237 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
241 error = bitmap_parselist(buf, bits, n_events);
246 if (!bitmap_subset(bits, bitmap, n_events)) {
251 for (i = 0; i < ddata->pdata->nbuttons; i++) {
252 struct gpio_button_data *bdata = &ddata->data[i];
254 if (bdata->button->type != type)
257 if (test_bit(bdata->button->code, bits) &&
258 !bdata->button->can_disable) {
264 mutex_lock(&ddata->disable_lock);
266 for (i = 0; i < ddata->pdata->nbuttons; i++) {
267 struct gpio_button_data *bdata = &ddata->data[i];
269 if (bdata->button->type != type)
272 if (test_bit(bdata->button->code, bits))
273 gpio_keys_disable_button(bdata);
275 gpio_keys_enable_button(bdata);
278 mutex_unlock(&ddata->disable_lock);
285 #define ATTR_SHOW_FN(name, type, only_disabled) \
286 static ssize_t gpio_keys_show_##name(struct device *dev, \
287 struct device_attribute *attr, \
290 struct platform_device *pdev = to_platform_device(dev); \
291 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
293 return gpio_keys_attr_show_helper(ddata, buf, \
294 type, only_disabled); \
297 ATTR_SHOW_FN(keys, EV_KEY, false);
298 ATTR_SHOW_FN(switches, EV_SW, false);
299 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
300 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
305 * /sys/devices/platform/gpio-keys/keys [ro]
306 * /sys/devices/platform/gpio-keys/switches [ro]
308 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
309 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
311 #define ATTR_STORE_FN(name, type) \
312 static ssize_t gpio_keys_store_##name(struct device *dev, \
313 struct device_attribute *attr, \
317 struct platform_device *pdev = to_platform_device(dev); \
318 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
321 error = gpio_keys_attr_store_helper(ddata, buf, type); \
328 ATTR_STORE_FN(disabled_keys, EV_KEY);
329 ATTR_STORE_FN(disabled_switches, EV_SW);
334 * /sys/devices/platform/gpio-keys/disabled_keys [rw]
335 * /sys/devices/platform/gpio-keys/disables_switches [rw]
337 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
338 gpio_keys_show_disabled_keys,
339 gpio_keys_store_disabled_keys);
340 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
341 gpio_keys_show_disabled_switches,
342 gpio_keys_store_disabled_switches);
344 static struct attribute *gpio_keys_attrs[] = {
346 &dev_attr_switches.attr,
347 &dev_attr_disabled_keys.attr,
348 &dev_attr_disabled_switches.attr,
352 static struct attribute_group gpio_keys_attr_group = {
353 .attrs = gpio_keys_attrs,
356 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
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 = gpio_get_value_cansleep(button->gpio);
364 dev_err(input->dev.parent, "failed to get gpio state\n");
368 state = (state ? 1 : 0) ^ button->active_low;
369 if (type == EV_ABS) {
371 input_event(input, type, button->code, button->value);
373 input_event(input, type, button->code, !!state);
378 static void gpio_keys_gpio_work_func(struct work_struct *work)
380 struct gpio_button_data *bdata =
381 container_of(work, struct gpio_button_data, work.work);
383 gpio_keys_gpio_report_event(bdata);
385 if (bdata->button->wakeup)
386 pm_relax(bdata->input->dev.parent);
389 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
391 struct gpio_button_data *bdata = dev_id;
393 BUG_ON(irq != bdata->irq);
395 if (bdata->button->wakeup)
396 pm_stay_awake(bdata->input->dev.parent);
398 mod_delayed_work(system_wq,
400 msecs_to_jiffies(bdata->software_debounce));
405 static void gpio_keys_irq_timer(unsigned long _data)
407 struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
408 struct input_dev *input = bdata->input;
411 spin_lock_irqsave(&bdata->lock, flags);
412 if (bdata->key_pressed) {
413 input_event(input, EV_KEY, bdata->button->code, 0);
415 bdata->key_pressed = false;
417 spin_unlock_irqrestore(&bdata->lock, flags);
420 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
422 struct gpio_button_data *bdata = dev_id;
423 const struct gpio_keys_button *button = bdata->button;
424 struct input_dev *input = bdata->input;
427 BUG_ON(irq != bdata->irq);
429 spin_lock_irqsave(&bdata->lock, flags);
431 if (!bdata->key_pressed) {
432 if (bdata->button->wakeup)
433 pm_wakeup_event(bdata->input->dev.parent, 0);
435 input_event(input, EV_KEY, button->code, 1);
438 if (!bdata->release_delay) {
439 input_event(input, EV_KEY, button->code, 0);
444 bdata->key_pressed = true;
447 if (bdata->release_delay)
448 mod_timer(&bdata->release_timer,
449 jiffies + msecs_to_jiffies(bdata->release_delay));
451 spin_unlock_irqrestore(&bdata->lock, flags);
455 static void gpio_keys_quiesce_key(void *data)
457 struct gpio_button_data *bdata = data;
459 if (gpio_is_valid(bdata->button->gpio))
460 cancel_delayed_work_sync(&bdata->work);
462 del_timer_sync(&bdata->release_timer);
465 static int gpio_keys_setup_key(struct platform_device *pdev,
466 struct input_dev *input,
467 struct gpio_button_data *bdata,
468 const struct gpio_keys_button *button)
470 const char *desc = button->desc ? button->desc : "gpio_keys";
471 struct device *dev = &pdev->dev;
473 unsigned long irqflags;
477 bdata->input = input;
478 bdata->button = button;
479 spin_lock_init(&bdata->lock);
481 if (gpio_is_valid(button->gpio)) {
483 error = devm_gpio_request_one(&pdev->dev, button->gpio,
486 dev_err(dev, "Failed to request GPIO %d, error %d\n",
487 button->gpio, error);
491 if (button->debounce_interval) {
492 error = gpio_set_debounce(button->gpio,
493 button->debounce_interval * 1000);
494 /* use timer if gpiolib doesn't provide debounce */
496 bdata->software_debounce =
497 button->debounce_interval;
501 bdata->irq = button->irq;
503 irq = gpio_to_irq(button->gpio);
507 "Unable to get irq number for GPIO %d, error %d\n",
508 button->gpio, error);
514 INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
516 isr = gpio_keys_gpio_isr;
517 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
521 dev_err(dev, "No IRQ specified\n");
524 bdata->irq = button->irq;
526 if (button->type && button->type != EV_KEY) {
527 dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
531 bdata->release_delay = button->debounce_interval;
532 setup_timer(&bdata->release_timer,
533 gpio_keys_irq_timer, (unsigned long)bdata);
535 isr = gpio_keys_irq_isr;
539 input_set_capability(input, button->type ?: EV_KEY, button->code);
542 * Install custom action to cancel release timer and
545 error = devm_add_action(&pdev->dev, gpio_keys_quiesce_key, bdata);
548 "failed to register quiesce action, error: %d\n",
554 * If platform has specified that the button can be disabled,
555 * we don't want it to share the interrupt line.
557 if (!button->can_disable)
558 irqflags |= IRQF_SHARED;
560 error = devm_request_any_context_irq(&pdev->dev, bdata->irq,
561 isr, irqflags, desc, bdata);
563 dev_err(dev, "Unable to claim irq %d; error %d\n",
571 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
573 struct input_dev *input = ddata->input;
576 for (i = 0; i < ddata->pdata->nbuttons; i++) {
577 struct gpio_button_data *bdata = &ddata->data[i];
578 if (gpio_is_valid(bdata->button->gpio))
579 gpio_keys_gpio_report_event(bdata);
584 static int gpio_keys_open(struct input_dev *input)
586 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
587 const struct gpio_keys_platform_data *pdata = ddata->pdata;
591 error = pdata->enable(input->dev.parent);
596 /* Report current state of buttons that are connected to GPIOs */
597 gpio_keys_report_state(ddata);
602 static void gpio_keys_close(struct input_dev *input)
604 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
605 const struct gpio_keys_platform_data *pdata = ddata->pdata;
608 pdata->disable(input->dev.parent);
612 * Handlers for alternative sources of platform_data
617 * Translate OpenFirmware node properties into platform_data
619 static struct gpio_keys_platform_data *
620 gpio_keys_get_devtree_pdata(struct device *dev)
622 struct device_node *node, *pp;
623 struct gpio_keys_platform_data *pdata;
624 struct gpio_keys_button *button;
631 return ERR_PTR(-ENODEV);
633 nbuttons = of_get_child_count(node);
635 return ERR_PTR(-ENODEV);
637 pdata = devm_kzalloc(dev,
638 sizeof(*pdata) + nbuttons * sizeof(*button),
641 return ERR_PTR(-ENOMEM);
643 pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
644 pdata->nbuttons = nbuttons;
646 pdata->rep = !!of_get_property(node, "autorepeat", NULL);
649 for_each_child_of_node(node, pp) {
650 enum of_gpio_flags flags;
652 button = &pdata->buttons[i++];
654 button->gpio = of_get_gpio_flags(pp, 0, &flags);
655 if (button->gpio < 0) {
656 error = button->gpio;
657 if (error != -ENOENT) {
658 if (error != -EPROBE_DEFER)
660 "Failed to get gpio flags, error: %d\n",
662 return ERR_PTR(error);
665 button->active_low = flags & OF_GPIO_ACTIVE_LOW;
668 button->irq = irq_of_parse_and_map(pp, 0);
670 if (!gpio_is_valid(button->gpio) && !button->irq) {
671 dev_err(dev, "Found button without gpios or irqs\n");
672 return ERR_PTR(-EINVAL);
675 if (of_property_read_u32(pp, "linux,code", &button->code)) {
676 dev_err(dev, "Button without keycode: 0x%x\n",
678 return ERR_PTR(-EINVAL);
681 button->desc = of_get_property(pp, "label", NULL);
683 if (of_property_read_u32(pp, "linux,input-type", &button->type))
684 button->type = EV_KEY;
686 button->wakeup = of_property_read_bool(pp, "wakeup-source") ||
688 of_property_read_bool(pp, "gpio-key,wakeup");
690 button->can_disable = !!of_get_property(pp, "linux,can-disable", NULL);
692 if (of_property_read_u32(pp, "debounce-interval",
693 &button->debounce_interval))
694 button->debounce_interval = 5;
697 if (pdata->nbuttons == 0)
698 return ERR_PTR(-EINVAL);
703 static const struct of_device_id gpio_keys_of_match[] = {
704 { .compatible = "gpio-keys", },
707 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
711 static inline struct gpio_keys_platform_data *
712 gpio_keys_get_devtree_pdata(struct device *dev)
714 return ERR_PTR(-ENODEV);
719 static int gpio_keys_probe(struct platform_device *pdev)
721 struct device *dev = &pdev->dev;
722 const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
723 struct gpio_keys_drvdata *ddata;
724 struct input_dev *input;
730 pdata = gpio_keys_get_devtree_pdata(dev);
732 return PTR_ERR(pdata);
735 size = sizeof(struct gpio_keys_drvdata) +
736 pdata->nbuttons * sizeof(struct gpio_button_data);
737 ddata = devm_kzalloc(dev, size, GFP_KERNEL);
739 dev_err(dev, "failed to allocate state\n");
743 input = devm_input_allocate_device(dev);
745 dev_err(dev, "failed to allocate input device\n");
749 ddata->pdata = pdata;
750 ddata->input = input;
751 mutex_init(&ddata->disable_lock);
753 platform_set_drvdata(pdev, ddata);
754 input_set_drvdata(input, ddata);
756 input->name = pdata->name ? : pdev->name;
757 input->phys = "gpio-keys/input0";
758 input->dev.parent = &pdev->dev;
759 input->open = gpio_keys_open;
760 input->close = gpio_keys_close;
762 input->id.bustype = BUS_HOST;
763 input->id.vendor = 0x0001;
764 input->id.product = 0x0001;
765 input->id.version = 0x0100;
767 /* Enable auto repeat feature of Linux input subsystem */
769 __set_bit(EV_REP, input->evbit);
771 for (i = 0; i < pdata->nbuttons; i++) {
772 const struct gpio_keys_button *button = &pdata->buttons[i];
773 struct gpio_button_data *bdata = &ddata->data[i];
775 error = gpio_keys_setup_key(pdev, input, bdata, button);
783 error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
785 dev_err(dev, "Unable to export keys/switches, error: %d\n",
790 error = input_register_device(input);
792 dev_err(dev, "Unable to register input device, error: %d\n",
794 goto err_remove_group;
797 device_init_wakeup(&pdev->dev, wakeup);
802 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
806 static int gpio_keys_remove(struct platform_device *pdev)
808 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
810 device_init_wakeup(&pdev->dev, 0);
815 #ifdef CONFIG_PM_SLEEP
816 static int gpio_keys_suspend(struct device *dev)
818 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
819 struct input_dev *input = ddata->input;
822 if (device_may_wakeup(dev)) {
823 for (i = 0; i < ddata->pdata->nbuttons; i++) {
824 struct gpio_button_data *bdata = &ddata->data[i];
825 if (bdata->button->wakeup)
826 enable_irq_wake(bdata->irq);
829 mutex_lock(&input->mutex);
831 gpio_keys_close(input);
832 mutex_unlock(&input->mutex);
838 static int gpio_keys_resume(struct device *dev)
840 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
841 struct input_dev *input = ddata->input;
845 if (device_may_wakeup(dev)) {
846 for (i = 0; i < ddata->pdata->nbuttons; i++) {
847 struct gpio_button_data *bdata = &ddata->data[i];
848 if (bdata->button->wakeup)
849 disable_irq_wake(bdata->irq);
852 mutex_lock(&input->mutex);
854 error = gpio_keys_open(input);
855 mutex_unlock(&input->mutex);
861 gpio_keys_report_state(ddata);
866 static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
868 static struct platform_driver gpio_keys_device_driver = {
869 .probe = gpio_keys_probe,
870 .remove = gpio_keys_remove,
873 .pm = &gpio_keys_pm_ops,
874 .of_match_table = of_match_ptr(gpio_keys_of_match),
878 static int __init gpio_keys_init(void)
880 return platform_driver_register(&gpio_keys_device_driver);
883 static void __exit gpio_keys_exit(void)
885 platform_driver_unregister(&gpio_keys_device_driver);
888 late_initcall(gpio_keys_init);
889 module_exit(gpio_keys_exit);
891 MODULE_LICENSE("GPL");
892 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
893 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
894 MODULE_ALIAS("platform:gpio-keys");