Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 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> |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 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> |
David Brownell | 49015be | 2007-03-05 00:30:22 -0800 | [diff] [blame] | 24 | #include <linux/gpio_keys.h> |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 25 | #include <linux/workqueue.h> |
Ben Dooks | 111bc59 | 2009-11-10 21:01:31 -0800 | [diff] [blame] | 26 | #include <linux/gpio.h> |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 27 | |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 28 | struct gpio_button_data { |
| 29 | struct gpio_keys_button *button; |
| 30 | struct input_dev *input; |
Jani Nikula | ca865a7 | 2009-06-28 22:38:44 -0700 | [diff] [blame] | 31 | struct timer_list timer; |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 32 | struct work_struct work; |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 33 | }; |
| 34 | |
| 35 | struct gpio_keys_drvdata { |
| 36 | struct input_dev *input; |
| 37 | struct gpio_button_data data[0]; |
| 38 | }; |
| 39 | |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 40 | static void gpio_keys_report_event(struct gpio_button_data *bdata) |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 41 | { |
Uwe Kleine-König | ce25d7e | 2008-08-08 12:14:36 -0400 | [diff] [blame] | 42 | struct gpio_keys_button *button = bdata->button; |
| 43 | struct input_dev *input = bdata->input; |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 44 | unsigned int type = button->type ?: EV_KEY; |
| 45 | int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low; |
| 46 | |
| 47 | input_event(input, type, button->code, !!state); |
| 48 | input_sync(input); |
| 49 | } |
| 50 | |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 51 | static void gpio_keys_work_func(struct work_struct *work) |
| 52 | { |
| 53 | struct gpio_button_data *bdata = |
| 54 | container_of(work, struct gpio_button_data, work); |
| 55 | |
| 56 | gpio_keys_report_event(bdata); |
| 57 | } |
| 58 | |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 59 | static void gpio_keys_timer(unsigned long _data) |
Jani Nikula | ca865a7 | 2009-06-28 22:38:44 -0700 | [diff] [blame] | 60 | { |
| 61 | struct gpio_button_data *data = (struct gpio_button_data *)_data; |
| 62 | |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 63 | schedule_work(&data->work); |
Jani Nikula | ca865a7 | 2009-06-28 22:38:44 -0700 | [diff] [blame] | 64 | } |
| 65 | |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 66 | static irqreturn_t gpio_keys_isr(int irq, void *dev_id) |
| 67 | { |
Uwe Kleine-König | 57ffe9d | 2008-08-08 12:14:34 -0400 | [diff] [blame] | 68 | struct gpio_button_data *bdata = dev_id; |
| 69 | struct gpio_keys_button *button = bdata->button; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 70 | |
Uwe Kleine-König | 57ffe9d | 2008-08-08 12:14:34 -0400 | [diff] [blame] | 71 | BUG_ON(irq != gpio_to_irq(button->gpio)); |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 72 | |
Jani Nikula | ca865a7 | 2009-06-28 22:38:44 -0700 | [diff] [blame] | 73 | if (button->debounce_interval) |
| 74 | mod_timer(&bdata->timer, |
| 75 | jiffies + msecs_to_jiffies(button->debounce_interval)); |
| 76 | else |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 77 | schedule_work(&bdata->work); |
Roman Moravcik | 84767d0 | 2007-05-01 00:39:13 -0400 | [diff] [blame] | 78 | |
Uwe Kleine-König | 57ffe9d | 2008-08-08 12:14:34 -0400 | [diff] [blame] | 79 | return IRQ_HANDLED; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 80 | } |
| 81 | |
Ben Dooks | bc8f1ea | 2009-11-10 21:01:31 -0800 | [diff] [blame] | 82 | static int __devinit gpio_keys_setup_key(struct device *dev, |
| 83 | struct gpio_button_data *bdata, |
| 84 | struct gpio_keys_button *button) |
| 85 | { |
| 86 | char *desc = button->desc ? button->desc : "gpio_keys"; |
| 87 | int irq, error; |
| 88 | |
| 89 | setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata); |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 90 | INIT_WORK(&bdata->work, gpio_keys_work_func); |
Ben Dooks | bc8f1ea | 2009-11-10 21:01:31 -0800 | [diff] [blame] | 91 | |
| 92 | error = gpio_request(button->gpio, desc); |
| 93 | if (error < 0) { |
| 94 | dev_err(dev, "failed to request GPIO %d, error %d\n", |
| 95 | button->gpio, error); |
| 96 | goto fail2; |
| 97 | } |
| 98 | |
| 99 | error = gpio_direction_input(button->gpio); |
| 100 | if (error < 0) { |
| 101 | dev_err(dev, "failed to configure" |
| 102 | " direction for GPIO %d, error %d\n", |
| 103 | button->gpio, error); |
| 104 | goto fail3; |
| 105 | } |
| 106 | |
| 107 | irq = gpio_to_irq(button->gpio); |
| 108 | if (irq < 0) { |
| 109 | error = irq; |
| 110 | dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n", |
| 111 | button->gpio, error); |
| 112 | goto fail3; |
| 113 | } |
| 114 | |
| 115 | error = request_irq(irq, gpio_keys_isr, |
| 116 | IRQF_SHARED | |
| 117 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
| 118 | desc, bdata); |
| 119 | if (error) { |
| 120 | dev_err(dev, "Unable to claim irq %d; error %d\n", |
| 121 | irq, error); |
| 122 | goto fail3; |
| 123 | } |
| 124 | |
| 125 | return 0; |
| 126 | |
| 127 | fail3: |
| 128 | gpio_free(button->gpio); |
| 129 | fail2: |
| 130 | return error; |
| 131 | } |
| 132 | |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 133 | static int __devinit gpio_keys_probe(struct platform_device *pdev) |
| 134 | { |
| 135 | struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 136 | struct gpio_keys_drvdata *ddata; |
Ben Dooks | db19fd8 | 2009-11-10 21:00:35 -0800 | [diff] [blame] | 137 | struct device *dev = &pdev->dev; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 138 | struct input_dev *input; |
| 139 | int i, error; |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 140 | int wakeup = 0; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 141 | |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 142 | ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + |
| 143 | pdata->nbuttons * sizeof(struct gpio_button_data), |
| 144 | GFP_KERNEL); |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 145 | input = input_allocate_device(); |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 146 | if (!ddata || !input) { |
Ben Dooks | db19fd8 | 2009-11-10 21:00:35 -0800 | [diff] [blame] | 147 | dev_err(dev, "failed to allocate state\n"); |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 148 | error = -ENOMEM; |
| 149 | goto fail1; |
| 150 | } |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 151 | |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 152 | platform_set_drvdata(pdev, ddata); |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 153 | |
| 154 | input->name = pdev->name; |
| 155 | input->phys = "gpio-keys/input0"; |
Dmitry Torokhov | 469ba4d | 2007-04-12 01:34:58 -0400 | [diff] [blame] | 156 | input->dev.parent = &pdev->dev; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 157 | |
| 158 | input->id.bustype = BUS_HOST; |
| 159 | input->id.vendor = 0x0001; |
| 160 | input->id.product = 0x0001; |
| 161 | input->id.version = 0x0100; |
| 162 | |
Dominic Curran | b67b4b1 | 2008-10-27 22:30:53 -0400 | [diff] [blame] | 163 | /* Enable auto repeat feature of Linux input subsystem */ |
| 164 | if (pdata->rep) |
| 165 | __set_bit(EV_REP, input->evbit); |
| 166 | |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 167 | ddata->input = input; |
| 168 | |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 169 | for (i = 0; i < pdata->nbuttons; i++) { |
Roman Moravcik | 84767d0 | 2007-05-01 00:39:13 -0400 | [diff] [blame] | 170 | struct gpio_keys_button *button = &pdata->buttons[i]; |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 171 | struct gpio_button_data *bdata = &ddata->data[i]; |
Roman Moravcik | 84767d0 | 2007-05-01 00:39:13 -0400 | [diff] [blame] | 172 | unsigned int type = button->type ?: EV_KEY; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 173 | |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 174 | bdata->input = input; |
Uwe Kleine-König | 74dd439 | 2008-07-30 10:33:43 -0400 | [diff] [blame] | 175 | bdata->button = button; |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 176 | |
Ben Dooks | bc8f1ea | 2009-11-10 21:01:31 -0800 | [diff] [blame] | 177 | error = gpio_keys_setup_key(dev, bdata, button); |
| 178 | if (error) |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 179 | goto fail2; |
Roman Moravcik | 84767d0 | 2007-05-01 00:39:13 -0400 | [diff] [blame] | 180 | |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 181 | if (button->wakeup) |
| 182 | wakeup = 1; |
| 183 | |
Roman Moravcik | 84767d0 | 2007-05-01 00:39:13 -0400 | [diff] [blame] | 184 | input_set_capability(input, type, button->code); |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | error = input_register_device(input); |
| 188 | if (error) { |
Ben Dooks | db19fd8 | 2009-11-10 21:00:35 -0800 | [diff] [blame] | 189 | dev_err(dev, "Unable to register input device, " |
Anti Sullin | 006df30 | 2007-09-26 00:01:03 -0400 | [diff] [blame] | 190 | "error: %d\n", error); |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 191 | goto fail2; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 192 | } |
| 193 | |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 194 | /* get current state of buttons */ |
| 195 | for (i = 0; i < pdata->nbuttons; i++) |
| 196 | gpio_keys_report_event(&ddata->data[i]); |
| 197 | input_sync(input); |
| 198 | |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 199 | device_init_wakeup(&pdev->dev, wakeup); |
| 200 | |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 201 | return 0; |
| 202 | |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 203 | fail2: |
Herbert Valerio Riedel | 6a2e391 | 2007-11-21 14:42:33 -0500 | [diff] [blame] | 204 | while (--i >= 0) { |
Uwe Kleine-König | 57ffe9d | 2008-08-08 12:14:34 -0400 | [diff] [blame] | 205 | free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]); |
Jani Nikula | ca865a7 | 2009-06-28 22:38:44 -0700 | [diff] [blame] | 206 | if (pdata->buttons[i].debounce_interval) |
| 207 | del_timer_sync(&ddata->data[i].timer); |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 208 | cancel_work_sync(&ddata->data[i].work); |
Herbert Valerio Riedel | 6a2e391 | 2007-11-21 14:42:33 -0500 | [diff] [blame] | 209 | gpio_free(pdata->buttons[i].gpio); |
| 210 | } |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 211 | |
Anti Sullin | 006df30 | 2007-09-26 00:01:03 -0400 | [diff] [blame] | 212 | platform_set_drvdata(pdev, NULL); |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 213 | fail1: |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 214 | input_free_device(input); |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 215 | kfree(ddata); |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 216 | |
| 217 | return error; |
| 218 | } |
| 219 | |
| 220 | static int __devexit gpio_keys_remove(struct platform_device *pdev) |
| 221 | { |
| 222 | struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
Dmitry Baryshkov | a33466e | 2008-05-07 16:30:15 -0400 | [diff] [blame] | 223 | struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); |
| 224 | struct input_dev *input = ddata->input; |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 225 | int i; |
| 226 | |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 227 | device_init_wakeup(&pdev->dev, 0); |
| 228 | |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 229 | for (i = 0; i < pdata->nbuttons; i++) { |
Philipp Zabel | 0d98f6b | 2007-02-18 01:40:46 -0500 | [diff] [blame] | 230 | int irq = gpio_to_irq(pdata->buttons[i].gpio); |
Uwe Kleine-König | 57ffe9d | 2008-08-08 12:14:34 -0400 | [diff] [blame] | 231 | free_irq(irq, &ddata->data[i]); |
Jani Nikula | ca865a7 | 2009-06-28 22:38:44 -0700 | [diff] [blame] | 232 | if (pdata->buttons[i].debounce_interval) |
| 233 | del_timer_sync(&ddata->data[i].timer); |
Jani Nikula | da0d03f | 2009-06-28 22:38:56 -0700 | [diff] [blame] | 234 | cancel_work_sync(&ddata->data[i].work); |
Herbert Valerio Riedel | 6a2e391 | 2007-11-21 14:42:33 -0500 | [diff] [blame] | 235 | gpio_free(pdata->buttons[i].gpio); |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 236 | } |
| 237 | |
| 238 | input_unregister_device(input); |
| 239 | |
| 240 | return 0; |
| 241 | } |
| 242 | |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 243 | |
| 244 | #ifdef CONFIG_PM |
Mike Rapoport | ae78e0e | 2009-07-22 23:02:54 -0700 | [diff] [blame] | 245 | static int gpio_keys_suspend(struct device *dev) |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 246 | { |
Mike Rapoport | ae78e0e | 2009-07-22 23:02:54 -0700 | [diff] [blame] | 247 | struct platform_device *pdev = to_platform_device(dev); |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 248 | struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
| 249 | int i; |
| 250 | |
| 251 | if (device_may_wakeup(&pdev->dev)) { |
| 252 | for (i = 0; i < pdata->nbuttons; i++) { |
| 253 | struct gpio_keys_button *button = &pdata->buttons[i]; |
| 254 | if (button->wakeup) { |
| 255 | int irq = gpio_to_irq(button->gpio); |
| 256 | enable_irq_wake(irq); |
| 257 | } |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | return 0; |
| 262 | } |
| 263 | |
Mike Rapoport | ae78e0e | 2009-07-22 23:02:54 -0700 | [diff] [blame] | 264 | static int gpio_keys_resume(struct device *dev) |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 265 | { |
Mike Rapoport | ae78e0e | 2009-07-22 23:02:54 -0700 | [diff] [blame] | 266 | struct platform_device *pdev = to_platform_device(dev); |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 267 | struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev); |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 268 | struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; |
| 269 | int i; |
| 270 | |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 271 | for (i = 0; i < pdata->nbuttons; i++) { |
| 272 | |
| 273 | struct gpio_keys_button *button = &pdata->buttons[i]; |
| 274 | if (button->wakeup && device_may_wakeup(&pdev->dev)) { |
| 275 | int irq = gpio_to_irq(button->gpio); |
| 276 | disable_irq_wake(irq); |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 277 | } |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 278 | |
| 279 | gpio_keys_report_event(&ddata->data[i]); |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 280 | } |
Daniel Mack | 6ee88d7 | 2009-11-30 00:04:02 -0800 | [diff] [blame] | 281 | input_sync(ddata->input); |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 282 | |
| 283 | return 0; |
| 284 | } |
Mike Rapoport | ae78e0e | 2009-07-22 23:02:54 -0700 | [diff] [blame] | 285 | |
| 286 | static const struct dev_pm_ops gpio_keys_pm_ops = { |
| 287 | .suspend = gpio_keys_suspend, |
| 288 | .resume = gpio_keys_resume, |
| 289 | }; |
Anti Sullin | e15b021 | 2007-09-26 00:01:17 -0400 | [diff] [blame] | 290 | #endif |
| 291 | |
Uwe Kleine-König | 9b07044 | 2008-07-30 10:34:02 -0400 | [diff] [blame] | 292 | static struct platform_driver gpio_keys_device_driver = { |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 293 | .probe = gpio_keys_probe, |
| 294 | .remove = __devexit_p(gpio_keys_remove), |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 295 | .driver = { |
| 296 | .name = "gpio-keys", |
Kay Sievers | d7b5247 | 2008-04-18 00:24:42 -0400 | [diff] [blame] | 297 | .owner = THIS_MODULE, |
Mike Rapoport | ae78e0e | 2009-07-22 23:02:54 -0700 | [diff] [blame] | 298 | #ifdef CONFIG_PM |
| 299 | .pm = &gpio_keys_pm_ops, |
| 300 | #endif |
Phil Blundell | 78a56aa | 2007-01-18 00:44:09 -0500 | [diff] [blame] | 301 | } |
| 302 | }; |
| 303 | |
| 304 | static int __init gpio_keys_init(void) |
| 305 | { |
| 306 | return platform_driver_register(&gpio_keys_device_driver); |
| 307 | } |
| 308 | |
| 309 | static void __exit gpio_keys_exit(void) |
| 310 | { |
| 311 | platform_driver_unregister(&gpio_keys_device_driver); |
| 312 | } |
| 313 | |
| 314 | module_init(gpio_keys_init); |
| 315 | module_exit(gpio_keys_exit); |
| 316 | |
| 317 | MODULE_LICENSE("GPL"); |
| 318 | MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>"); |
| 319 | MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs"); |
Kay Sievers | d7b5247 | 2008-04-18 00:24:42 -0400 | [diff] [blame] | 320 | MODULE_ALIAS("platform:gpio-keys"); |