[PATCH 10/14] Input: samsung-keypad - handle compact binding

Dmitry Torokhov
2024-08-19T04:58:38Z

Add support for standard matrix keymap binding (in addition to the
existing verbose binding with a sub-node for each key). This will
allow easier conversions from platform data to device properties when
using static device properties.

Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
---
drivers/input/keyboard/samsung-keypad.c | 122 +++++++++++++-----------
1 file changed, 64 insertions(+), 58 deletions(-)

diff --git a/drivers/input/keyboard/samsung-keypad.c b/drivers/input/keyboard/samsung-keypad.c
index e262137b6838..df2427ac63d7 100644
--- a/drivers/input/keyboard/samsung-keypad.c
+++ b/drivers/input/keyboard/samsung-keypad.c
@@ -231,78 +231,85 @@ static void samsung_keypad_close(struct input_dev *input_dev)
samsung_keypad_stop(keypad);
}

-#ifdef CONFIG_OF
-static struct samsung_keypad_platdata *
-samsung_keypad_parse_dt(struct device *dev)
+static const struct matrix_keymap_data *
+samsung_parse_verbose_keymap(struct device *dev)
{
- struct samsung_keypad_platdata *pdata;
struct matrix_keymap_data *keymap_data;
- uint32_t *keymap, num_rows = 0, num_cols = 0;
- struct device_node *np = dev->of_node, *key_np;
+ struct fwnode_handle *child;
+ u32 *keymap;
unsigned int key_count;

- if (!np) {
- dev_err(dev, "missing device tree data\n");
- return ERR_PTR(-EINVAL);
- }
-
- pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
- if (!pdata) {
- dev_err(dev, "could not allocate memory for platform data\n");
- return ERR_PTR(-ENOMEM);
- }
-
- of_property_read_u32(np, "samsung,keypad-num-rows", &num_rows);
- of_property_read_u32(np, "samsung,keypad-num-columns", &num_cols);
- if (!num_rows || !num_cols) {
- dev_err(dev, "number of keypad rows/columns not specified\n");
- return ERR_PTR(-EINVAL);
- }
- pdata->rows = num_rows;
- pdata->cols = num_cols;
-
keymap_data = devm_kzalloc(dev, sizeof(*keymap_data), GFP_KERNEL);
if (!keymap_data) {
dev_err(dev, "could not allocate memory for keymap data\n");
return ERR_PTR(-ENOMEM);
}
- pdata->keymap_data = keymap_data;

- key_count = of_get_child_count(np);
- keymap_data->keymap_size = key_count;
- keymap = devm_kcalloc(dev, key_count, sizeof(uint32_t), GFP_KERNEL);
+ key_count = device_get_child_node_count(dev);
+ keymap = devm_kcalloc(dev, key_count, sizeof(*keymap), GFP_KERNEL);
if (!keymap) {
dev_err(dev, "could not allocate memory for keymap\n");
return ERR_PTR(-ENOMEM);
}
+
+ keymap_data->keymap_size = key_count;
keymap_data->keymap = keymap;

- for_each_child_of_node(np, key_np) {
+ device_for_each_child_node(dev, child) {
u32 row, col, key_code;
- of_property_read_u32(key_np, "keypad,row", &row);
- of_property_read_u32(key_np, "keypad,column", &col);
- of_property_read_u32(key_np, "linux,code", &key_code);
+
+ fwnode_property_read_u32(child, "keypad,row", &row);
+ fwnode_property_read_u32(child, "keypad,column", &col);
+ fwnode_property_read_u32(child, "linux,code", &key_code);
+
*keymap++ = KEY(row, col, key_code);
}

- pdata->no_autorepeat = of_property_read_bool(np, "linux,input-no-autorepeat");
+ return keymap_data;
+}

- pdata->wakeup = of_property_read_bool(np, "wakeup-source") ||
- /* legacy name */
- of_property_read_bool(np, "linux,input-wakeup");
+static const struct samsung_keypad_platdata *
+samsung_keypad_parse_properties(struct device *dev)
+{
+ const struct matrix_keymap_data *keymap_data;
+ struct samsung_keypad_platdata *pdata;
+ u32 num_rows = 0, num_cols = 0;
+ int error;
+
+ pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+ if (!pdata) {
+ dev_err(dev, "could not allocate memory for platform data\n");
+ return ERR_PTR(-ENOMEM);
+ }

+ device_property_read_u32(dev, "samsung,keypad-num-rows", &num_rows);
+ device_property_read_u32(dev, "samsung,keypad-num-columns", &num_cols);
+
+ error = matrix_keypad_parse_properties(dev, &num_rows, &num_cols);
+ if (error)
+ return ERR_PTR(error);
+
+ pdata->rows = num_rows;
+ pdata->cols = num_cols;
+
+ if (!device_property_present(dev, "linux,keymap")) {
+ keymap_data = samsung_parse_verbose_keymap(dev);
+ if (IS_ERR(keymap_data))
+ return ERR_CAST(keymap_data);
+
+ pdata->keymap_data = keymap_data;
+ }

- return pdata;
-}
-#else
-static struct samsung_keypad_platdata *
-samsung_keypad_parse_dt(struct device *dev)
-{
- dev_err(dev, "no platform data defined\n");

- return ERR_PTR(-EINVAL);
+ pdata->no_autorepeat =
+ device_property_read_bool(dev, "linux,input-no-autorepeat");
+
+ pdata->wakeup = device_property_read_bool(dev, "wakeup-source") ||
+ /* legacy name */
+ device_property_read_bool(dev, "linux,input-wakeup");
+
+ return pdata;
}
-#endif

static void samsung_disable_runtime_pm(void *data)
{
@@ -314,7 +321,6 @@ static void samsung_disable_runtime_pm(void *data)
static int samsung_keypad_probe(struct platform_device *pdev)
{
const struct samsung_keypad_platdata *pdata;
- const struct matrix_keymap_data *keymap_data;
const struct platform_device_id *id;
struct samsung_keypad *keypad;
struct resource *res;
@@ -323,18 +329,17 @@ static int samsung_keypad_probe(struct platform_device *pdev)
int error;

pdata = dev_get_platdata(&pdev->dev);
- if (!pdata) {
- pdata = samsung_keypad_parse_dt(&pdev->dev);
+ if (pdata) {
+ if (!pdata->keymap_data) {
+ dev_err(&pdev->dev, "no keymap data defined\n");
+ return -EINVAL;
+ }
+ } else {
+ pdata = samsung_keypad_parse_properties(&pdev->dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
}

- keymap_data = pdata->keymap_data;
- if (!keymap_data) {
- dev_err(&pdev->dev, "no keymap data defined\n");
- return -EINVAL;
- }
-
if (!pdata->rows || pdata->rows > SAMSUNG_MAX_ROWS)
return -EINVAL;

@@ -398,7 +403,7 @@ static int samsung_keypad_probe(struct platform_device *pdev)
input_dev->open = samsung_keypad_open;
input_dev->close = samsung_keypad_close;

- error = matrix_keypad_build_keymap(keymap_data, NULL,
+ error = matrix_keypad_build_keymap(pdata->keymap_data, NULL,
pdata->rows, pdata->cols,
keypad->keycodes, input_dev);
if (error) {
@@ -439,11 +444,12 @@ static int samsung_keypad_probe(struct platform_device *pdev)
if (error)
return error;

- if (pdev->dev.of_node) {
+ if (!dev_get_platdata(&pdev->dev)) {
devm_kfree(&pdev->dev, (void *)pdata->keymap_data->keymap);
devm_kfree(&pdev->dev, (void *)pdata->keymap_data);
devm_kfree(&pdev->dev, (void *)pdata);
}
+
return 0;
}

--
2.46.0.184.g6999bdac58-goog