Lines Matching +full:wakeup +full:- +full:event +full:- +full:action
1 // SPDX-License-Identifier: GPL-2.0-only
31 #include <dt-bindings/input/gpio-keys.h>
41 unsigned int release_delay; /* in msecs, for IRQ-only buttons */
45 unsigned int software_debounce; /* in msecs, for GPIO-driven buttons */
69 * There are 4 attributes under /sys/devices/platform/gpio-keys/
70 * keys [ro] - bitmap of keys (EV_KEY) which can be
72 * switches [ro] - bitmap of switches (EV_SW) which can be
74 * disabled_keys [rw] - bitmap of keys currently disabled
75 * disabled_switches [rw] - bitmap of switches currently disabled
77 * Userland can change these values and hence disable event generation
81 * For example, if we have following switches set up as gpio-keys:
87 * 11-9,5
101 * get_n_events_by_type() - returns maximum number of events per @type
115 * get_bm_events_by_type() - returns bitmap of supported events per @type
127 return (type == EV_KEY) ? dev->keybit : dev->swbit;
134 if (!bdata->gpiod)
135 hrtimer_cancel(&bdata->release_timer);
136 else if (bdata->debounce_use_hrtimer)
137 hrtimer_cancel(&bdata->debounce_timer);
139 cancel_delayed_work_sync(&bdata->work);
143 * gpio_keys_disable_button() - disables given GPIO button
151 * Make sure that @bdata->disable_lock is locked when entering
157 if (!bdata->disabled) {
161 disable_irq(bdata->irq);
163 bdata->disabled = true;
168 * gpio_keys_enable_button() - enables given GPIO button
173 * Make sure that @bdata->disable_lock is locked when entering
179 if (bdata->disabled) {
180 enable_irq(bdata->irq);
181 bdata->disabled = false;
186 * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
210 return -ENOMEM;
212 for (i = 0; i < ddata->pdata->nbuttons; i++) {
213 struct gpio_button_data *bdata = &ddata->data[i];
215 if (bdata->button->type != type)
218 if (only_disabled && !bdata->disabled)
221 __set_bit(*bdata->code, bits);
224 ret = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", n_events, bits);
234 * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
247 const unsigned long *bitmap = get_bm_events_by_type(ddata->input, type);
253 return -ENOMEM;
261 return -EINVAL;
263 for (i = 0; i < ddata->pdata->nbuttons; i++) {
264 struct gpio_button_data *bdata = &ddata->data[i];
266 if (bdata->button->type != type)
269 if (test_bit(*bdata->code, bits) &&
270 !bdata->button->can_disable) {
271 return -EINVAL;
275 guard(mutex)(&ddata->disable_lock);
277 for (i = 0; i < ddata->pdata->nbuttons; i++) {
278 struct gpio_button_data *bdata = &ddata->data[i];
280 if (bdata->button->type != type)
283 if (test_bit(*bdata->code, bits))
312 * /sys/devices/platform/gpio-keys/keys [ro]
313 * /sys/devices/platform/gpio-keys/switches [ro]
341 * /sys/devices/platform/gpio-keys/disabled_keys [rw]
342 * /sys/devices/platform/gpio-keys/disables_switches [rw]
362 const struct gpio_keys_button *button = bdata->button;
363 struct input_dev *input = bdata->input;
364 unsigned int type = button->type ?: EV_KEY;
367 state = bdata->debounce_use_hrtimer ?
368 gpiod_get_value(bdata->gpiod) :
369 gpiod_get_value_cansleep(bdata->gpiod);
371 dev_err(input->dev.parent,
378 input_event(input, type, button->code, button->value);
380 input_event(input, type, *bdata->code, state);
387 input_sync(bdata->input);
389 if (bdata->button->wakeup)
390 pm_relax(bdata->input->dev.parent);
415 BUG_ON(irq != bdata->irq);
417 if (bdata->button->wakeup) {
418 const struct gpio_keys_button *button = bdata->button;
420 pm_stay_awake(bdata->input->dev.parent);
421 if (bdata->suspended &&
422 (button->type == 0 || button->type == EV_KEY)) {
424 * Simulate wakeup key press in case the key has
428 input_report_key(bdata->input, button->code, 1);
432 if (bdata->debounce_use_hrtimer) {
433 hrtimer_start(&bdata->debounce_timer,
434 ms_to_ktime(bdata->software_debounce),
438 &bdata->work,
439 msecs_to_jiffies(bdata->software_debounce));
450 struct input_dev *input = bdata->input;
452 guard(spinlock_irqsave)(&bdata->lock);
454 if (bdata->key_pressed) {
455 input_report_key(input, *bdata->code, 0);
457 bdata->key_pressed = false;
466 struct input_dev *input = bdata->input;
468 BUG_ON(irq != bdata->irq);
470 guard(spinlock_irqsave)(&bdata->lock);
472 if (!bdata->key_pressed) {
473 if (bdata->button->wakeup)
474 pm_wakeup_event(bdata->input->dev.parent, 0);
476 input_report_key(input, *bdata->code, 1);
479 if (!bdata->release_delay) {
480 input_report_key(input, *bdata->code, 0);
485 bdata->key_pressed = true;
488 if (bdata->release_delay)
489 hrtimer_start(&bdata->release_timer,
490 ms_to_ktime(bdata->release_delay),
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];
512 bdata->input = input;
513 bdata->button = button;
514 spin_lock_init(&bdata->lock);
517 bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
519 if (IS_ERR(bdata->gpiod)) {
520 error = PTR_ERR(bdata->gpiod);
521 if (error != -ENOENT)
527 * purely interrupt-driven setup.
529 bdata->gpiod = NULL;
531 } else if (gpio_is_valid(button->gpio)) {
536 error = devm_gpio_request_one(dev, button->gpio, GPIOF_IN, desc);
539 button->gpio, error);
543 bdata->gpiod = gpio_to_desc(button->gpio);
544 if (!bdata->gpiod)
545 return -EINVAL;
547 if (button->active_low ^ gpiod_is_active_low(bdata->gpiod))
548 gpiod_toggle_active_low(bdata->gpiod);
551 if (bdata->gpiod) {
552 bool active_low = gpiod_is_active_low(bdata->gpiod);
554 if (button->debounce_interval) {
555 error = gpiod_set_debounce(bdata->gpiod,
556 button->debounce_interval * 1000);
559 bdata->software_debounce =
560 button->debounce_interval;
567 bdata->debounce_use_hrtimer =
568 !gpiod_cansleep(bdata->gpiod);
577 * for bdata->wakeirq setup.
579 if (button->irq) {
580 bdata->irq = button->irq;
582 irq = gpiod_to_irq(bdata->gpiod);
587 button->gpio);
590 bdata->irq = irq;
593 INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func);
595 hrtimer_setup(&bdata->debounce_timer, gpio_keys_debounce_timer,
601 switch (button->wakeup_event_action) {
603 bdata->wakeup_trigger_type = active_low ?
607 bdata->wakeup_trigger_type = active_low ?
619 if (!button->irq) {
621 return -EINVAL;
624 bdata->irq = button->irq;
626 if (button->type && button->type != EV_KEY) {
628 return -EINVAL;
631 bdata->release_delay = button->debounce_interval;
632 hrtimer_setup(&bdata->release_timer, gpio_keys_irq_timer,
640 * So we don't need to reconfigure the trigger type for wakeup.
644 bdata->code = &ddata->keymap[idx];
645 *bdata->code = button->code;
646 input_set_capability(input, button->type ?: EV_KEY, *bdata->code);
649 * Install custom action to cancel release timer and
654 dev_err(dev, "failed to register quiesce action, error: %d\n",
663 if (!button->can_disable)
666 error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags,
670 bdata->irq, error);
674 if (!button->wakeirq)
677 /* Use :wakeup suffix like drivers/base/power/wakeirq.c does */
678 wakedesc = devm_kasprintf(dev, GFP_KERNEL, "%s:wakeup", desc);
680 return -ENOMEM;
682 bdata->wakeirq = button->wakeirq;
690 error = devm_request_any_context_irq(dev, bdata->wakeirq, isr,
694 bdata->irq, error);
700 * IRQF_SHARED was set based on !button->can_disable.
702 disable_irq(bdata->wakeirq);
709 struct input_dev *input = ddata->input;
712 for (i = 0; i < ddata->pdata->nbuttons; i++) {
713 struct gpio_button_data *bdata = &ddata->data[i];
714 if (bdata->gpiod)
723 const struct gpio_keys_platform_data *pdata = ddata->pdata;
726 if (pdata->enable) {
727 error = pdata->enable(input->dev.parent);
741 const struct gpio_keys_platform_data *pdata = ddata->pdata;
743 if (pdata->disable)
744 pdata->disable(input->dev.parent);
763 return ERR_PTR(-ENODEV);
769 return ERR_PTR(-ENOMEM);
773 pdata->buttons = button;
774 pdata->nbuttons = nbuttons;
776 pdata->rep = device_property_read_bool(dev, "autorepeat");
778 device_property_read_string(dev, "label", &pdata->name);
784 button->irq = irq;
786 irq = of_irq_get_byname(to_of_node(child), "wakeup");
788 button->wakeirq = irq;
790 if (!button->irq && !button->wakeirq)
791 button->irq =
796 &button->code)) {
798 return ERR_PTR(-EINVAL);
801 fwnode_property_read_string(child, "label", &button->desc);
803 if (fwnode_property_read_u32(child, "linux,input-type",
804 &button->type))
805 button->type = EV_KEY;
807 fwnode_property_read_u32(child, "linux,input-value",
808 (u32 *)&button->value);
810 button->wakeup =
811 fwnode_property_read_bool(child, "wakeup-source") ||
813 fwnode_property_read_bool(child, "gpio-key,wakeup");
815 fwnode_property_read_u32(child, "wakeup-event-action",
816 &button->wakeup_event_action);
818 button->can_disable =
819 fwnode_property_read_bool(child, "linux,can-disable");
821 if (fwnode_property_read_u32(child, "debounce-interval",
822 &button->debounce_interval))
823 button->debounce_interval = 5;
832 { .compatible = "gpio-keys", },
839 struct device *dev = &pdev->dev;
845 int wakeup = 0;
853 ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons),
857 return -ENOMEM;
860 ddata->keymap = devm_kcalloc(dev,
861 pdata->nbuttons, sizeof(ddata->keymap[0]),
863 if (!ddata->keymap)
864 return -ENOMEM;
869 return -ENOMEM;
872 ddata->pdata = pdata;
873 ddata->input = input;
874 mutex_init(&ddata->disable_lock);
879 input->name = pdata->name ? : pdev->name;
880 input->phys = "gpio-keys/input0";
881 input->dev.parent = dev;
882 input->open = gpio_keys_open;
883 input->close = gpio_keys_close;
885 input->id.bustype = BUS_HOST;
886 input->id.vendor = 0x0001;
887 input->id.product = 0x0001;
888 input->id.version = 0x0100;
890 input->keycode = ddata->keymap;
891 input->keycodesize = sizeof(ddata->keymap[0]);
892 input->keycodemax = pdata->nbuttons;
895 if (pdata->rep)
896 __set_bit(EV_REP, input->evbit);
898 for (i = 0; i < pdata->nbuttons; i++) {
899 const struct gpio_keys_button *button = &pdata->buttons[i];
907 return -EINVAL;
918 if (button->wakeup)
919 wakeup = 1;
931 device_init_wakeup(dev, wakeup);
941 error = enable_irq_wake(bdata->irq);
943 dev_err(bdata->input->dev.parent,
944 "failed to configure IRQ %d as wakeup source: %d\n",
945 bdata->irq, error);
949 if (bdata->wakeup_trigger_type) {
950 error = irq_set_irq_type(bdata->irq,
951 bdata->wakeup_trigger_type);
953 dev_err(bdata->input->dev.parent,
954 "failed to set wakeup trigger %08x for IRQ %d: %d\n",
955 bdata->wakeup_trigger_type, bdata->irq, error);
956 disable_irq_wake(bdata->irq);
961 if (bdata->wakeirq) {
962 enable_irq(bdata->wakeirq);
963 disable_irq(bdata->irq);
974 if (bdata->wakeirq) {
975 enable_irq(bdata->irq);
976 disable_irq(bdata->wakeirq);
980 * The trigger type is always both edges for gpio-based keys and we do
981 * not support changing wakeup trigger for interrupt-based keys.
983 if (bdata->wakeup_trigger_type) {
984 error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH);
986 dev_warn(bdata->input->dev.parent,
988 bdata->irq, error);
991 error = disable_irq_wake(bdata->irq);
993 dev_warn(bdata->input->dev.parent,
995 bdata->irq, error);
1005 for (i = 0; i < ddata->pdata->nbuttons; i++) {
1006 bdata = &ddata->data[i];
1007 if (bdata->button->wakeup) {
1012 bdata->suspended = true;
1018 while (i--) {
1019 bdata = &ddata->data[i];
1020 if (bdata->button->wakeup)
1022 bdata->suspended = false;
1034 for (i = 0; i < ddata->pdata->nbuttons; i++) {
1035 bdata = &ddata->data[i];
1036 bdata->suspended = false;
1037 if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq)))
1045 struct input_dev *input = ddata->input;
1053 guard(mutex)(&input->mutex);
1065 struct input_dev *input = ddata->input;
1071 guard(mutex)(&input->mutex);
1090 ret = gpio_keys_suspend(&pdev->dev);
1092 dev_err(&pdev->dev, "failed to shutdown\n");
1099 .name = "gpio-keys",
1122 MODULE_ALIAS("platform:gpio-keys");