1 /* 2 * GPIO driven matrix keyboard driver 3 * 4 * Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com> 5 * 6 * Based on corgikbd.c 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 */ 13 14 #include <linux/types.h> 15 #include <linux/delay.h> 16 #include <linux/platform_device.h> 17 #include <linux/input.h> 18 #include <linux/irq.h> 19 #include <linux/interrupt.h> 20 #include <linux/jiffies.h> 21 #include <linux/module.h> 22 #include <linux/gpio.h> 23 #include <linux/input/matrix_keypad.h> 24 #include <linux/slab.h> 25 #include <linux/of.h> 26 #include <linux/of_gpio.h> 27 #include <linux/of_platform.h> 28 29 struct matrix_keypad { 30 const struct matrix_keypad_platform_data *pdata; 31 struct input_dev *input_dev; 32 unsigned int row_shift; 33 34 DECLARE_BITMAP(disabled_gpios, MATRIX_MAX_ROWS); 35 36 uint32_t last_key_state[MATRIX_MAX_COLS]; 37 struct delayed_work work; 38 spinlock_t lock; 39 bool scan_pending; 40 bool stopped; 41 bool gpio_all_disabled; 42 }; 43 44 /* 45 * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause 46 * minmal side effect when scanning other columns, here it is configured to 47 * be input, and it should work on most platforms. 48 */ 49 static void __activate_col(const struct matrix_keypad_platform_data *pdata, 50 int col, bool on) 51 { 52 bool level_on = !pdata->active_low; 53 54 if (on) { 55 gpio_direction_output(pdata->col_gpios[col], level_on); 56 } else { 57 gpio_set_value_cansleep(pdata->col_gpios[col], !level_on); 58 gpio_direction_input(pdata->col_gpios[col]); 59 } 60 } 61 62 static void activate_col(const struct matrix_keypad_platform_data *pdata, 63 int col, bool on) 64 { 65 __activate_col(pdata, col, on); 66 67 if (on && pdata->col_scan_delay_us) 68 udelay(pdata->col_scan_delay_us); 69 } 70 71 static void activate_all_cols(const struct matrix_keypad_platform_data *pdata, 72 bool on) 73 { 74 int col; 75 76 for (col = 0; col < pdata->num_col_gpios; col++) 77 __activate_col(pdata, col, on); 78 } 79 80 static bool row_asserted(const struct matrix_keypad_platform_data *pdata, 81 int row) 82 { 83 return gpio_get_value_cansleep(pdata->row_gpios[row]) ? 84 !pdata->active_low : pdata->active_low; 85 } 86 87 static void enable_row_irqs(struct matrix_keypad *keypad) 88 { 89 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 90 int i; 91 92 if (pdata->clustered_irq > 0) 93 enable_irq(pdata->clustered_irq); 94 else { 95 for (i = 0; i < pdata->num_row_gpios; i++) 96 enable_irq(gpio_to_irq(pdata->row_gpios[i])); 97 } 98 } 99 100 static void disable_row_irqs(struct matrix_keypad *keypad) 101 { 102 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 103 int i; 104 105 if (pdata->clustered_irq > 0) 106 disable_irq_nosync(pdata->clustered_irq); 107 else { 108 for (i = 0; i < pdata->num_row_gpios; i++) 109 disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i])); 110 } 111 } 112 113 /* 114 * This gets the keys from keyboard and reports it to input subsystem 115 */ 116 static void matrix_keypad_scan(struct work_struct *work) 117 { 118 struct matrix_keypad *keypad = 119 container_of(work, struct matrix_keypad, work.work); 120 struct input_dev *input_dev = keypad->input_dev; 121 const unsigned short *keycodes = input_dev->keycode; 122 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 123 uint32_t new_state[MATRIX_MAX_COLS]; 124 int row, col, code; 125 126 /* de-activate all columns for scanning */ 127 activate_all_cols(pdata, false); 128 129 memset(new_state, 0, sizeof(new_state)); 130 131 /* assert each column and read the row status out */ 132 for (col = 0; col < pdata->num_col_gpios; col++) { 133 134 activate_col(pdata, col, true); 135 136 for (row = 0; row < pdata->num_row_gpios; row++) 137 new_state[col] |= 138 row_asserted(pdata, row) ? (1 << row) : 0; 139 140 activate_col(pdata, col, false); 141 } 142 143 for (col = 0; col < pdata->num_col_gpios; col++) { 144 uint32_t bits_changed; 145 146 bits_changed = keypad->last_key_state[col] ^ new_state[col]; 147 if (bits_changed == 0) 148 continue; 149 150 for (row = 0; row < pdata->num_row_gpios; row++) { 151 if ((bits_changed & (1 << row)) == 0) 152 continue; 153 154 code = MATRIX_SCAN_CODE(row, col, keypad->row_shift); 155 input_event(input_dev, EV_MSC, MSC_SCAN, code); 156 input_report_key(input_dev, 157 keycodes[code], 158 new_state[col] & (1 << row)); 159 } 160 } 161 input_sync(input_dev); 162 163 memcpy(keypad->last_key_state, new_state, sizeof(new_state)); 164 165 activate_all_cols(pdata, true); 166 167 /* Enable IRQs again */ 168 spin_lock_irq(&keypad->lock); 169 keypad->scan_pending = false; 170 enable_row_irqs(keypad); 171 spin_unlock_irq(&keypad->lock); 172 } 173 174 static irqreturn_t matrix_keypad_interrupt(int irq, void *id) 175 { 176 struct matrix_keypad *keypad = id; 177 unsigned long flags; 178 179 spin_lock_irqsave(&keypad->lock, flags); 180 181 /* 182 * See if another IRQ beaten us to it and scheduled the 183 * scan already. In that case we should not try to 184 * disable IRQs again. 185 */ 186 if (unlikely(keypad->scan_pending || keypad->stopped)) 187 goto out; 188 189 disable_row_irqs(keypad); 190 keypad->scan_pending = true; 191 schedule_delayed_work(&keypad->work, 192 msecs_to_jiffies(keypad->pdata->debounce_ms)); 193 194 out: 195 spin_unlock_irqrestore(&keypad->lock, flags); 196 return IRQ_HANDLED; 197 } 198 199 static int matrix_keypad_start(struct input_dev *dev) 200 { 201 struct matrix_keypad *keypad = input_get_drvdata(dev); 202 203 keypad->stopped = false; 204 mb(); 205 206 /* 207 * Schedule an immediate key scan to capture current key state; 208 * columns will be activated and IRQs be enabled after the scan. 209 */ 210 schedule_delayed_work(&keypad->work, 0); 211 212 return 0; 213 } 214 215 static void matrix_keypad_stop(struct input_dev *dev) 216 { 217 struct matrix_keypad *keypad = input_get_drvdata(dev); 218 219 keypad->stopped = true; 220 mb(); 221 flush_work(&keypad->work.work); 222 /* 223 * matrix_keypad_scan() will leave IRQs enabled; 224 * we should disable them now. 225 */ 226 disable_row_irqs(keypad); 227 } 228 229 #ifdef CONFIG_PM_SLEEP 230 static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad) 231 { 232 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 233 unsigned int gpio; 234 int i; 235 236 if (pdata->clustered_irq > 0) { 237 if (enable_irq_wake(pdata->clustered_irq) == 0) 238 keypad->gpio_all_disabled = true; 239 } else { 240 241 for (i = 0; i < pdata->num_row_gpios; i++) { 242 if (!test_bit(i, keypad->disabled_gpios)) { 243 gpio = pdata->row_gpios[i]; 244 245 if (enable_irq_wake(gpio_to_irq(gpio)) == 0) 246 __set_bit(i, keypad->disabled_gpios); 247 } 248 } 249 } 250 } 251 252 static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad) 253 { 254 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 255 unsigned int gpio; 256 int i; 257 258 if (pdata->clustered_irq > 0) { 259 if (keypad->gpio_all_disabled) { 260 disable_irq_wake(pdata->clustered_irq); 261 keypad->gpio_all_disabled = false; 262 } 263 } else { 264 for (i = 0; i < pdata->num_row_gpios; i++) { 265 if (test_and_clear_bit(i, keypad->disabled_gpios)) { 266 gpio = pdata->row_gpios[i]; 267 disable_irq_wake(gpio_to_irq(gpio)); 268 } 269 } 270 } 271 } 272 273 static int matrix_keypad_suspend(struct device *dev) 274 { 275 struct platform_device *pdev = to_platform_device(dev); 276 struct matrix_keypad *keypad = platform_get_drvdata(pdev); 277 278 matrix_keypad_stop(keypad->input_dev); 279 280 if (device_may_wakeup(&pdev->dev)) 281 matrix_keypad_enable_wakeup(keypad); 282 283 return 0; 284 } 285 286 static int matrix_keypad_resume(struct device *dev) 287 { 288 struct platform_device *pdev = to_platform_device(dev); 289 struct matrix_keypad *keypad = platform_get_drvdata(pdev); 290 291 if (device_may_wakeup(&pdev->dev)) 292 matrix_keypad_disable_wakeup(keypad); 293 294 matrix_keypad_start(keypad->input_dev); 295 296 return 0; 297 } 298 #endif 299 300 static SIMPLE_DEV_PM_OPS(matrix_keypad_pm_ops, 301 matrix_keypad_suspend, matrix_keypad_resume); 302 303 static int matrix_keypad_init_gpio(struct platform_device *pdev, 304 struct matrix_keypad *keypad) 305 { 306 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 307 int i, err; 308 309 /* initialized strobe lines as outputs, activated */ 310 for (i = 0; i < pdata->num_col_gpios; i++) { 311 err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col"); 312 if (err) { 313 dev_err(&pdev->dev, 314 "failed to request GPIO%d for COL%d\n", 315 pdata->col_gpios[i], i); 316 goto err_free_cols; 317 } 318 319 gpio_direction_output(pdata->col_gpios[i], !pdata->active_low); 320 } 321 322 for (i = 0; i < pdata->num_row_gpios; i++) { 323 err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row"); 324 if (err) { 325 dev_err(&pdev->dev, 326 "failed to request GPIO%d for ROW%d\n", 327 pdata->row_gpios[i], i); 328 goto err_free_rows; 329 } 330 331 gpio_direction_input(pdata->row_gpios[i]); 332 } 333 334 if (pdata->clustered_irq > 0) { 335 err = request_irq(pdata->clustered_irq, 336 matrix_keypad_interrupt, 337 pdata->clustered_irq_flags, 338 "matrix-keypad", keypad); 339 if (err) { 340 dev_err(&pdev->dev, 341 "Unable to acquire clustered interrupt\n"); 342 goto err_free_rows; 343 } 344 } else { 345 for (i = 0; i < pdata->num_row_gpios; i++) { 346 err = request_irq(gpio_to_irq(pdata->row_gpios[i]), 347 matrix_keypad_interrupt, 348 IRQF_TRIGGER_RISING | 349 IRQF_TRIGGER_FALLING, 350 "matrix-keypad", keypad); 351 if (err) { 352 dev_err(&pdev->dev, 353 "Unable to acquire interrupt for GPIO line %i\n", 354 pdata->row_gpios[i]); 355 goto err_free_irqs; 356 } 357 } 358 } 359 360 /* initialized as disabled - enabled by input->open */ 361 disable_row_irqs(keypad); 362 return 0; 363 364 err_free_irqs: 365 while (--i >= 0) 366 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad); 367 i = pdata->num_row_gpios; 368 err_free_rows: 369 while (--i >= 0) 370 gpio_free(pdata->row_gpios[i]); 371 i = pdata->num_col_gpios; 372 err_free_cols: 373 while (--i >= 0) 374 gpio_free(pdata->col_gpios[i]); 375 376 return err; 377 } 378 379 static void matrix_keypad_free_gpio(struct matrix_keypad *keypad) 380 { 381 const struct matrix_keypad_platform_data *pdata = keypad->pdata; 382 int i; 383 384 if (pdata->clustered_irq > 0) { 385 free_irq(pdata->clustered_irq, keypad); 386 } else { 387 for (i = 0; i < pdata->num_row_gpios; i++) 388 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad); 389 } 390 391 for (i = 0; i < pdata->num_row_gpios; i++) 392 gpio_free(pdata->row_gpios[i]); 393 394 for (i = 0; i < pdata->num_col_gpios; i++) 395 gpio_free(pdata->col_gpios[i]); 396 } 397 398 #ifdef CONFIG_OF 399 static struct matrix_keypad_platform_data * 400 matrix_keypad_parse_dt(struct device *dev) 401 { 402 struct matrix_keypad_platform_data *pdata; 403 struct device_node *np = dev->of_node; 404 unsigned int *gpios; 405 int i, nrow, ncol; 406 407 if (!np) { 408 dev_err(dev, "device lacks DT data\n"); 409 return ERR_PTR(-ENODEV); 410 } 411 412 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 413 if (!pdata) { 414 dev_err(dev, "could not allocate memory for platform data\n"); 415 return ERR_PTR(-ENOMEM); 416 } 417 418 pdata->num_row_gpios = nrow = of_gpio_named_count(np, "row-gpios"); 419 pdata->num_col_gpios = ncol = of_gpio_named_count(np, "col-gpios"); 420 if (nrow <= 0 || ncol <= 0) { 421 dev_err(dev, "number of keypad rows/columns not specified\n"); 422 return ERR_PTR(-EINVAL); 423 } 424 425 if (of_get_property(np, "linux,no-autorepeat", NULL)) 426 pdata->no_autorepeat = true; 427 if (of_get_property(np, "linux,wakeup", NULL)) 428 pdata->wakeup = true; 429 if (of_get_property(np, "gpio-activelow", NULL)) 430 pdata->active_low = true; 431 432 of_property_read_u32(np, "debounce-delay-ms", &pdata->debounce_ms); 433 of_property_read_u32(np, "col-scan-delay-us", 434 &pdata->col_scan_delay_us); 435 436 gpios = devm_kzalloc(dev, 437 sizeof(unsigned int) * 438 (pdata->num_row_gpios + pdata->num_col_gpios), 439 GFP_KERNEL); 440 if (!gpios) { 441 dev_err(dev, "could not allocate memory for gpios\n"); 442 return ERR_PTR(-ENOMEM); 443 } 444 445 for (i = 0; i < pdata->num_row_gpios; i++) 446 gpios[i] = of_get_named_gpio(np, "row-gpios", i); 447 448 for (i = 0; i < pdata->num_col_gpios; i++) 449 gpios[pdata->num_row_gpios + i] = 450 of_get_named_gpio(np, "col-gpios", i); 451 452 pdata->row_gpios = gpios; 453 pdata->col_gpios = &gpios[pdata->num_row_gpios]; 454 455 return pdata; 456 } 457 #else 458 static inline struct matrix_keypad_platform_data * 459 matrix_keypad_parse_dt(struct device *dev) 460 { 461 dev_err(dev, "no platform data defined\n"); 462 463 return ERR_PTR(-EINVAL); 464 } 465 #endif 466 467 static int matrix_keypad_probe(struct platform_device *pdev) 468 { 469 const struct matrix_keypad_platform_data *pdata; 470 struct matrix_keypad *keypad; 471 struct input_dev *input_dev; 472 int err; 473 474 pdata = dev_get_platdata(&pdev->dev); 475 if (!pdata) { 476 pdata = matrix_keypad_parse_dt(&pdev->dev); 477 if (IS_ERR(pdata)) { 478 dev_err(&pdev->dev, "no platform data defined\n"); 479 return PTR_ERR(pdata); 480 } 481 } else if (!pdata->keymap_data) { 482 dev_err(&pdev->dev, "no keymap data defined\n"); 483 return -EINVAL; 484 } 485 486 keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL); 487 input_dev = input_allocate_device(); 488 if (!keypad || !input_dev) { 489 err = -ENOMEM; 490 goto err_free_mem; 491 } 492 493 keypad->input_dev = input_dev; 494 keypad->pdata = pdata; 495 keypad->row_shift = get_count_order(pdata->num_col_gpios); 496 keypad->stopped = true; 497 INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan); 498 spin_lock_init(&keypad->lock); 499 500 input_dev->name = pdev->name; 501 input_dev->id.bustype = BUS_HOST; 502 input_dev->dev.parent = &pdev->dev; 503 input_dev->open = matrix_keypad_start; 504 input_dev->close = matrix_keypad_stop; 505 506 err = matrix_keypad_build_keymap(pdata->keymap_data, NULL, 507 pdata->num_row_gpios, 508 pdata->num_col_gpios, 509 NULL, input_dev); 510 if (err) { 511 dev_err(&pdev->dev, "failed to build keymap\n"); 512 goto err_free_mem; 513 } 514 515 if (!pdata->no_autorepeat) 516 __set_bit(EV_REP, input_dev->evbit); 517 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 518 input_set_drvdata(input_dev, keypad); 519 520 err = matrix_keypad_init_gpio(pdev, keypad); 521 if (err) 522 goto err_free_mem; 523 524 err = input_register_device(keypad->input_dev); 525 if (err) 526 goto err_free_gpio; 527 528 device_init_wakeup(&pdev->dev, pdata->wakeup); 529 platform_set_drvdata(pdev, keypad); 530 531 return 0; 532 533 err_free_gpio: 534 matrix_keypad_free_gpio(keypad); 535 err_free_mem: 536 input_free_device(input_dev); 537 kfree(keypad); 538 return err; 539 } 540 541 static int matrix_keypad_remove(struct platform_device *pdev) 542 { 543 struct matrix_keypad *keypad = platform_get_drvdata(pdev); 544 545 device_init_wakeup(&pdev->dev, 0); 546 547 matrix_keypad_free_gpio(keypad); 548 input_unregister_device(keypad->input_dev); 549 kfree(keypad); 550 551 return 0; 552 } 553 554 #ifdef CONFIG_OF 555 static const struct of_device_id matrix_keypad_dt_match[] = { 556 { .compatible = "gpio-matrix-keypad" }, 557 { } 558 }; 559 MODULE_DEVICE_TABLE(of, matrix_keypad_dt_match); 560 #endif 561 562 static struct platform_driver matrix_keypad_driver = { 563 .probe = matrix_keypad_probe, 564 .remove = matrix_keypad_remove, 565 .driver = { 566 .name = "matrix-keypad", 567 .owner = THIS_MODULE, 568 .pm = &matrix_keypad_pm_ops, 569 .of_match_table = of_match_ptr(matrix_keypad_dt_match), 570 }, 571 }; 572 module_platform_driver(matrix_keypad_driver); 573 574 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>"); 575 MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver"); 576 MODULE_LICENSE("GPL v2"); 577 MODULE_ALIAS("platform:matrix-keypad"); 578