2 * linux/drivers/input/keyboard/omap-keypad.c
6 * Copyright (C) 2003 Nokia Corporation
7 * Written by Timo Teräs <ext-timo.teras@nokia.com>
9 * Added support for H2 & H3 Keypad
10 * Copyright (C) 2004 Texas Instruments
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.
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.
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
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 <linux/mutex.h>
36 #include <linux/errno.h>
37 #include <mach/gpio.h>
38 #include <mach/keypad.h>
39 #include <mach/menelaus.h>
41 #include <mach/hardware.h>
45 #undef NEW_BOARD_LEARNING_MODE
47 static void omap_kp_tasklet(unsigned long);
48 static void omap_kp_timer(unsigned long);
50 static unsigned char keypad_state
[8];
51 static DEFINE_MUTEX(kp_enable_mutex
);
52 static int kp_enable
= 1;
53 static int kp_cur_group
= -1;
56 struct input_dev
*input
;
57 struct timer_list timer
;
62 unsigned int debounce
;
65 DECLARE_TASKLET_DISABLED(kp_tasklet
, omap_kp_tasklet
, 0);
68 static unsigned int *row_gpios
;
69 static unsigned int *col_gpios
;
71 #ifdef CONFIG_ARCH_OMAP2
72 static void set_col_gpio_val(struct omap_kp
*omap_kp
, u8 value
)
75 for (col
= 0; col
< omap_kp
->cols
; col
++) {
76 if (value
& (1 << col
))
77 omap_set_gpio_dataout(col_gpios
[col
], 1);
79 omap_set_gpio_dataout(col_gpios
[col
], 0);
83 static u8
get_row_gpio_val(struct omap_kp
*omap_kp
)
88 for (row
= 0; row
< omap_kp
->rows
; row
++) {
89 if (omap_get_gpio_datain(row_gpios
[row
]))
95 #define set_col_gpio_val(x, y) do {} while (0)
96 #define get_row_gpio_val(x) 0
99 static irqreturn_t
omap_kp_interrupt(int irq
, void *dev_id
)
101 struct omap_kp
*omap_kp
= dev_id
;
103 /* disable keyboard interrupt and schedule for handling */
104 if (cpu_is_omap24xx()) {
106 for (i
= 0; i
< omap_kp
->rows
; i
++)
107 disable_irq(OMAP_GPIO_IRQ(row_gpios
[i
]));
109 /* disable keyboard interrupt and schedule for handling */
110 omap_writew(1, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
112 tasklet_schedule(&kp_tasklet
);
117 static void omap_kp_timer(unsigned long data
)
119 tasklet_schedule(&kp_tasklet
);
122 static void omap_kp_scan_keypad(struct omap_kp
*omap_kp
, unsigned char *state
)
126 /* read the keypad status */
127 if (cpu_is_omap24xx()) {
129 for (i
= 0; i
< omap_kp
->rows
; i
++)
130 disable_irq(OMAP_GPIO_IRQ(row_gpios
[i
]));
132 /* read the keypad status */
133 for (col
= 0; col
< omap_kp
->cols
; col
++) {
134 set_col_gpio_val(omap_kp
, ~(1 << col
));
135 state
[col
] = ~(get_row_gpio_val(omap_kp
)) & 0x3f;
137 set_col_gpio_val(omap_kp
, 0);
140 /* disable keyboard interrupt and schedule for handling */
141 omap_writew(1, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
143 /* read the keypad status */
144 omap_writew(0xff, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBC
);
145 for (col
= 0; col
< omap_kp
->cols
; col
++) {
146 omap_writew(~(1 << col
) & 0xff,
147 OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBC
);
149 udelay(omap_kp
->delay
);
151 state
[col
] = ~omap_readw(OMAP_MPUIO_BASE
+
152 OMAP_MPUIO_KBR_LATCH
) & 0xff;
154 omap_writew(0x00, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBC
);
159 static inline int omap_kp_find_key(int col
, int row
)
163 key
= KEY(col
, row
, 0);
164 for (i
= 0; keymap
[i
] != 0; i
++)
165 if ((keymap
[i
] & 0xff000000) == key
)
166 return keymap
[i
] & 0x00ffffff;
170 static void omap_kp_tasklet(unsigned long data
)
172 struct omap_kp
*omap_kp_data
= (struct omap_kp
*) data
;
173 unsigned char new_state
[8], changed
, key_down
= 0;
177 /* check for any changes */
178 omap_kp_scan_keypad(omap_kp_data
, new_state
);
180 /* check for changes and print those */
181 for (col
= 0; col
< omap_kp_data
->cols
; col
++) {
182 changed
= new_state
[col
] ^ keypad_state
[col
];
183 key_down
|= new_state
[col
];
187 for (row
= 0; row
< omap_kp_data
->rows
; row
++) {
189 if (!(changed
& (1 << row
)))
191 #ifdef NEW_BOARD_LEARNING_MODE
192 printk(KERN_INFO
"omap-keypad: key %d-%d %s\n", col
,
193 row
, (new_state
[col
] & (1 << row
)) ?
194 "pressed" : "released");
196 key
= omap_kp_find_key(col
, row
);
199 "omap-keypad: Spurious key event %d-%d\n",
201 /* We scan again after a couple of seconds */
206 if (!(kp_cur_group
== (key
& GROUP_MASK
) ||
210 kp_cur_group
= key
& GROUP_MASK
;
211 input_report_key(omap_kp_data
->input
, key
& ~GROUP_MASK
,
212 new_state
[col
] & (1 << row
));
216 memcpy(keypad_state
, new_state
, sizeof(keypad_state
));
220 /* some key is pressed - keep irq disabled and use timer
221 * to poll the keypad */
224 mod_timer(&omap_kp_data
->timer
, jiffies
+ delay
);
226 /* enable interrupts */
227 if (cpu_is_omap24xx()) {
229 for (i
= 0; i
< omap_kp_data
->rows
; i
++)
230 enable_irq(OMAP_GPIO_IRQ(row_gpios
[i
]));
232 omap_writew(0, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
238 static ssize_t
omap_kp_enable_show(struct device
*dev
,
239 struct device_attribute
*attr
, char *buf
)
241 return sprintf(buf
, "%u\n", kp_enable
);
244 static ssize_t
omap_kp_enable_store(struct device
*dev
, struct device_attribute
*attr
,
245 const char *buf
, size_t count
)
249 if (sscanf(buf
, "%u", &state
) != 1)
252 if ((state
!= 1) && (state
!= 0))
255 mutex_lock(&kp_enable_mutex
);
256 if (state
!= kp_enable
) {
258 enable_irq(INT_KEYBOARD
);
260 disable_irq(INT_KEYBOARD
);
263 mutex_unlock(&kp_enable_mutex
);
265 return strnlen(buf
, count
);
268 static DEVICE_ATTR(enable
, S_IRUGO
| S_IWUSR
, omap_kp_enable_show
, omap_kp_enable_store
);
271 static int omap_kp_suspend(struct platform_device
*dev
, pm_message_t state
)
278 static int omap_kp_resume(struct platform_device
*dev
)
285 #define omap_kp_suspend NULL
286 #define omap_kp_resume NULL
289 static int __init
omap_kp_probe(struct platform_device
*pdev
)
291 struct omap_kp
*omap_kp
;
292 struct input_dev
*input_dev
;
293 struct omap_kp_platform_data
*pdata
= pdev
->dev
.platform_data
;
294 int i
, col_idx
, row_idx
, irq_idx
, ret
;
296 if (!pdata
->rows
|| !pdata
->cols
|| !pdata
->keymap
) {
297 printk(KERN_ERR
"No rows, cols or keymap from pdata\n");
301 omap_kp
= kzalloc(sizeof(struct omap_kp
), GFP_KERNEL
);
302 input_dev
= input_allocate_device();
303 if (!omap_kp
|| !input_dev
) {
305 input_free_device(input_dev
);
309 platform_set_drvdata(pdev
, omap_kp
);
311 omap_kp
->input
= input_dev
;
313 /* Disable the interrupt for the MPUIO keyboard */
314 if (!cpu_is_omap24xx())
315 omap_writew(1, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
317 keymap
= pdata
->keymap
;
320 __set_bit(EV_REP
, input_dev
->evbit
);
323 omap_kp
->delay
= pdata
->delay
;
325 if (pdata
->row_gpios
&& pdata
->col_gpios
) {
326 row_gpios
= pdata
->row_gpios
;
327 col_gpios
= pdata
->col_gpios
;
330 omap_kp
->rows
= pdata
->rows
;
331 omap_kp
->cols
= pdata
->cols
;
333 if (cpu_is_omap24xx()) {
335 for (col_idx
= 0; col_idx
< omap_kp
->cols
; col_idx
++) {
336 if (omap_request_gpio(col_gpios
[col_idx
]) < 0) {
337 printk(KERN_ERR
"Failed to request"
338 "GPIO%d for keypad\n",
342 omap_set_gpio_direction(col_gpios
[col_idx
], 0);
345 for (row_idx
= 0; row_idx
< omap_kp
->rows
; row_idx
++) {
346 if (omap_request_gpio(row_gpios
[row_idx
]) < 0) {
347 printk(KERN_ERR
"Failed to request"
348 "GPIO%d for keypad\n",
352 omap_set_gpio_direction(row_gpios
[row_idx
], 1);
359 setup_timer(&omap_kp
->timer
, omap_kp_timer
, (unsigned long)omap_kp
);
361 /* get the irq and init timer*/
362 tasklet_enable(&kp_tasklet
);
363 kp_tasklet
.data
= (unsigned long) omap_kp
;
365 ret
= device_create_file(&pdev
->dev
, &dev_attr_enable
);
369 /* setup input device */
370 __set_bit(EV_KEY
, input_dev
->evbit
);
371 for (i
= 0; keymap
[i
] != 0; i
++)
372 __set_bit(keymap
[i
] & KEY_MAX
, input_dev
->keybit
);
373 input_dev
->name
= "omap-keypad";
374 input_dev
->phys
= "omap-keypad/input0";
375 input_dev
->dev
.parent
= &pdev
->dev
;
377 input_dev
->id
.bustype
= BUS_HOST
;
378 input_dev
->id
.vendor
= 0x0001;
379 input_dev
->id
.product
= 0x0001;
380 input_dev
->id
.version
= 0x0100;
382 ret
= input_register_device(omap_kp
->input
);
384 printk(KERN_ERR
"Unable to register omap-keypad input device\n");
389 omap_writew(0xff, OMAP_MPUIO_BASE
+ OMAP_MPUIO_GPIO_DEBOUNCING
);
391 /* scan current status and enable interrupt */
392 omap_kp_scan_keypad(omap_kp
, keypad_state
);
393 if (!cpu_is_omap24xx()) {
394 omap_kp
->irq
= platform_get_irq(pdev
, 0);
395 if (omap_kp
->irq
>= 0) {
396 if (request_irq(omap_kp
->irq
, omap_kp_interrupt
, 0,
397 "omap-keypad", omap_kp
) < 0)
400 omap_writew(0, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
402 for (irq_idx
= 0; irq_idx
< omap_kp
->rows
; irq_idx
++) {
403 if (request_irq(OMAP_GPIO_IRQ(row_gpios
[irq_idx
]),
405 IRQF_TRIGGER_FALLING
,
406 "omap-keypad", omap_kp
) < 0)
412 for (i
= irq_idx
- 1; i
>=0; i
--)
413 free_irq(row_gpios
[i
], 0);
415 input_unregister_device(omap_kp
->input
);
418 device_remove_file(&pdev
->dev
, &dev_attr_enable
);
420 for (i
= row_idx
- 1; i
>=0; i
--)
421 omap_free_gpio(row_gpios
[i
]);
423 for (i
= col_idx
- 1; i
>=0; i
--)
424 omap_free_gpio(col_gpios
[i
]);
427 input_free_device(input_dev
);
432 static int omap_kp_remove(struct platform_device
*pdev
)
434 struct omap_kp
*omap_kp
= platform_get_drvdata(pdev
);
436 /* disable keypad interrupt handling */
437 tasklet_disable(&kp_tasklet
);
438 if (cpu_is_omap24xx()) {
440 for (i
= 0; i
< omap_kp
->cols
; i
++)
441 omap_free_gpio(col_gpios
[i
]);
442 for (i
= 0; i
< omap_kp
->rows
; i
++) {
443 omap_free_gpio(row_gpios
[i
]);
444 free_irq(OMAP_GPIO_IRQ(row_gpios
[i
]), 0);
447 omap_writew(1, OMAP_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
448 free_irq(omap_kp
->irq
, 0);
451 del_timer_sync(&omap_kp
->timer
);
452 tasklet_kill(&kp_tasklet
);
454 /* unregister everything */
455 input_unregister_device(omap_kp
->input
);
462 static struct platform_driver omap_kp_driver
= {
463 .probe
= omap_kp_probe
,
464 .remove
= omap_kp_remove
,
465 .suspend
= omap_kp_suspend
,
466 .resume
= omap_kp_resume
,
468 .name
= "omap-keypad",
469 .owner
= THIS_MODULE
,
473 static int __devinit
omap_kp_init(void)
475 printk(KERN_INFO
"OMAP Keypad Driver\n");
476 return platform_driver_register(&omap_kp_driver
);
479 static void __exit
omap_kp_exit(void)
481 platform_driver_unregister(&omap_kp_driver
);
484 module_init(omap_kp_init
);
485 module_exit(omap_kp_exit
);
487 MODULE_AUTHOR("Timo Teräs");
488 MODULE_DESCRIPTION("OMAP Keypad Driver");
489 MODULE_LICENSE("GPL");
490 MODULE_ALIAS("platform:omap-keypad");