1 /* 2 * Driver for keys on GPIO lines capable of generating interrupts. 3 * 4 * Copyright 2005 Phil Blundell 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/module.h> 12 13 #include <linux/init.h> 14 #include <linux/fs.h> 15 #include <linux/interrupt.h> 16 #include <linux/irq.h> 17 #include <linux/sched.h> 18 #include <linux/pm.h> 19 #include <linux/sysctl.h> 20 #include <linux/proc_fs.h> 21 #include <linux/delay.h> 22 #include <linux/platform_device.h> 23 #include <linux/input.h> 24 #include <linux/gpio_keys.h> 25 26 #include <asm/gpio.h> 27 28 struct gpio_button_data { 29 struct gpio_keys_button *button; 30 struct input_dev *input; 31 struct timer_list timer; 32 }; 33 34 struct gpio_keys_drvdata { 35 struct input_dev *input; 36 struct gpio_button_data data[0]; 37 }; 38 39 static void gpio_keys_report_event(struct gpio_button_data *bdata) 40 { 41 struct gpio_keys_button *button = bdata->button; 42 struct input_dev *input = bdata->input; 43 unsigned int type = button->type ?: EV_KEY; 44 int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low; 45 46 input_event(input, type, button->code, !!state); 47 input_sync(input); 48 } 49 50 static void gpio_check_button(unsigned long _data) 51 { 52 struct gpio_button_data *data = (struct gpio_button_data *)_data; 53 54 gpio_keys_report_event(data); 55 } 56 57 static irqreturn_t gpio_keys_isr(int irq, void *dev_id) 58 { 59 struct gpio_button_data *bdata = dev_id; 60 struct gpio_keys_button *button = bdata->button; 61 62 BUG_ON(irq != gpio_to_irq(button->gpio)); 63 64 if (button->debounce_interval) 65 mod_timer(&bdata->timer, 66 jiffies + msecs_to_jiffies(button->debounce_interval)); 67 else 68 gpio_keys_report_event(bdata); 69 70 return IRQ_HANDLED; 71 } 72 73 static int __devinit gpio_keys_probe(struct platform_device *pdev) 74 { 75 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 76 struct gpio_keys_drvdata *ddata; 77 struct input_dev *input; 78 int i, error; 79 int wakeup = 0; 80 81 ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + 82 pdata->nbuttons * sizeof(struct gpio_button_data), 83 GFP_KERNEL); 84 input = input_allocate_device(); 85 if (!ddata || !input) { 86 error = -ENOMEM; 87 goto fail1; 88 } 89 90 platform_set_drvdata(pdev, ddata); 91 92 input->name = pdev->name; 93 input->phys = "gpio-keys/input0"; 94 input->dev.parent = &pdev->dev; 95 96 input->id.bustype = BUS_HOST; 97 input->id.vendor = 0x0001; 98 input->id.product = 0x0001; 99 input->id.version = 0x0100; 100 101 ddata->input = input; 102 103 for (i = 0; i < pdata->nbuttons; i++) { 104 struct gpio_keys_button *button = &pdata->buttons[i]; 105 struct gpio_button_data *bdata = &ddata->data[i]; 106 int irq; 107 unsigned int type = button->type ?: EV_KEY; 108 109 bdata->input = input; 110 bdata->button = button; 111 setup_timer(&bdata->timer, 112 gpio_check_button, (unsigned long)bdata); 113 114 error = gpio_request(button->gpio, button->desc ?: "gpio_keys"); 115 if (error < 0) { 116 pr_err("gpio-keys: failed to request GPIO %d," 117 " error %d\n", button->gpio, error); 118 goto fail2; 119 } 120 121 error = gpio_direction_input(button->gpio); 122 if (error < 0) { 123 pr_err("gpio-keys: failed to configure input" 124 " direction for GPIO %d, error %d\n", 125 button->gpio, error); 126 gpio_free(button->gpio); 127 goto fail2; 128 } 129 130 irq = gpio_to_irq(button->gpio); 131 if (irq < 0) { 132 error = irq; 133 pr_err("gpio-keys: Unable to get irq number" 134 " for GPIO %d, error %d\n", 135 button->gpio, error); 136 gpio_free(button->gpio); 137 goto fail2; 138 } 139 140 error = request_irq(irq, gpio_keys_isr, 141 IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_RISING | 142 IRQF_TRIGGER_FALLING, 143 button->desc ? button->desc : "gpio_keys", 144 bdata); 145 if (error) { 146 pr_err("gpio-keys: Unable to claim irq %d; error %d\n", 147 irq, error); 148 gpio_free(button->gpio); 149 goto fail2; 150 } 151 152 if (button->wakeup) 153 wakeup = 1; 154 155 input_set_capability(input, type, button->code); 156 } 157 158 error = input_register_device(input); 159 if (error) { 160 pr_err("gpio-keys: Unable to register input device, " 161 "error: %d\n", error); 162 goto fail2; 163 } 164 165 device_init_wakeup(&pdev->dev, wakeup); 166 167 return 0; 168 169 fail2: 170 while (--i >= 0) { 171 free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]); 172 if (pdata->buttons[i].debounce_interval) 173 del_timer_sync(&ddata->data[i].timer); 174 gpio_free(pdata->buttons[i].gpio); 175 } 176 177 platform_set_drvdata(pdev, NULL); 178 fail1: 179 input_free_device(input); 180 kfree(ddata); 181 182 return error; 183 } 184 185 static int __devexit gpio_keys_remove(struct platform_device *pdev) 186 { 187 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 188 struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); 189 struct input_dev *input = ddata->input; 190 int i; 191 192 device_init_wakeup(&pdev->dev, 0); 193 194 for (i = 0; i < pdata->nbuttons; i++) { 195 int irq = gpio_to_irq(pdata->buttons[i].gpio); 196 free_irq(irq, &ddata->data[i]); 197 if (pdata->buttons[i].debounce_interval) 198 del_timer_sync(&ddata->data[i].timer); 199 gpio_free(pdata->buttons[i].gpio); 200 } 201 202 input_unregister_device(input); 203 204 return 0; 205 } 206 207 208 #ifdef CONFIG_PM 209 static int gpio_keys_suspend(struct platform_device *pdev, pm_message_t state) 210 { 211 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 212 int i; 213 214 if (device_may_wakeup(&pdev->dev)) { 215 for (i = 0; i < pdata->nbuttons; i++) { 216 struct gpio_keys_button *button = &pdata->buttons[i]; 217 if (button->wakeup) { 218 int irq = gpio_to_irq(button->gpio); 219 enable_irq_wake(irq); 220 } 221 } 222 } 223 224 return 0; 225 } 226 227 static int gpio_keys_resume(struct platform_device *pdev) 228 { 229 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; 230 int i; 231 232 if (device_may_wakeup(&pdev->dev)) { 233 for (i = 0; i < pdata->nbuttons; i++) { 234 struct gpio_keys_button *button = &pdata->buttons[i]; 235 if (button->wakeup) { 236 int irq = gpio_to_irq(button->gpio); 237 disable_irq_wake(irq); 238 } 239 } 240 } 241 242 return 0; 243 } 244 #else 245 #define gpio_keys_suspend NULL 246 #define gpio_keys_resume NULL 247 #endif 248 249 static struct platform_driver gpio_keys_device_driver = { 250 .probe = gpio_keys_probe, 251 .remove = __devexit_p(gpio_keys_remove), 252 .suspend = gpio_keys_suspend, 253 .resume = gpio_keys_resume, 254 .driver = { 255 .name = "gpio-keys", 256 .owner = THIS_MODULE, 257 } 258 }; 259 260 static int __init gpio_keys_init(void) 261 { 262 return platform_driver_register(&gpio_keys_device_driver); 263 } 264 265 static void __exit gpio_keys_exit(void) 266 { 267 platform_driver_unregister(&gpio_keys_device_driver); 268 } 269 270 module_init(gpio_keys_init); 271 module_exit(gpio_keys_exit); 272 273 MODULE_LICENSE("GPL"); 274 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>"); 275 MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs"); 276 MODULE_ALIAS("platform:gpio-keys"); 277