[PATCH v3 1/4] Input: ts-overlay - Add touchscreen overlay object handling

Javier Carrasco
2023-06-16T07:30:21Z

Some touchscreens provide mechanical overlays with different objects
like buttons or clipped touchscreen surfaces.

In order to support these objects, add a series of helper functions
to the input subsystem to transform them into overlay objects via
device tree nodes.

These overlay objects consume the raw touch events and report the
expected input events depending on the object properties.

Signed-off-by: Javier Carrasco <javier.carrasco@wolfvision.net>
---
MAINTAINERS | 7 +
drivers/input/touchscreen/Kconfig | 9 +
drivers/input/touchscreen/Makefile | 1 +
drivers/input/touchscreen/ts-overlay.c | 356 +++++++++++++++++++++++++++++++++
include/linux/input/ts-overlay.h | 43 ++++
5 files changed, 416 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 7e0b87d5aa2e..db9427926a4c 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -21434,6 +21434,13 @@ W: https://github.com/srcres258/linux-doc
T: git git://github.com/srcres258/linux-doc.git doc-zh-tw
F: Documentation/translations/zh_TW/

+TOUCHSCREEN OVERLAY OBJECTS
+M: Javier Carrasco <javier.carrasco@wolfvision.net>
+L: linux-input@vger.kernel.org
+S: Maintained
+F: drivers/input/touchscreen/ts-overlay.c
+F: include/linux/input/ts-overlay.h
+
TTY LAYER
M: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M: Jiri Slaby <jirislaby@kernel.org>
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 143ff43c67ae..8382a4d68326 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -1388,4 +1388,13 @@ config TOUCHSCREEN_HIMAX_HX83112B
To compile this driver as a module, choose M here: the
module will be called himax_hx83112b.

+config TOUCHSCREEN_TS_OVERLAY
+ bool "Touchscreen Overlay Objects"
+ help
+ Say Y here if you are using a touchscreen driver that supports
+ printed overlays with keys or a clipped touchscreen area.
+
+ Should be selected by the touchscren drivers that support
+ this feature.
+
endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 159cd5136fdb..f554826706ff 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -117,3 +117,4 @@ obj-$(CONFIG_TOUCHSCREEN_RASPBERRYPI_FW) += raspberrypi-ts.o
obj-$(CONFIG_TOUCHSCREEN_IQS5XX) += iqs5xx.o
obj-$(CONFIG_TOUCHSCREEN_ZINITIX) += zinitix.o
obj-$(CONFIG_TOUCHSCREEN_HIMAX_HX83112B) += himax_hx83112b.o
+obj-$(CONFIG_TOUCHSCREEN_TS_OVERLAY) += ts-overlay.o
diff --git a/drivers/input/touchscreen/ts-overlay.c b/drivers/input/touchscreen/ts-overlay.c
new file mode 100644
index 000000000000..7afa77d86c1f
--- /dev/null
+++ b/drivers/input/touchscreen/ts-overlay.c
@@ -0,0 +1,356 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Helper functions for overlay objects on touchscreens
+ *
+ * Copyright (c) 2023 Javier Carrasco <javier.carrasco@wolfvision.net>
+ */
+
+#include <linux/property.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/module.h>
+#include <linux/input/ts-overlay.h>
+
+enum ts_overlay_valid_objects {
+ TOUCHSCREEN,
+ BUTTON,
+};
+
+static const char *const ts_overlay_names[] = {
+ [TOUCHSCREEN] = "overlay-touchscreen",
+ [BUTTON] = "overlay-buttons",
+};
+
+struct ts_overlay_shape {
+ u32 x_origin;
+ u32 y_origin;
+ u32 x_size;
+ u32 y_size;
+};
+
+struct ts_overlay_button {
+ struct ts_overlay_shape shape;
+ u32 key;
+ bool pressed;
+ int slot;
+};
+
+static int ts_overlay_get_shape_properties(struct fwnode_handle *child_node,
+ struct ts_overlay_shape *shape)
+{
+ int rc;
+
+ rc = fwnode_property_read_u32(child_node, "x-origin", &shape->x_origin);
+ if (rc < 0)
+ return rc;
+
+ rc = fwnode_property_read_u32(child_node, "y-origin", &shape->y_origin);
+ if (rc < 0)
+ return rc;
+
+ rc = fwnode_property_read_u32(child_node, "x-size", &shape->x_size);
+ if (rc < 0)
+ return rc;
+
+ rc = fwnode_property_read_u32(child_node, "y-size", &shape->y_size);
+ if (rc < 0)
+ return rc;
+
+ return 0;
+}
+
+static int ts_overlay_get_button_properties(struct device *dev,
+ struct fwnode_handle *child_node,
+ struct ts_overlay_button *btn)
+{
+ struct fwnode_handle *child_btn;
+ int rc;
+ int j = 0;
+
+ fwnode_for_each_child_node(child_node, child_btn) {
+ rc = ts_overlay_get_shape_properties(child_btn, &btn[j].shape);
+ if (rc < 0)
+ goto button_prop_cleanup;
+
+ rc = fwnode_property_read_u32(child_btn, "linux,code",
+ &btn[j].key);
+ if (rc < 0)
+ goto button_prop_cleanup;
+
+ dev_info(dev, "Added button at (%u, %u), size %ux%u, code=%u\n",
+ btn[j].shape.x_origin, btn[j].shape.y_origin,
+ btn[j].shape.x_size, btn[j].shape.y_size, btn[j].key);
+ j++;
+ }
+
+ return 0;
+
+button_prop_cleanup:
+ fwnode_handle_put(child_btn);
+ return rc;
+}
+
+void ts_overlay_set_button_caps(struct ts_overlay_map *map,
+ struct input_dev *dev)
+{
+ int i;
+
+ for (i = 0; i < map->button_count; i++)
+ input_set_capability(dev, EV_KEY, map->buttons[i].key);
+}
+EXPORT_SYMBOL(ts_overlay_set_button_caps);
+
+static int ts_overlay_count_buttons(struct device *dev)
+{
+ struct fwnode_handle *child_node;
+ struct fwnode_handle *child_button;
+ int count = 0;
+
+ child_node = device_get_named_child_node(dev, ts_overlay_names[BUTTON]);
+ if (!child_node)
+ return 0;
+
+ fwnode_for_each_child_node(child_node, child_button)
+ count++;
+ fwnode_handle_put(child_node);
+
+ return count;
+}
+
+static int ts_overlay_map_touchscreen(struct device *dev,
+ struct ts_overlay_map *map)
+{
+ struct fwnode_handle *child;
+ int rc = 0;
+
+ child = device_get_named_child_node(dev, ts_overlay_names[TOUCHSCREEN]);
+ if (!child)
+ goto touchscreen_ret;
+
+ map->touchscreen =
+ devm_kzalloc(dev, sizeof(*map->touchscreen), GFP_KERNEL);
+ if (!map->touchscreen) {
+ rc = -ENOMEM;
+ goto touchscreen_handle;
+ }
+ rc = ts_overlay_get_shape_properties(child, map->touchscreen);
+ if (rc < 0)
+ goto touchscreen_free;
+
+ map->overlay_touchscreen = true;
+ dev_info(dev, "Added overlay touchscreen at (%u, %u), size %u x %u\n",
+ map->touchscreen->x_origin, map->touchscreen->y_origin,
+ map->touchscreen->x_size, map->touchscreen->y_size);
+
+ rc = 0;
+ goto touchscreen_handle;
+
+touchscreen_free:
+ devm_kfree(dev, map->touchscreen);
+touchscreen_handle:
+ fwnode_handle_put(child);
+touchscreen_ret:
+ return rc;
+}
+
+static int ts_overlay_map_buttons(struct device *dev,
+ struct ts_overlay_map *map,
+ struct input_dev *input)
+{
+ struct fwnode_handle *child;
+ u32 button_count;
+ int rc = 0;
+
+ button_count = ts_overlay_count_buttons(dev);
+ if (button_count) {
+ map->buttons = devm_kcalloc(dev, button_count,
+ sizeof(*map->buttons), GFP_KERNEL);
+ if (!map->buttons) {
+ rc = -ENOMEM;
+ goto map_buttons_ret;
+ }
+ child = device_get_named_child_node(dev,
+ ts_overlay_names[BUTTON]);
+ if (unlikely(!child))
+ goto map_buttons_free;
+
+ rc = ts_overlay_get_button_properties(dev, child, map->buttons);
+ if (rc < 0)
+ goto map_buttons_free;
+
+ map->button_count = button_count;
+ }
+
+ return 0;
+
+map_buttons_free:
+ devm_kfree(dev, map->buttons);
+map_buttons_ret:
+ return rc;
+}
+
+static bool ts_overlay_defined_objects(struct device *dev)
+{
+ struct fwnode_handle *child;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(ts_overlay_names); i++) {
+ child = device_get_named_child_node(dev, ts_overlay_names[i]);
+ if (child) {
+ fwnode_handle_put(child);
+ return true;
+ }
+ fwnode_handle_put(child);
+ }
+
+ return false;
+}
+
+struct ts_overlay_map *ts_overlay_map_objects(struct device *dev,
+ struct input_dev *input)
+{
+ struct ts_overlay_map *map = NULL;
+ int rc;
+
+ if (!ts_overlay_defined_objects(dev))
+ return NULL;
+
+ map = devm_kzalloc(dev, sizeof(*map), GFP_KERNEL);
+ if (!map) {
+ rc = -ENOMEM;
+ goto objects_err;
+ }
+ rc = ts_overlay_map_touchscreen(dev, map);
+ if (rc < 0)
+ goto objects_free;
+
+ rc = ts_overlay_map_buttons(dev, map, input);
+ if (rc < 0)
+ goto objects_free;
+
+ return map;
+
+objects_free:
+ devm_kfree(dev, map);
+objects_err:
+ return ERR_PTR(rc);
+}
+EXPORT_SYMBOL(ts_overlay_map_objects);
+
+void ts_overlay_get_touchscreen_abs(struct ts_overlay_map *map, u16 *x, u16 *y)
+{
+ *x = map->touchscreen->x_size - 1;
+ *y = map->touchscreen->y_size - 1;
+}
+EXPORT_SYMBOL(ts_overlay_get_touchscreen_abs);
+
+static bool ts_overlay_shape_event(struct ts_overlay_shape *shape, u32 x, u32 y)
+{
+ if (!shape)
+ return false;
+
+ if (x >= shape->x_origin && x < (shape->x_origin + shape->x_size) &&
+ y >= shape->y_origin && y < (shape->y_origin + shape->y_size))
+ return true;
+
+ return false;
+}
+
+static bool ts_overlay_touchscreen_event(struct ts_overlay_shape *touchscreen,
+ u32 *x, u32 *y)
+{
+ if (ts_overlay_shape_event(touchscreen, *x, *y)) {
+ *x -= touchscreen->x_origin;
+ *y -= touchscreen->y_origin;
+ return true;
+ }
+
+ return false;
+}
+
+bool ts_overlay_mapped_touchscreen(struct ts_overlay_map *map)
+{
+ if (!map || !map->overlay_touchscreen)
+ return false;
+
+ return true;
+}
+EXPORT_SYMBOL(ts_overlay_mapped_touchscreen);
+
+bool ts_overlay_mapped_buttons(struct ts_overlay_map *map)
+{
+ if (!map || !map->button_count)
+ return false;
+
+ return true;
+}
+EXPORT_SYMBOL(ts_overlay_mapped_buttons);
+
+bool ts_overlay_mt_on_touchscreen(struct ts_overlay_map *map, u32 *x, u32 *y)
+{
+ if (!ts_overlay_mapped_touchscreen(map))
+ return true;
+
+ if (!ts_overlay_touchscreen_event(map->touchscreen, x, y))
+ return false;
+
+ return true;
+}
+EXPORT_SYMBOL(ts_overlay_mt_on_touchscreen);
+
+bool ts_overlay_button_press(struct ts_overlay_map *map,
+ struct input_dev *input, u32 x, u32 y, u32 slot)
+{
+ int i;
+
+ if (!ts_overlay_mapped_buttons(map))
+ return false;
+
+ for (i = 0; i < map->button_count; i++) {
+ if (ts_overlay_shape_event(&map->buttons[i].shape, x, y)) {
+ input_report_key(input, map->buttons[i].key, 1);
+ map->buttons[i].pressed = true;
+ map->buttons[i].slot = slot;
+ return true;
+ }
+ }
+
+ return false;
+}
+EXPORT_SYMBOL(ts_overlay_button_press);
+
+bool ts_overlay_is_button_slot(struct ts_overlay_map *map, int slot)
+{
+ int i;
+
+ if (!map || !map->button_count)
+ return false;
+
+ for (i = 0; i < map->button_count; i++) {
+ if (map->buttons[i].pressed && map->buttons[i].slot == slot)
+ return true;
+ }
+
+ return false;
+}
+EXPORT_SYMBOL(ts_overlay_is_button_slot);
+
+void ts_overlay_button_release(struct ts_overlay_map *map,
+ struct input_dev *input, u32 slot)
+{
+ int i;
+
+ if (!map || !map->button_count)
+ return;
+
+ for (i = 0; i < map->button_count; i++) {
+ if (map->buttons[i].pressed && map->buttons[i].slot == slot) {
+ input_report_key(input, map->buttons[i].key, 0);
+ map->buttons[i].pressed = false;
+ }
+ }
+}
+EXPORT_SYMBOL(ts_overlay_button_release);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Helper functions for overlay objects on touchscreens");
diff --git a/include/linux/input/ts-overlay.h b/include/linux/input/ts-overlay.h
new file mode 100644
index 000000000000..b75df0dec3ab
--- /dev/null
+++ b/include/linux/input/ts-overlay.h
@@ -0,0 +1,43 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2023 Javier Carrasco <javier.carrasco@wolfvision.net>
+ */
+
+#ifndef _TS_OVERLAY
+#define _TS_OVERLAY
+
+#include <linux/types.h>
+
+struct input_dev;
+struct device;
+
+struct ts_overlay_map {
+ struct ts_overlay_shape *touchscreen;
+ bool overlay_touchscreen;
+ struct ts_overlay_button *buttons;
+ u32 button_count;
+};
+
+struct ts_overlay_map *ts_overlay_map_objects(struct device *dev,
+ struct input_dev *input);
+
+void ts_overlay_get_touchscreen_abs(struct ts_overlay_map *map, u16 *x, u16 *y);
+
+bool ts_overlay_mapped_touchscreen(struct ts_overlay_map *map);
+
+bool ts_overlay_mapped_buttons(struct ts_overlay_map *map);
+
+bool ts_overlay_mt_on_touchscreen(struct ts_overlay_map *map, u32 *x, u32 *y);
+
+bool ts_overlay_button_press(struct ts_overlay_map *map,
+ struct input_dev *input, u32 x, u32 y, u32 slot);
+
+bool ts_overlay_is_button_slot(struct ts_overlay_map *map, int slot);
+
+void ts_overlay_button_release(struct ts_overlay_map *map,
+ struct input_dev *input, u32 slot);
+
+void ts_overlay_set_button_caps(struct ts_overlay_map *map,
+ struct input_dev *dev);
+
+#endif

--
2.39.2