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