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 inline 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 * gpio_keys_disable_button() - disables given GPIO button
108 * @bdata: button data for button to be disabled
110 * Disables button pointed by @bdata. This is done by masking
111 * IRQ line. After this function is called, button won't generate
112 * input events anymore. Note that one can only disable buttons
113 * that don't share IRQs.
115 * Make sure that @bdata->disable_lock is locked when entering
116 * this function to avoid races when concurrent threads are
117 * disabling buttons at the same time.
119 static void gpio_keys_disable_button(struct gpio_button_data *bdata)
121 if (!bdata->disabled) {
123 * Disable IRQ and associated timer/work structure.
125 disable_irq(bdata->irq);
127 if (gpio_is_valid(bdata->button->gpio))
128 cancel_delayed_work_sync(&bdata->work);
130 del_timer_sync(&bdata->release_timer);
132 bdata->disabled = true;
137 * gpio_keys_enable_button() - enables given GPIO button
138 * @bdata: button data for button to be disabled
140 * Enables given button pointed by @bdata.
142 * Make sure that @bdata->disable_lock is locked when entering
143 * this function to avoid races with concurrent threads trying
144 * to enable the same button at the same time.
146 static void gpio_keys_enable_button(struct gpio_button_data *bdata)
148 if (bdata->disabled) {
149 enable_irq(bdata->irq);
150 bdata->disabled = false;
155 * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
156 * @ddata: pointer to drvdata
157 * @buf: buffer where stringified bitmap is written
158 * @type: button type (%EV_KEY, %EV_SW)
159 * @only_disabled: does caller want only those buttons that are
160 * currently disabled or all buttons that can be
163 * This function writes buttons that can be disabled to @buf. If
164 * @only_disabled is true, then @buf contains only those buttons
165 * that are currently disabled. Returns 0 on success or negative
168 static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
169 char *buf, unsigned int type,
172 int n_events = get_n_events_by_type(type);
177 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
181 for (i = 0; i < ddata->pdata->nbuttons; i++) {
182 struct gpio_button_data *bdata = &ddata->data[i];
184 if (bdata->button->type != type)
187 if (only_disabled && !bdata->disabled)
190 __set_bit(bdata->button->code, bits);
193 ret = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", n_events, bits);
203 * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
204 * @ddata: pointer to drvdata
205 * @buf: buffer from userspace that contains stringified bitmap
206 * @type: button type (%EV_KEY, %EV_SW)
208 * This function parses stringified bitmap from @buf and disables/enables
209 * GPIO buttons accordingly. Returns 0 on success and negative error
212 static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
213 const char *buf, unsigned int type)
215 int n_events = get_n_events_by_type(type);
220 bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
224 error = bitmap_parselist(buf, bits, n_events);
229 for (i = 0; i < ddata->pdata->nbuttons; i++) {
230 struct gpio_button_data *bdata = &ddata->data[i];
232 if (bdata->button->type != type)
235 if (test_bit(bdata->button->code, bits) &&
236 !bdata->button->can_disable) {
242 if (i == ddata->pdata->nbuttons) {
247 mutex_lock(&ddata->disable_lock);
249 for (i = 0; i < ddata->pdata->nbuttons; i++) {
250 struct gpio_button_data *bdata = &ddata->data[i];
252 if (bdata->button->type != type)
255 if (test_bit(bdata->button->code, bits))
256 gpio_keys_disable_button(bdata);
258 gpio_keys_enable_button(bdata);
261 mutex_unlock(&ddata->disable_lock);
268 #define ATTR_SHOW_FN(name, type, only_disabled) \
269 static ssize_t gpio_keys_show_##name(struct device *dev, \
270 struct device_attribute *attr, \
273 struct platform_device *pdev = to_platform_device(dev); \
274 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
276 return gpio_keys_attr_show_helper(ddata, buf, \
277 type, only_disabled); \
280 ATTR_SHOW_FN(keys, EV_KEY, false);
281 ATTR_SHOW_FN(switches, EV_SW, false);
282 ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
283 ATTR_SHOW_FN(disabled_switches, EV_SW, true);
288 * /sys/devices/platform/gpio-keys/keys [ro]
289 * /sys/devices/platform/gpio-keys/switches [ro]
291 static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
292 static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
294 #define ATTR_STORE_FN(name, type) \
295 static ssize_t gpio_keys_store_##name(struct device *dev, \
296 struct device_attribute *attr, \
300 struct platform_device *pdev = to_platform_device(dev); \
301 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \
304 error = gpio_keys_attr_store_helper(ddata, buf, type); \
311 ATTR_STORE_FN(disabled_keys, EV_KEY);
312 ATTR_STORE_FN(disabled_switches, EV_SW);
317 * /sys/devices/platform/gpio-keys/disabled_keys [rw]
318 * /sys/devices/platform/gpio-keys/disables_switches [rw]
320 static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
321 gpio_keys_show_disabled_keys,
322 gpio_keys_store_disabled_keys);
323 static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
324 gpio_keys_show_disabled_switches,
325 gpio_keys_store_disabled_switches);
327 static struct attribute *gpio_keys_attrs[] = {
329 &dev_attr_switches.attr,
330 &dev_attr_disabled_keys.attr,
331 &dev_attr_disabled_switches.attr,
335 static struct attribute_group gpio_keys_attr_group = {
336 .attrs = gpio_keys_attrs,
339 static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
341 const struct gpio_keys_button *button = bdata->button;
342 struct input_dev *input = bdata->input;
343 unsigned int type = button->type ?: EV_KEY;
344 int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
346 if (type == EV_ABS) {
348 input_event(input, type, button->code, button->value);
350 input_event(input, type, button->code, !!state);
355 static void gpio_keys_gpio_work_func(struct work_struct *work)
357 struct gpio_button_data *bdata =
358 container_of(work, struct gpio_button_data, work.work);
360 gpio_keys_gpio_report_event(bdata);
362 if (bdata->button->wakeup)
363 pm_relax(bdata->input->dev.parent);
366 static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
368 struct gpio_button_data *bdata = dev_id;
370 BUG_ON(irq != bdata->irq);
372 if (bdata->button->wakeup)
373 pm_stay_awake(bdata->input->dev.parent);
375 mod_delayed_work(system_wq,
377 msecs_to_jiffies(bdata->software_debounce));
382 static void gpio_keys_irq_timer(unsigned long _data)
384 struct gpio_button_data *bdata = (struct gpio_button_data *)_data;
385 struct input_dev *input = bdata->input;
388 spin_lock_irqsave(&bdata->lock, flags);
389 if (bdata->key_pressed) {
390 input_event(input, EV_KEY, bdata->button->code, 0);
392 bdata->key_pressed = false;
394 spin_unlock_irqrestore(&bdata->lock, flags);
397 static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
399 struct gpio_button_data *bdata = dev_id;
400 const struct gpio_keys_button *button = bdata->button;
401 struct input_dev *input = bdata->input;
404 BUG_ON(irq != bdata->irq);
406 spin_lock_irqsave(&bdata->lock, flags);
408 if (!bdata->key_pressed) {
409 if (bdata->button->wakeup)
410 pm_wakeup_event(bdata->input->dev.parent, 0);
412 input_event(input, EV_KEY, button->code, 1);
415 if (!bdata->release_delay) {
416 input_event(input, EV_KEY, button->code, 0);
421 bdata->key_pressed = true;
424 if (bdata->release_delay)
425 mod_timer(&bdata->release_timer,
426 jiffies + msecs_to_jiffies(bdata->release_delay));
428 spin_unlock_irqrestore(&bdata->lock, flags);
432 static void gpio_keys_quiesce_key(void *data)
434 struct gpio_button_data *bdata = data;
436 if (gpio_is_valid(bdata->button->gpio))
437 cancel_delayed_work_sync(&bdata->work);
439 del_timer_sync(&bdata->release_timer);
442 static int gpio_keys_setup_key(struct platform_device *pdev,
443 struct input_dev *input,
444 struct gpio_button_data *bdata,
445 const struct gpio_keys_button *button)
447 const char *desc = button->desc ? button->desc : "gpio_keys";
448 struct device *dev = &pdev->dev;
450 unsigned long irqflags;
454 bdata->input = input;
455 bdata->button = button;
456 spin_lock_init(&bdata->lock);
458 if (gpio_is_valid(button->gpio)) {
460 error = devm_gpio_request_one(&pdev->dev, button->gpio,
463 dev_err(dev, "Failed to request GPIO %d, error %d\n",
464 button->gpio, error);
468 if (button->debounce_interval) {
469 error = gpio_set_debounce(button->gpio,
470 button->debounce_interval * 1000);
471 /* use timer if gpiolib doesn't provide debounce */
473 bdata->software_debounce =
474 button->debounce_interval;
478 bdata->irq = button->irq;
480 irq = gpio_to_irq(button->gpio);
484 "Unable to get irq number for GPIO %d, error %d\n",
485 button->gpio, error);
491 INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
493 isr = gpio_keys_gpio_isr;
494 irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
498 dev_err(dev, "No IRQ specified\n");
501 bdata->irq = button->irq;
503 if (button->type && button->type != EV_KEY) {
504 dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n");
508 bdata->release_delay = button->debounce_interval;
509 setup_timer(&bdata->release_timer,
510 gpio_keys_irq_timer, (unsigned long)bdata);
512 isr = gpio_keys_irq_isr;
516 input_set_capability(input, button->type ?: EV_KEY, button->code);
519 * Install custom action to cancel release timer and
522 error = devm_add_action(&pdev->dev, gpio_keys_quiesce_key, bdata);
525 "failed to register quiesce action, error: %d\n",
531 * If platform has specified that the button can be disabled,
532 * we don't want it to share the interrupt line.
534 if (!button->can_disable)
535 irqflags |= IRQF_SHARED;
537 error = devm_request_any_context_irq(&pdev->dev, bdata->irq,
538 isr, irqflags, desc, bdata);
540 dev_err(dev, "Unable to claim irq %d; error %d\n",
548 static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata)
550 struct input_dev *input = ddata->input;
553 for (i = 0; i < ddata->pdata->nbuttons; i++) {
554 struct gpio_button_data *bdata = &ddata->data[i];
555 if (gpio_is_valid(bdata->button->gpio))
556 gpio_keys_gpio_report_event(bdata);
561 static int gpio_keys_open(struct input_dev *input)
563 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
564 const struct gpio_keys_platform_data *pdata = ddata->pdata;
568 error = pdata->enable(input->dev.parent);
573 /* Report current state of buttons that are connected to GPIOs */
574 gpio_keys_report_state(ddata);
579 static void gpio_keys_close(struct input_dev *input)
581 struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
582 const struct gpio_keys_platform_data *pdata = ddata->pdata;
585 pdata->disable(input->dev.parent);
589 * Handlers for alternative sources of platform_data
594 * Translate OpenFirmware node properties into platform_data
596 static struct gpio_keys_platform_data *
597 gpio_keys_get_devtree_pdata(struct device *dev)
599 struct device_node *node, *pp;
600 struct gpio_keys_platform_data *pdata;
601 struct gpio_keys_button *button;
608 return ERR_PTR(-ENODEV);
610 nbuttons = of_get_child_count(node);
612 return ERR_PTR(-ENODEV);
614 pdata = devm_kzalloc(dev,
615 sizeof(*pdata) + nbuttons * sizeof(*button),
618 return ERR_PTR(-ENOMEM);
620 pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
621 pdata->nbuttons = nbuttons;
623 pdata->rep = !!of_get_property(node, "autorepeat", NULL);
626 for_each_child_of_node(node, pp) {
627 enum of_gpio_flags flags;
629 button = &pdata->buttons[i++];
631 button->gpio = of_get_gpio_flags(pp, 0, &flags);
632 if (button->gpio < 0) {
633 error = button->gpio;
634 if (error != -ENOENT) {
635 if (error != -EPROBE_DEFER)
637 "Failed to get gpio flags, error: %d\n",
639 return ERR_PTR(error);
642 button->active_low = flags & OF_GPIO_ACTIVE_LOW;
645 button->irq = irq_of_parse_and_map(pp, 0);
647 if (!gpio_is_valid(button->gpio) && !button->irq) {
648 dev_err(dev, "Found button without gpios or irqs\n");
649 return ERR_PTR(-EINVAL);
652 if (of_property_read_u32(pp, "linux,code", &button->code)) {
653 dev_err(dev, "Button without keycode: 0x%x\n",
655 return ERR_PTR(-EINVAL);
658 button->desc = of_get_property(pp, "label", NULL);
660 if (of_property_read_u32(pp, "linux,input-type", &button->type))
661 button->type = EV_KEY;
663 button->wakeup = of_property_read_bool(pp, "wakeup-source") ||
665 of_property_read_bool(pp, "gpio-key,wakeup");
667 button->can_disable = !!of_get_property(pp, "linux,can-disable", NULL);
669 if (of_property_read_u32(pp, "debounce-interval",
670 &button->debounce_interval))
671 button->debounce_interval = 5;
674 if (pdata->nbuttons == 0)
675 return ERR_PTR(-EINVAL);
680 static const struct of_device_id gpio_keys_of_match[] = {
681 { .compatible = "gpio-keys", },
684 MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
688 static inline struct gpio_keys_platform_data *
689 gpio_keys_get_devtree_pdata(struct device *dev)
691 return ERR_PTR(-ENODEV);
696 static int gpio_keys_probe(struct platform_device *pdev)
698 struct device *dev = &pdev->dev;
699 const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
700 struct gpio_keys_drvdata *ddata;
701 struct input_dev *input;
707 pdata = gpio_keys_get_devtree_pdata(dev);
709 return PTR_ERR(pdata);
712 size = sizeof(struct gpio_keys_drvdata) +
713 pdata->nbuttons * sizeof(struct gpio_button_data);
714 ddata = devm_kzalloc(dev, size, GFP_KERNEL);
716 dev_err(dev, "failed to allocate state\n");
720 input = devm_input_allocate_device(dev);
722 dev_err(dev, "failed to allocate input device\n");
726 ddata->pdata = pdata;
727 ddata->input = input;
728 mutex_init(&ddata->disable_lock);
730 platform_set_drvdata(pdev, ddata);
731 input_set_drvdata(input, ddata);
733 input->name = pdata->name ? : pdev->name;
734 input->phys = "gpio-keys/input0";
735 input->dev.parent = &pdev->dev;
736 input->open = gpio_keys_open;
737 input->close = gpio_keys_close;
739 input->id.bustype = BUS_HOST;
740 input->id.vendor = 0x0001;
741 input->id.product = 0x0001;
742 input->id.version = 0x0100;
744 /* Enable auto repeat feature of Linux input subsystem */
746 __set_bit(EV_REP, input->evbit);
748 for (i = 0; i < pdata->nbuttons; i++) {
749 const struct gpio_keys_button *button = &pdata->buttons[i];
750 struct gpio_button_data *bdata = &ddata->data[i];
752 error = gpio_keys_setup_key(pdev, input, bdata, button);
760 error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
762 dev_err(dev, "Unable to export keys/switches, error: %d\n",
767 error = input_register_device(input);
769 dev_err(dev, "Unable to register input device, error: %d\n",
771 goto err_remove_group;
774 device_init_wakeup(&pdev->dev, wakeup);
779 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
783 static int gpio_keys_remove(struct platform_device *pdev)
785 sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
787 device_init_wakeup(&pdev->dev, 0);
792 #ifdef CONFIG_PM_SLEEP
793 static int gpio_keys_suspend(struct device *dev)
795 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
796 struct input_dev *input = ddata->input;
799 if (device_may_wakeup(dev)) {
800 for (i = 0; i < ddata->pdata->nbuttons; i++) {
801 struct gpio_button_data *bdata = &ddata->data[i];
802 if (bdata->button->wakeup)
803 enable_irq_wake(bdata->irq);
806 mutex_lock(&input->mutex);
808 gpio_keys_close(input);
809 mutex_unlock(&input->mutex);
815 static int gpio_keys_resume(struct device *dev)
817 struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
818 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 disable_irq_wake(bdata->irq);
829 mutex_lock(&input->mutex);
831 error = gpio_keys_open(input);
832 mutex_unlock(&input->mutex);
838 gpio_keys_report_state(ddata);
843 static SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume);
845 static struct platform_driver gpio_keys_device_driver = {
846 .probe = gpio_keys_probe,
847 .remove = gpio_keys_remove,
850 .pm = &gpio_keys_pm_ops,
851 .of_match_table = of_match_ptr(gpio_keys_of_match),
855 static int __init gpio_keys_init(void)
857 return platform_driver_register(&gpio_keys_device_driver);
860 static void __exit gpio_keys_exit(void)
862 platform_driver_unregister(&gpio_keys_device_driver);
865 late_initcall(gpio_keys_init);
866 module_exit(gpio_keys_exit);
868 MODULE_LICENSE("GPL");
869 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
870 MODULE_DESCRIPTION("Keyboard driver for GPIOs");
871 MODULE_ALIAS("platform:gpio-keys");