]> www.pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/input/keyboard/omap-keypad.c
Merge with /home/tmlind/src/kernel/linux-2.6
[linux-2.6-omap-h63xx.git] / drivers / input / keyboard / omap-keypad.c
1 /*
2  * linux/drivers/char/omap-keypad.c
3  *
4  * OMAP Keypad Driver
5  *
6  * Copyright (C) 2003 Nokia Corporation
7  * Written by Timo Teräs <ext-timo.teras@nokia.com>
8  *
9  * Added support for H2 & H3 Keypad
10  * Copyright (C) 2004 Texas Instruments
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  */
26
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/interrupt.h>
30 #include <linux/types.h>
31 #include <linux/input.h>
32 #include <linux/kernel.h>
33 #include <linux/delay.h>
34 #include <linux/platform_device.h>
35 #include <asm/arch/irqs.h>
36 #include <asm/arch/gpio.h>
37 #include <asm/arch/hardware.h>
38 #include <asm/io.h>
39 #include <asm/errno.h>
40 #include <asm/mach-types.h>
41 #include <asm/arch/mux.h>
42
43 #undef NEW_BOARD_LEARNING_MODE
44
45 static void omap_kp_tasklet(unsigned long);
46 static void omap_kp_timer(unsigned long);
47
48 static unsigned char keypad_state[8];
49 static unsigned int keypad_irq = INT_KEYBOARD;
50
51 struct omap_kp {
52         struct input_dev *input;
53         struct timer_list timer;
54 };
55
56 DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0);
57
58 #define KEY(col, row, val) (((col) << 28) | ((row) << 24) | (val))
59
60 static int h2_keymap[] = {
61         KEY(0, 0, KEY_LEFT),
62         KEY(0, 1, KEY_RIGHT),
63         KEY(0, 2, KEY_3),
64         KEY(0, 3, KEY_F10),
65         KEY(0, 4, KEY_F5),
66         KEY(0, 5, KEY_9),
67         KEY(1, 0, KEY_DOWN),
68         KEY(1, 1, KEY_UP),
69         KEY(1, 2, KEY_2),
70         KEY(1, 3, KEY_F9),
71         KEY(1, 4, KEY_F7),
72         KEY(1, 5, KEY_0),
73         KEY(2, 0, KEY_ENTER),
74         KEY(2, 1, KEY_6),
75         KEY(2, 2, KEY_1),
76         KEY(2, 3, KEY_F2),
77         KEY(2, 4, KEY_F6),
78         KEY(2, 5, KEY_HOME),
79         KEY(3, 0, KEY_8),
80         KEY(3, 1, KEY_5),
81         KEY(3, 2, KEY_F12),
82         KEY(3, 3, KEY_F3),
83         KEY(3, 4, KEY_F8),
84         KEY(3, 5, KEY_END),
85         KEY(4, 0, KEY_7),
86         KEY(4, 1, KEY_4),
87         KEY(4, 2, KEY_F11),
88         KEY(4, 3, KEY_F1),
89         KEY(4, 4, KEY_F4),
90         KEY(4, 5, KEY_ESC),
91         KEY(5, 0, KEY_F13),
92         KEY(5, 1, KEY_F14),
93         KEY(5, 2, KEY_F15),
94         KEY(5, 3, KEY_F16),
95         KEY(5, 4, KEY_SLEEP),
96         0
97 };
98
99 static int test_keymap[] = {
100         KEY(0, 0, KEY_F4),
101         KEY(1, 0, KEY_LEFT),
102         KEY(2, 0, KEY_F1),
103         KEY(0, 1, KEY_DOWN),
104         KEY(1, 1, KEY_ENTER),
105         KEY(2, 1, KEY_UP),
106         KEY(0, 2, KEY_F3),
107         KEY(1, 2, KEY_RIGHT),
108         KEY(2, 2, KEY_F2),
109         0
110 };
111
112 static int innovator_keymap[] = {
113         KEY(0, 0, KEY_F1),
114         KEY(0, 3, KEY_DOWN),
115         KEY(1, 1, KEY_F2),
116         KEY(1, 2, KEY_RIGHT),
117         KEY(2, 0, KEY_F3),
118         KEY(2, 1, KEY_F4),
119         KEY(2, 2, KEY_UP),
120         KEY(3, 2, KEY_ENTER),
121         KEY(3, 3, KEY_LEFT),
122         0
123 };
124
125 static int osk_keymap[] = {
126         KEY(0, 0, KEY_F1),
127         KEY(0, 3, KEY_UP),
128         KEY(1, 1, KEY_LEFTCTRL),
129         KEY(1, 2, KEY_LEFT),
130         KEY(2, 0, KEY_SPACE),
131         KEY(2, 1, KEY_ESC),
132         KEY(2, 2, KEY_DOWN),
133         KEY(3, 2, KEY_ENTER),
134         KEY(3, 3, KEY_RIGHT),
135         0 
136 }; 
137
138 static int p2_keymap[] = {
139         KEY(0,0,KEY_UP),
140         KEY(0,1,KEY_RIGHT),
141         KEY(0,2,KEY_LEFT),
142         KEY(0,3,KEY_DOWN),
143         KEY(0,4,KEY_CENTER),
144         KEY(0,5,KEY_0_5),
145         KEY(1,0,KEY_SOFT2),
146         KEY(1,1,KEY_SEND),
147         KEY(1,2,KEY_END),
148         KEY(1,3,KEY_VOLUMEDOWN),
149         KEY(1,4,KEY_VOLUMEUP),
150         KEY(1,5,KEY_RECORD),
151         KEY(2,0,KEY_SOFT1),
152         KEY(2,1,KEY_3),
153         KEY(2,2,KEY_6),
154         KEY(2,3,KEY_9),
155         KEY(2,4,KEY_SHARP),
156         KEY(2,5,KEY_2_5),
157         KEY(3,0,KEY_BACK),
158         KEY(3,1,KEY_2),
159         KEY(3,2,KEY_5),
160         KEY(3,3,KEY_8),
161         KEY(3,4,KEY_0),
162         KEY(3,5,KEY_HEADSETHOOK),
163         KEY(4,0,KEY_HOME),
164         KEY(4,1,KEY_1),
165         KEY(4,2,KEY_4),
166         KEY(4,3,KEY_7),
167         KEY(4,4,KEY_STAR),
168         KEY(4,5,KEY_POWER),
169         0
170 };
171
172 static int *keymap;
173
174 static irqreturn_t omap_kp_interrupt(int irq, void *dev_id,
175                                      struct pt_regs *regs)
176 {
177         /* disable keyboard interrupt and schedule for handling */
178         omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
179         tasklet_schedule(&kp_tasklet);
180
181         return IRQ_HANDLED;
182 }
183
184 static void omap_kp_timer(unsigned long data)
185 {
186         tasklet_schedule(&kp_tasklet);
187 }
188
189 static void omap_kp_scan_keypad(unsigned char *state)
190 {
191         int col = 0;
192
193         /* read the keypad status */
194         omap_writew(0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC);
195         for (col = 0; col < 8; col++) {
196                 omap_writew(~(1 << col) & 0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC);
197
198                 if (machine_is_omap_osk() || machine_is_omap_h2() || machine_is_omap_h3()) {
199                         udelay(9);
200                 } else {
201                         udelay(4);
202                 }
203
204                 state[col] = ~omap_readw(OMAP_MPUIO_BASE + OMAP_MPUIO_KBR_LATCH) & 0xff;
205         }
206         omap_writew(0x00, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC);
207         udelay(2);
208 }
209
210 static inline int omap_kp_find_key(int col, int row)
211 {
212         int i, key;
213
214         key = KEY(col, row, 0);
215         for (i = 0; keymap[i] != 0; i++)
216                 if ((keymap[i] & 0xff000000) == key)
217                         return keymap[i] & 0x00ffffff;
218         return -1;
219 }
220
221 static void omap_kp_tasklet(unsigned long data)
222 {
223         struct omap_kp *omap_kp_data = (struct omap_kp *) data;
224         unsigned char new_state[8], changed, key_down = 0;
225         int col, row;
226         int spurious = 0;
227
228         /* check for any changes */
229         omap_kp_scan_keypad(new_state);
230
231         /* check for changes and print those */
232         for (col = 0; col < 8; col++) {
233                 changed = new_state[col] ^ keypad_state[col];
234                 key_down |= new_state[col];
235                 if (changed == 0)
236                         continue;
237
238                 for (row = 0; row < 8; row++) {
239                         int key;
240                         if (!(changed & (1 << row)))
241                                 continue;
242 #ifdef NEW_BOARD_LEARNING_MODE
243                         printk(KERN_INFO "omap-keypad: key %d-%d %s\n", col, row, (new_state[col] & (1 << row)) ? "pressed" : "released");
244 #else
245                         key = omap_kp_find_key(col, row);
246                         if (key < 0) {
247                                 printk(KERN_WARNING "omap-keypad: Spurious key event %d-%d\n",
248                                        col, row);
249                                 /* We scan again after a couple of seconds */
250                                 spurious = 1;
251                                 continue;
252                         }
253
254                         input_report_key(omap_kp_data->input, key,
255                                          new_state[col] & (1 << row));
256 #endif
257                 }
258         }
259         memcpy(keypad_state, new_state, sizeof(keypad_state));
260
261         if (key_down) {
262                 int delay = HZ / 20;
263                 /* some key is pressed - keep irq disabled and use timer
264                  * to poll the keypad */
265                 if (spurious)
266                         delay = 2 * HZ;
267                 mod_timer(&omap_kp_data->timer, jiffies + delay);
268         } else {
269                 /* enable interrupts */
270                 omap_writew(0, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
271         }
272 }
273
274 #ifdef CONFIG_PM
275 static int omap_kp_suspend(struct platform_device *dev, pm_message_t state)
276 {
277         /* Nothing yet */
278
279         return 0;
280 }
281
282 static int omap_kp_resume(struct platform_device *dev)
283 {
284         /* Nothing yet */
285
286         return 0;
287 }
288 #else
289 #define omap_kp_suspend NULL
290 #define omap_kp_resume  NULL
291 #endif
292
293 static int __init omap_kp_probe(struct platform_device *pdev)
294 {
295         struct omap_kp *omap_kp;
296         struct input_dev *input_dev;
297         int i;
298
299         omap_kp = kzalloc(sizeof(struct omap_kp), GFP_KERNEL);
300         input_dev = input_allocate_device();
301         if (!omap_kp || !input_dev) {
302                 kfree(omap_kp);
303                 input_free_device(input_dev);
304                 return -ENOMEM;
305         }
306
307         platform_set_drvdata(pdev, omap_kp);
308
309         omap_kp->input = input_dev;
310
311         /* Disable the interrupt for the MPUIO keyboard */
312         omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
313
314         if (machine_is_omap_h2() || machine_is_omap_h3()) {
315                 keymap = h2_keymap;
316                 set_bit(EV_REP, input_dev->evbit);
317         } else if (machine_is_omap_innovator()) {
318                 keymap = innovator_keymap;
319         } else if (machine_is_omap_osk()) {
320                 keymap = osk_keymap;
321         } else if (machine_is_omap_perseus2()) {
322                 keymap = p2_keymap;
323                 keypad_irq = INT_730_MPUIO_KEYPAD;
324         } else {
325                 keymap = test_keymap;
326         }
327
328         init_timer(&omap_kp->timer);
329         omap_kp->timer.function = omap_kp_timer;
330         omap_kp->timer.data = (unsigned long) omap_kp;
331
332         /* get the irq and init timer*/
333         tasklet_enable(&kp_tasklet);
334         if (request_irq(keypad_irq, omap_kp_interrupt, 0,
335                         "omap-keypad", 0) < 0)
336                 return -EINVAL;
337
338         /* setup input device */
339         set_bit(EV_KEY, input_dev->evbit);
340         for (i = 0; keymap[i] != 0; i++)
341                 set_bit(keymap[i] & 0x00ffffff, input_dev->keybit);
342         input_dev->name = "omap-keypad";
343         input_dev->cdev.dev = &pdev->dev;
344         input_dev->private = omap_kp;
345         input_register_device(omap_kp->input);
346
347         if (machine_is_omap_h2() || machine_is_omap_h3() ||
348             machine_is_omap_perseus2()) {
349                 omap_writew(0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING);
350         }
351         /* scan current status and enable interrupt */
352         omap_kp_scan_keypad(keypad_state);
353         omap_writew(0, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
354
355         return 0;
356 }
357
358 static int omap_kp_remove(struct platform_device *pdev)
359 {
360         struct omap_kp *omap_kp = platform_get_drvdata(pdev);
361
362         /* disable keypad interrupt handling */
363         tasklet_disable(&kp_tasklet);
364         omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
365
366         free_irq(keypad_irq, 0);
367         del_timer_sync(&omap_kp->timer);
368
369         /* unregister everything */
370         input_unregister_device(omap_kp->input);
371
372         kfree(omap_kp);
373
374         return 0;
375 }
376
377 static struct platform_driver omap_kp_driver = {
378         .probe          = omap_kp_probe,
379         .remove         = omap_kp_remove,
380         .suspend        = omap_kp_suspend,
381         .resume         = omap_kp_resume,
382         .driver         = {
383                 .name   = "omap-keypad",
384         },
385 };
386
387 static int __devinit omap_kp_init(void)
388 {
389         printk(KERN_INFO "OMAP Keypad Driver\n");
390         return platform_driver_register(&omap_kp_driver);
391 }
392
393 static void __exit omap_kp_exit(void)
394 {
395         platform_driver_unregister(&omap_kp_driver);
396 }
397
398 module_init(omap_kp_init);
399 module_exit(omap_kp_exit);
400
401 MODULE_AUTHOR("Timo Teräs");
402 MODULE_DESCRIPTION("OMAP Keypad Driver");
403 MODULE_LICENSE("GPL");