1/* 2 * linux/drivers/input/keyboard/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 <linux/mutex.h> 36#include <linux/errno.h> 37#include <linux/slab.h> 38#include <mach/gpio.h> 39#include <plat/keypad.h> 40#include <plat/menelaus.h> 41#include <asm/irq.h> 42#include <mach/hardware.h> 43#include <asm/io.h> 44#include <plat/mux.h> 45 46#undef NEW_BOARD_LEARNING_MODE 47 48static void omap_kp_tasklet(unsigned long); 49static void omap_kp_timer(unsigned long); 50 51static unsigned char keypad_state[8]; 52static DEFINE_MUTEX(kp_enable_mutex); 53static int kp_enable = 1; 54static int kp_cur_group = -1; 55 56struct omap_kp { 57 struct input_dev *input; 58 struct timer_list timer; 59 int irq; 60 unsigned int rows; 61 unsigned int cols; 62 unsigned long delay; 63 unsigned int debounce; 64}; 65 66static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0); 67 68static int *keymap; 69static unsigned int *row_gpios; 70static unsigned int *col_gpios; 71 72#ifdef CONFIG_ARCH_OMAP2 73static void set_col_gpio_val(struct omap_kp *omap_kp, u8 value) 74{ 75 int col; 76 77 for (col = 0; col < omap_kp->cols; col++) 78 gpio_set_value(col_gpios[col], value & (1 << col)); 79} 80 81static u8 get_row_gpio_val(struct omap_kp *omap_kp) 82{ 83 int row; 84 u8 value = 0; 85 86 for (row = 0; row < omap_kp->rows; row++) { 87 if (gpio_get_value(row_gpios[row])) 88 value |= (1 << row); 89 } 90 return value; 91} 92#else 93#define set_col_gpio_val(x, y) do {} while (0) 94#define get_row_gpio_val(x) 0 95#endif 96 97static irqreturn_t omap_kp_interrupt(int irq, void *dev_id) 98{ 99 struct omap_kp *omap_kp = dev_id; 100 101 /* disable keyboard interrupt and schedule for handling */ 102 if (cpu_is_omap24xx()) { 103 int i; 104 105 for (i = 0; i < omap_kp->rows; i++) { 106 int gpio_irq = gpio_to_irq(row_gpios[i]); 107 /* 108 * The interrupt which we're currently handling should 109 * be disabled _nosync() to avoid deadlocks waiting 110 * for this handler to complete. All others should 111 * be disabled the regular way for SMP safety. 112 */ 113 if (gpio_irq == irq) 114 disable_irq_nosync(gpio_irq); 115 else 116 disable_irq(gpio_irq); 117 } 118 } else 119 /* disable keyboard interrupt and schedule for handling */ 120 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 121 122 tasklet_schedule(&kp_tasklet); 123 124 return IRQ_HANDLED; 125} 126 127static void omap_kp_timer(unsigned long data) 128{ 129 tasklet_schedule(&kp_tasklet); 130} 131 132static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state) 133{ 134 int col = 0; 135 136 /* read the keypad status */ 137 if (cpu_is_omap24xx()) { 138 /* read the keypad status */ 139 for (col = 0; col < omap_kp->cols; col++) { 140 set_col_gpio_val(omap_kp, ~(1 << col)); 141 state[col] = ~(get_row_gpio_val(omap_kp)) & 0xff; 142 } 143 set_col_gpio_val(omap_kp, 0); 144 145 } else { 146 /* disable keyboard interrupt and schedule for handling */ 147 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 148 149 /* read the keypad status */ 150 omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC); 151 for (col = 0; col < omap_kp->cols; col++) { 152 omap_writew(~(1 << col) & 0xff, 153 OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC); 154 155 udelay(omap_kp->delay); 156 157 state[col] = ~omap_readw(OMAP1_MPUIO_BASE + 158 OMAP_MPUIO_KBR_LATCH) & 0xff; 159 } 160 omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC); 161 udelay(2); 162 } 163} 164 165static inline int omap_kp_find_key(int col, int row) 166{ 167 int i, key; 168 169 key = KEY(col, row, 0); 170 for (i = 0; keymap[i] != 0; i++) 171 if ((keymap[i] & 0xff000000) == key) 172 return keymap[i] & 0x00ffffff; 173 return -1; 174} 175 176static void omap_kp_tasklet(unsigned long data) 177{ 178 struct omap_kp *omap_kp_data = (struct omap_kp *) data; 179 unsigned char new_state[8], changed, key_down = 0; 180 int col, row; 181 int spurious = 0; 182 183 /* check for any changes */ 184 omap_kp_scan_keypad(omap_kp_data, new_state); 185 186 /* check for changes and print those */ 187 for (col = 0; col < omap_kp_data->cols; col++) { 188 changed = new_state[col] ^ keypad_state[col]; 189 key_down |= new_state[col]; 190 if (changed == 0) 191 continue; 192 193 for (row = 0; row < omap_kp_data->rows; row++) { 194 int key; 195 if (!(changed & (1 << row))) 196 continue; 197#ifdef NEW_BOARD_LEARNING_MODE 198 printk(KERN_INFO "omap-keypad: key %d-%d %s\n", col, 199 row, (new_state[col] & (1 << row)) ? 200 "pressed" : "released"); 201#else 202 key = omap_kp_find_key(col, row); 203 if (key < 0) { 204 printk(KERN_WARNING 205 "omap-keypad: Spurious key event %d-%d\n", 206 col, row); 207 /* We scan again after a couple of seconds */ 208 spurious = 1; 209 continue; 210 } 211 212 if (!(kp_cur_group == (key & GROUP_MASK) || 213 kp_cur_group == -1)) 214 continue; 215 216 kp_cur_group = key & GROUP_MASK; 217 input_report_key(omap_kp_data->input, key & ~GROUP_MASK, 218 new_state[col] & (1 << row)); 219#endif 220 } 221 } 222 memcpy(keypad_state, new_state, sizeof(keypad_state)); 223 224 if (key_down) { 225 int delay = HZ / 20; 226 /* some key is pressed - keep irq disabled and use timer 227 * to poll the keypad */ 228 if (spurious) 229 delay = 2 * HZ; 230 mod_timer(&omap_kp_data->timer, jiffies + delay); 231 } else { 232 /* enable interrupts */ 233 if (cpu_is_omap24xx()) { 234 int i; 235 for (i = 0; i < omap_kp_data->rows; i++) 236 enable_irq(gpio_to_irq(row_gpios[i])); 237 } else { 238 omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 239 kp_cur_group = -1; 240 } 241 } 242} 243 244static ssize_t omap_kp_enable_show(struct device *dev, 245 struct device_attribute *attr, char *buf) 246{ 247 return sprintf(buf, "%u\n", kp_enable); 248} 249 250static ssize_t omap_kp_enable_store(struct device *dev, struct device_attribute *attr, 251 const char *buf, size_t count) 252{ 253 int state; 254 255 if (sscanf(buf, "%u", &state) != 1) 256 return -EINVAL; 257 258 if ((state != 1) && (state != 0)) 259 return -EINVAL; 260 261 mutex_lock(&kp_enable_mutex); 262 if (state != kp_enable) { 263 if (state) 264 enable_irq(INT_KEYBOARD); 265 else 266 disable_irq(INT_KEYBOARD); 267 kp_enable = state; 268 } 269 mutex_unlock(&kp_enable_mutex); 270 271 return strnlen(buf, count); 272} 273 274static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, omap_kp_enable_show, omap_kp_enable_store); 275 276#ifdef CONFIG_PM 277static int omap_kp_suspend(struct platform_device *dev, pm_message_t state) 278{ 279 /* Nothing yet */ 280 281 return 0; 282} 283 284static int omap_kp_resume(struct platform_device *dev) 285{ 286 /* Nothing yet */ 287 288 return 0; 289} 290#else 291#define omap_kp_suspend NULL 292#define omap_kp_resume NULL 293#endif 294 295static int __devinit omap_kp_probe(struct platform_device *pdev) 296{ 297 struct omap_kp *omap_kp; 298 struct input_dev *input_dev; 299 struct omap_kp_platform_data *pdata = pdev->dev.platform_data; 300 int i, col_idx, row_idx, irq_idx, ret; 301 302 if (!pdata->rows || !pdata->cols || !pdata->keymap) { 303 printk(KERN_ERR "No rows, cols or keymap from pdata\n"); 304 return -EINVAL; 305 } 306 307 omap_kp = kzalloc(sizeof(struct omap_kp), GFP_KERNEL); 308 input_dev = input_allocate_device(); 309 if (!omap_kp || !input_dev) { 310 kfree(omap_kp); 311 input_free_device(input_dev); 312 return -ENOMEM; 313 } 314 315 platform_set_drvdata(pdev, omap_kp); 316 317 omap_kp->input = input_dev; 318 319 /* Disable the interrupt for the MPUIO keyboard */ 320 if (!cpu_is_omap24xx()) 321 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 322 323 keymap = pdata->keymap; 324 325 if (pdata->rep) 326 __set_bit(EV_REP, input_dev->evbit); 327 328 if (pdata->delay) 329 omap_kp->delay = pdata->delay; 330 331 if (pdata->row_gpios && pdata->col_gpios) { 332 row_gpios = pdata->row_gpios; 333 col_gpios = pdata->col_gpios; 334 } 335 336 omap_kp->rows = pdata->rows; 337 omap_kp->cols = pdata->cols; 338 339 if (cpu_is_omap24xx()) { 340 /* Cols: outputs */ 341 for (col_idx = 0; col_idx < omap_kp->cols; col_idx++) { 342 if (gpio_request(col_gpios[col_idx], "omap_kp_col") < 0) { 343 printk(KERN_ERR "Failed to request" 344 "GPIO%d for keypad\n", 345 col_gpios[col_idx]); 346 goto err1; 347 } 348 gpio_direction_output(col_gpios[col_idx], 0); 349 } 350 /* Rows: inputs */ 351 for (row_idx = 0; row_idx < omap_kp->rows; row_idx++) { 352 if (gpio_request(row_gpios[row_idx], "omap_kp_row") < 0) { 353 printk(KERN_ERR "Failed to request" 354 "GPIO%d for keypad\n", 355 row_gpios[row_idx]); 356 goto err2; 357 } 358 gpio_direction_input(row_gpios[row_idx]); 359 } 360 } else { 361 col_idx = 0; 362 row_idx = 0; 363 } 364 365 setup_timer(&omap_kp->timer, omap_kp_timer, (unsigned long)omap_kp); 366 367 /* get the irq and init timer*/ 368 tasklet_enable(&kp_tasklet); 369 kp_tasklet.data = (unsigned long) omap_kp; 370 371 ret = device_create_file(&pdev->dev, &dev_attr_enable); 372 if (ret < 0) 373 goto err2; 374 375 /* setup input device */ 376 __set_bit(EV_KEY, input_dev->evbit); 377 for (i = 0; keymap[i] != 0; i++) 378 __set_bit(keymap[i] & KEY_MAX, input_dev->keybit); 379 input_dev->name = "omap-keypad"; 380 input_dev->phys = "omap-keypad/input0"; 381 input_dev->dev.parent = &pdev->dev; 382 383 input_dev->id.bustype = BUS_HOST; 384 input_dev->id.vendor = 0x0001; 385 input_dev->id.product = 0x0001; 386 input_dev->id.version = 0x0100; 387 388 ret = input_register_device(omap_kp->input); 389 if (ret < 0) { 390 printk(KERN_ERR "Unable to register omap-keypad input device\n"); 391 goto err3; 392 } 393 394 if (pdata->dbounce) 395 omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING); 396 397 /* scan current status and enable interrupt */ 398 omap_kp_scan_keypad(omap_kp, keypad_state); 399 if (!cpu_is_omap24xx()) { 400 omap_kp->irq = platform_get_irq(pdev, 0); 401 if (omap_kp->irq >= 0) { 402 if (request_irq(omap_kp->irq, omap_kp_interrupt, 0, 403 "omap-keypad", omap_kp) < 0) 404 goto err4; 405 } 406 omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 407 } else { 408 for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) { 409 if (request_irq(gpio_to_irq(row_gpios[irq_idx]), 410 omap_kp_interrupt, 411 IRQF_TRIGGER_FALLING, 412 "omap-keypad", omap_kp) < 0) 413 goto err5; 414 } 415 } 416 return 0; 417err5: 418 for (i = irq_idx - 1; i >=0; i--) 419 free_irq(row_gpios[i], 0); 420err4: 421 input_unregister_device(omap_kp->input); 422 input_dev = NULL; 423err3: 424 device_remove_file(&pdev->dev, &dev_attr_enable); 425err2: 426 for (i = row_idx - 1; i >=0; i--) 427 gpio_free(row_gpios[i]); 428err1: 429 for (i = col_idx - 1; i >=0; i--) 430 gpio_free(col_gpios[i]); 431 432 kfree(omap_kp); 433 input_free_device(input_dev); 434 435 return -EINVAL; 436} 437 438static int __devexit omap_kp_remove(struct platform_device *pdev) 439{ 440 struct omap_kp *omap_kp = platform_get_drvdata(pdev); 441 442 /* disable keypad interrupt handling */ 443 tasklet_disable(&kp_tasklet); 444 if (cpu_is_omap24xx()) { 445 int i; 446 for (i = 0; i < omap_kp->cols; i++) 447 gpio_free(col_gpios[i]); 448 for (i = 0; i < omap_kp->rows; i++) { 449 gpio_free(row_gpios[i]); 450 free_irq(gpio_to_irq(row_gpios[i]), 0); 451 } 452 } else { 453 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 454 free_irq(omap_kp->irq, 0); 455 } 456 457 del_timer_sync(&omap_kp->timer); 458 tasklet_kill(&kp_tasklet); 459 460 /* unregister everything */ 461 input_unregister_device(omap_kp->input); 462 463 kfree(omap_kp); 464 465 return 0; 466} 467 468static struct platform_driver omap_kp_driver = { 469 .probe = omap_kp_probe, 470 .remove = __devexit_p(omap_kp_remove), 471 .suspend = omap_kp_suspend, 472 .resume = omap_kp_resume, 473 .driver = { 474 .name = "omap-keypad", 475 .owner = THIS_MODULE, 476 }, 477}; 478 479static int __init omap_kp_init(void) 480{ 481 printk(KERN_INFO "OMAP Keypad Driver\n"); 482 return platform_driver_register(&omap_kp_driver); 483} 484 485static void __exit omap_kp_exit(void) 486{ 487 platform_driver_unregister(&omap_kp_driver); 488} 489 490module_init(omap_kp_init); 491module_exit(omap_kp_exit); 492 493MODULE_AUTHOR("Timo Ter��s"); 494MODULE_DESCRIPTION("OMAP Keypad Driver"); 495MODULE_LICENSE("GPL"); 496MODULE_ALIAS("platform:omap-keypad"); 497