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

Subversion Repositories test_project

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

Details | Compare with Previous | View Log


/*
 * File:         drivers/input/keyboard/bf54x-keys.c
 * Based on:
 * Author:       Michael Hennerich <hennerich@blackfin.uclinux.org>
 *
 * Created:
 * Description:  keypad driver for Analog Devices Blackfin BF54x Processors
 *
 *
 * Modified:
 *               Copyright 2007 Analog Devices Inc.
 *
 * Bugs:         Enter bugs at http://blackfin.uclinux.org/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see the file COPYING, or write
 * to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#include <linux/module.h>
#include <linux/version.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/irq.h>
 
#include <asm/portmux.h>
#include <asm/mach/bf54x_keys.h>
 
#define DRV_NAME        "bf54x-keys"
#define TIME_SCALE      100     /* 100 ns */
#define MAX_MULT        (0xFF * TIME_SCALE)
#define MAX_RC          8       /* Max Row/Col */
 
static const u16 per_rows[] = {
        P_KEY_ROW7,
        P_KEY_ROW6,
        P_KEY_ROW5,
        P_KEY_ROW4,
        P_KEY_ROW3,
        P_KEY_ROW2,
        P_KEY_ROW1,
        P_KEY_ROW0,
 
};
 
static const u16 per_cols[] = {
        P_KEY_COL7,
        P_KEY_COL6,
        P_KEY_COL5,
        P_KEY_COL4,
        P_KEY_COL3,
        P_KEY_COL2,
        P_KEY_COL1,
        P_KEY_COL0,
 
};
 
struct bf54x_kpad {
        struct input_dev *input;
        int irq;
        unsigned short lastkey;
        unsigned short *keycode;
        struct timer_list timer;
        unsigned int keyup_test_jiffies;
};
 
static inline int bfin_kpad_find_key(struct bf54x_kpad *bf54x_kpad,
                        struct input_dev *input, u16 keyident)
{
        u16 i;
 
        for (i = 0; i < input->keycodemax; i++)
                if (bf54x_kpad->keycode[i + input->keycodemax] == keyident)
                        return bf54x_kpad->keycode[i];
        return -1;
}
 
static inline void bfin_keycodecpy(unsigned short *keycode,
                        const unsigned int *pdata_kc,
                        unsigned short keymapsize)
{
        unsigned int i;
 
        for (i = 0; i < keymapsize; i++) {
                keycode[i] = pdata_kc[i] & 0xffff;
                keycode[i + keymapsize] = pdata_kc[i] >> 16;
        }
}
 
static inline u16 bfin_kpad_get_prescale(u32 timescale)
{
        u32 sclk = get_sclk();
 
        return ((((sclk / 1000) * timescale) / 1024) - 1);
}
 
static inline u16 bfin_kpad_get_keypressed(struct bf54x_kpad *bf54x_kpad)
{
        return (bfin_read_KPAD_STAT() & KPAD_PRESSED);
}
 
static inline void bfin_kpad_clear_irq(void)
{
        bfin_write_KPAD_STAT(0xFFFF);
        bfin_write_KPAD_ROWCOL(0xFFFF);
}
 
static void bfin_kpad_timer(unsigned long data)
{
        struct platform_device *pdev =  (struct platform_device *) data;
        struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
 
        if (bfin_kpad_get_keypressed(bf54x_kpad)) {
                /* Try again later */
                mod_timer(&bf54x_kpad->timer,
                          jiffies + bf54x_kpad->keyup_test_jiffies);
                return;
        }
 
        input_report_key(bf54x_kpad->input, bf54x_kpad->lastkey, 0);
        input_sync(bf54x_kpad->input);
 
        /* Clear IRQ Status */
 
        bfin_kpad_clear_irq();
        enable_irq(bf54x_kpad->irq);
}
 
static irqreturn_t bfin_kpad_isr(int irq, void *dev_id)
{
        struct platform_device *pdev = dev_id;
        struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
        struct input_dev *input = bf54x_kpad->input;
        int key;
        u16 rowcol = bfin_read_KPAD_ROWCOL();
 
        key = bfin_kpad_find_key(bf54x_kpad, input, rowcol);
 
        input_report_key(input, key, 1);
        input_sync(input);
 
        if (bfin_kpad_get_keypressed(bf54x_kpad)) {
                disable_irq(bf54x_kpad->irq);
                bf54x_kpad->lastkey = key;
                mod_timer(&bf54x_kpad->timer,
                          jiffies + bf54x_kpad->keyup_test_jiffies);
        } else {
                input_report_key(input, key, 0);
                input_sync(input);
 
                bfin_kpad_clear_irq();
        }
 
        return IRQ_HANDLED;
}
 
static int __devinit bfin_kpad_probe(struct platform_device *pdev)
{
        struct bf54x_kpad *bf54x_kpad;
        struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;
        struct input_dev *input;
        int i, error;
 
        if (!pdata->rows || !pdata->cols || !pdata->keymap) {
                printk(KERN_ERR DRV_NAME
                        ": No rows, cols or keymap from pdata\n");
                return -EINVAL;
        }
 
        if (!pdata->keymapsize ||
            pdata->keymapsize > (pdata->rows * pdata->cols)) {
                printk(KERN_ERR DRV_NAME ": Invalid keymapsize\n");
                return -EINVAL;
        }
 
        bf54x_kpad = kzalloc(sizeof(struct bf54x_kpad), GFP_KERNEL);
        if (!bf54x_kpad)
                return -ENOMEM;
 
        platform_set_drvdata(pdev, bf54x_kpad);
 
        /* Allocate memory for keymap followed by private LUT */
        bf54x_kpad->keycode = kmalloc(pdata->keymapsize *
                                        sizeof(unsigned short) * 2, GFP_KERNEL);
        if (!bf54x_kpad->keycode) {
                error = -ENOMEM;
                goto out;
        }
 
        if (!pdata->debounce_time || !pdata->debounce_time > MAX_MULT ||
            !pdata->coldrive_time || !pdata->coldrive_time > MAX_MULT) {
                printk(KERN_ERR DRV_NAME
                        ": Invalid Debounce/Columdrive Time from pdata\n");
                bfin_write_KPAD_MSEL(0xFF0);    /* Default MSEL */
        } else {
                bfin_write_KPAD_MSEL(
                        ((pdata->debounce_time / TIME_SCALE)
                                                & DBON_SCALE) |
                        (((pdata->coldrive_time / TIME_SCALE) << 8)
                                                & COLDRV_SCALE));
 
        }
 
        if (!pdata->keyup_test_interval)
                bf54x_kpad->keyup_test_jiffies = msecs_to_jiffies(50);
        else
                bf54x_kpad->keyup_test_jiffies =
                        msecs_to_jiffies(pdata->keyup_test_interval);
 
        if (peripheral_request_list((u16 *)&per_rows[MAX_RC - pdata->rows],
                                    DRV_NAME)) {
                printk(KERN_ERR DRV_NAME
                        ": Requesting Peripherals failed\n");
                error = -EFAULT;
                goto out0;
        }
 
        if (peripheral_request_list((u16 *)&per_cols[MAX_RC - pdata->cols],
                                    DRV_NAME)) {
                printk(KERN_ERR DRV_NAME
                        ": Requesting Peripherals failed\n");
                error = -EFAULT;
                goto out1;
        }
 
        bf54x_kpad->irq = platform_get_irq(pdev, 0);
        if (bf54x_kpad->irq < 0) {
                error = -ENODEV;
                goto out2;
        }
 
        error = request_irq(bf54x_kpad->irq, bfin_kpad_isr,
                                 IRQF_SAMPLE_RANDOM, DRV_NAME, pdev);
        if (error) {
                printk(KERN_ERR DRV_NAME
                        ": unable to claim irq %d; error %d\n",
                        bf54x_kpad->irq, error);
                goto out2;
        }
 
        input = input_allocate_device();
        if (!input) {
                error = -ENOMEM;
                goto out3;
        }
 
        bf54x_kpad->input = input;
 
        input->name = pdev->name;
        input->phys = "bf54x-keys/input0";
        input->dev.parent = &pdev->dev;
 
        input_set_drvdata(input, bf54x_kpad);
 
        input->id.bustype = BUS_HOST;
        input->id.vendor = 0x0001;
        input->id.product = 0x0001;
        input->id.version = 0x0100;
 
        input->keycodesize = sizeof(unsigned short);
        input->keycodemax = pdata->keymapsize;
        input->keycode = bf54x_kpad->keycode;
 
        bfin_keycodecpy(bf54x_kpad->keycode, pdata->keymap, pdata->keymapsize);
 
        /* setup input device */
        __set_bit(EV_KEY, input->evbit);
 
        if (pdata->repeat)
                __set_bit(EV_REP, input->evbit);
 
        for (i = 0; i < input->keycodemax; i++)
                __set_bit(bf54x_kpad->keycode[i] & KEY_MAX, input->keybit);
        __clear_bit(KEY_RESERVED, input->keybit);
 
        error = input_register_device(input);
        if (error) {
                printk(KERN_ERR DRV_NAME
                        ": Unable to register input device (%d)\n", error);
                goto out4;
        }
 
        /* Init Keypad Key Up/Release test timer */
 
        setup_timer(&bf54x_kpad->timer, bfin_kpad_timer, (unsigned long) pdev);
 
        bfin_write_KPAD_PRESCALE(bfin_kpad_get_prescale(TIME_SCALE));
 
        bfin_write_KPAD_CTL((((pdata->cols - 1) << 13) & KPAD_COLEN) |
                                (((pdata->rows - 1) << 10) & KPAD_ROWEN) |
                                (2 & KPAD_IRQMODE));
 
        bfin_write_KPAD_CTL(bfin_read_KPAD_CTL() | KPAD_EN);
 
        printk(KERN_ERR DRV_NAME
                ": Blackfin BF54x Keypad registered IRQ %d\n", bf54x_kpad->irq);
 
        return 0;
 
out4:
        input_free_device(input);
out3:
        free_irq(bf54x_kpad->irq, pdev);
out2:
        peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
out1:
        peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
out0:
        kfree(bf54x_kpad->keycode);
out:
        kfree(bf54x_kpad);
        platform_set_drvdata(pdev, NULL);
 
        return error;
}
 
static int __devexit bfin_kpad_remove(struct platform_device *pdev)
{
        struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;
        struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);
 
        del_timer_sync(&bf54x_kpad->timer);
        free_irq(bf54x_kpad->irq, pdev);
 
        input_unregister_device(bf54x_kpad->input);
 
        peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);
        peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);
 
        kfree(bf54x_kpad->keycode);
        kfree(bf54x_kpad);
        platform_set_drvdata(pdev, NULL);
 
        return 0;
}
 
struct platform_driver bfin_kpad_device_driver = {
        .probe          = bfin_kpad_probe,
        .remove         = __devexit_p(bfin_kpad_remove),
        .driver         = {
                .name   = DRV_NAME,
        }
};
 
static int __init bfin_kpad_init(void)
{
        return platform_driver_register(&bfin_kpad_device_driver);
}
 
static void __exit bfin_kpad_exit(void)
{
        platform_driver_unregister(&bfin_kpad_device_driver);
}
 
module_init(bfin_kpad_init);
module_exit(bfin_kpad_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("Keypad driver for BF54x Processors");

Browse

Tools

Subversion Repositories test_project

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

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* File: drivers/input/keyboard/bf54x-keys.c`
3			`* Based on:`
4			`* Author: Michael Hennerich <hennerich@blackfin.uclinux.org>`
5			`*`
6			`* Created:`
7			`* Description: keypad driver for Analog Devices Blackfin BF54x Processors`
8			`*`
9			`*`
10			`* Modified:`
11			`* Copyright 2007 Analog Devices Inc.`
12			`*`
13			`* Bugs: Enter bugs at http://blackfin.uclinux.org/`
14			`*`
15			`* This program is free software; you can redistribute it and/or modify`
16			`* it under the terms of the GNU General Public License as published by`
17			`* the Free Software Foundation; either version 2 of the License, or`
18			`* (at your option) any later version.`
19			`*`
20			`* This program is distributed in the hope that it will be useful,`
21			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
22			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
23			`* GNU General Public License for more details.`
24			`*`
25			`* You should have received a copy of the GNU General Public License`
26			`* along with this program; if not, see the file COPYING, or write`
27			`* to the Free Software Foundation, Inc.,`
28			`* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA`
29			`*/`
30
31			`#include <linux/module.h>`
32			`#include <linux/version.h>`
33
34			`#include <linux/init.h>`
35			`#include <linux/fs.h>`
36			`#include <linux/interrupt.h>`
37			`#include <linux/irq.h>`
38			`#include <linux/sched.h>`
39			`#include <linux/pm.h>`
40			`#include <linux/sysctl.h>`
41			`#include <linux/proc_fs.h>`
42			`#include <linux/delay.h>`
43			`#include <linux/platform_device.h>`
44			`#include <linux/input.h>`
45			`#include <linux/irq.h>`
46
47			`#include <asm/portmux.h>`
48			`#include <asm/mach/bf54x_keys.h>`
49
50			`#define DRV_NAME "bf54x-keys"`
51			`#define TIME_SCALE 100 /* 100 ns */`
52			`#define MAX_MULT (0xFF * TIME_SCALE)`
53			`#define MAX_RC 8 /* Max Row/Col */`
54
55			`static const u16 per_rows[] = {`
56			`P_KEY_ROW7,`
57			`P_KEY_ROW6,`
58			`P_KEY_ROW5,`
59			`P_KEY_ROW4,`
60			`P_KEY_ROW3,`
61			`P_KEY_ROW2,`
62			`P_KEY_ROW1,`
63			`P_KEY_ROW0,`
64
65			`};`
66
67			`static const u16 per_cols[] = {`
68			`P_KEY_COL7,`
69			`P_KEY_COL6,`
70			`P_KEY_COL5,`
71			`P_KEY_COL4,`
72			`P_KEY_COL3,`
73			`P_KEY_COL2,`
74			`P_KEY_COL1,`
75			`P_KEY_COL0,`
76
77			`};`
78
79			`struct bf54x_kpad {`
80			`struct input_dev *input;`
81			`int irq;`
82			`unsigned short lastkey;`
83			`unsigned short *keycode;`
84			`struct timer_list timer;`
85			`unsigned int keyup_test_jiffies;`
86			`};`
87
88			`static inline int bfin_kpad_find_key(struct bf54x_kpad *bf54x_kpad,`
89			`struct input_dev *input, u16 keyident)`
90			`{`
91			`u16 i;`
92
93			`for (i = 0; i < input->keycodemax; i++)`
94			`if (bf54x_kpad->keycode[i + input->keycodemax] == keyident)`
95			`return bf54x_kpad->keycode[i];`
96			`return -1;`
97			`}`
98
99			`static inline void bfin_keycodecpy(unsigned short *keycode,`
100			`const unsigned int *pdata_kc,`
101			`unsigned short keymapsize)`
102			`{`
103			`unsigned int i;`
104
105			`for (i = 0; i < keymapsize; i++) {`
106			`keycode[i] = pdata_kc[i] & 0xffff;`
107			`keycode[i + keymapsize] = pdata_kc[i] >> 16;`
108			`}`
109			`}`
110
111			`static inline u16 bfin_kpad_get_prescale(u32 timescale)`
112			`{`
113			`u32 sclk = get_sclk();`
114
115			`return ((((sclk / 1000) * timescale) / 1024) - 1);`
116			`}`
117
118			`static inline u16 bfin_kpad_get_keypressed(struct bf54x_kpad *bf54x_kpad)`
119			`{`
120			`return (bfin_read_KPAD_STAT() & KPAD_PRESSED);`
121			`}`
122
123			`static inline void bfin_kpad_clear_irq(void)`
124			`{`
125			`bfin_write_KPAD_STAT(0xFFFF);`
126			`bfin_write_KPAD_ROWCOL(0xFFFF);`
127			`}`
128
129			`static void bfin_kpad_timer(unsigned long data)`
130			`{`
131			`struct platform_device pdev = (struct platform_device ) data;`
132			`struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);`
133
134			`if (bfin_kpad_get_keypressed(bf54x_kpad)) {`
135			`/* Try again later */`
136			`mod_timer(&bf54x_kpad->timer,`
137			`jiffies + bf54x_kpad->keyup_test_jiffies);`
138			`return;`
139			`}`
140
141			`input_report_key(bf54x_kpad->input, bf54x_kpad->lastkey, 0);`
142			`input_sync(bf54x_kpad->input);`
143
144			`/* Clear IRQ Status */`
145
146			`bfin_kpad_clear_irq();`
147			`enable_irq(bf54x_kpad->irq);`
148			`}`
149
150			`static irqreturn_t bfin_kpad_isr(int irq, void *dev_id)`
151			`{`
152			`struct platform_device *pdev = dev_id;`
153			`struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);`
154			`struct input_dev *input = bf54x_kpad->input;`
155			`int key;`
156			`u16 rowcol = bfin_read_KPAD_ROWCOL();`
157
158			`key = bfin_kpad_find_key(bf54x_kpad, input, rowcol);`
159
160			`input_report_key(input, key, 1);`
161			`input_sync(input);`
162
163			`if (bfin_kpad_get_keypressed(bf54x_kpad)) {`
164			`disable_irq(bf54x_kpad->irq);`
165			`bf54x_kpad->lastkey = key;`
166			`mod_timer(&bf54x_kpad->timer,`
167			`jiffies + bf54x_kpad->keyup_test_jiffies);`
168			`} else {`
169			`input_report_key(input, key, 0);`
170			`input_sync(input);`
171
172			`bfin_kpad_clear_irq();`
173			`}`
174
175			`return IRQ_HANDLED;`
176			`}`
177
178			`static int __devinit bfin_kpad_probe(struct platform_device *pdev)`
179			`{`
180			`struct bf54x_kpad *bf54x_kpad;`
181			`struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;`
182			`struct input_dev *input;`
183			`int i, error;`
184
185			`if (!pdata->rows \|\| !pdata->cols \|\| !pdata->keymap) {`
186			`printk(KERN_ERR DRV_NAME`
187			`": No rows, cols or keymap from pdata\n");`
188			`return -EINVAL;`
189			`}`
190
191			`if (!pdata->keymapsize \|\|`
192			`pdata->keymapsize > (pdata->rows * pdata->cols)) {`
193			`printk(KERN_ERR DRV_NAME ": Invalid keymapsize\n");`
194			`return -EINVAL;`
195			`}`
196
197			`bf54x_kpad = kzalloc(sizeof(struct bf54x_kpad), GFP_KERNEL);`
198			`if (!bf54x_kpad)`
199			`return -ENOMEM;`
200
201			`platform_set_drvdata(pdev, bf54x_kpad);`
202
203			`/* Allocate memory for keymap followed by private LUT */`
204			`bf54x_kpad->keycode = kmalloc(pdata->keymapsize *`
205			`sizeof(unsigned short) * 2, GFP_KERNEL);`
206			`if (!bf54x_kpad->keycode) {`
207			`error = -ENOMEM;`
208			`goto out;`
209			`}`
210
211			`if (!pdata->debounce_time \|\| !pdata->debounce_time > MAX_MULT \|\|`
212			`!pdata->coldrive_time \|\| !pdata->coldrive_time > MAX_MULT) {`
213			`printk(KERN_ERR DRV_NAME`
214			`": Invalid Debounce/Columdrive Time from pdata\n");`
215			`bfin_write_KPAD_MSEL(0xFF0); /* Default MSEL */`
216			`} else {`
217			`bfin_write_KPAD_MSEL(`
218			`((pdata->debounce_time / TIME_SCALE)`
219			`& DBON_SCALE) \|`
220			`(((pdata->coldrive_time / TIME_SCALE) << 8)`
221			`& COLDRV_SCALE));`
222
223			`}`
224
225			`if (!pdata->keyup_test_interval)`
226			`bf54x_kpad->keyup_test_jiffies = msecs_to_jiffies(50);`
227			`else`
228			`bf54x_kpad->keyup_test_jiffies =`
229			`msecs_to_jiffies(pdata->keyup_test_interval);`
230
231			`if (peripheral_request_list((u16 *)&per_rows[MAX_RC - pdata->rows],`
232			`DRV_NAME)) {`
233			`printk(KERN_ERR DRV_NAME`
234			`": Requesting Peripherals failed\n");`
235			`error = -EFAULT;`
236			`goto out0;`
237			`}`
238
239			`if (peripheral_request_list((u16 *)&per_cols[MAX_RC - pdata->cols],`
240			`DRV_NAME)) {`
241			`printk(KERN_ERR DRV_NAME`
242			`": Requesting Peripherals failed\n");`
243			`error = -EFAULT;`
244			`goto out1;`
245			`}`
246
247			`bf54x_kpad->irq = platform_get_irq(pdev, 0);`
248			`if (bf54x_kpad->irq < 0) {`
249			`error = -ENODEV;`
250			`goto out2;`
251			`}`
252
253			`error = request_irq(bf54x_kpad->irq, bfin_kpad_isr,`
254			`IRQF_SAMPLE_RANDOM, DRV_NAME, pdev);`
255			`if (error) {`
256			`printk(KERN_ERR DRV_NAME`
257			`": unable to claim irq %d; error %d\n",`
258			`bf54x_kpad->irq, error);`
259			`goto out2;`
260			`}`
261
262			`input = input_allocate_device();`
263			`if (!input) {`
264			`error = -ENOMEM;`
265			`goto out3;`
266			`}`
267
268			`bf54x_kpad->input = input;`
269
270			`input->name = pdev->name;`
271			`input->phys = "bf54x-keys/input0";`
272			`input->dev.parent = &pdev->dev;`
273
274			`input_set_drvdata(input, bf54x_kpad);`
275
276			`input->id.bustype = BUS_HOST;`
277			`input->id.vendor = 0x0001;`
278			`input->id.product = 0x0001;`
279			`input->id.version = 0x0100;`
280
281			`input->keycodesize = sizeof(unsigned short);`
282			`input->keycodemax = pdata->keymapsize;`
283			`input->keycode = bf54x_kpad->keycode;`
284
285			`bfin_keycodecpy(bf54x_kpad->keycode, pdata->keymap, pdata->keymapsize);`
286
287			`/* setup input device */`
288			`__set_bit(EV_KEY, input->evbit);`
289
290			`if (pdata->repeat)`
291			`__set_bit(EV_REP, input->evbit);`
292
293			`for (i = 0; i < input->keycodemax; i++)`
294			`__set_bit(bf54x_kpad->keycode[i] & KEY_MAX, input->keybit);`
295			`__clear_bit(KEY_RESERVED, input->keybit);`
296
297			`error = input_register_device(input);`
298			`if (error) {`
299			`printk(KERN_ERR DRV_NAME`
300			`": Unable to register input device (%d)\n", error);`
301			`goto out4;`
302			`}`
303
304			`/* Init Keypad Key Up/Release test timer */`
305
306			`setup_timer(&bf54x_kpad->timer, bfin_kpad_timer, (unsigned long) pdev);`
307
308			`bfin_write_KPAD_PRESCALE(bfin_kpad_get_prescale(TIME_SCALE));`
309
310			`bfin_write_KPAD_CTL((((pdata->cols - 1) << 13) & KPAD_COLEN) \|`
311			`(((pdata->rows - 1) << 10) & KPAD_ROWEN) \|`
312			`(2 & KPAD_IRQMODE));`
313
314			`bfin_write_KPAD_CTL(bfin_read_KPAD_CTL() \| KPAD_EN);`
315
316			`printk(KERN_ERR DRV_NAME`
317			`": Blackfin BF54x Keypad registered IRQ %d\n", bf54x_kpad->irq);`
318
319			`return 0;`
320
321			`out4:`
322			`input_free_device(input);`
323			`out3:`
324			`free_irq(bf54x_kpad->irq, pdev);`
325			`out2:`
326			`peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);`
327			`out1:`
328			`peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);`
329			`out0:`
330			`kfree(bf54x_kpad->keycode);`
331			`out:`
332			`kfree(bf54x_kpad);`
333			`platform_set_drvdata(pdev, NULL);`
334
335			`return error;`
336			`}`
337
338			`static int __devexit bfin_kpad_remove(struct platform_device *pdev)`
339			`{`
340			`struct bfin_kpad_platform_data *pdata = pdev->dev.platform_data;`
341			`struct bf54x_kpad *bf54x_kpad = platform_get_drvdata(pdev);`
342
343			`del_timer_sync(&bf54x_kpad->timer);`
344			`free_irq(bf54x_kpad->irq, pdev);`
345
346			`input_unregister_device(bf54x_kpad->input);`
347
348			`peripheral_free_list((u16 *)&per_rows[MAX_RC - pdata->rows]);`
349			`peripheral_free_list((u16 *)&per_cols[MAX_RC - pdata->cols]);`
350
351			`kfree(bf54x_kpad->keycode);`
352			`kfree(bf54x_kpad);`
353			`platform_set_drvdata(pdev, NULL);`
354
355			`return 0;`
356			`}`
357
358			`struct platform_driver bfin_kpad_device_driver = {`
359			`.probe = bfin_kpad_probe,`
360			`.remove = __devexit_p(bfin_kpad_remove),`
361			`.driver = {`
362			`.name = DRV_NAME,`
363			`}`
364			`};`
365
366			`static int __init bfin_kpad_init(void)`
367			`{`
368			`return platform_driver_register(&bfin_kpad_device_driver);`
369			`}`
370
371			`static void __exit bfin_kpad_exit(void)`
372			`{`
373			`platform_driver_unregister(&bfin_kpad_device_driver);`
374			`}`
375
376			`module_init(bfin_kpad_init);`
377			`module_exit(bfin_kpad_exit);`
378
379			`MODULE_LICENSE("GPL");`
380			`MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");`
381			`MODULE_DESCRIPTION("Keypad driver for BF54x Processors");`