| /* |
| * Driver for keys on GPIO lines capable of generating interrupts. |
| * |
| * Copyright 2005 Phil Blundell |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| */ |
| |
| #include <linux/module.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/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> |
| |
| struct gpio_button_data { |
| struct gpio_keys_button *button; |
| struct input_dev *input; |
| struct timer_list timer; |
| struct work_struct work; |
| }; |
| |
| struct gpio_keys_drvdata { |
| struct input_dev *input; |
| struct gpio_button_data data[0]; |
| }; |
| |
| static void gpio_keys_report_event(struct work_struct *work) |
| { |
| struct gpio_button_data *bdata = |
| container_of(work, struct gpio_button_data, work); |
| struct gpio_keys_button *button = bdata->button; |
| struct input_dev *input = bdata->input; |
| unsigned int type = button->type ?: EV_KEY; |
| int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low; |
| |
| input_event(input, type, button->code, !!state); |
| input_sync(input); |
| } |
| |
| static void gpio_keys_timer(unsigned long _data) |
| { |
| struct gpio_button_data *data = (struct gpio_button_data *)_data; |
| |
| schedule_work(&data->work); |
| } |
| |
| static irqreturn_t gpio_keys_isr(int irq, void *dev_id) |
| { |
| struct gpio_button_data *bdata = dev_id; |
| struct gpio_keys_button *button = bdata->button; |
| |
| BUG_ON(irq != gpio_to_irq(button->gpio)); |
| |
| if (button->debounce_interval) |
| mod_timer(&bdata->timer, |
| jiffies + msecs_to_jiffies(button->debounce_interval)); |
| else |
| schedule_work(&bdata->work); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static int __devinit gpio_keys_setup_key(struct device *dev, |
| struct gpio_button_data *bdata, |
| struct gpio_keys_button *button) |
| { |
| char *desc = button->desc ? button->desc : "gpio_keys"; |
| int irq, error; |
| |
| setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata); |
| INIT_WORK(&bdata->work, gpio_keys_report_event); |
| |
| error = gpio_request(button->gpio, desc); |
| if (error < 0) { |
| dev_err(dev, "failed to request GPIO %d, error %d\n", |
| button->gpio, error); |
| goto fail2; |
| } |
| |
| error = gpio_direction_input(button->gpio); |
| if (error < 0) { |
| dev_err(dev, "failed to configure" |
| " direction for GPIO %d, error %d\n", |
| button->gpio, error); |
| goto fail3; |
| } |
| |
| irq = gpio_to_irq(button->gpio); |
| if (irq < 0) { |
| error = irq; |
| dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n", |
| button->gpio, error); |
| goto fail3; |
| } |
| |
| error = request_irq(irq, gpio_keys_isr, |
| IRQF_SHARED | |
| IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| desc, bdata); |
| if (error) { |
| dev_err(dev, "Unable to claim irq %d; error %d\n", |
| irq, error); |
| goto fail3; |
| } |
| |
| return 0; |
| |
| fail3: |
| gpio_free(button->gpio); |
| fail2: |
| return error; |
| } |
| |
| static int __devinit gpio_keys_probe(struct platform_device *pdev) |
| { |
| struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
| struct gpio_keys_drvdata *ddata; |
| struct device *dev = &pdev->dev; |
| struct input_dev *input; |
| int i, error; |
| int wakeup = 0; |
| |
| ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + |
| pdata->nbuttons * sizeof(struct gpio_button_data), |
| GFP_KERNEL); |
| input = input_allocate_device(); |
| if (!ddata || !input) { |
| dev_err(dev, "failed to allocate state\n"); |
| error = -ENOMEM; |
| goto fail1; |
| } |
| |
| platform_set_drvdata(pdev, ddata); |
| |
| input->name = pdev->name; |
| input->phys = "gpio-keys/input0"; |
| input->dev.parent = &pdev->dev; |
| |
| input->id.bustype = BUS_HOST; |
| input->id.vendor = 0x0001; |
| input->id.product = 0x0001; |
| input->id.version = 0x0100; |
| |
| /* Enable auto repeat feature of Linux input subsystem */ |
| if (pdata->rep) |
| __set_bit(EV_REP, input->evbit); |
| |
| ddata->input = input; |
| |
| for (i = 0; i < pdata->nbuttons; i++) { |
| struct gpio_keys_button *button = &pdata->buttons[i]; |
| struct gpio_button_data *bdata = &ddata->data[i]; |
| unsigned int type = button->type ?: EV_KEY; |
| |
| bdata->input = input; |
| bdata->button = button; |
| |
| error = gpio_keys_setup_key(dev, bdata, button); |
| if (error) |
| goto fail2; |
| |
| if (button->wakeup) |
| wakeup = 1; |
| |
| input_set_capability(input, type, button->code); |
| } |
| |
| error = input_register_device(input); |
| if (error) { |
| dev_err(dev, "Unable to register input device, " |
| "error: %d\n", error); |
| goto fail2; |
| } |
| |
| device_init_wakeup(&pdev->dev, wakeup); |
| |
| return 0; |
| |
| fail2: |
| while (--i >= 0) { |
| free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]); |
| if (pdata->buttons[i].debounce_interval) |
| del_timer_sync(&ddata->data[i].timer); |
| cancel_work_sync(&ddata->data[i].work); |
| gpio_free(pdata->buttons[i].gpio); |
| } |
| |
| platform_set_drvdata(pdev, NULL); |
| fail1: |
| input_free_device(input); |
| kfree(ddata); |
| |
| return error; |
| } |
| |
| static int __devexit gpio_keys_remove(struct platform_device *pdev) |
| { |
| struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
| struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); |
| struct input_dev *input = ddata->input; |
| int i; |
| |
| device_init_wakeup(&pdev->dev, 0); |
| |
| for (i = 0; i < pdata->nbuttons; i++) { |
| int irq = gpio_to_irq(pdata->buttons[i].gpio); |
| free_irq(irq, &ddata->data[i]); |
| if (pdata->buttons[i].debounce_interval) |
| del_timer_sync(&ddata->data[i].timer); |
| cancel_work_sync(&ddata->data[i].work); |
| gpio_free(pdata->buttons[i].gpio); |
| } |
| |
| input_unregister_device(input); |
| |
| return 0; |
| } |
| |
| |
| #ifdef CONFIG_PM |
| static int gpio_keys_suspend(struct device *dev) |
| { |
| struct platform_device *pdev = to_platform_device(dev); |
| struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
| int i; |
| |
| if (device_may_wakeup(&pdev->dev)) { |
| for (i = 0; i < pdata->nbuttons; i++) { |
| struct gpio_keys_button *button = &pdata->buttons[i]; |
| if (button->wakeup) { |
| int irq = gpio_to_irq(button->gpio); |
| enable_irq_wake(irq); |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int gpio_keys_resume(struct device *dev) |
| { |
| struct platform_device *pdev = to_platform_device(dev); |
| struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
| int i; |
| |
| if (device_may_wakeup(&pdev->dev)) { |
| for (i = 0; i < pdata->nbuttons; i++) { |
| struct gpio_keys_button *button = &pdata->buttons[i]; |
| if (button->wakeup) { |
| int irq = gpio_to_irq(button->gpio); |
| disable_irq_wake(irq); |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| static const struct dev_pm_ops gpio_keys_pm_ops = { |
| .suspend = gpio_keys_suspend, |
| .resume = gpio_keys_resume, |
| }; |
| #endif |
| |
| static struct platform_driver gpio_keys_device_driver = { |
| .probe = gpio_keys_probe, |
| .remove = __devexit_p(gpio_keys_remove), |
| .driver = { |
| .name = "gpio-keys", |
| .owner = THIS_MODULE, |
| #ifdef CONFIG_PM |
| .pm = &gpio_keys_pm_ops, |
| #endif |
| } |
| }; |
| |
| 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); |
| } |
| |
| module_init(gpio_keys_init); |
| module_exit(gpio_keys_exit); |
| |
| MODULE_LICENSE("GPL"); |
| MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>"); |
| MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs"); |
| MODULE_ALIAS("platform:gpio-keys"); |