1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Driver for the IMX keypad port. 4 // Copyright (C) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com> 5 6 #include <linux/clk.h> 7 #include <linux/delay.h> 8 #include <linux/device.h> 9 #include <linux/err.h> 10 #include <linux/input/matrix_keypad.h> 11 #include <linux/interrupt.h> 12 #include <linux/io.h> 13 #include <linux/jiffies.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/platform_device.h> 18 #include <linux/slab.h> 19 #include <linux/timer.h> 20 21 /* 22 * Keypad Controller registers (halfword) 23 */ 24 #define KPCR 0x00 /* Keypad Control Register */ 25 26 #define KPSR 0x02 /* Keypad Status Register */ 27 #define KBD_STAT_KPKD (0x1 << 0) /* Key Press Interrupt Status bit (w1c) */ 28 #define KBD_STAT_KPKR (0x1 << 1) /* Key Release Interrupt Status bit (w1c) */ 29 #define KBD_STAT_KDSC (0x1 << 2) /* Key Depress Synch Chain Status bit (w1c)*/ 30 #define KBD_STAT_KRSS (0x1 << 3) /* Key Release Synch Status bit (w1c)*/ 31 #define KBD_STAT_KDIE (0x1 << 8) /* Key Depress Interrupt Enable Status bit */ 32 #define KBD_STAT_KRIE (0x1 << 9) /* Key Release Interrupt Enable */ 33 #define KBD_STAT_KPPEN (0x1 << 10) /* Keypad Clock Enable */ 34 35 #define KDDR 0x04 /* Keypad Data Direction Register */ 36 #define KPDR 0x06 /* Keypad Data Register */ 37 38 #define MAX_MATRIX_KEY_ROWS 8 39 #define MAX_MATRIX_KEY_COLS 8 40 #define MATRIX_ROW_SHIFT 3 41 42 #define MAX_MATRIX_KEY_NUM (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS) 43 44 struct imx_keypad { 45 46 struct clk *clk; 47 struct input_dev *input_dev; 48 void __iomem *mmio_base; 49 50 int irq; 51 struct timer_list check_matrix_timer; 52 53 /* 54 * The matrix is stable only if no changes are detected after 55 * IMX_KEYPAD_SCANS_FOR_STABILITY scans 56 */ 57 #define IMX_KEYPAD_SCANS_FOR_STABILITY 3 58 int stable_count; 59 60 bool enabled; 61 62 /* Masks for enabled rows/cols */ 63 unsigned short rows_en_mask; 64 unsigned short cols_en_mask; 65 66 unsigned short keycodes[MAX_MATRIX_KEY_NUM]; 67 68 /* 69 * Matrix states: 70 * -stable: achieved after a complete debounce process. 71 * -unstable: used in the debouncing process. 72 */ 73 unsigned short matrix_stable_state[MAX_MATRIX_KEY_COLS]; 74 unsigned short matrix_unstable_state[MAX_MATRIX_KEY_COLS]; 75 }; 76 77 /* Scan the matrix and return the new state in *matrix_volatile_state. */ 78 static void imx_keypad_scan_matrix(struct imx_keypad *keypad, 79 unsigned short *matrix_volatile_state) 80 { 81 int col; 82 unsigned short reg_val; 83 84 for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) { 85 if ((keypad->cols_en_mask & (1 << col)) == 0) 86 continue; 87 /* 88 * Discharge keypad capacitance: 89 * 2. write 1s on column data. 90 * 3. configure columns as totem-pole to discharge capacitance. 91 * 4. configure columns as open-drain. 92 */ 93 reg_val = readw(keypad->mmio_base + KPDR); 94 reg_val |= 0xff00; 95 writew(reg_val, keypad->mmio_base + KPDR); 96 97 reg_val = readw(keypad->mmio_base + KPCR); 98 reg_val &= ~((keypad->cols_en_mask & 0xff) << 8); 99 writew(reg_val, keypad->mmio_base + KPCR); 100 101 udelay(2); 102 103 reg_val = readw(keypad->mmio_base + KPCR); 104 reg_val |= (keypad->cols_en_mask & 0xff) << 8; 105 writew(reg_val, keypad->mmio_base + KPCR); 106 107 /* 108 * 5. Write a single column to 0, others to 1. 109 * 6. Sample row inputs and save data. 110 * 7. Repeat steps 2 - 6 for remaining columns. 111 */ 112 reg_val = readw(keypad->mmio_base + KPDR); 113 reg_val &= ~(1 << (8 + col)); 114 writew(reg_val, keypad->mmio_base + KPDR); 115 116 /* 117 * Delay added to avoid propagating the 0 from column to row 118 * when scanning. 119 */ 120 udelay(5); 121 122 /* 123 * 1s in matrix_volatile_state[col] means key pressures 124 * throw data from non enabled rows. 125 */ 126 reg_val = readw(keypad->mmio_base + KPDR); 127 matrix_volatile_state[col] = (~reg_val) & keypad->rows_en_mask; 128 } 129 130 /* 131 * Return in standby mode: 132 * 9. write 0s to columns 133 */ 134 reg_val = readw(keypad->mmio_base + KPDR); 135 reg_val &= 0x00ff; 136 writew(reg_val, keypad->mmio_base + KPDR); 137 } 138 139 /* 140 * Compare the new matrix state (volatile) with the stable one stored in 141 * keypad->matrix_stable_state and fire events if changes are detected. 142 */ 143 static void imx_keypad_fire_events(struct imx_keypad *keypad, 144 unsigned short *matrix_volatile_state) 145 { 146 struct input_dev *input_dev = keypad->input_dev; 147 int row, col; 148 149 for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) { 150 unsigned short bits_changed; 151 int code; 152 153 if ((keypad->cols_en_mask & (1 << col)) == 0) 154 continue; /* Column is not enabled */ 155 156 bits_changed = keypad->matrix_stable_state[col] ^ 157 matrix_volatile_state[col]; 158 159 if (bits_changed == 0) 160 continue; /* Column does not contain changes */ 161 162 for (row = 0; row < MAX_MATRIX_KEY_ROWS; row++) { 163 if ((keypad->rows_en_mask & (1 << row)) == 0) 164 continue; /* Row is not enabled */ 165 if ((bits_changed & (1 << row)) == 0) 166 continue; /* Row does not contain changes */ 167 168 code = MATRIX_SCAN_CODE(row, col, MATRIX_ROW_SHIFT); 169 input_event(input_dev, EV_MSC, MSC_SCAN, code); 170 input_report_key(input_dev, keypad->keycodes[code], 171 matrix_volatile_state[col] & (1 << row)); 172 dev_dbg(&input_dev->dev, "Event code: %d, val: %d", 173 keypad->keycodes[code], 174 matrix_volatile_state[col] & (1 << row)); 175 } 176 } 177 input_sync(input_dev); 178 } 179 180 /* 181 * imx_keypad_check_for_events is the timer handler. 182 */ 183 static void imx_keypad_check_for_events(struct timer_list *t) 184 { 185 struct imx_keypad *keypad = from_timer(keypad, t, check_matrix_timer); 186 unsigned short matrix_volatile_state[MAX_MATRIX_KEY_COLS]; 187 unsigned short reg_val; 188 bool state_changed, is_zero_matrix; 189 int i; 190 191 memset(matrix_volatile_state, 0, sizeof(matrix_volatile_state)); 192 193 imx_keypad_scan_matrix(keypad, matrix_volatile_state); 194 195 state_changed = false; 196 for (i = 0; i < MAX_MATRIX_KEY_COLS; i++) { 197 if ((keypad->cols_en_mask & (1 << i)) == 0) 198 continue; 199 200 if (keypad->matrix_unstable_state[i] ^ matrix_volatile_state[i]) { 201 state_changed = true; 202 break; 203 } 204 } 205 206 /* 207 * If the matrix state is changed from the previous scan 208 * (Re)Begin the debouncing process, saving the new state in 209 * keypad->matrix_unstable_state. 210 * else 211 * Increase the count of number of scans with a stable state. 212 */ 213 if (state_changed) { 214 memcpy(keypad->matrix_unstable_state, matrix_volatile_state, 215 sizeof(matrix_volatile_state)); 216 keypad->stable_count = 0; 217 } else 218 keypad->stable_count++; 219 220 /* 221 * If the matrix is not as stable as we want reschedule scan 222 * in the near future. 223 */ 224 if (keypad->stable_count < IMX_KEYPAD_SCANS_FOR_STABILITY) { 225 mod_timer(&keypad->check_matrix_timer, 226 jiffies + msecs_to_jiffies(10)); 227 return; 228 } 229 230 /* 231 * If the matrix state is stable, fire the events and save the new 232 * stable state. Note, if the matrix is kept stable for longer 233 * (keypad->stable_count > IMX_KEYPAD_SCANS_FOR_STABILITY) all 234 * events have already been generated. 235 */ 236 if (keypad->stable_count == IMX_KEYPAD_SCANS_FOR_STABILITY) { 237 imx_keypad_fire_events(keypad, matrix_volatile_state); 238 239 memcpy(keypad->matrix_stable_state, matrix_volatile_state, 240 sizeof(matrix_volatile_state)); 241 } 242 243 is_zero_matrix = true; 244 for (i = 0; i < MAX_MATRIX_KEY_COLS; i++) { 245 if (matrix_volatile_state[i] != 0) { 246 is_zero_matrix = false; 247 break; 248 } 249 } 250 251 252 if (is_zero_matrix) { 253 /* 254 * All keys have been released. Enable only the KDI 255 * interrupt for future key presses (clear the KDI 256 * status bit and its sync chain before that). 257 */ 258 reg_val = readw(keypad->mmio_base + KPSR); 259 reg_val |= KBD_STAT_KPKD | KBD_STAT_KDSC; 260 writew(reg_val, keypad->mmio_base + KPSR); 261 262 reg_val = readw(keypad->mmio_base + KPSR); 263 reg_val |= KBD_STAT_KDIE; 264 reg_val &= ~KBD_STAT_KRIE; 265 writew(reg_val, keypad->mmio_base + KPSR); 266 } else { 267 /* 268 * Some keys are still pressed. Schedule a rescan in 269 * attempt to detect multiple key presses and enable 270 * the KRI interrupt to react quickly to key release 271 * event. 272 */ 273 mod_timer(&keypad->check_matrix_timer, 274 jiffies + msecs_to_jiffies(60)); 275 276 reg_val = readw(keypad->mmio_base + KPSR); 277 reg_val |= KBD_STAT_KPKR | KBD_STAT_KRSS; 278 writew(reg_val, keypad->mmio_base + KPSR); 279 280 reg_val = readw(keypad->mmio_base + KPSR); 281 reg_val |= KBD_STAT_KRIE; 282 reg_val &= ~KBD_STAT_KDIE; 283 writew(reg_val, keypad->mmio_base + KPSR); 284 } 285 } 286 287 static irqreturn_t imx_keypad_irq_handler(int irq, void *dev_id) 288 { 289 struct imx_keypad *keypad = dev_id; 290 unsigned short reg_val; 291 292 reg_val = readw(keypad->mmio_base + KPSR); 293 294 /* Disable both interrupt types */ 295 reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE); 296 /* Clear interrupts status bits */ 297 reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD; 298 writew(reg_val, keypad->mmio_base + KPSR); 299 300 if (keypad->enabled) { 301 /* The matrix is supposed to be changed */ 302 keypad->stable_count = 0; 303 304 /* Schedule the scanning procedure near in the future */ 305 mod_timer(&keypad->check_matrix_timer, 306 jiffies + msecs_to_jiffies(2)); 307 } 308 309 return IRQ_HANDLED; 310 } 311 312 static void imx_keypad_config(struct imx_keypad *keypad) 313 { 314 unsigned short reg_val; 315 316 /* 317 * Include enabled rows in interrupt generation (KPCR[7:0]) 318 * Configure keypad columns as open-drain (KPCR[15:8]) 319 */ 320 reg_val = readw(keypad->mmio_base + KPCR); 321 reg_val |= keypad->rows_en_mask & 0xff; /* rows */ 322 reg_val |= (keypad->cols_en_mask & 0xff) << 8; /* cols */ 323 writew(reg_val, keypad->mmio_base + KPCR); 324 325 /* Write 0's to KPDR[15:8] (Colums) */ 326 reg_val = readw(keypad->mmio_base + KPDR); 327 reg_val &= 0x00ff; 328 writew(reg_val, keypad->mmio_base + KPDR); 329 330 /* Configure columns as output, rows as input (KDDR[15:0]) */ 331 writew(0xff00, keypad->mmio_base + KDDR); 332 333 /* 334 * Clear Key Depress and Key Release status bit. 335 * Clear both synchronizer chain. 336 */ 337 reg_val = readw(keypad->mmio_base + KPSR); 338 reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD | 339 KBD_STAT_KDSC | KBD_STAT_KRSS; 340 writew(reg_val, keypad->mmio_base + KPSR); 341 342 /* Enable KDI and disable KRI (avoid false release events). */ 343 reg_val |= KBD_STAT_KDIE; 344 reg_val &= ~KBD_STAT_KRIE; 345 writew(reg_val, keypad->mmio_base + KPSR); 346 } 347 348 static void imx_keypad_inhibit(struct imx_keypad *keypad) 349 { 350 unsigned short reg_val; 351 352 /* Inhibit KDI and KRI interrupts. */ 353 reg_val = readw(keypad->mmio_base + KPSR); 354 reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE); 355 reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD; 356 writew(reg_val, keypad->mmio_base + KPSR); 357 358 /* Colums as open drain and disable all rows */ 359 reg_val = (keypad->cols_en_mask & 0xff) << 8; 360 writew(reg_val, keypad->mmio_base + KPCR); 361 } 362 363 static void imx_keypad_close(struct input_dev *dev) 364 { 365 struct imx_keypad *keypad = input_get_drvdata(dev); 366 367 dev_dbg(&dev->dev, ">%s\n", __func__); 368 369 /* Mark keypad as being inactive */ 370 keypad->enabled = false; 371 synchronize_irq(keypad->irq); 372 del_timer_sync(&keypad->check_matrix_timer); 373 374 imx_keypad_inhibit(keypad); 375 376 /* Disable clock unit */ 377 clk_disable_unprepare(keypad->clk); 378 } 379 380 static int imx_keypad_open(struct input_dev *dev) 381 { 382 struct imx_keypad *keypad = input_get_drvdata(dev); 383 int error; 384 385 dev_dbg(&dev->dev, ">%s\n", __func__); 386 387 /* Enable the kpp clock */ 388 error = clk_prepare_enable(keypad->clk); 389 if (error) 390 return error; 391 392 /* We became active from now */ 393 keypad->enabled = true; 394 395 imx_keypad_config(keypad); 396 397 /* Sanity control, not all the rows must be actived now. */ 398 if ((readw(keypad->mmio_base + KPDR) & keypad->rows_en_mask) == 0) { 399 dev_err(&dev->dev, 400 "too many keys pressed, control pins initialisation\n"); 401 goto open_err; 402 } 403 404 return 0; 405 406 open_err: 407 imx_keypad_close(dev); 408 return -EIO; 409 } 410 411 #ifdef CONFIG_OF 412 static const struct of_device_id imx_keypad_of_match[] = { 413 { .compatible = "fsl,imx21-kpp", }, 414 { /* sentinel */ } 415 }; 416 MODULE_DEVICE_TABLE(of, imx_keypad_of_match); 417 #endif 418 419 static int imx_keypad_probe(struct platform_device *pdev) 420 { 421 const struct matrix_keymap_data *keymap_data = 422 dev_get_platdata(&pdev->dev); 423 struct imx_keypad *keypad; 424 struct input_dev *input_dev; 425 int irq, error, i, row, col; 426 427 if (!keymap_data && !pdev->dev.of_node) { 428 dev_err(&pdev->dev, "no keymap defined\n"); 429 return -EINVAL; 430 } 431 432 irq = platform_get_irq(pdev, 0); 433 if (irq < 0) 434 return irq; 435 436 input_dev = devm_input_allocate_device(&pdev->dev); 437 if (!input_dev) { 438 dev_err(&pdev->dev, "failed to allocate the input device\n"); 439 return -ENOMEM; 440 } 441 442 keypad = devm_kzalloc(&pdev->dev, sizeof(*keypad), GFP_KERNEL); 443 if (!keypad) { 444 dev_err(&pdev->dev, "not enough memory for driver data\n"); 445 return -ENOMEM; 446 } 447 448 keypad->input_dev = input_dev; 449 keypad->irq = irq; 450 keypad->stable_count = 0; 451 452 timer_setup(&keypad->check_matrix_timer, 453 imx_keypad_check_for_events, 0); 454 455 keypad->mmio_base = devm_platform_ioremap_resource(pdev, 0); 456 if (IS_ERR(keypad->mmio_base)) 457 return PTR_ERR(keypad->mmio_base); 458 459 keypad->clk = devm_clk_get(&pdev->dev, NULL); 460 if (IS_ERR(keypad->clk)) { 461 dev_err(&pdev->dev, "failed to get keypad clock\n"); 462 return PTR_ERR(keypad->clk); 463 } 464 465 /* Init the Input device */ 466 input_dev->name = pdev->name; 467 input_dev->id.bustype = BUS_HOST; 468 input_dev->dev.parent = &pdev->dev; 469 input_dev->open = imx_keypad_open; 470 input_dev->close = imx_keypad_close; 471 472 error = matrix_keypad_build_keymap(keymap_data, NULL, 473 MAX_MATRIX_KEY_ROWS, 474 MAX_MATRIX_KEY_COLS, 475 keypad->keycodes, input_dev); 476 if (error) { 477 dev_err(&pdev->dev, "failed to build keymap\n"); 478 return error; 479 } 480 481 /* Search for rows and cols enabled */ 482 for (row = 0; row < MAX_MATRIX_KEY_ROWS; row++) { 483 for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) { 484 i = MATRIX_SCAN_CODE(row, col, MATRIX_ROW_SHIFT); 485 if (keypad->keycodes[i] != KEY_RESERVED) { 486 keypad->rows_en_mask |= 1 << row; 487 keypad->cols_en_mask |= 1 << col; 488 } 489 } 490 } 491 dev_dbg(&pdev->dev, "enabled rows mask: %x\n", keypad->rows_en_mask); 492 dev_dbg(&pdev->dev, "enabled cols mask: %x\n", keypad->cols_en_mask); 493 494 __set_bit(EV_REP, input_dev->evbit); 495 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 496 input_set_drvdata(input_dev, keypad); 497 498 /* Ensure that the keypad will stay dormant until opened */ 499 error = clk_prepare_enable(keypad->clk); 500 if (error) 501 return error; 502 imx_keypad_inhibit(keypad); 503 clk_disable_unprepare(keypad->clk); 504 505 error = devm_request_irq(&pdev->dev, irq, imx_keypad_irq_handler, 0, 506 pdev->name, keypad); 507 if (error) { 508 dev_err(&pdev->dev, "failed to request IRQ\n"); 509 return error; 510 } 511 512 /* Register the input device */ 513 error = input_register_device(input_dev); 514 if (error) { 515 dev_err(&pdev->dev, "failed to register input device\n"); 516 return error; 517 } 518 519 platform_set_drvdata(pdev, keypad); 520 device_init_wakeup(&pdev->dev, 1); 521 522 return 0; 523 } 524 525 static int __maybe_unused imx_kbd_noirq_suspend(struct device *dev) 526 { 527 struct platform_device *pdev = to_platform_device(dev); 528 struct imx_keypad *kbd = platform_get_drvdata(pdev); 529 struct input_dev *input_dev = kbd->input_dev; 530 unsigned short reg_val = readw(kbd->mmio_base + KPSR); 531 532 /* imx kbd can wake up system even clock is disabled */ 533 mutex_lock(&input_dev->mutex); 534 535 if (input_dev->users) 536 clk_disable_unprepare(kbd->clk); 537 538 mutex_unlock(&input_dev->mutex); 539 540 if (device_may_wakeup(&pdev->dev)) { 541 if (reg_val & KBD_STAT_KPKD) 542 reg_val |= KBD_STAT_KRIE; 543 if (reg_val & KBD_STAT_KPKR) 544 reg_val |= KBD_STAT_KDIE; 545 writew(reg_val, kbd->mmio_base + KPSR); 546 547 enable_irq_wake(kbd->irq); 548 } 549 550 return 0; 551 } 552 553 static int __maybe_unused imx_kbd_noirq_resume(struct device *dev) 554 { 555 struct platform_device *pdev = to_platform_device(dev); 556 struct imx_keypad *kbd = platform_get_drvdata(pdev); 557 struct input_dev *input_dev = kbd->input_dev; 558 int ret = 0; 559 560 if (device_may_wakeup(&pdev->dev)) 561 disable_irq_wake(kbd->irq); 562 563 mutex_lock(&input_dev->mutex); 564 565 if (input_dev->users) { 566 ret = clk_prepare_enable(kbd->clk); 567 if (ret) 568 goto err_clk; 569 } 570 571 err_clk: 572 mutex_unlock(&input_dev->mutex); 573 574 return ret; 575 } 576 577 static const struct dev_pm_ops imx_kbd_pm_ops = { 578 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(imx_kbd_noirq_suspend, imx_kbd_noirq_resume) 579 }; 580 581 static struct platform_driver imx_keypad_driver = { 582 .driver = { 583 .name = "imx-keypad", 584 .pm = &imx_kbd_pm_ops, 585 .of_match_table = of_match_ptr(imx_keypad_of_match), 586 }, 587 .probe = imx_keypad_probe, 588 }; 589 module_platform_driver(imx_keypad_driver); 590 591 MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>"); 592 MODULE_DESCRIPTION("IMX Keypad Port Driver"); 593 MODULE_LICENSE("GPL v2"); 594 MODULE_ALIAS("platform:imx-keypad"); 595