OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [keyboard/] [gpio_keys.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl 
/*
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 
#include <linux/version.h>
13 
 
14 
#include <linux/init.h>
15 
#include <linux/fs.h>
16 
#include <linux/interrupt.h>
17 
#include <linux/irq.h>
18 
#include <linux/sched.h>
19 
#include <linux/pm.h>
20 
#include <linux/sysctl.h>
21 
#include <linux/proc_fs.h>
22 
#include <linux/delay.h>
23 
#include <linux/platform_device.h>
24 
#include <linux/input.h>
25 
#include <linux/gpio_keys.h>
26 
 
27 
#include <asm/gpio.h>
28 
 
29 
static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
30 
{
31 
        int i;
32 
        struct platform_device *pdev = dev_id;
33 
        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
34 
        struct input_dev *input = platform_get_drvdata(pdev);
35 
 
36 
        for (i = 0; i < pdata->nbuttons; i++) {
37 
                struct gpio_keys_button *button = &pdata->buttons[i];
38 
                int gpio = button->gpio;
39 
 
40 
                if (irq == gpio_to_irq(gpio)) {
41 
                        unsigned int type = button->type ?: EV_KEY;
42 
                        int state = (gpio_get_value(gpio) ? 1 : 0) ^ button->active_low;
43 
 
44 
                        input_event(input, type, button->code, !!state);
45 
                        input_sync(input);
46 
                }
47 
        }
48 
 
49 
        return IRQ_HANDLED;
50 
}
51 
 
52 
static int __devinit gpio_keys_probe(struct platform_device *pdev)
53 
{
54 
        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
55 
        struct input_dev *input;
56 
        int i, error;
57 
        int wakeup = 0;
58 
 
59 
        input = input_allocate_device();
60 
        if (!input)
61 
                return -ENOMEM;
62 
 
63 
        platform_set_drvdata(pdev, input);
64 
 
65 
        input->evbit[0] = BIT_MASK(EV_KEY);
66 
 
67 
        input->name = pdev->name;
68 
        input->phys = "gpio-keys/input0";
69 
        input->dev.parent = &pdev->dev;
70 
 
71 
        input->id.bustype = BUS_HOST;
72 
        input->id.vendor = 0x0001;
73 
        input->id.product = 0x0001;
74 
        input->id.version = 0x0100;
75 
 
76 
        for (i = 0; i < pdata->nbuttons; i++) {
77 
                struct gpio_keys_button *button = &pdata->buttons[i];
78 
                int irq;
79 
                unsigned int type = button->type ?: EV_KEY;
80 
 
81 
                error = gpio_request(button->gpio, button->desc ?: "gpio_keys");
82 
                if (error < 0) {
83 
                        pr_err("gpio-keys: failed to request GPIO %d,"
84 
                                " error %d\n", button->gpio, error);
85 
                        goto fail;
86 
                }
87 
 
88 
                error = gpio_direction_input(button->gpio);
89 
                if (error < 0) {
90 
                        pr_err("gpio-keys: failed to configure input"
91 
                                " direction for GPIO %d, error %d\n",
92 
                                button->gpio, error);
93 
                        gpio_free(button->gpio);
94 
                        goto fail;
95 
                }
96 
 
97 
                irq = gpio_to_irq(button->gpio);
98 
                if (irq < 0) {
99 
                        error = irq;
100 
                        pr_err("gpio-keys: Unable to get irq number"
101 
                                " for GPIO %d, error %d\n",
102 
                                button->gpio, error);
103 
                        gpio_free(button->gpio);
104 
                        goto fail;
105 
                }
106 
 
107 
                error = request_irq(irq, gpio_keys_isr,
108 
                                    IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_RISING |
109 
                                        IRQF_TRIGGER_FALLING,
110 
                                    button->desc ? button->desc : "gpio_keys",
111 
                                    pdev);
112 
                if (error) {
113 
                        pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
114 
                                irq, error);
115 
                        gpio_free(button->gpio);
116 
                        goto fail;
117 
                }
118 
 
119 
                if (button->wakeup)
120 
                        wakeup = 1;
121 
 
122 
                input_set_capability(input, type, button->code);
123 
        }
124 
 
125 
        error = input_register_device(input);
126 
        if (error) {
127 
                pr_err("gpio-keys: Unable to register input device, "
128 
                        "error: %d\n", error);
129 
                goto fail;
130 
        }
131 
 
132 
        device_init_wakeup(&pdev->dev, wakeup);
133 
 
134 
        return 0;
135 
 
136 
 fail:
137 
        while (--i >= 0) {
138 
                free_irq(gpio_to_irq(pdata->buttons[i].gpio), pdev);
139 
                gpio_free(pdata->buttons[i].gpio);
140 
        }
141 
 
142 
        platform_set_drvdata(pdev, NULL);
143 
        input_free_device(input);
144 
 
145 
        return error;
146 
}
147 
 
148 
static int __devexit gpio_keys_remove(struct platform_device *pdev)
149 
{
150 
        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
151 
        struct input_dev *input = platform_get_drvdata(pdev);
152 
        int i;
153 
 
154 
        device_init_wakeup(&pdev->dev, 0);
155 
 
156 
        for (i = 0; i < pdata->nbuttons; i++) {
157 
                int irq = gpio_to_irq(pdata->buttons[i].gpio);
158 
                free_irq(irq, pdev);
159 
                gpio_free(pdata->buttons[i].gpio);
160 
        }
161 
 
162 
        input_unregister_device(input);
163 
 
164 
        return 0;
165 
}
166 
 
167 
 
168 
#ifdef CONFIG_PM
169 
static int gpio_keys_suspend(struct platform_device *pdev, pm_message_t state)
170 
{
171 
        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
172 
        int i;
173 
 
174 
        if (device_may_wakeup(&pdev->dev)) {
175 
                for (i = 0; i < pdata->nbuttons; i++) {
176 
                        struct gpio_keys_button *button = &pdata->buttons[i];
177 
                        if (button->wakeup) {
178 
                                int irq = gpio_to_irq(button->gpio);
179 
                                enable_irq_wake(irq);
180 
                        }
181 
                }
182 
        }
183 
 
184 
        return 0;
185 
}
186 
 
187 
static int gpio_keys_resume(struct platform_device *pdev)
188 
{
189 
        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
190 
        int i;
191 
 
192 
        if (device_may_wakeup(&pdev->dev)) {
193 
                for (i = 0; i < pdata->nbuttons; i++) {
194 
                        struct gpio_keys_button *button = &pdata->buttons[i];
195 
                        if (button->wakeup) {
196 
                                int irq = gpio_to_irq(button->gpio);
197 
                                disable_irq_wake(irq);
198 
                        }
199 
                }
200 
        }
201 
 
202 
        return 0;
203 
}
204 
#else
205 
#define gpio_keys_suspend       NULL
206 
#define gpio_keys_resume        NULL
207 
#endif
208 
 
209 
struct platform_driver gpio_keys_device_driver = {
210 
        .probe          = gpio_keys_probe,
211 
        .remove         = __devexit_p(gpio_keys_remove),
212 
        .suspend        = gpio_keys_suspend,
213 
        .resume         = gpio_keys_resume,
214 
        .driver         = {
215 
                .name   = "gpio-keys",
216 
        }
217 
};
218 
 
219 
static int __init gpio_keys_init(void)
220 
{
221 
        return platform_driver_register(&gpio_keys_device_driver);
222 
}
223 
 
224 
static void __exit gpio_keys_exit(void)
225 
{
226 
        platform_driver_unregister(&gpio_keys_device_driver);
227 
}
228 
 
229 
module_init(gpio_keys_init);
230 
module_exit(gpio_keys_exit);
231 
 
232 
MODULE_LICENSE("GPL");
233 
MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
234 
MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.