| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * Driver for keys on GPIO lines capable of generating interrupts. |
| * |
| * Copyright 2005 Phil Blundell |
| * Copyright 2010, 2011 David Jander <david@protonic.nl> |
| */ |
| |
| #include <linux/module.h> |
| |
| #include <linux/hrtimer.h> |
| #include <linux/init.h> |
| #include <linux/fs.h> |
| #include <linux/interrupt.h> |
| #include <linux/irq.h> |
| #include <linux/sched.h> |
| #include <linux/pm.h> |
| #include <linux/slab.h> |
| #include <linux/sysctl.h> |
| #include <linux/proc_fs.h> |
| #include <linux/delay.h> |
| #include <linux/platform_device.h> |
| #include <linux/input.h> |
| #include <linux/gpio_keys.h> |
| #include <linux/workqueue.h> |
| #include <linux/gpio.h> |
| #include <linux/gpio/consumer.h> |
| #include <linux/of.h> |
| #include <linux/of_irq.h> |
| #include <linux/spinlock.h> |
| #include <dt-bindings/input/gpio-keys.h> |
| |
| struct gpio_button_data { |
| const struct gpio_keys_button *button; |
| struct input_dev *input; |
| struct gpio_desc *gpiod; |
| |
| unsigned short *code; |
| |
| struct hrtimer release_timer; |
| unsigned int release_delay; /* in msecs, for IRQ-only buttons */ |
| |
| struct delayed_work work; |
| struct hrtimer debounce_timer; |
| unsigned int software_debounce; /* in msecs, for GPIO-driven buttons */ |
| |
| unsigned int irq; |
| unsigned int wakeup_trigger_type; |
| spinlock_t lock; |
| bool disabled; |
| bool key_pressed; |
| bool suspended; |
| bool debounce_use_hrtimer; |
| }; |
| |
| struct gpio_keys_drvdata { |
| const struct gpio_keys_platform_data *pdata; |
| struct input_dev *input; |
| struct mutex disable_lock; |
| unsigned short *keymap; |
| struct gpio_button_data data[]; |
| }; |
| |
| /* |
| * SYSFS interface for enabling/disabling keys and switches: |
| * |
| * There are 4 attributes under /sys/devices/platform/gpio-keys/ |
| * keys [ro] - bitmap of keys (EV_KEY) which can be |
| * disabled |
| * switches [ro] - bitmap of switches (EV_SW) which can be |
| * disabled |
| * disabled_keys [rw] - bitmap of keys currently disabled |
| * disabled_switches [rw] - bitmap of switches currently disabled |
| * |
| * Userland can change these values and hence disable event generation |
| * for each key (or switch). Disabling a key means its interrupt line |
| * is disabled. |
| * |
| * For example, if we have following switches set up as gpio-keys: |
| * SW_DOCK = 5 |
| * SW_CAMERA_LENS_COVER = 9 |
| * SW_KEYPAD_SLIDE = 10 |
| * SW_FRONT_PROXIMITY = 11 |
| * This is read from switches: |
| * 11-9,5 |
| * Next we want to disable proximity (11) and dock (5), we write: |
| * 11,5 |
| * to file disabled_switches. Now proximity and dock IRQs are disabled. |
| * This can be verified by reading the file disabled_switches: |
| * 11,5 |
| * If we now want to enable proximity (11) switch we write: |
| * 5 |
| * to disabled_switches. |
| * |
| * We can disable only those keys which don't allow sharing the irq. |
| */ |
| |
| /** |
| * get_n_events_by_type() - returns maximum number of events per @type |
| * @type: type of button (%EV_KEY, %EV_SW) |
| * |
| * Return value of this function can be used to allocate bitmap |
| * large enough to hold all bits for given type. |
| */ |
| static int get_n_events_by_type(int type) |
| { |
| BUG_ON(type != EV_SW && type != EV_KEY); |
| |
| return (type == EV_KEY) ? KEY_CNT : SW_CNT; |
| } |
| |
| /** |
| * get_bm_events_by_type() - returns bitmap of supported events per @type |
| * @dev: input device from which bitmap is retrieved |
| * @type: type of button (%EV_KEY, %EV_SW) |
| * |
| * Return value of this function can be used to allocate bitmap |
| * large enough to hold all bits for given type. |
| */ |
| static const unsigned long *get_bm_events_by_type(struct input_dev *dev, |
| int type) |
| { |
| BUG_ON(type != EV_SW && type != EV_KEY); |
| |
| return (type == EV_KEY) ? dev->keybit : dev->swbit; |
| } |
| |
| static void gpio_keys_quiesce_key(void *data) |
| { |
| struct gpio_button_data *bdata = data; |
| |
| if (!bdata->gpiod) |
| hrtimer_cancel(&bdata->release_timer); |
| else if (bdata->debounce_use_hrtimer) |
| hrtimer_cancel(&bdata->debounce_timer); |
| else |
| cancel_delayed_work_sync(&bdata->work); |
| } |
| |
| /** |
| * gpio_keys_disable_button() - disables given GPIO button |
| * @bdata: button data for button to be disabled |
| * |
| * Disables button pointed by @bdata. This is done by masking |
| * IRQ line. After this function is called, button won't generate |
| * input events anymore. Note that one can only disable buttons |
| * that don't share IRQs. |
| * |
| * Make sure that @bdata->disable_lock is locked when entering |
| * this function to avoid races when concurrent threads are |
| * disabling buttons at the same time. |
| */ |
| static void gpio_keys_disable_button(struct gpio_button_data *bdata) |
| { |
| if (!bdata->disabled) { |
| /* |
| * Disable IRQ and associated timer/work structure. |
| */ |
| disable_irq(bdata->irq); |
| gpio_keys_quiesce_key(bdata); |
| bdata->disabled = true; |
| } |
| } |
| |
| /** |
| * gpio_keys_enable_button() - enables given GPIO button |
| * @bdata: button data for button to be disabled |
| * |
| * Enables given button pointed by @bdata. |
| * |
| * Make sure that @bdata->disable_lock is locked when entering |
| * this function to avoid races with concurrent threads trying |
| * to enable the same button at the same time. |
| */ |
| static void gpio_keys_enable_button(struct gpio_button_data *bdata) |
| { |
| if (bdata->disabled) { |
| enable_irq(bdata->irq); |
| bdata->disabled = false; |
| } |
| } |
| |
| /** |
| * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons |
| * @ddata: pointer to drvdata |
| * @buf: buffer where stringified bitmap is written |
| * @type: button type (%EV_KEY, %EV_SW) |
| * @only_disabled: does caller want only those buttons that are |
| * currently disabled or all buttons that can be |
| * disabled |
| * |
| * This function writes buttons that can be disabled to @buf. If |
| * @only_disabled is true, then @buf contains only those buttons |
| * that are currently disabled. Returns 0 on success or negative |
| * errno on failure. |
| */ |
| static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata, |
| char *buf, unsigned int type, |
| bool only_disabled) |
| { |
| int n_events = get_n_events_by_type(type); |
| unsigned long *bits; |
| ssize_t ret; |
| int i; |
| |
| bits = bitmap_zalloc(n_events, GFP_KERNEL); |
| if (!bits) |
| return -ENOMEM; |
| |
| for (i = 0; i < ddata->pdata->nbuttons; i++) { |
| struct gpio_button_data *bdata = &ddata->data[i]; |
| |
| if (bdata->button->type != type) |
| continue; |
| |
| if (only_disabled && !bdata->disabled) |
| continue; |
| |
| __set_bit(*bdata->code, bits); |
| } |
| |
| ret = scnprintf(buf, PAGE_SIZE - 1, "%*pbl", n_events, bits); |
| buf[ret++] = '\n'; |
| buf[ret] = '\0'; |
| |
| bitmap_free(bits); |
| |
| return ret; |
| } |
| |
| /** |
| * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap |
| * @ddata: pointer to drvdata |
| * @buf: buffer from userspace that contains stringified bitmap |
| * @type: button type (%EV_KEY, %EV_SW) |
| * |
| * This function parses stringified bitmap from @buf and disables/enables |
| * GPIO buttons accordingly. Returns 0 on success and negative error |
| * on failure. |
| */ |
| static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata, |
| const char *buf, unsigned int type) |
| { |
| int n_events = get_n_events_by_type(type); |
| const unsigned long *bitmap = get_bm_events_by_type(ddata->input, type); |
| unsigned long *bits; |
| ssize_t error; |
| int i; |
| |
| bits = bitmap_alloc(n_events, GFP_KERNEL); |
| if (!bits) |
| return -ENOMEM; |
| |
| error = bitmap_parselist(buf, bits, n_events); |
| if (error) |
| goto out; |
| |
| /* First validate */ |
| if (!bitmap_subset(bits, bitmap, n_events)) { |
| error = -EINVAL; |
| goto out; |
| } |
| |
| for (i = 0; i < ddata->pdata->nbuttons; i++) { |
| struct gpio_button_data *bdata = &ddata->data[i]; |
| |
| if (bdata->button->type != type) |
| continue; |
| |
| if (test_bit(*bdata->code, bits) && |
| !bdata->button->can_disable) { |
| error = -EINVAL; |
| goto out; |
| } |
| } |
| |
| mutex_lock(&ddata->disable_lock); |
| |
| for (i = 0; i < ddata->pdata->nbuttons; i++) { |
| struct gpio_button_data *bdata = &ddata->data[i]; |
| |
| if (bdata->button->type != type) |
| continue; |
| |
| if (test_bit(*bdata->code, bits)) |
| gpio_keys_disable_button(bdata); |
| else |
| gpio_keys_enable_button(bdata); |
| } |
| |
| mutex_unlock(&ddata->disable_lock); |
| |
| out: |
| bitmap_free(bits); |
| return error; |
| } |
| |
| #define ATTR_SHOW_FN(name, type, only_disabled) \ |
| static ssize_t gpio_keys_show_##name(struct device *dev, \ |
| struct device_attribute *attr, \ |
| char *buf) \ |
| { \ |
| struct platform_device *pdev = to_platform_device(dev); \ |
| struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \ |
| \ |
| return gpio_keys_attr_show_helper(ddata, buf, \ |
| type, only_disabled); \ |
| } |
| |
| ATTR_SHOW_FN(keys, EV_KEY, false); |
| ATTR_SHOW_FN(switches, EV_SW, false); |
| ATTR_SHOW_FN(disabled_keys, EV_KEY, true); |
| ATTR_SHOW_FN(disabled_switches, EV_SW, true); |
| |
| /* |
| * ATTRIBUTES: |
| * |
| * /sys/devices/platform/gpio-keys/keys [ro] |
| * /sys/devices/platform/gpio-keys/switches [ro] |
| */ |
| static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL); |
| static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL); |
| |
| #define ATTR_STORE_FN(name, type) \ |
| static ssize_t gpio_keys_store_##name(struct device *dev, \ |
| struct device_attribute *attr, \ |
| const char *buf, \ |
| size_t count) \ |
| { \ |
| struct platform_device *pdev = to_platform_device(dev); \ |
| struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); \ |
| ssize_t error; \ |
| \ |
| error = gpio_keys_attr_store_helper(ddata, buf, type); \ |
| if (error) \ |
| return error; \ |
| \ |
| return count; \ |
| } |
| |
| ATTR_STORE_FN(disabled_keys, EV_KEY); |
| ATTR_STORE_FN(disabled_switches, EV_SW); |
| |
| /* |
| * ATTRIBUTES: |
| * |
| * /sys/devices/platform/gpio-keys/disabled_keys [rw] |
| * /sys/devices/platform/gpio-keys/disables_switches [rw] |
| */ |
| static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO, |
| gpio_keys_show_disabled_keys, |
| gpio_keys_store_disabled_keys); |
| static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO, |
| gpio_keys_show_disabled_switches, |
| gpio_keys_store_disabled_switches); |
| |
| static struct attribute *gpio_keys_attrs[] = { |
| &dev_attr_keys.attr, |
| &dev_attr_switches.attr, |
| &dev_attr_disabled_keys.attr, |
| &dev_attr_disabled_switches.attr, |
| NULL, |
| }; |
| ATTRIBUTE_GROUPS(gpio_keys); |
| |
| static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata) |
| { |
| const struct gpio_keys_button *button = bdata->button; |
| struct input_dev *input = bdata->input; |
| unsigned int type = button->type ?: EV_KEY; |
| int state; |
| |
| state = bdata->debounce_use_hrtimer ? |
| gpiod_get_value(bdata->gpiod) : |
| gpiod_get_value_cansleep(bdata->gpiod); |
| if (state < 0) { |
| dev_err(input->dev.parent, |
| "failed to get gpio state: %d\n", state); |
| return; |
| } |
| |
| if (type == EV_ABS) { |
| if (state) |
| input_event(input, type, button->code, button->value); |
| } else { |
| input_event(input, type, *bdata->code, state); |
| } |
| } |
| |
| static void gpio_keys_debounce_event(struct gpio_button_data *bdata) |
| { |
| gpio_keys_gpio_report_event(bdata); |
| input_sync(bdata->input); |
| |
| if (bdata->button->wakeup) |
| pm_relax(bdata->input->dev.parent); |
| } |
| |
| static void gpio_keys_gpio_work_func(struct work_struct *work) |
| { |
| struct gpio_button_data *bdata = |
| container_of(work, struct gpio_button_data, work.work); |
| |
| gpio_keys_debounce_event(bdata); |
| } |
| |
| static enum hrtimer_restart gpio_keys_debounce_timer(struct hrtimer *t) |
| { |
| struct gpio_button_data *bdata = |
| container_of(t, struct gpio_button_data, debounce_timer); |
| |
| gpio_keys_debounce_event(bdata); |
| |
| return HRTIMER_NORESTART; |
| } |
| |
| static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id) |
| { |
| struct gpio_button_data *bdata = dev_id; |
| |
| BUG_ON(irq != bdata->irq); |
| |
| if (bdata->button->wakeup) { |
| const struct gpio_keys_button *button = bdata->button; |
| |
| pm_stay_awake(bdata->input->dev.parent); |
| if (bdata->suspended && |
| (button->type == 0 || button->type == EV_KEY)) { |
| /* |
| * Simulate wakeup key press in case the key has |
| * already released by the time we got interrupt |
| * handler to run. |
| */ |
| input_report_key(bdata->input, button->code, 1); |
| } |
| } |
| |
| if (bdata->debounce_use_hrtimer) { |
| hrtimer_start(&bdata->debounce_timer, |
| ms_to_ktime(bdata->software_debounce), |
| HRTIMER_MODE_REL); |
| } else { |
| mod_delayed_work(system_wq, |
| &bdata->work, |
| msecs_to_jiffies(bdata->software_debounce)); |
| } |
| |
| return IRQ_HANDLED; |
| } |
| |
| static enum hrtimer_restart gpio_keys_irq_timer(struct hrtimer *t) |
| { |
| struct gpio_button_data *bdata = container_of(t, |
| struct gpio_button_data, |
| release_timer); |
| struct input_dev *input = bdata->input; |
| |
| if (bdata->key_pressed) { |
| input_event(input, EV_KEY, *bdata->code, 0); |
| input_sync(input); |
| bdata->key_pressed = false; |
| } |
| |
| return HRTIMER_NORESTART; |
| } |
| |
| static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id) |
| { |
| struct gpio_button_data *bdata = dev_id; |
| struct input_dev *input = bdata->input; |
| unsigned long flags; |
| |
| BUG_ON(irq != bdata->irq); |
| |
| spin_lock_irqsave(&bdata->lock, flags); |
| |
| if (!bdata->key_pressed) { |
| if (bdata->button->wakeup) |
| pm_wakeup_event(bdata->input->dev.parent, 0); |
| |
| input_event(input, EV_KEY, *bdata->code, 1); |
| input_sync(input); |
| |
| if (!bdata->release_delay) { |
| input_event(input, EV_KEY, *bdata->code, 0); |
| input_sync(input); |
| goto out; |
| } |
| |
| bdata->key_pressed = true; |
| } |
| |
| if (bdata->release_delay) |
| hrtimer_start(&bdata->release_timer, |
| ms_to_ktime(bdata->release_delay), |
| HRTIMER_MODE_REL_HARD); |
| out: |
| spin_unlock_irqrestore(&bdata->lock, flags); |
| return IRQ_HANDLED; |
| } |
| |
| static int 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) |
| { |
| const char *desc = button->desc ? button->desc : "gpio_keys"; |
| struct device *dev = &pdev->dev; |
| struct gpio_button_data *bdata = &ddata->data[idx]; |
| irq_handler_t isr; |
| unsigned long irqflags; |
| int irq; |
| int error; |
| |
| bdata->input = input; |
| bdata->button = button; |
| spin_lock_init(&bdata->lock); |
| |
| if (child) { |
| bdata->gpiod = devm_fwnode_gpiod_get(dev, child, |
| NULL, GPIOD_IN, desc); |
| if (IS_ERR(bdata->gpiod)) { |
| error = PTR_ERR(bdata->gpiod); |
| if (error == -ENOENT) { |
| /* |
| * GPIO is optional, we may be dealing with |
| * purely interrupt-driven setup. |
| */ |
| bdata->gpiod = NULL; |
| } else { |
| if (error != -EPROBE_DEFER) |
| dev_err(dev, "failed to get gpio: %d\n", |
| error); |
| return error; |
| } |
| } |
| } else if (gpio_is_valid(button->gpio)) { |
| /* |
| * Legacy GPIO number, so request the GPIO here and |
| * convert it to descriptor. |
| */ |
| unsigned flags = GPIOF_IN; |
| |
| if (button->active_low) |
| flags |= GPIOF_ACTIVE_LOW; |
| |
| error = devm_gpio_request_one(dev, button->gpio, flags, desc); |
| if (error < 0) { |
| dev_err(dev, "Failed to request GPIO %d, error %d\n", |
| button->gpio, error); |
| return error; |
| } |
| |
| bdata->gpiod = gpio_to_desc(button->gpio); |
| if (!bdata->gpiod) |
| return -EINVAL; |
| } |
| |
| if (bdata->gpiod) { |
| bool active_low = gpiod_is_active_low(bdata->gpiod); |
| |
| if (button->debounce_interval) { |
| error = gpiod_set_debounce(bdata->gpiod, |
| button->debounce_interval * 1000); |
| /* use timer if gpiolib doesn't provide debounce */ |
| if (error < 0) |
| bdata->software_debounce = |
| button->debounce_interval; |
| |
| /* |
| * If reading the GPIO won't sleep, we can use a |
| * hrtimer instead of a standard timer for the software |
| * debounce, to reduce the latency as much as possible. |
| */ |
| bdata->debounce_use_hrtimer = |
| !gpiod_cansleep(bdata->gpiod); |
| } |
| |
| if (button->irq) { |
| bdata->irq = button->irq; |
| } else { |
| irq = gpiod_to_irq(bdata->gpiod); |
| if (irq < 0) { |
| error = irq; |
| dev_err(dev, |
| "Unable to get irq number for GPIO %d, error %d\n", |
| button->gpio, error); |
| return error; |
| } |
| bdata->irq = irq; |
| } |
| |
| INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func); |
| |
| hrtimer_init(&bdata->debounce_timer, |
| CLOCK_REALTIME, HRTIMER_MODE_REL); |
| bdata->debounce_timer.function = gpio_keys_debounce_timer; |
| |
| isr = gpio_keys_gpio_isr; |
| irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; |
| |
| switch (button->wakeup_event_action) { |
| case EV_ACT_ASSERTED: |
| bdata->wakeup_trigger_type = active_low ? |
| IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING; |
| break; |
| case EV_ACT_DEASSERTED: |
| bdata->wakeup_trigger_type = active_low ? |
| IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING; |
| break; |
| case EV_ACT_ANY: |
| default: |
| /* |
| * For other cases, we are OK letting suspend/resume |
| * not reconfigure the trigger type. |
| */ |
| break; |
| } |
| } else { |
| if (!button->irq) { |
| dev_err(dev, "Found button without gpio or irq\n"); |
| return -EINVAL; |
| } |
| |
| bdata->irq = button->irq; |
| |
| if (button->type && button->type != EV_KEY) { |
| dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n"); |
| return -EINVAL; |
| } |
| |
| bdata->release_delay = button->debounce_interval; |
| hrtimer_init(&bdata->release_timer, |
| CLOCK_REALTIME, HRTIMER_MODE_REL_HARD); |
| bdata->release_timer.function = gpio_keys_irq_timer; |
| |
| isr = gpio_keys_irq_isr; |
| irqflags = 0; |
| |
| /* |
| * For IRQ buttons, there is no interrupt for release. |
| * So we don't need to reconfigure the trigger type for wakeup. |
| */ |
| } |
| |
| bdata->code = &ddata->keymap[idx]; |
| *bdata->code = button->code; |
| input_set_capability(input, button->type ?: EV_KEY, *bdata->code); |
| |
| /* |
| * Install custom action to cancel release timer and |
| * workqueue item. |
| */ |
| error = devm_add_action(dev, gpio_keys_quiesce_key, bdata); |
| if (error) { |
| dev_err(dev, "failed to register quiesce action, error: %d\n", |
| error); |
| return error; |
| } |
| |
| /* |
| * If platform has specified that the button can be disabled, |
| * we don't want it to share the interrupt line. |
| */ |
| if (!button->can_disable) |
| irqflags |= IRQF_SHARED; |
| |
| error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags, |
| desc, bdata); |
| if (error < 0) { |
| dev_err(dev, "Unable to claim irq %d; error %d\n", |
| bdata->irq, error); |
| return error; |
| } |
| |
| return 0; |
| } |
| |
| static void gpio_keys_report_state(struct gpio_keys_drvdata *ddata) |
| { |
| struct input_dev *input = ddata->input; |
| int i; |
| |
| for (i = 0; i < ddata->pdata->nbuttons; i++) { |
| struct gpio_button_data *bdata = &ddata->data[i]; |
| if (bdata->gpiod) |
| gpio_keys_gpio_report_event(bdata); |
| } |
| input_sync(input); |
| } |
| |
| static int gpio_keys_open(struct input_dev *input) |
| { |
| struct gpio_keys_drvdata *ddata = input_get_drvdata(input); |
| const struct gpio_keys_platform_data *pdata = ddata->pdata; |
| int error; |
| |
| if (pdata->enable) { |
| error = pdata->enable(input->dev.parent); |
| if (error) |
| return error; |
| } |
| |
| /* Report current state of buttons that are connected to GPIOs */ |
| gpio_keys_report_state(ddata); |
| |
| return 0; |
| } |
| |
| static void gpio_keys_close(struct input_dev *input) |
| { |
| struct gpio_keys_drvdata *ddata = input_get_drvdata(input); |
| const struct gpio_keys_platform_data *pdata = ddata->pdata; |
| |
| if (pdata->disable) |
| pdata->disable(input->dev.parent); |
| } |
| |
| /* |
| * Handlers for alternative sources of platform_data |
| */ |
| |
| /* |
| * Translate properties into platform_data |
| */ |
| static struct gpio_keys_platform_data * |
| gpio_keys_get_devtree_pdata(struct device *dev) |
| { |
| struct gpio_keys_platform_data *pdata; |
| struct gpio_keys_button *button; |
| struct fwnode_handle *child; |
| int nbuttons; |
| |
| nbuttons = device_get_child_node_count(dev); |
| if (nbuttons == 0) |
| return ERR_PTR(-ENODEV); |
| |
| pdata = devm_kzalloc(dev, |
| sizeof(*pdata) + nbuttons * sizeof(*button), |
| GFP_KERNEL); |
| if (!pdata) |
| return ERR_PTR(-ENOMEM); |
| |
| button = (struct gpio_keys_button *)(pdata + 1); |
| |
| pdata->buttons = button; |
| pdata->nbuttons = nbuttons; |
| |
| pdata->rep = device_property_read_bool(dev, "autorepeat"); |
| |
| device_property_read_string(dev, "label", &pdata->name); |
| |
| device_for_each_child_node(dev, child) { |
| if (is_of_node(child)) |
| button->irq = |
| irq_of_parse_and_map(to_of_node(child), 0); |
| |
| if (fwnode_property_read_u32(child, "linux,code", |
| &button->code)) { |
| dev_err(dev, "Button without keycode\n"); |
| fwnode_handle_put(child); |
| return ERR_PTR(-EINVAL); |
| } |
| |
| fwnode_property_read_string(child, "label", &button->desc); |
| |
| if (fwnode_property_read_u32(child, "linux,input-type", |
| &button->type)) |
| button->type = EV_KEY; |
| |
| button->wakeup = |
| fwnode_property_read_bool(child, "wakeup-source") || |
| /* legacy name */ |
| fwnode_property_read_bool(child, "gpio-key,wakeup"); |
| |
| fwnode_property_read_u32(child, "wakeup-event-action", |
| &button->wakeup_event_action); |
| |
| button->can_disable = |
| fwnode_property_read_bool(child, "linux,can-disable"); |
| |
| if (fwnode_property_read_u32(child, "debounce-interval", |
| &button->debounce_interval)) |
| button->debounce_interval = 5; |
| |
| button++; |
| } |
| |
| return pdata; |
| } |
| |
| static const struct of_device_id gpio_keys_of_match[] = { |
| { .compatible = "gpio-keys", }, |
| { }, |
| }; |
| MODULE_DEVICE_TABLE(of, gpio_keys_of_match); |
| |
| static int gpio_keys_probe(struct platform_device *pdev) |
| { |
| struct device *dev = &pdev->dev; |
| const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev); |
| struct fwnode_handle *child = NULL; |
| struct gpio_keys_drvdata *ddata; |
| struct input_dev *input; |
| int i, error; |
| int wakeup = 0; |
| |
| if (!pdata) { |
| pdata = gpio_keys_get_devtree_pdata(dev); |
| if (IS_ERR(pdata)) |
| return PTR_ERR(pdata); |
| } |
| |
| ddata = devm_kzalloc(dev, struct_size(ddata, data, pdata->nbuttons), |
| GFP_KERNEL); |
| if (!ddata) { |
| dev_err(dev, "failed to allocate state\n"); |
| return -ENOMEM; |
| } |
| |
| ddata->keymap = devm_kcalloc(dev, |
| pdata->nbuttons, sizeof(ddata->keymap[0]), |
| GFP_KERNEL); |
| if (!ddata->keymap) |
| return -ENOMEM; |
| |
| input = devm_input_allocate_device(dev); |
| if (!input) { |
| dev_err(dev, "failed to allocate input device\n"); |
| return -ENOMEM; |
| } |
| |
| ddata->pdata = pdata; |
| ddata->input = input; |
| mutex_init(&ddata->disable_lock); |
| |
| platform_set_drvdata(pdev, ddata); |
| input_set_drvdata(input, ddata); |
| |
| input->name = pdata->name ? : pdev->name; |
| input->phys = "gpio-keys/input0"; |
| input->dev.parent = dev; |
| input->open = gpio_keys_open; |
| input->close = gpio_keys_close; |
| |
| input->id.bustype = BUS_HOST; |
| input->id.vendor = 0x0001; |
| input->id.product = 0x0001; |
| input->id.version = 0x0100; |
| |
| input->keycode = ddata->keymap; |
| input->keycodesize = sizeof(ddata->keymap[0]); |
| input->keycodemax = pdata->nbuttons; |
| |
| /* Enable auto repeat feature of Linux input subsystem */ |
| if (pdata->rep) |
| __set_bit(EV_REP, input->evbit); |
| |
| for (i = 0; i < pdata->nbuttons; i++) { |
| const struct gpio_keys_button *button = &pdata->buttons[i]; |
| |
| if (!dev_get_platdata(dev)) { |
| child = device_get_next_child_node(dev, child); |
| if (!child) { |
| dev_err(dev, |
| "missing child device node for entry %d\n", |
| i); |
| return -EINVAL; |
| } |
| } |
| |
| error = gpio_keys_setup_key(pdev, input, ddata, |
| button, i, child); |
| if (error) { |
| fwnode_handle_put(child); |
| return error; |
| } |
| |
| if (button->wakeup) |
| wakeup = 1; |
| } |
| |
| fwnode_handle_put(child); |
| |
| error = input_register_device(input); |
| if (error) { |
| dev_err(dev, "Unable to register input device, error: %d\n", |
| error); |
| return error; |
| } |
| |
| device_init_wakeup(dev, wakeup); |
| |
| return 0; |
| } |
| |
| static int __maybe_unused |
| gpio_keys_button_enable_wakeup(struct gpio_button_data *bdata) |
| { |
| int error; |
| |
| error = enable_irq_wake(bdata->irq); |
| if (error) { |
| dev_err(bdata->input->dev.parent, |
| "failed to configure IRQ %d as wakeup source: %d\n", |
| bdata->irq, error); |
| return error; |
| } |
| |
| if (bdata->wakeup_trigger_type) { |
| error = irq_set_irq_type(bdata->irq, |
| bdata->wakeup_trigger_type); |
| if (error) { |
| dev_err(bdata->input->dev.parent, |
| "failed to set wakeup trigger %08x for IRQ %d: %d\n", |
| bdata->wakeup_trigger_type, bdata->irq, error); |
| disable_irq_wake(bdata->irq); |
| return error; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void __maybe_unused |
| gpio_keys_button_disable_wakeup(struct gpio_button_data *bdata) |
| { |
| int error; |
| |
| /* |
| * The trigger type is always both edges for gpio-based keys and we do |
| * not support changing wakeup trigger for interrupt-based keys. |
| */ |
| if (bdata->wakeup_trigger_type) { |
| error = irq_set_irq_type(bdata->irq, IRQ_TYPE_EDGE_BOTH); |
| if (error) |
| dev_warn(bdata->input->dev.parent, |
| "failed to restore interrupt trigger for IRQ %d: %d\n", |
| bdata->irq, error); |
| } |
| |
| error = disable_irq_wake(bdata->irq); |
| if (error) |
| dev_warn(bdata->input->dev.parent, |
| "failed to disable IRQ %d as wake source: %d\n", |
| bdata->irq, error); |
| } |
| |
| static int __maybe_unused |
| gpio_keys_enable_wakeup(struct gpio_keys_drvdata *ddata) |
| { |
| struct gpio_button_data *bdata; |
| int error; |
| int i; |
| |
| for (i = 0; i < ddata->pdata->nbuttons; i++) { |
| bdata = &ddata->data[i]; |
| if (bdata->button->wakeup) { |
| error = gpio_keys_button_enable_wakeup(bdata); |
| if (error) |
| goto err_out; |
| } |
| bdata->suspended = true; |
| } |
| |
| return 0; |
| |
| err_out: |
| while (i--) { |
| bdata = &ddata->data[i]; |
| if (bdata->button->wakeup) |
| gpio_keys_button_disable_wakeup(bdata); |
| bdata->suspended = false; |
| } |
| |
| return error; |
| } |
| |
| static void __maybe_unused |
| gpio_keys_disable_wakeup(struct gpio_keys_drvdata *ddata) |
| { |
| struct gpio_button_data *bdata; |
| int i; |
| |
| for (i = 0; i < ddata->pdata->nbuttons; i++) { |
| bdata = &ddata->data[i]; |
| bdata->suspended = false; |
| if (irqd_is_wakeup_set(irq_get_irq_data(bdata->irq))) |
| gpio_keys_button_disable_wakeup(bdata); |
| } |
| } |
| |
| static int gpio_keys_suspend(struct device *dev) |
| { |
| struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); |
| struct input_dev *input = ddata->input; |
| int error; |
| |
| if (device_may_wakeup(dev)) { |
| error = gpio_keys_enable_wakeup(ddata); |
| if (error) |
| return error; |
| } else { |
| mutex_lock(&input->mutex); |
| if (input_device_enabled(input)) |
| gpio_keys_close(input); |
| mutex_unlock(&input->mutex); |
| } |
| |
| return 0; |
| } |
| |
| static int gpio_keys_resume(struct device *dev) |
| { |
| struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); |
| struct input_dev *input = ddata->input; |
| int error = 0; |
| |
| if (device_may_wakeup(dev)) { |
| gpio_keys_disable_wakeup(ddata); |
| } else { |
| mutex_lock(&input->mutex); |
| if (input_device_enabled(input)) |
| error = gpio_keys_open(input); |
| mutex_unlock(&input->mutex); |
| } |
| |
| if (error) |
| return error; |
| |
| gpio_keys_report_state(ddata); |
| return 0; |
| } |
| |
| static DEFINE_SIMPLE_DEV_PM_OPS(gpio_keys_pm_ops, gpio_keys_suspend, gpio_keys_resume); |
| |
| static void gpio_keys_shutdown(struct platform_device *pdev) |
| { |
| int ret; |
| |
| ret = gpio_keys_suspend(&pdev->dev); |
| if (ret) |
| dev_err(&pdev->dev, "failed to shutdown\n"); |
| } |
| |
| static struct platform_driver gpio_keys_device_driver = { |
| .probe = gpio_keys_probe, |
| .shutdown = gpio_keys_shutdown, |
| .driver = { |
| .name = "gpio-keys", |
| .pm = pm_sleep_ptr(&gpio_keys_pm_ops), |
| .of_match_table = gpio_keys_of_match, |
| .dev_groups = gpio_keys_groups, |
| } |
| }; |
| |
| static int __init gpio_keys_init(void) |
| { |
| return platform_driver_register(&gpio_keys_device_driver); |
| } |
| |
| static void __exit gpio_keys_exit(void) |
| { |
| platform_driver_unregister(&gpio_keys_device_driver); |
| } |
| |
| late_initcall(gpio_keys_init); |
| module_exit(gpio_keys_exit); |
| |
| MODULE_LICENSE("GPL"); |
| MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>"); |
| MODULE_DESCRIPTION("Keyboard driver for GPIOs"); |
| MODULE_ALIAS("platform:gpio-keys"); |