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 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 < pdata->num_row_gpios; i++) 456 gpios[i] = of_get_named_gpio(np, "row-gpios", i); 457 458 for (i = 0; i < pdata->num_col_gpios; i++) 459 gpios[pdata->num_row_gpios + i] = 460 of_get_named_gpio(np, "col-gpios", i); 461 462 pdata->row_gpios = gpios; 463 pdata->col_gpios = &gpios[pdata->num_row_gpios]; 464 465 return pdata; 466 } 467 #else 468 static inline struct matrix_keypad_platform_data * 469 matrix_keypad_parse_dt(struct device *dev) 470 { 471 dev_err(dev, "no platform data defined\n"); 472 473 return ERR_PTR(-EINVAL); 474 } 475 #endif 476 477 static int matrix_keypad_probe(struct platform_device *pdev) 478 { 479 const struct matrix_keypad_platform_data *pdata; 480 struct matrix_keypad *keypad; 481 struct input_dev *input_dev; 482 int err; 483 484 pdata = dev_get_platdata(&pdev->dev); 485 if (!pdata) { 486 pdata = matrix_keypad_parse_dt(&pdev->dev); 487 if (IS_ERR(pdata)) { 488 dev_err(&pdev->dev, "no platform data defined\n"); 489 return PTR_ERR(pdata); 490 } 491 } else if (!pdata->keymap_data) { 492 dev_err(&pdev->dev, "no keymap data defined\n"); 493 return -EINVAL; 494 } 495 496 keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL); 497 input_dev = input_allocate_device(); 498 if (!keypad || !input_dev) { 499 err = -ENOMEM; 500 goto err_free_mem; 501 } 502 503 keypad->input_dev = input_dev; 504 keypad->pdata = pdata; 505 keypad->row_shift = get_count_order(pdata->num_col_gpios); 506 keypad->stopped = true; 507 INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan); 508 spin_lock_init(&keypad->lock); 509 510 input_dev->name = pdev->name; 511 input_dev->id.bustype = BUS_HOST; 512 input_dev->dev.parent = &pdev->dev; 513 input_dev->open = matrix_keypad_start; 514 input_dev->close = matrix_keypad_stop; 515 516 err = matrix_keypad_build_keymap(pdata->keymap_data, NULL, 517 pdata->num_row_gpios, 518 pdata->num_col_gpios, 519 NULL, input_dev); 520 if (err) { 521 dev_err(&pdev->dev, "failed to build keymap\n"); 522 goto err_free_mem; 523 } 524 525 if (!pdata->no_autorepeat) 526 __set_bit(EV_REP, input_dev->evbit); 527 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 528 input_set_drvdata(input_dev, keypad); 529 530 err = matrix_keypad_init_gpio(pdev, keypad); 531 if (err) 532 goto err_free_mem; 533 534 err = input_register_device(keypad->input_dev); 535 if (err) 536 goto err_free_gpio; 537 538 device_init_wakeup(&pdev->dev, pdata->wakeup); 539 platform_set_drvdata(pdev, keypad); 540 541 return 0; 542 543 err_free_gpio: 544 matrix_keypad_free_gpio(keypad); 545 err_free_mem: 546 input_free_device(input_dev); 547 kfree(keypad); 548 return err; 549 } 550 551 static int matrix_keypad_remove(struct platform_device *pdev) 552 { 553 struct matrix_keypad *keypad = platform_get_drvdata(pdev); 554 555 matrix_keypad_free_gpio(keypad); 556 input_unregister_device(keypad->input_dev); 557 kfree(keypad); 558 559 return 0; 560 } 561 562 #ifdef CONFIG_OF 563 static const struct of_device_id matrix_keypad_dt_match[] = { 564 { .compatible = "gpio-matrix-keypad" }, 565 { } 566 }; 567 MODULE_DEVICE_TABLE(of, matrix_keypad_dt_match); 568 #endif 569 570 static struct platform_driver matrix_keypad_driver = { 571 .probe = matrix_keypad_probe, 572 .remove = matrix_keypad_remove, 573 .driver = { 574 .name = "matrix-keypad", 575 .pm = &matrix_keypad_pm_ops, 576 .of_match_table = of_match_ptr(matrix_keypad_dt_match), 577 }, 578 }; 579 module_platform_driver(matrix_keypad_driver); 580 581 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>"); 582 MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver"); 583 MODULE_LICENSE("GPL v2"); 584 MODULE_ALIAS("platform:matrix-keypad"); 585