History

Input: pmic8xxx-keypad - migrate to DT

The driver is only supported on DT enabled platforms. Convert the driver to DT so that it can probe properly.

Stephen Boyd committed 12 years ago

Commit 86ea5e61 parent a5dde0c3 files · +175 −116Browse files

Unified · Split

3 files
  1. Documentation/devicetree/bindings/input/qcom,pm8xxx-keypad.txt +89 −0
  2. drivers/input/keyboard/pmic8xxx-keypad.c +86 −64
  3. include/linux/input/pmic8xxx-keypad.h +0 −52
Documentation/devicetree/bindings/input/qcom,pm8xxx-keypad.txt+89−0
@@ -0,0 +1,89 @@
1+Qualcomm PM8xxx PMIC Keypad
2+
3+PROPERTIES
4+
5+- compatible:
6+ Usage: required
7+ Value type: <string>
8+ Definition: must be one of:
9+ "qcom,pm8058-keypad"
10+ "qcom,pm8921-keypad"
11+
12+- reg:
13+ Usage: required
14+ Value type: <prop-encoded-array>
15+ Definition: address of keypad control register
16+
17+- interrupts:
18+ Usage: required
19+ Value type: <prop-encoded-array>
20+ Definition: the first interrupt specifies the key sense interrupt
21+ and the second interrupt specifies the key stuck interrupt.
22+ The format of the specifier is defined by the binding
23+ document describing the node's interrupt parent.
24+
25+- linux,keymap:
26+ Usage: required
27+ Value type: <prop-encoded-array>
28+ Definition: the linux keymap. More information can be found in
29+ input/matrix-keymap.txt.
30+
31+- linux,keypad-no-autorepeat:
32+ Usage: optional
33+ Value type: <bool>
34+ Definition: don't enable autorepeat feature.
35+
36+- linux,keypad-wakeup:
37+ Usage: optional
38+ Value type: <bool>
39+ Definition: use any event on keypad as wakeup event.
40+
41+- keypad,num-rows:
42+ Usage: required
43+ Value type: <u32>
44+ Definition: number of rows in the keymap. More information can be found
45+ in input/matrix-keymap.txt.
46+
47+- keypad,num-columns:
48+ Usage: required
49+ Value type: <u32>
50+ Definition: number of columns in the keymap. More information can be
51+ found in input/matrix-keymap.txt.
52+
53+- debounce:
54+ Usage: optional
55+ Value type: <u32>
56+ Definition: time in microseconds that key must be pressed or release
57+ for key sense interrupt to trigger.
58+
59+- scan-delay:
60+ Usage: optional
61+ Value type: <u32>
62+ Definition: time in microseconds to pause between successive scans
63+ of the matrix array.
64+
65+- row-hold:
66+ Usage: optional
67+ Value type: <u32>
68+ Definition: time in nanoseconds to pause between scans of each row in
69+ the matrix array.
70+
71+EXAMPLE
72+
73+ keypad@148 {
74+ compatible = "qcom,pm8921-keypad";
75+ reg = <0x148>;
76+ interrupt-parent = <&pmicintc>;
77+ interrupts = <74 1>, <75 1>;
78+ linux,keymap = <
79+ MATRIX_KEY(0, 0, KEY_VOLUMEUP)
80+ MATRIX_KEY(0, 1, KEY_VOLUMEDOWN)
81+ MATRIX_KEY(0, 2, KEY_CAMERA_FOCUS)
82+ MATRIX_KEY(0, 3, KEY_CAMERA)
83+ >;
84+ keypad,num-rows = <1>;
85+ keypad,num-columns = <5>;
86+ debounce = <15>;
87+ scan-delay = <32>;
88+ row-hold = <91500>;
89+ };
drivers/input/keyboard/pmic8xxx-keypad.c+86−64
@@ -20,8 +20,8 @@ · 19 unmodified lines
2020 #include <linux/delay.h>
2121 #include <linux/mutex.h>
2222 #include <linux/regmap.h>
23−
24−#include <linux/input/pmic8xxx-keypad.h>
23+#include <linux/of.h>
24+#include <linux/input/matrix_keypad.h>
2525
2626 #define PM8XXX_MAX_ROWS 18
2727 #define PM8XXX_MAX_COLS 8
@@ -84,7 +84,8 @@ · 56 unmodified lines
8484
8585 /**
8686 * struct pmic8xxx_kp - internal keypad data structure
87− * @pdata - keypad platform data pointer
87+ * @num_cols - number of columns of keypad
88+ * @num_rows - number of row of keypad
8889 * @input - input device pointer for keypad
8990 * @regmap - regmap handle
9091 * @key_sense_irq - key press/release irq number
@@ -96,7 +97,8 @@ · 5 unmodified lines
9697 * @ctrl_reg - control register value
9798 */
9899 struct pmic8xxx_kp {
99− const struct pm8xxx_keypad_platform_data *pdata;
100+ unsigned int num_rows;
101+ unsigned int num_cols;
100102 struct input_dev *input;
101103 struct regmap *regmap;
102104 int key_sense_irq;
@@ -115,9 +117,9 @@ static u8 pmic8xxx_col_state(struct pmic8xxx_kp *kp, u8 col) · 12 unmodified lines
115117 {
116118 /* all keys pressed on that particular row? */
117119 if (col == 0x00)
118− return 1 << kp->pdata->num_cols;
120+ return 1 << kp->num_cols;
119121 else
120− return col & ((1 << kp->pdata->num_cols) - 1);
122+ return col & ((1 << kp->num_cols) - 1);
121123 }
122124
123125 /*
@@ -180,10 +182,10 @@ static int pmic8xxx_kp_read_matrix(struct pmic8xxx_kp *kp, u16 *new_state, · 56 unmodified lines
180182 int rc, read_rows;
181183 unsigned int scan_val;
182184
183− if (kp->pdata->num_rows < PM8XXX_MIN_ROWS)
185+ if (kp->num_rows < PM8XXX_MIN_ROWS)
184186 read_rows = PM8XXX_MIN_ROWS;
185187 else
186− read_rows = kp->pdata->num_rows;
188+ read_rows = kp->num_rows;
187189
188190 pmic8xxx_chk_sync_read(kp);
189191
@@ -227,13 +229,13 @@ static void __pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, u16 *new_state, · 37 unmodified lines
227229 {
228230 int row, col, code;
229231
230− for (row = 0; row < kp->pdata->num_rows; row++) {
232+ for (row = 0; row < kp->num_rows; row++) {
231233 int bits_changed = new_state[row] ^ old_state[row];
232234
233235 if (!bits_changed)
234236 continue;
235237
236− for (col = 0; col < kp->pdata->num_cols; col++) {
238+ for (col = 0; col < kp->num_cols; col++) {
237239 if (!(bits_changed & (1 << col)))
238240 continue;
239241
@@ -259,9 +261,9 @@ static bool pmic8xxx_detect_ghost_keys(struct pmic8xxx_kp *kp, u16 *new_state) · 19 unmodified lines
259261 u16 check, row_state;
260262
261263 check = 0;
262− for (row = 0; row < kp->pdata->num_rows; row++) {
264+ for (row = 0; row < kp->num_rows; row++) {
263265 row_state = (~new_state[row]) &
264− ((1 << kp->pdata->num_cols) - 1);
266+ ((1 << kp->num_cols) - 1);
265267
266268 if (hweight16(row_state) > 1) {
267269 if (found_first == -1)
@@ -369,8 +371,13 @@ static irqreturn_t pmic8xxx_kp_irq(int irq, void *data) · 101 unmodified lines
369371 return IRQ_HANDLED;
370372 }
371373
372−static int pmic8xxx_kpd_init(struct pmic8xxx_kp *kp)
374+static int pmic8xxx_kpd_init(struct pmic8xxx_kp *kp,
375+ struct platform_device *pdev)
373376 {
377+ const struct device_node *of_node = pdev->dev.of_node;
378+ unsigned int scan_delay_ms;
379+ unsigned int row_hold_ns;
380+ unsigned int debounce_ms;
374381 int bits, rc, cycles;
375382 u8 scan_val = 0, ctrl_val = 0;
376383 static const u8 row_bits[] = {
@@ -378,18 +385,18 @@ static int pmic8xxx_kpd_init(struct pmic8xxx_kp *kp) · 1 unmodified line
378385 };
379386
380387 /* Find column bits */
381− if (kp->pdata->num_cols < KEYP_CTRL_SCAN_COLS_MIN)
388+ if (kp->num_cols < KEYP_CTRL_SCAN_COLS_MIN)
382389 bits = 0;
383390 else
384− bits = kp->pdata->num_cols - KEYP_CTRL_SCAN_COLS_MIN;
391+ bits = kp->num_cols - KEYP_CTRL_SCAN_COLS_MIN;
385392 ctrl_val = (bits & KEYP_CTRL_SCAN_COLS_BITS) <<
386393 KEYP_CTRL_SCAN_COLS_SHIFT;
387394
388395 /* Find row bits */
389− if (kp->pdata->num_rows < KEYP_CTRL_SCAN_ROWS_MIN)
396+ if (kp->num_rows < KEYP_CTRL_SCAN_ROWS_MIN)
390397 bits = 0;
391398 else
392− bits = row_bits[kp->pdata->num_rows - KEYP_CTRL_SCAN_ROWS_MIN];
399+ bits = row_bits[kp->num_rows - KEYP_CTRL_SCAN_ROWS_MIN];
393400
394401 ctrl_val |= (bits << KEYP_CTRL_SCAN_ROWS_SHIFT);
395402
@@ -399,15 +406,44 @@ static int pmic8xxx_kpd_init(struct pmic8xxx_kp *kp) · 3 unmodified lines
399406 return rc;
400407 }
401408
402− bits = (kp->pdata->debounce_ms / 5) - 1;
409+ if (of_property_read_u32(of_node, "scan-delay", &scan_delay_ms))
410+ scan_delay_ms = MIN_SCAN_DELAY;
411+
412+ if (scan_delay_ms > MAX_SCAN_DELAY || scan_delay_ms < MIN_SCAN_DELAY ||
413+ !is_power_of_2(scan_delay_ms)) {
414+ dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
415+ return -EINVAL;
416+ }
417+
418+ if (of_property_read_u32(of_node, "row-hold", &row_hold_ns))
419+ row_hold_ns = MIN_ROW_HOLD_DELAY;
420+
421+ if (row_hold_ns > MAX_ROW_HOLD_DELAY ||
422+ row_hold_ns < MIN_ROW_HOLD_DELAY ||
423+ ((row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
424+ dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
425+ return -EINVAL;
426+ }
427+
428+ if (of_property_read_u32(of_node, "debounce", &debounce_ms))
429+ debounce_ms = MIN_DEBOUNCE_TIME;
430+
431+ if (((debounce_ms % 5) != 0) ||
432+ debounce_ms > MAX_DEBOUNCE_TIME ||
433+ debounce_ms < MIN_DEBOUNCE_TIME) {
434+ dev_err(&pdev->dev, "invalid debounce time supplied\n");
435+ return -EINVAL;
436+ }
437+
438+ bits = (debounce_ms / 5) - 1;
403439
404440 scan_val |= (bits << KEYP_SCAN_DBOUNCE_SHIFT);
405441
406− bits = fls(kp->pdata->scan_delay_ms) - 1;
442+ bits = fls(scan_delay_ms) - 1;
407443 scan_val |= (bits << KEYP_SCAN_PAUSE_SHIFT);
408444
409445 /* Row hold time is a multiple of 32KHz cycles. */
410− cycles = (kp->pdata->row_hold_ns * KEYP_CLOCK_FREQ) / NSEC_PER_SEC;
446+ cycles = (row_hold_ns * KEYP_CLOCK_FREQ) / NSEC_PER_SEC;
411447
412448 scan_val |= (cycles << KEYP_SCAN_ROW_HOLD_SHIFT);
413449
@@ -471,50 +507,27 @@ static void pmic8xxx_kp_close(struct input_dev *dev) · 57 unmodified lines
471507 */
472508 static int pmic8xxx_kp_probe(struct platform_device *pdev)
473509 {
474− const struct pm8xxx_keypad_platform_data *pdata =
475− dev_get_platdata(&pdev->dev);
476− const struct matrix_keymap_data *keymap_data;
510+ unsigned int rows, cols;
511+ bool repeat;
512+ bool wakeup;
477513 struct pmic8xxx_kp *kp;
478514 int rc;
479515 unsigned int ctrl_val;
480516
481− if (!pdata || !pdata->num_cols || !pdata->num_rows ||
482− pdata->num_cols > PM8XXX_MAX_COLS ||
483− pdata->num_rows > PM8XXX_MAX_ROWS ||
484− pdata->num_cols < PM8XXX_MIN_COLS) {
485− dev_err(&pdev->dev, "invalid platform data\n");
486− return -EINVAL;
487− }
488−
489− if (!pdata->scan_delay_ms ||
490− pdata->scan_delay_ms > MAX_SCAN_DELAY ||
491− pdata->scan_delay_ms < MIN_SCAN_DELAY ||
492− !is_power_of_2(pdata->scan_delay_ms)) {
493− dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
494− return -EINVAL;
495− }
496−
497− if (!pdata->row_hold_ns ||
498− pdata->row_hold_ns > MAX_ROW_HOLD_DELAY ||
499− pdata->row_hold_ns < MIN_ROW_HOLD_DELAY ||
500− ((pdata->row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
501− dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
502− return -EINVAL;
503− }
517+ rc = matrix_keypad_parse_of_params(&pdev->dev, &rows, &cols);
518+ if (rc)
519+ return rc;
504520
505− if (!pdata->debounce_ms ||
506− ((pdata->debounce_ms % 5) != 0) ||
507− pdata->debounce_ms > MAX_DEBOUNCE_TIME ||
508− pdata->debounce_ms < MIN_DEBOUNCE_TIME) {
509− dev_err(&pdev->dev, "invalid debounce time supplied\n");
521+ if (cols > PM8XXX_MAX_COLS || rows > PM8XXX_MAX_ROWS ||
522+ cols < PM8XXX_MIN_COLS) {
523+ dev_err(&pdev->dev, "invalid platform data\n");
510524 return -EINVAL;
511525 }
512526
513− keymap_data = pdata->keymap_data;
514− if (!keymap_data) {
515− dev_err(&pdev->dev, "no keymap data supplied\n");
516− return -EINVAL;
517− }
527+ repeat = !of_property_read_bool(pdev->dev.of_node,
528+ "linux,input-no-autorepeat");
529+ wakeup = of_property_read_bool(pdev->dev.of_node,
530+ "linux,keypad-wakeup");
518531
519532 kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
520533 if (!kp)
@@ -526,7 +539,8 @@ static int pmic8xxx_kp_probe(struct platform_device *pdev) · 5 unmodified lines
526539
527540 platform_set_drvdata(pdev, kp);
528541
529− kp->pdata = pdata;
542+ kp->num_rows = rows;
543+ kp->num_cols = cols;
530544 kp->dev = &pdev->dev;
531545
532546 kp->input = devm_input_allocate_device(&pdev->dev);
@@ -547,8 +561,8 @@ static int pmic8xxx_kp_probe(struct platform_device *pdev) · 14 unmodified lines
547561 return kp->key_stuck_irq;
548562 }
549563
550− kp->input->name = pdata->input_name ? : "PMIC8XXX keypad";
551− kp->input->phys = pdata->input_phys_device ? : "pmic8xxx_keypad/input0";
564+ kp->input->name = "PMIC8XXX keypad";
565+ kp->input->phys = "pmic8xxx_keypad/input0";
552566
553567 kp->input->id.bustype = BUS_I2C;
554568 kp->input->id.version = 0x0001;
@@ -558,7 +572,7 @@ static int pmic8xxx_kp_probe(struct platform_device *pdev) · 3 unmodified lines
558572 kp->input->open = pmic8xxx_kp_open;
559573 kp->input->close = pmic8xxx_kp_close;
560574
561− rc = matrix_keypad_build_keymap(keymap_data, NULL,
575+ rc = matrix_keypad_build_keymap(NULL, NULL,
562576 PM8XXX_MAX_ROWS, PM8XXX_MAX_COLS,
563577 kp->keycodes, kp->input);
564578 if (rc) {
@@ -566,7 +580,7 @@ static int pmic8xxx_kp_probe(struct platform_device *pdev) · 1 unmodified line
566580 return rc;
567581 }
568582
569− if (pdata->rep)
583+ if (repeat)
570584 __set_bit(EV_REP, kp->input->evbit);
571585 input_set_capability(kp->input, EV_MSC, MSC_SCAN);
572586
@@ -576,7 +590,7 @@ static int pmic8xxx_kp_probe(struct platform_device *pdev) · 3 unmodified lines
576590 memset(kp->keystate, 0xff, sizeof(kp->keystate));
577591 memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
578592
579− rc = pmic8xxx_kpd_init(kp);
593+ rc = pmic8xxx_kpd_init(kp, pdev);
580594 if (rc < 0) {
581595 dev_err(&pdev->dev, "unable to initialize keypad controller\n");
582596 return rc;
@@ -612,7 +626,7 @@ static int pmic8xxx_kp_probe(struct platform_device *pdev) · 29 unmodified lines
612626 return rc;
613627 }
614628
615− device_init_wakeup(&pdev->dev, pdata->wakeup);
629+ device_init_wakeup(&pdev->dev, wakeup);
616630
617631 return 0;
618632 }
@@ -662,12 +676,20 @@ static int pmic8xxx_kp_resume(struct device *dev) · 43 unmodified lines
662676 static SIMPLE_DEV_PM_OPS(pm8xxx_kp_pm_ops,
663677 pmic8xxx_kp_suspend, pmic8xxx_kp_resume);
664678
679+static const struct of_device_id pm8xxx_match_table[] = {
680+ { .compatible = "qcom,pm8058-keypad" },
681+ { .compatible = "qcom,pm8921-keypad" },
682+ { }
683+};
684+MODULE_DEVICE_TABLE(of, pm8xxx_match_table);
685+
665686 static struct platform_driver pmic8xxx_kp_driver = {
666687 .probe = pmic8xxx_kp_probe,
667688 .driver = {
668− .name = PM8XXX_KEYPAD_DEV_NAME,
689+ .name = "pm8xxx-keypad",
669690 .owner = THIS_MODULE,
670691 .pm = &pm8xxx_kp_pm_ops,
692+ .of_match_table = pm8xxx_match_table,
671693 },
672694 };
673695 module_platform_driver(pmic8xxx_kp_driver);
include/linux/input/pmic8xxx-keypad.h+0−52
@@ -1,52 +0,0 @@
1−/* Copyright (c) 2011, Code Aurora Forum. All rights reserved.
2− *
3− * This program is free software; you can redistribute it and/or modify
4− * it under the terms of the GNU General Public License version 2 and
5− * only version 2 as published by the Free Software Foundation.
6− *
7− * This program is distributed in the hope that it will be useful,
8− * but WITHOUT ANY WARRANTY; without even the implied warranty of
9− * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10− * GNU General Public License for more details.
11− */
12−
13−#ifndef __PMIC8XXX_KEYPAD_H__
14−#define __PMIC8XXX_KEYPAD_H__
15−
16−#include <linux/input/matrix_keypad.h>
17−
18−#define PM8XXX_KEYPAD_DEV_NAME "pm8xxx-keypad"
19−
20−/**
21− * struct pm8xxx_keypad_platform_data - platform data for keypad
22− * @keymap_data - matrix keymap data
23− * @input_name - input device name
24− * @input_phys_device - input device name
25− * @num_cols - number of columns of keypad
26− * @num_rows - number of row of keypad
27− * @debounce_ms - debounce period in milliseconds
28− * @scan_delay_ms - scan delay in milliseconds
29− * @row_hold_ns - row hold period in nanoseconds
30− * @wakeup - configure keypad as wakeup
31− * @rep - enable or disable key repeat bit
32− */
33−struct pm8xxx_keypad_platform_data {
34− const struct matrix_keymap_data *keymap_data;
35−
36− const char *input_name;
37− const char *input_phys_device;
38−
39− unsigned int num_cols;
40− unsigned int num_rows;
41− unsigned int rows_gpio_start;
42− unsigned int cols_gpio_start;
43−
44− unsigned int debounce_ms;
45− unsigned int scan_delay_ms;
46− unsigned int row_hold_ns;
47−
48− bool wakeup;
49− bool rep;
50−};
51−
52−#endif /*__PMIC8XXX_KEYPAD_H__ */