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");