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 <linux/slab.h>
38 #include <linux/gpio.h>
39 #include <linux/platform_data/gpio-omap.h>
40 #include <linux/platform_data/keypad-omap.h>
42 #undef NEW_BOARD_LEARNING_MODE
44 static void omap_kp_tasklet(unsigned long);
45 static void omap_kp_timer(unsigned long);
47 static unsigned char keypad_state
[8];
48 static DEFINE_MUTEX(kp_enable_mutex
);
49 static int kp_enable
= 1;
50 static int kp_cur_group
= -1;
53 struct input_dev
*input
;
54 struct timer_list timer
;
59 unsigned int debounce
;
60 unsigned short keymap
[];
63 static DECLARE_TASKLET_DISABLED(kp_tasklet
, omap_kp_tasklet
, 0);
65 static unsigned int *row_gpios
;
66 static unsigned int *col_gpios
;
68 #ifdef CONFIG_ARCH_OMAP2
69 static void set_col_gpio_val(struct omap_kp
*omap_kp
, u8 value
)
73 for (col
= 0; col
< omap_kp
->cols
; col
++)
74 gpio_set_value(col_gpios
[col
], value
& (1 << col
));
77 static u8
get_row_gpio_val(struct omap_kp
*omap_kp
)
82 for (row
= 0; row
< omap_kp
->rows
; row
++) {
83 if (gpio_get_value(row_gpios
[row
]))
89 #define set_col_gpio_val(x, y) do {} while (0)
90 #define get_row_gpio_val(x) 0
93 static irqreturn_t
omap_kp_interrupt(int irq
, void *dev_id
)
95 /* disable keyboard interrupt and schedule for handling */
96 omap_writew(1, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
98 tasklet_schedule(&kp_tasklet
);
103 static void omap_kp_timer(unsigned long data
)
105 tasklet_schedule(&kp_tasklet
);
108 static void omap_kp_scan_keypad(struct omap_kp
*omap_kp
, unsigned char *state
)
112 /* disable keyboard interrupt and schedule for handling */
113 omap_writew(1, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
115 /* read the keypad status */
116 omap_writew(0xff, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBC
);
117 for (col
= 0; col
< omap_kp
->cols
; col
++) {
118 omap_writew(~(1 << col
) & 0xff,
119 OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBC
);
121 udelay(omap_kp
->delay
);
123 state
[col
] = ~omap_readw(OMAP1_MPUIO_BASE
+
124 OMAP_MPUIO_KBR_LATCH
) & 0xff;
126 omap_writew(0x00, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBC
);
130 static void omap_kp_tasklet(unsigned long data
)
132 struct omap_kp
*omap_kp_data
= (struct omap_kp
*) data
;
133 unsigned short *keycodes
= omap_kp_data
->input
->keycode
;
134 unsigned int row_shift
= get_count_order(omap_kp_data
->cols
);
135 unsigned char new_state
[8], changed
, key_down
= 0;
139 /* check for any changes */
140 omap_kp_scan_keypad(omap_kp_data
, new_state
);
142 /* check for changes and print those */
143 for (col
= 0; col
< omap_kp_data
->cols
; col
++) {
144 changed
= new_state
[col
] ^ keypad_state
[col
];
145 key_down
|= new_state
[col
];
149 for (row
= 0; row
< omap_kp_data
->rows
; row
++) {
151 if (!(changed
& (1 << row
)))
153 #ifdef NEW_BOARD_LEARNING_MODE
154 printk(KERN_INFO
"omap-keypad: key %d-%d %s\n", col
,
155 row
, (new_state
[col
] & (1 << row
)) ?
156 "pressed" : "released");
158 key
= keycodes
[MATRIX_SCAN_CODE(row
, col
, row_shift
)];
161 "omap-keypad: Spurious key event %d-%d\n",
163 /* We scan again after a couple of seconds */
168 if (!(kp_cur_group
== (key
& GROUP_MASK
) ||
172 kp_cur_group
= key
& GROUP_MASK
;
173 input_report_key(omap_kp_data
->input
, key
& ~GROUP_MASK
,
174 new_state
[col
] & (1 << row
));
178 input_sync(omap_kp_data
->input
);
179 memcpy(keypad_state
, new_state
, sizeof(keypad_state
));
183 /* some key is pressed - keep irq disabled and use timer
184 * to poll the keypad */
187 mod_timer(&omap_kp_data
->timer
, jiffies
+ delay
);
189 /* enable interrupts */
190 omap_writew(0, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
195 static ssize_t
omap_kp_enable_show(struct device
*dev
,
196 struct device_attribute
*attr
, char *buf
)
198 return sprintf(buf
, "%u\n", kp_enable
);
201 static ssize_t
omap_kp_enable_store(struct device
*dev
, struct device_attribute
*attr
,
202 const char *buf
, size_t count
)
204 struct omap_kp
*omap_kp
= dev_get_drvdata(dev
);
207 if (sscanf(buf
, "%u", &state
) != 1)
210 if ((state
!= 1) && (state
!= 0))
213 mutex_lock(&kp_enable_mutex
);
214 if (state
!= kp_enable
) {
216 enable_irq(omap_kp
->irq
);
218 disable_irq(omap_kp
->irq
);
221 mutex_unlock(&kp_enable_mutex
);
223 return strnlen(buf
, count
);
226 static DEVICE_ATTR(enable
, S_IRUGO
| S_IWUSR
, omap_kp_enable_show
, omap_kp_enable_store
);
229 static int omap_kp_suspend(struct platform_device
*dev
, pm_message_t state
)
236 static int omap_kp_resume(struct platform_device
*dev
)
243 #define omap_kp_suspend NULL
244 #define omap_kp_resume NULL
247 static int omap_kp_probe(struct platform_device
*pdev
)
249 struct omap_kp
*omap_kp
;
250 struct input_dev
*input_dev
;
251 struct omap_kp_platform_data
*pdata
= pdev
->dev
.platform_data
;
252 int i
, col_idx
, row_idx
, ret
;
253 unsigned int row_shift
, keycodemax
;
255 if (!pdata
->rows
|| !pdata
->cols
|| !pdata
->keymap_data
) {
256 printk(KERN_ERR
"No rows, cols or keymap_data from pdata\n");
260 row_shift
= get_count_order(pdata
->cols
);
261 keycodemax
= pdata
->rows
<< row_shift
;
263 omap_kp
= kzalloc(sizeof(struct omap_kp
) +
264 keycodemax
* sizeof(unsigned short), GFP_KERNEL
);
265 input_dev
= input_allocate_device();
266 if (!omap_kp
|| !input_dev
) {
268 input_free_device(input_dev
);
272 platform_set_drvdata(pdev
, omap_kp
);
274 omap_kp
->input
= input_dev
;
276 /* Disable the interrupt for the MPUIO keyboard */
277 omap_writew(1, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
280 omap_kp
->delay
= pdata
->delay
;
282 if (pdata
->row_gpios
&& pdata
->col_gpios
) {
283 row_gpios
= pdata
->row_gpios
;
284 col_gpios
= pdata
->col_gpios
;
287 omap_kp
->rows
= pdata
->rows
;
288 omap_kp
->cols
= pdata
->cols
;
293 setup_timer(&omap_kp
->timer
, omap_kp_timer
, (unsigned long)omap_kp
);
295 /* get the irq and init timer*/
296 tasklet_enable(&kp_tasklet
);
297 kp_tasklet
.data
= (unsigned long) omap_kp
;
299 ret
= device_create_file(&pdev
->dev
, &dev_attr_enable
);
303 /* setup input device */
304 input_dev
->name
= "omap-keypad";
305 input_dev
->phys
= "omap-keypad/input0";
306 input_dev
->dev
.parent
= &pdev
->dev
;
308 input_dev
->id
.bustype
= BUS_HOST
;
309 input_dev
->id
.vendor
= 0x0001;
310 input_dev
->id
.product
= 0x0001;
311 input_dev
->id
.version
= 0x0100;
314 __set_bit(EV_REP
, input_dev
->evbit
);
316 ret
= matrix_keypad_build_keymap(pdata
->keymap_data
, NULL
,
317 pdata
->rows
, pdata
->cols
,
318 omap_kp
->keymap
, input_dev
);
322 ret
= input_register_device(omap_kp
->input
);
324 printk(KERN_ERR
"Unable to register omap-keypad input device\n");
329 omap_writew(0xff, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_GPIO_DEBOUNCING
);
331 /* scan current status and enable interrupt */
332 omap_kp_scan_keypad(omap_kp
, keypad_state
);
333 omap_kp
->irq
= platform_get_irq(pdev
, 0);
334 if (omap_kp
->irq
>= 0) {
335 if (request_irq(omap_kp
->irq
, omap_kp_interrupt
, 0,
336 "omap-keypad", omap_kp
) < 0)
339 omap_writew(0, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
344 input_unregister_device(omap_kp
->input
);
347 device_remove_file(&pdev
->dev
, &dev_attr_enable
);
349 for (i
= row_idx
- 1; i
>= 0; i
--)
350 gpio_free(row_gpios
[i
]);
351 for (i
= col_idx
- 1; i
>= 0; i
--)
352 gpio_free(col_gpios
[i
]);
355 input_free_device(input_dev
);
360 static int omap_kp_remove(struct platform_device
*pdev
)
362 struct omap_kp
*omap_kp
= platform_get_drvdata(pdev
);
364 /* disable keypad interrupt handling */
365 tasklet_disable(&kp_tasklet
);
366 omap_writew(1, OMAP1_MPUIO_BASE
+ OMAP_MPUIO_KBD_MASKIT
);
367 free_irq(omap_kp
->irq
, omap_kp
);
369 del_timer_sync(&omap_kp
->timer
);
370 tasklet_kill(&kp_tasklet
);
372 /* unregister everything */
373 input_unregister_device(omap_kp
->input
);
380 static struct platform_driver omap_kp_driver
= {
381 .probe
= omap_kp_probe
,
382 .remove
= omap_kp_remove
,
383 .suspend
= omap_kp_suspend
,
384 .resume
= omap_kp_resume
,
386 .name
= "omap-keypad",
387 .owner
= THIS_MODULE
,
390 module_platform_driver(omap_kp_driver
);
392 MODULE_AUTHOR("Timo Teräs");
393 MODULE_DESCRIPTION("OMAP Keypad Driver");
394 MODULE_LICENSE("GPL");
395 MODULE_ALIAS("platform:omap-keypad");