tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Input: matrix-keymap - uninline and prepare for device tree support

Change matrix-keymap helper to be out-of-line, like sparse keymap,
allow the helper perform basic keymap validation and return errors,
and prepare for device tree support.

Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

Dmitry Torokhov 1932811f d0a3457d

+265 -209
+13 -4
drivers/input/Kconfig
··· 25 25 26 26 if INPUT 27 27 28 - config INPUT_OF_MATRIX_KEYMAP 29 - depends on USE_OF 30 - bool 31 - 32 28 config INPUT_FF_MEMLESS 33 29 tristate "Support for memoryless force-feedback devices" 34 30 help ··· 63 67 64 68 To compile this driver as a module, choose M here: the 65 69 module will be called sparse-keymap. 70 + 71 + config INPUT_MATRIXKMAP 72 + tristate "Matrix keymap support library" 73 + help 74 + Say Y here if you are using a driver for an input 75 + device that uses matrix keymap. This option is only 76 + useful for out-of-tree drivers since in-tree drivers 77 + select it automatically. 78 + 79 + If unsure, say N. 80 + 81 + To compile this driver as a module, choose M here: the 82 + module will be called matrix-keymap. 66 83 67 84 comment "Userland interfaces" 68 85
+1 -1
drivers/input/Makefile
··· 10 10 obj-$(CONFIG_INPUT_FF_MEMLESS) += ff-memless.o 11 11 obj-$(CONFIG_INPUT_POLLDEV) += input-polldev.o 12 12 obj-$(CONFIG_INPUT_SPARSEKMAP) += sparse-keymap.o 13 + obj-$(CONFIG_INPUT_MATRIXKMAP) += matrix-keymap.o 13 14 14 15 obj-$(CONFIG_INPUT_MOUSEDEV) += mousedev.o 15 16 obj-$(CONFIG_INPUT_JOYDEV) += joydev.o ··· 25 24 obj-$(CONFIG_INPUT_MISC) += misc/ 26 25 27 26 obj-$(CONFIG_INPUT_APMPOWER) += apm-power.o 28 - obj-$(CONFIG_INPUT_OF_MATRIX_KEYMAP) += of_keymap.o
+17 -1
drivers/input/keyboard/Kconfig
··· 166 166 config KEYBOARD_EP93XX 167 167 tristate "EP93xx Matrix Keypad support" 168 168 depends on ARCH_EP93XX 169 + select INPUT_MATRIXKMAP 169 170 help 170 171 Say Y here to enable the matrix keypad on the Cirrus EP93XX. 171 172 ··· 225 224 config KEYBOARD_TCA8418 226 225 tristate "TCA8418 Keypad Support" 227 226 depends on I2C 227 + select INPUT_MATRIXKMAP 228 228 help 229 229 This driver implements basic keypad functionality 230 230 for keys connected through TCA8418 keypad decoder. ··· 242 240 config KEYBOARD_MATRIX 243 241 tristate "GPIO driven matrix keypad support" 244 242 depends on GENERIC_GPIO 243 + select INPUT_MATRIXKMAP 245 244 help 246 245 Enable support for GPIO driven matrix keypad. 247 246 ··· 315 312 config KEYBOARD_LM8333 316 313 tristate "LM8333 keypad chip" 317 314 depends on I2C 315 + select INPUT_MATRIXKMAP 318 316 help 319 317 If you say yes here you get support for the National Semiconductor 320 318 LM8333 keypad controller. ··· 380 376 config KEYBOARD_IMX 381 377 tristate "IMX keypad support" 382 378 depends on ARCH_MXC 379 + select INPUT_MATRIXKMAP 383 380 help 384 381 Enable support for IMX keypad port. 385 382 ··· 399 394 config KEYBOARD_NOMADIK 400 395 tristate "ST-Ericsson Nomadik SKE keyboard" 401 396 depends on PLAT_NOMADIK 397 + select INPUT_MATRIXKMAP 402 398 help 403 399 Say Y here if you want to use a keypad provided on the SKE controller 404 400 used on the Ux500 and Nomadik platforms ··· 410 404 config KEYBOARD_TEGRA 411 405 tristate "NVIDIA Tegra internal matrix keyboard controller support" 412 406 depends on ARCH_TEGRA 413 - select INPUT_OF_MATRIX_KEYMAP if USE_OF 407 + select INPUT_MATRIXKMAP 414 408 help 415 409 Say Y here if you want to use a matrix keyboard connected directly 416 410 to the internal keyboard controller on Tegra SoCs. ··· 448 442 config KEYBOARD_PMIC8XXX 449 443 tristate "Qualcomm PMIC8XXX keypad support" 450 444 depends on MFD_PM8XXX 445 + select INPUT_MATRIXKMAP 451 446 help 452 447 Say Y here if you want to enable the driver for the PMIC8XXX 453 448 keypad provided as a reference design from Qualcomm. This is intended ··· 460 453 config KEYBOARD_SAMSUNG 461 454 tristate "Samsung keypad support" 462 455 depends on HAVE_CLK 456 + select INPUT_MATRIXKMAP 463 457 help 464 458 Say Y here if you want to use the keypad on your Samsung mobile 465 459 device. ··· 503 495 config KEYBOARD_STMPE 504 496 tristate "STMPE keypad support" 505 497 depends on MFD_STMPE 498 + select INPUT_MATRIXKMAP 506 499 help 507 500 Say Y here if you want to use the keypad controller on STMPE I/O 508 501 expanders. ··· 524 515 config KEYBOARD_OMAP 525 516 tristate "TI OMAP keypad support" 526 517 depends on (ARCH_OMAP1 || ARCH_OMAP2) 518 + select INPUT_MATRIXKMAP 527 519 help 528 520 Say Y here if you want to use the OMAP keypad. 529 521 ··· 533 523 534 524 config KEYBOARD_OMAP4 535 525 tristate "TI OMAP4+ keypad support" 526 + select INPUT_MATRIXKMAP 536 527 help 537 528 Say Y here if you want to use the OMAP4+ keypad. 538 529 ··· 543 532 config KEYBOARD_SPEAR 544 533 tristate "ST SPEAR keyboard support" 545 534 depends on PLAT_SPEAR 535 + select INPUT_MATRIXKMAP 546 536 help 547 537 Say Y here if you want to use the SPEAR keyboard. 548 538 ··· 553 541 config KEYBOARD_TC3589X 554 542 tristate "TC3589X Keypad support" 555 543 depends on MFD_TC3589X 544 + select INPUT_MATRIXKMAP 556 545 help 557 546 Say Y here if you want to use the keypad controller on 558 547 TC35892/3 I/O expander. ··· 564 551 config KEYBOARD_TNETV107X 565 552 tristate "TI TNETV107X keypad support" 566 553 depends on ARCH_DAVINCI_TNETV107X 554 + select INPUT_MATRIXKMAP 567 555 help 568 556 Say Y here if you want to use the TNETV107X keypad. 569 557 ··· 574 560 config KEYBOARD_TWL4030 575 561 tristate "TI TWL4030/TWL5030/TPS659x0 keypad support" 576 562 depends on TWL4030_CORE 563 + select INPUT_MATRIXKMAP 577 564 help 578 565 Say Y here if your board use the keypad controller on 579 566 TWL4030 family chips. It's safe to say enable this ··· 598 583 config KEYBOARD_W90P910 599 584 tristate "W90P910 Matrix Keypad support" 600 585 depends on ARCH_W90X900 586 + select INPUT_MATRIXKMAP 601 587 help 602 588 Say Y here to enable the matrix keypad on evaluation board 603 589 based on W90P910.
+8 -10
drivers/input/keyboard/ep93xx_keypad.c
··· 303 303 input_dev->open = ep93xx_keypad_open; 304 304 input_dev->close = ep93xx_keypad_close; 305 305 input_dev->dev.parent = &pdev->dev; 306 - input_dev->keycode = keypad->keycodes; 307 - input_dev->keycodesize = sizeof(keypad->keycodes[0]); 308 - input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes); 309 306 310 - input_set_drvdata(input_dev, keypad); 307 + err = matrix_keypad_build_keymap(keymap_data, NULL, 308 + EP93XX_MATRIX_ROWS, EP93XX_MATRIX_COLS, 309 + keypad->keycodes, input_dev); 310 + if (err) 311 + goto failed_free_dev; 311 312 312 - input_dev->evbit[0] = BIT_MASK(EV_KEY); 313 313 if (keypad->pdata->flags & EP93XX_KEYPAD_AUTOREPEAT) 314 - input_dev->evbit[0] |= BIT_MASK(EV_REP); 315 - 316 - matrix_keypad_build_keymap(keymap_data, 3, 317 - input_dev->keycode, input_dev->keybit); 318 - platform_set_drvdata(pdev, keypad); 314 + __set_bit(EV_REP, input_dev->evbit); 315 + input_set_drvdata(input_dev, keypad); 319 316 320 317 err = request_irq(keypad->irq, ep93xx_keypad_irq_handler, 321 318 0, pdev->name, keypad); ··· 323 326 if (err) 324 327 goto failed_free_irq; 325 328 329 + platform_set_drvdata(pdev, keypad); 326 330 device_init_wakeup(&pdev->dev, 1); 327 331 328 332 return 0;
+10 -7
drivers/input/keyboard/imx_keypad.c
··· 481 481 } 482 482 483 483 if (keypad->rows_en_mask > ((1 << MAX_MATRIX_KEY_ROWS) - 1) || 484 - keypad->cols_en_mask > ((1 << MAX_MATRIX_KEY_COLS) - 1)) { 484 + keypad->cols_en_mask > ((1 << MAX_MATRIX_KEY_COLS) - 1)) { 485 485 dev_err(&pdev->dev, 486 486 "invalid key data (too many rows or colums)\n"); 487 487 error = -EINVAL; ··· 496 496 input_dev->dev.parent = &pdev->dev; 497 497 input_dev->open = imx_keypad_open; 498 498 input_dev->close = imx_keypad_close; 499 - input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 500 - input_dev->keycode = keypad->keycodes; 501 - input_dev->keycodesize = sizeof(keypad->keycodes[0]); 502 - input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes); 503 499 504 - matrix_keypad_build_keymap(keymap_data, MATRIX_ROW_SHIFT, 505 - keypad->keycodes, input_dev->keybit); 500 + error = matrix_keypad_build_keymap(keymap_data, NULL, 501 + MAX_MATRIX_KEY_ROWS, 502 + MAX_MATRIX_KEY_COLS, 503 + keypad->keycodes, input_dev); 504 + if (error) { 505 + dev_err(&pdev->dev, "failed to build keymap\n"); 506 + goto failed_clock_put; 507 + } 506 508 509 + __set_bit(EV_REP, input_dev->evbit); 507 510 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 508 511 input_set_drvdata(input_dev, keypad); 509 512
+7 -8
drivers/input/keyboard/lm8333.c
··· 29 29 30 30 #define LM8333_FIFO_TRANSFER_SIZE 16 31 31 32 - #define LM8333_ROW_SHIFT 4 33 32 #define LM8333_NUM_ROWS 8 34 - 33 + #define LM8333_NUM_COLS 16 34 + #define LM8333_ROW_SHIFT 4 35 35 36 36 struct lm8333 { 37 37 struct i2c_client *client; ··· 159 159 input->dev.parent = &client->dev; 160 160 input->id.bustype = BUS_I2C; 161 161 162 - input->keycode = lm8333->keycodes; 163 - input->keycodesize = sizeof(lm8333->keycodes[0]); 164 - input->keycodemax = ARRAY_SIZE(lm8333->keycodes); 165 - input->evbit[0] = BIT_MASK(EV_KEY); 166 162 input_set_capability(input, EV_MSC, MSC_SCAN); 167 163 168 - matrix_keypad_build_keymap(pdata->matrix_data, LM8333_ROW_SHIFT, 169 - input->keycode, input->keybit); 164 + err = matrix_keypad_build_keymap(pdata->matrix_data, NULL, 165 + LM8333_NUM_ROWS, LM8333_NUM_COLS, 166 + lm8333->keycodes, input); 167 + if (err) 168 + goto free_mem; 170 169 171 170 if (pdata->debounce_time) { 172 171 err = lm8333_write8(lm8333, LM8333_DEBOUNCE,
+8 -9
drivers/input/keyboard/matrix_keypad.c
··· 437 437 input_dev->name = pdev->name; 438 438 input_dev->id.bustype = BUS_HOST; 439 439 input_dev->dev.parent = &pdev->dev; 440 - input_dev->evbit[0] = BIT_MASK(EV_KEY); 441 - if (!pdata->no_autorepeat) 442 - input_dev->evbit[0] |= BIT_MASK(EV_REP); 443 440 input_dev->open = matrix_keypad_start; 444 441 input_dev->close = matrix_keypad_stop; 445 442 446 - input_dev->keycode = keypad->keycodes; 447 - input_dev->keycodesize = sizeof(keypad->keycodes[0]); 448 - input_dev->keycodemax = pdata->num_row_gpios << row_shift; 443 + err = matrix_keypad_build_keymap(keymap_data, NULL, 444 + pdata->num_row_gpios, 445 + pdata->num_col_gpios, 446 + keypad->keycodes, input_dev); 447 + if (err) 448 + goto err_free_mem; 449 449 450 - matrix_keypad_build_keymap(keymap_data, row_shift, 451 - input_dev->keycode, input_dev->keybit); 452 - 450 + if (!pdata->no_autorepeat) 451 + __set_bit(EV_REP, input_dev->evbit); 453 452 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 454 453 input_set_drvdata(input_dev, keypad); 455 454
+10 -10
drivers/input/keyboard/nomadik-ske-keypad.c
··· 39 39 #define SKE_KPRISA (0x1 << 2) 40 40 41 41 #define SKE_KEYPAD_ROW_SHIFT 3 42 - #define SKE_KPD_KEYMAP_SIZE (8 * 8) 42 + #define SKE_KPD_NUM_ROWS 8 43 + #define SKE_KPD_NUM_COLS 8 43 44 44 45 /* keypad auto scan registers */ 45 46 #define SKE_ASR0 0x20 ··· 64 63 void __iomem *reg_base; 65 64 struct input_dev *input; 66 65 const struct ske_keypad_platform_data *board; 67 - unsigned short keymap[SKE_KPD_KEYMAP_SIZE]; 66 + unsigned short keymap[SKE_KPD_NUM_ROWS * SKE_KPD_NUM_COLS]; 68 67 struct clk *clk; 69 68 spinlock_t ske_keypad_lock; 70 69 }; ··· 262 261 input->name = "ux500-ske-keypad"; 263 262 input->dev.parent = &pdev->dev; 264 263 265 - input->keycode = keypad->keymap; 266 - input->keycodesize = sizeof(keypad->keymap[0]); 267 - input->keycodemax = ARRAY_SIZE(keypad->keymap); 264 + error = matrix_keypad_build_keymap(plat->keymap_data, NULL, 265 + SKE_KPD_NUM_ROWS, SKE_KPD_NUM_COLS, 266 + keypad->keymap, input); 267 + if (error) { 268 + dev_err(&pdev->dev, "Failed to build keymap\n"); 269 + goto err_iounmap; 270 + } 268 271 269 272 input_set_capability(input, EV_MSC, MSC_SCAN); 270 - 271 - __set_bit(EV_KEY, input->evbit); 272 273 if (!plat->no_autorepeat) 273 274 __set_bit(EV_REP, input->evbit); 274 - 275 - matrix_keypad_build_keymap(plat->keymap_data, SKE_KEYPAD_ROW_SHIFT, 276 - input->keycode, input->keybit); 277 275 278 276 clk_enable(keypad->clk); 279 277
+10 -10
drivers/input/keyboard/omap-keypad.c
··· 61 61 unsigned int cols; 62 62 unsigned long delay; 63 63 unsigned int debounce; 64 + unsigned short keymap[]; 64 65 }; 65 66 66 67 static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0); ··· 317 316 if (!cpu_is_omap24xx()) 318 317 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT); 319 318 320 - input_dev->keycode = &omap_kp[1]; 321 - input_dev->keycodesize = sizeof(unsigned short); 322 - input_dev->keycodemax = keycodemax; 323 - 324 - if (pdata->rep) 325 - __set_bit(EV_REP, input_dev->evbit); 326 - 327 319 if (pdata->delay) 328 320 omap_kp->delay = pdata->delay; 329 321 ··· 365 371 goto err2; 366 372 367 373 /* setup input device */ 368 - __set_bit(EV_KEY, input_dev->evbit); 369 - matrix_keypad_build_keymap(pdata->keymap_data, row_shift, 370 - input_dev->keycode, input_dev->keybit); 371 374 input_dev->name = "omap-keypad"; 372 375 input_dev->phys = "omap-keypad/input0"; 373 376 input_dev->dev.parent = &pdev->dev; ··· 373 382 input_dev->id.vendor = 0x0001; 374 383 input_dev->id.product = 0x0001; 375 384 input_dev->id.version = 0x0100; 385 + 386 + if (pdata->rep) 387 + __set_bit(EV_REP, input_dev->evbit); 388 + 389 + ret = matrix_keypad_build_keymap(pdata->keymap_data, NULL, 390 + pdata->rows, pdata->cols, 391 + omap_kp->keymap, input_dev); 392 + if (ret < 0) 393 + goto err3; 376 394 377 395 ret = input_register_device(omap_kp->input); 378 396 if (ret < 0) {
+7 -8
drivers/input/keyboard/omap4-keypad.c
··· 322 322 input_dev->open = omap4_keypad_open; 323 323 input_dev->close = omap4_keypad_close; 324 324 325 - input_dev->keycode = keypad_data->keymap; 326 - input_dev->keycodesize = sizeof(keypad_data->keymap[0]); 327 - input_dev->keycodemax = max_keys; 325 + error = matrix_keypad_build_keymap(pdata->keymap_data, NULL, 326 + pdata->rows, pdata->cols, 327 + keypad_data->keymap, input_dev); 328 + if (error) { 329 + dev_err(&pdev->dev, "failed to build keymap\n"); 330 + goto err_free_input; 331 + } 328 332 329 - __set_bit(EV_KEY, input_dev->evbit); 330 333 __set_bit(EV_REP, input_dev->evbit); 331 - 332 334 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 333 335 334 336 input_set_drvdata(input_dev, keypad_data); 335 - 336 - matrix_keypad_build_keymap(pdata->keymap_data, row_shift, 337 - input_dev->keycode, input_dev->keybit); 338 337 339 338 error = request_irq(keypad_data->irq, omap4_keypad_interrupt, 340 339 IRQF_TRIGGER_RISING,
+10 -10
drivers/input/keyboard/pmic8xxx-keypad.c
··· 626 626 kp->input->id.product = 0x0001; 627 627 kp->input->id.vendor = 0x0001; 628 628 629 - kp->input->evbit[0] = BIT_MASK(EV_KEY); 630 - 631 - if (pdata->rep) 632 - __set_bit(EV_REP, kp->input->evbit); 633 - 634 - kp->input->keycode = kp->keycodes; 635 - kp->input->keycodemax = PM8XXX_MATRIX_MAX_SIZE; 636 - kp->input->keycodesize = sizeof(kp->keycodes); 637 629 kp->input->open = pmic8xxx_kp_open; 638 630 kp->input->close = pmic8xxx_kp_close; 639 631 640 - matrix_keypad_build_keymap(keymap_data, PM8XXX_ROW_SHIFT, 641 - kp->input->keycode, kp->input->keybit); 632 + rc = matrix_keypad_build_keymap(keymap_data, NULL, 633 + PM8XXX_MAX_ROWS, PM8XXX_MAX_COLS, 634 + kp->keycodes, kp->input); 635 + if (rc) { 636 + dev_err(&pdev->dev, "failed to build keymap\n"); 637 + goto err_get_irq; 638 + } 642 639 640 + if (pdata->rep) 641 + __set_bit(EV_REP, kp->input->evbit); 643 642 input_set_capability(kp->input, EV_MSC, MSC_SCAN); 643 + 644 644 input_set_drvdata(kp->input, kp); 645 645 646 646 /* initialize keypad state */
+10 -10
drivers/input/keyboard/samsung-keypad.c
··· 454 454 input_dev->name = pdev->name; 455 455 input_dev->id.bustype = BUS_HOST; 456 456 input_dev->dev.parent = &pdev->dev; 457 - input_set_drvdata(input_dev, keypad); 458 457 459 458 input_dev->open = samsung_keypad_open; 460 459 input_dev->close = samsung_keypad_close; 461 460 462 - input_dev->evbit[0] = BIT_MASK(EV_KEY); 463 - if (!pdata->no_autorepeat) 464 - input_dev->evbit[0] |= BIT_MASK(EV_REP); 461 + error = matrix_keypad_build_keymap(keymap_data, NULL, 462 + pdata->rows, pdata->cols, 463 + keypad->keycodes, input_dev); 464 + if (error) { 465 + dev_err(&pdev->dev, "failed to build keymap\n"); 466 + goto err_put_clk; 467 + } 465 468 466 469 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 470 + if (!pdata->no_autorepeat) 471 + __set_bit(EV_REP, input_dev->evbit); 467 472 468 - input_dev->keycode = keypad->keycodes; 469 - input_dev->keycodesize = sizeof(keypad->keycodes[0]); 470 - input_dev->keycodemax = pdata->rows << row_shift; 471 - 472 - matrix_keypad_build_keymap(keymap_data, row_shift, 473 - input_dev->keycode, input_dev->keybit); 473 + input_set_drvdata(input_dev, keypad); 474 474 475 475 keypad->irq = platform_get_irq(pdev, 0); 476 476 if (keypad->irq < 0) {
+11 -10
drivers/input/keyboard/spear-keyboard.c
··· 49 49 #define KEY_VALUE 0x00FFFFFF 50 50 #define ROW_MASK 0xF0 51 51 #define COLUMN_MASK 0x0F 52 - #define ROW_SHIFT 4 52 + #define NUM_ROWS 16 53 + #define NUM_COLS 16 54 + 53 55 #define KEY_MATRIX_SHIFT 6 54 56 55 57 struct spear_kbd { ··· 62 60 unsigned int irq; 63 61 unsigned int mode; 64 62 unsigned short last_key; 65 - unsigned short keycodes[256]; 63 + unsigned short keycodes[NUM_ROWS * NUM_COLS]; 66 64 }; 67 65 68 66 static irqreturn_t spear_kbd_interrupt(int irq, void *dev_id) ··· 214 212 input_dev->open = spear_kbd_open; 215 213 input_dev->close = spear_kbd_close; 216 214 217 - __set_bit(EV_KEY, input_dev->evbit); 215 + error = matrix_keypad_build_keymap(keymap, NULL, NUM_ROWS, NUM_COLS, 216 + kbd->keycodes, input_dev); 217 + if (error) { 218 + dev_err(&pdev->dev, "Failed to build keymap\n"); 219 + goto err_put_clk; 220 + } 221 + 218 222 if (pdata->rep) 219 223 __set_bit(EV_REP, input_dev->evbit); 220 224 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 221 - 222 - input_dev->keycode = kbd->keycodes; 223 - input_dev->keycodesize = sizeof(kbd->keycodes[0]); 224 - input_dev->keycodemax = ARRAY_SIZE(kbd->keycodes); 225 - 226 - matrix_keypad_build_keymap(keymap, ROW_SHIFT, 227 - input_dev->keycode, input_dev->keybit); 228 225 229 226 input_set_drvdata(input_dev, kbd); 230 227
+7 -9
drivers/input/keyboard/stmpe-keypad.c
··· 289 289 input->id.bustype = BUS_I2C; 290 290 input->dev.parent = &pdev->dev; 291 291 292 - input_set_capability(input, EV_MSC, MSC_SCAN); 292 + ret = matrix_keypad_build_keymap(plat->keymap_data, NULL, 293 + STMPE_KEYPAD_MAX_ROWS, 294 + STMPE_KEYPAD_MAX_COLS, 295 + keypad->keymap, input); 296 + if (ret) 297 + goto out_freeinput; 293 298 294 - __set_bit(EV_KEY, input->evbit); 299 + input_set_capability(input, EV_MSC, MSC_SCAN); 295 300 if (!plat->no_autorepeat) 296 301 __set_bit(EV_REP, input->evbit); 297 - 298 - input->keycode = keypad->keymap; 299 - input->keycodesize = sizeof(keypad->keymap[0]); 300 - input->keycodemax = ARRAY_SIZE(keypad->keymap); 301 - 302 - matrix_keypad_build_keymap(plat->keymap_data, STMPE_KEYPAD_ROW_SHIFT, 303 - input->keycode, input->keybit); 304 302 305 303 for (i = 0; i < plat->keymap_data->keymap_size; i++) { 306 304 unsigned int key = plat->keymap_data->keymap[i];
+9 -10
drivers/input/keyboard/tc3589x-keypad.c
··· 78 78 * @input: pointer to input device object 79 79 * @board: keypad platform device 80 80 * @krow: number of rows 81 - * @kcol: number of coloumns 81 + * @kcol: number of columns 82 82 * @keymap: matrix scan code table for keycodes 83 83 * @keypad_stopped: holds keypad status 84 84 */ ··· 333 333 input->name = pdev->name; 334 334 input->dev.parent = &pdev->dev; 335 335 336 - input->keycode = keypad->keymap; 337 - input->keycodesize = sizeof(keypad->keymap[0]); 338 - input->keycodemax = ARRAY_SIZE(keypad->keymap); 339 - 340 336 input->open = tc3589x_keypad_open; 341 337 input->close = tc3589x_keypad_close; 342 338 343 - input_set_drvdata(input, keypad); 339 + error = matrix_keypad_build_keymap(plat->keymap_data, NULL, 340 + TC3589x_MAX_KPROW, TC3589x_MAX_KPCOL, 341 + keypad->keymap, input); 342 + if (error) { 343 + dev_err(&pdev->dev, "Failed to build keymap\n"); 344 + goto err_free_mem; 345 + } 344 346 345 347 input_set_capability(input, EV_MSC, MSC_SCAN); 346 - 347 - __set_bit(EV_KEY, input->evbit); 348 348 if (!plat->no_autorepeat) 349 349 __set_bit(EV_REP, input->evbit); 350 350 351 - matrix_keypad_build_keymap(plat->keymap_data, 0x3, 352 - input->keycode, input->keybit); 351 + input_set_drvdata(input, keypad); 353 352 354 353 error = request_threaded_irq(irq, NULL, 355 354 tc3589x_keypad_irq, plat->irqtype,
+7 -8
drivers/input/keyboard/tca8418_keypad.c
··· 342 342 input->id.product = 0x001; 343 343 input->id.version = 0x0001; 344 344 345 - input->keycode = keypad_data->keymap; 346 - input->keycodesize = sizeof(keypad_data->keymap[0]); 347 - input->keycodemax = max_keys; 345 + error = matrix_keypad_build_keymap(pdata->keymap_data, NULL, 346 + pdata->rows, pdata->cols, 347 + keypad_data->keymap, input); 348 + if (error) { 349 + dev_dbg(&client->dev, "Failed to build keymap\n"); 350 + goto fail2; 351 + } 348 352 349 - __set_bit(EV_KEY, input->evbit); 350 353 if (pdata->rep) 351 354 __set_bit(EV_REP, input->evbit); 352 - 353 355 input_set_capability(input, EV_MSC, MSC_SCAN); 354 356 355 357 input_set_drvdata(input, keypad_data); 356 - 357 - matrix_keypad_build_keymap(pdata->keymap_data, row_shift, 358 - input->keycode, input->keybit); 359 358 360 359 if (pdata->irq_is_gpio) 361 360 client->irq = gpio_to_irq(client->irq);
+20 -14
drivers/input/keyboard/tegra-kbc.c
··· 686 686 int num_rows = 0; 687 687 unsigned int debounce_cnt; 688 688 unsigned int scan_time_rows; 689 + unsigned int keymap_rows; 689 690 690 691 if (!pdata) 691 692 pdata = tegra_kbc_dt_parse_pdata(pdev); ··· 758 757 kbc->repoll_dly = KBC_ROW_SCAN_DLY + scan_time_rows + pdata->repeat_cnt; 759 758 kbc->repoll_dly = DIV_ROUND_UP(kbc->repoll_dly, KBC_CYCLE_MS); 760 759 760 + kbc->wakeup_key = pdata->wakeup_key; 761 + kbc->use_fn_map = pdata->use_fn_map; 762 + kbc->use_ghost_filter = pdata->use_ghost_filter; 763 + 761 764 input_dev->name = pdev->name; 762 765 input_dev->id.bustype = BUS_HOST; 763 766 input_dev->dev.parent = &pdev->dev; 764 767 input_dev->open = tegra_kbc_open; 765 768 input_dev->close = tegra_kbc_close; 766 769 767 - input_set_drvdata(input_dev, kbc); 770 + keymap_rows = KBC_MAX_KEY; 771 + if (pdata->use_fn_map) 772 + keymap_rows *= 2; 768 773 769 - input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 774 + keymap_data = pdata->keymap_data ?: &tegra_kbc_default_keymap_data; 775 + 776 + err = matrix_keypad_build_keymap(keymap_data, NULL, 777 + keymap_rows, KBC_MAX_COL, 778 + kbc->keycode, input_dev); 779 + if (err) { 780 + dev_err(&pdev->dev, "failed to build keymap\n"); 781 + goto err_put_clk; 782 + } 783 + 784 + __set_bit(EV_REP, input_dev->evbit); 770 785 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 771 786 772 - input_dev->keycode = kbc->keycode; 773 - input_dev->keycodesize = sizeof(kbc->keycode[0]); 774 - input_dev->keycodemax = KBC_MAX_KEY; 775 - if (pdata->use_fn_map) 776 - input_dev->keycodemax *= 2; 777 - 778 - kbc->use_fn_map = pdata->use_fn_map; 779 - kbc->use_ghost_filter = pdata->use_ghost_filter; 780 - keymap_data = pdata->keymap_data ?: &tegra_kbc_default_keymap_data; 781 - matrix_keypad_build_keymap(keymap_data, KBC_ROW_SHIFT, 782 - input_dev->keycode, input_dev->keybit); 783 - kbc->wakeup_key = pdata->wakeup_key; 787 + input_set_drvdata(input_dev, kbc); 784 788 785 789 err = request_irq(kbc->irq, tegra_kbc_isr, 786 790 IRQF_NO_SUSPEND | IRQF_TRIGGER_HIGH, pdev->name, kbc);
+11 -10
drivers/input/keyboard/tnetv107x-keypad.c
··· 247 247 error = -ENOMEM; 248 248 goto error_input; 249 249 } 250 - input_set_drvdata(kp->input_dev, kp); 251 250 252 251 kp->input_dev->name = pdev->name; 253 252 kp->input_dev->dev.parent = &pdev->dev; 254 253 kp->input_dev->open = keypad_start; 255 254 kp->input_dev->close = keypad_stop; 256 - kp->input_dev->evbit[0] = BIT_MASK(EV_KEY); 257 - if (!pdata->no_autorepeat) 258 - kp->input_dev->evbit[0] |= BIT_MASK(EV_REP); 259 255 260 256 clk_enable(kp->clk); 261 257 rev = keypad_read(kp, rev); ··· 260 264 kp->input_dev->id.version = ((rev >> 16) & 0xfff); 261 265 clk_disable(kp->clk); 262 266 263 - kp->input_dev->keycode = kp->keycodes; 264 - kp->input_dev->keycodesize = sizeof(kp->keycodes[0]); 265 - kp->input_dev->keycodemax = kp->rows << kp->row_shift; 267 + error = matrix_keypad_build_keymap(keymap_data, NULL, 268 + kp->rows, kp->cols, 269 + kp->keycodes, kp->input_dev); 270 + if (error) { 271 + dev_err(dev, "Failed to build keymap\n"); 272 + goto error_reg; 273 + } 266 274 267 - matrix_keypad_build_keymap(keymap_data, kp->row_shift, kp->keycodes, 268 - kp->input_dev->keybit); 269 - 275 + if (!pdata->no_autorepeat) 276 + kp->input_dev->evbit[0] |= BIT_MASK(EV_REP); 270 277 input_set_capability(kp->input_dev, EV_MSC, MSC_SCAN); 278 + 279 + input_set_drvdata(kp->input_dev, kp); 271 280 272 281 error = input_register_device(kp->input_dev); 273 282 if (error < 0) {
+12 -13
drivers/input/keyboard/twl4030_keypad.c
··· 361 361 kp->irq = platform_get_irq(pdev, 0); 362 362 363 363 /* setup input device */ 364 - __set_bit(EV_KEY, input->evbit); 365 - 366 - /* Enable auto repeat feature of Linux input subsystem */ 367 - if (pdata->rep) 368 - __set_bit(EV_REP, input->evbit); 369 - 370 - input_set_capability(input, EV_MSC, MSC_SCAN); 371 - 372 364 input->name = "TWL4030 Keypad"; 373 365 input->phys = "twl4030_keypad/input0"; 374 366 input->dev.parent = &pdev->dev; ··· 370 378 input->id.product = 0x0001; 371 379 input->id.version = 0x0003; 372 380 373 - input->keycode = kp->keymap; 374 - input->keycodesize = sizeof(kp->keymap[0]); 375 - input->keycodemax = ARRAY_SIZE(kp->keymap); 381 + error = matrix_keypad_build_keymap(keymap_data, NULL, 382 + TWL4030_MAX_ROWS, 383 + 1 << TWL4030_ROW_SHIFT, 384 + kp->keymap, input); 385 + if (error) { 386 + dev_err(kp->dbg_dev, "Failed to build keymap\n"); 387 + goto err1; 388 + } 376 389 377 - matrix_keypad_build_keymap(keymap_data, TWL4030_ROW_SHIFT, 378 - input->keycode, input->keybit); 390 + input_set_capability(input, EV_MSC, MSC_SCAN); 391 + /* Enable auto repeat feature of Linux input subsystem */ 392 + if (pdata->rep) 393 + __set_bit(EV_REP, input->evbit); 379 394 380 395 error = input_register_device(input); 381 396 if (error) {
+14 -13
drivers/input/keyboard/w90p910_keypad.c
··· 42 42 #define KGET_RAW(n) (((n) & KEY0R) >> 3) 43 43 #define KGET_COLUMN(n) ((n) & KEY0C) 44 44 45 - #define W90P910_MAX_KEY_NUM (8 * 8) 45 + #define W90P910_NUM_ROWS 8 46 + #define W90P910_NUM_COLS 8 46 47 #define W90P910_ROW_SHIFT 3 47 48 48 49 struct w90p910_keypad { ··· 52 51 struct input_dev *input_dev; 53 52 void __iomem *mmio_base; 54 53 int irq; 55 - unsigned short keymap[W90P910_MAX_KEY_NUM]; 54 + unsigned short keymap[W90P910_NUM_ROWS * W90P910_NUM_COLS]; 56 55 }; 57 56 58 57 static void w90p910_keypad_scan_matrix(struct w90p910_keypad *keypad, ··· 191 190 input_dev->close = w90p910_keypad_close; 192 191 input_dev->dev.parent = &pdev->dev; 193 192 194 - input_dev->keycode = keypad->keymap; 195 - input_dev->keycodesize = sizeof(keypad->keymap[0]); 196 - input_dev->keycodemax = ARRAY_SIZE(keypad->keymap); 197 - 198 - input_set_drvdata(input_dev, keypad); 199 - 200 - input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 201 - input_set_capability(input_dev, EV_MSC, MSC_SCAN); 202 - 203 - matrix_keypad_build_keymap(keymap_data, W90P910_ROW_SHIFT, 204 - input_dev->keycode, input_dev->keybit); 193 + error = matrix_keypad_build_keymap(keymap_data, NULL, 194 + W90P910_NUM_ROWS, W90P910_NUM_COLS, 195 + keypad->keymap, input_dev); 196 + if (error) { 197 + dev_err(&pdev->dev, "failed to build keymap\n"); 198 + goto failed_put_clk; 199 + } 205 200 206 201 error = request_irq(keypad->irq, w90p910_keypad_irq_handler, 207 202 0, pdev->name, keypad); ··· 205 208 dev_err(&pdev->dev, "failed to request IRQ\n"); 206 209 goto failed_put_clk; 207 210 } 211 + 212 + __set_bit(EV_REP, input_dev->evbit); 213 + input_set_capability(input_dev, EV_MSC, MSC_SCAN); 214 + input_set_drvdata(input_dev, keypad); 208 215 209 216 /* Register the input device */ 210 217 error = input_register_device(input_dev);
+57 -2
drivers/input/of_keymap.c drivers/input/matrix-keymap.c
··· 1 1 /* 2 - * Helpers for open firmware matrix keyboard bindings 2 + * Helpers for matrix keyboard bindings 3 3 * 4 4 * Copyright (C) 2012 Google, Inc 5 5 * ··· 21 21 #include <linux/types.h> 22 22 #include <linux/input.h> 23 23 #include <linux/of.h> 24 - #include <linux/input/matrix_keypad.h> 25 24 #include <linux/export.h> 26 25 #include <linux/gfp.h> 27 26 #include <linux/slab.h> 27 + #include <linux/input/matrix_keypad.h> 28 28 29 + 30 + /** 31 + * matrix_keypad_build_keymap - convert platform keymap into matrix keymap 32 + * @keymap_data: keymap supplied by the platform code 33 + * @keymap_name: name of device tree property containing keymap (if device 34 + * tree support is enabled). 35 + * @rows: number of rows in target keymap array 36 + * @cols: number of cols in target keymap array 37 + * @keymap: expanded version of keymap that is suitable for use by 38 + * matrix keyboard driver 39 + * @input_dev: input devices for which we are setting up the keymap 40 + * 41 + * This function converts platform keymap (encoded with KEY() macro) into 42 + * an array of keycodes that is suitable for using in a standard matrix 43 + * keyboard driver that uses row and col as indices. 44 + */ 45 + int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data, 46 + const char *keymap_name, 47 + unsigned int rows, unsigned int cols, 48 + unsigned short *keymap, 49 + struct input_dev *input_dev) 50 + { 51 + unsigned int row_shift = get_count_order(cols); 52 + int i; 53 + 54 + input_dev->keycode = keymap; 55 + input_dev->keycodesize = sizeof(*keymap); 56 + input_dev->keycodemax = rows << row_shift; 57 + 58 + __set_bit(EV_KEY, input_dev->evbit); 59 + 60 + for (i = 0; i < keymap_data->keymap_size; i++) { 61 + unsigned int key = keymap_data->keymap[i]; 62 + unsigned int row = KEY_ROW(key); 63 + unsigned int col = KEY_COL(key); 64 + unsigned short code = KEY_VAL(key); 65 + 66 + if (row >= rows || col >= cols) { 67 + dev_err(input_dev->dev.parent, 68 + "%s: invalid keymap entry %d (row: %d, col: %d, rows: %d, cols: %d)\n", 69 + __func__, i, row, col, rows, cols); 70 + return -EINVAL; 71 + } 72 + 73 + keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code; 74 + __set_bit(code, input_dev->keybit); 75 + } 76 + __clear_bit(KEY_RESERVED, input_dev->keybit); 77 + 78 + return 0; 79 + } 80 + EXPORT_SYMBOL(matrix_keypad_build_keymap); 81 + 82 + #ifdef CONFIG_OF 29 83 struct matrix_keymap_data * 30 84 matrix_keyboard_of_fill_keymap(struct device_node *np, 31 85 const char *propname) ··· 139 85 } 140 86 } 141 87 EXPORT_SYMBOL_GPL(matrix_keyboard_of_free_keymap); 88 + #endif
+6 -32
include/linux/input/matrix_keypad.h
··· 75 75 bool no_autorepeat; 76 76 }; 77 77 78 - /** 79 - * matrix_keypad_build_keymap - convert platform keymap into matrix keymap 80 - * @keymap_data: keymap supplied by the platform code 81 - * @row_shift: number of bits to shift row value by to advance to the next 82 - * line in the keymap 83 - * @keymap: expanded version of keymap that is suitable for use by 84 - * matrix keyboad driver 85 - * @keybit: pointer to bitmap of keys supported by input device 86 - * 87 - * This function converts platform keymap (encoded with KEY() macro) into 88 - * an array of keycodes that is suitable for using in a standard matrix 89 - * keyboard driver that uses row and col as indices. 90 - */ 91 - static inline void 92 - matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data, 93 - unsigned int row_shift, 94 - unsigned short *keymap, unsigned long *keybit) 95 - { 96 - int i; 78 + int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data, 79 + const char *keymap_name, 80 + unsigned int rows, unsigned int cols, 81 + unsigned short *keymap, 82 + struct input_dev *input_dev); 97 83 98 - for (i = 0; i < keymap_data->keymap_size; i++) { 99 - unsigned int key = keymap_data->keymap[i]; 100 - unsigned int row = KEY_ROW(key); 101 - unsigned int col = KEY_COL(key); 102 - unsigned short code = KEY_VAL(key); 103 - 104 - keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code; 105 - __set_bit(code, keybit); 106 - } 107 - __clear_bit(KEY_RESERVED, keybit); 108 - } 109 - 110 - #ifdef CONFIG_INPUT_OF_MATRIX_KEYMAP 84 + #ifdef CONFIG_OF 111 85 struct matrix_keymap_data * 112 86 matrix_keyboard_of_fill_keymap(struct device_node *np, const char *propname); 113 87