[PATCH 0/2] Add support for Wacom W9000-series penabled touchscreens

[PATCH 0/2] Add support for Wacom W9000-series penabled touchscreens

[Hendrik Noack]

Add devicetree bindings and a driver for the Wacom W9000-series penabled
touchscreens.

The driver currently only contains the information for the W9007A, which I
tested on my devices. It should also work with other chips, such as W9001 or
W9010. However, I couldn't test it on these and the message length would
need to be added.

Note: This is my first driver I have ever worked on so if there is
anything I can do to improve it please let me know!

Signed-off-by: Hendrik Noack <hendrik-noack@gmx.de>
---
Hendrik Noack (2):
  dt-bindings: Input: Add Wacom W9000-series penabled touchscreens
  Input: Add support for Wacom W9000-series penabled touchscreens

 .../input/touchscreen/wacom,w9000-series.yaml |  79 +++
 drivers/input/touchscreen/Kconfig             |  12 +
 drivers/input/touchscreen/Makefile            |   1 +
 drivers/input/touchscreen/wacom_w9000.c       | 525 ++++++++++++++++++
 4 files changed, 617 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml
 create mode 100644 drivers/input/touchscreen/wacom_w9000.c

-- 
2.43.0

Re: [PATCH 0/2] Add support for Wacom W9000-series penabled touchscreens

[Krzysztof Kozlowski]

On 27/10/2025 17:36, Hendrik Noack wrote:
> Add devicetree bindings and a driver for the Wacom W9000-series penabled
> touchscreens.
> 
> The driver currently only contains the information for the W9007A, which I
> tested on my devices. It should also work with other chips, such as W9001 or
> W9010. However, I couldn't test it on these and the message length would
> need to be added.
> 
> Note: This is my first driver I have ever worked on so if there is
> anything I can do to improve it please let me know!
> 
> Signed-off-by: Hendrik Noack <hendrik-noack@gmx.de>
> ---
> Hendrik Noack (2):
>   dt-bindings: Input: Add Wacom W9000-series penabled touchscreens
>   Input: Add support for Wacom W9000-series penabled touchscreens


You missed to send actual patches or this is incorrectly threaded.

Best regards,
Krzysztof

[PATCH 1/2] dt-bindings: Input: Add Wacom W9000-series penabled touchscreens

[Hendrik Noack]

Add bindings for two Wacom W9007 variants which can be found in tablets.

Signed-off-by: Hendrik Noack <hendrik-noack@gmx.de>
---
 .../input/touchscreen/wacom,w9000-series.yaml | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml

diff --git a/Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml b/Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml
new file mode 100644
index 000000000000..93579ae0297e
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/input/touchscreen/wacom,w9000-series.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Wacom W9000-series penabled I2C touchscreen driver
+
+description:
+  The W9000-series are penabled touchscreen controllers by Wacom.
+
+maintainers:
+  - Hendrik Noack <hendrik-noack@gmx.de>
+
+allOf:
+  - $ref: touchscreen.yaml#
+
+properties:
+  compatible:
+    enum:
+      - wacom,w9007a_lt03
+      - wacom,w9007a_v1
+
+  reg:
+    maxItems: 1
+
+  interrupts:
+    maxItems: 1
+
+  vdd-supply:
+    description:
+      Optional regulator for the VDD digital voltage.
+
+  pdct-gpios:
+    maxItems: 1
+    description:
+      Optional GPIO specifier for the touchscreen's pdct pin.
+
+  flash-mode-gpios:
+    maxItems: 1
+    description:
+      Optional GPIO specifier for the touchscreen's flash-mode pin.
+
+  pen-inserted-gpios:
+    maxItems: 1
+    description:
+      Optional GPIO specifier for the touchscreen's pen-insert pin.
+
+required:
+  - compatible
+  - reg
+  - interrupts
+  - vdd-supply
+
+additionalProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/interrupt-controller/irq.h>
+    #include <dt-bindings/gpio/gpio.h>
+    i2c {
+      #address-cells = <1>;
+      #size-cells = <0>;
+      digitizer@56 {
+        compatible = "wacom,wacom,w9007a_v1";
+        reg = <0x56>;
+        interrupt-parent = <&gpx3>;
+        interrupts = <5 IRQ_TYPE_EDGE_RISING>;
+
+        vdd-supply = <&stylus_reg>;
+
+        pdct-gpios = <&gpd1 2 GPIO_ACTIVE_HIGH>;
+        flash-mode-gpios = <&gpd1 3 GPIO_ACTIVE_HIGH>;
+        pen-inserted-gpios = <&gpx0 0 GPIO_ACTIVE_LOW>;
+
+        touchscreen-x-mm = <262>;
+        touchscreen-y-mm = <164>;
+      };
+    };
-- 
2.43.0

[PATCH 2/2] Input: Add support for Wacom W9000-series penabled touchscreens

[Hendrik Noack]

Add driver for two Wacom W9007A variants. These are penabled touchscreens
supporting passive Wacom Pens and use I2C.

Signed-off-by: Hendrik Noack <hendrik-noack@gmx.de>
---
 drivers/input/touchscreen/Kconfig       |  12 +
 drivers/input/touchscreen/Makefile      |   1 +
 drivers/input/touchscreen/wacom_w9000.c | 525 ++++++++++++++++++++++++
 3 files changed, 538 insertions(+)
 create mode 100644 drivers/input/touchscreen/wacom_w9000.c

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 7d5b72ee07fa..40f7af0a681a 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -610,6 +610,18 @@ config TOUCHSCREEN_WACOM_I2C
 	  To compile this driver as a module, choose M here: the module
 	  will be called wacom_i2c.
 
+config TOUCHSCREEN_WACOM_W9000
+	tristate "Wacom W9000-series penabled touchscreen (I2C)"
+	depends on I2C
+	help
+	  Say Y here if you have a Wacom W9000-series penabled I2C touchscreen.
+	  This driver supports model W9007A.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called wacom_w9000.
+
 config TOUCHSCREEN_LPC32XX
 	tristate "LPC32XX touchscreen controller"
 	depends on ARCH_LPC32XX
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index ab9abd151078..aa3915df83b2 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -102,6 +102,7 @@ tsc2007-$(CONFIG_TOUCHSCREEN_TSC2007_IIO)	+= tsc2007_iio.o
 obj-$(CONFIG_TOUCHSCREEN_TSC2007)	+= tsc2007.o
 obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)	+= wacom_w8001.o
 obj-$(CONFIG_TOUCHSCREEN_WACOM_I2C)	+= wacom_i2c.o
+obj-$(CONFIG_TOUCHSCREEN_WACOM_W9000)	+= wacom_w9000.o
 obj-$(CONFIG_TOUCHSCREEN_WDT87XX_I2C)	+= wdt87xx_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_WM831X)	+= wm831x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX)	+= wm97xx-ts.o
diff --git a/drivers/input/touchscreen/wacom_w9000.c b/drivers/input/touchscreen/wacom_w9000.c
new file mode 100644
index 000000000000..11c6c98303b8
--- /dev/null
+++ b/drivers/input/touchscreen/wacom_w9000.c
@@ -0,0 +1,525 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Wacom W9000-series penabled I2C touchscreen driver
+ *
+ * Copyright (c) 2025 Hendrik Noack <hendrik-noack@gmx.de>
+ *
+ * Partially based on vendor driver:
+ *	Copyright (C) 2012, Samsung Electronics Co. Ltd.
+ */
+
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input/touchscreen.h>
+
+// Message length
+#define COM_COORD_NUM_MAX		12
+#define COM_QUERY_NUM_MAX		9
+
+// Commands
+#define COM_QUERY		0x2a
+
+struct wacom_w9000_variant {
+	int com_coord_num;
+	int com_query_num;
+	char *name;
+};
+
+struct wacom_w9000_data {
+	struct i2c_client *client;
+	struct input_dev *input_dev;
+	const struct wacom_w9000_variant *variant;
+	unsigned int fw_version;
+
+	struct touchscreen_properties prop;
+	unsigned int max_pressure;
+
+	struct regulator *regulator;
+
+	struct gpio_desc *flash_mode_gpio;
+	struct gpio_desc *pen_detect_gpio;
+	struct gpio_desc *pen_inserted_gpio;
+
+	unsigned int irq;
+	unsigned int pen_detect_irq;
+	unsigned int pen_insert_irq;
+
+	bool pen_inserted;
+	bool pen_detect;
+	bool pen_proximity;
+};
+
+static const struct wacom_w9000_variant wacom_w9007a_lt03 = {
+	.com_coord_num	= 8,
+	.com_query_num	= 9,
+	.name = "Wacom W9007 LT03 Digitizer",
+};
+
+static const struct wacom_w9000_variant wacom_w9007a_v1 = {
+	.com_coord_num	= 12,
+	.com_query_num	= 9,
+	.name = "Wacom W9007 V1 Digitizer",
+};
+
+static const struct of_device_id wacom_w9000_of_match[] = {
+	{ .compatible = "wacom,w9007a_lt03", .data = &wacom_w9007a_lt03, },
+	{ .compatible = "wacom,w9007a_v1", .data = &wacom_w9007a_v1, },
+	{},
+};
+MODULE_DEVICE_TABLE(of, wacom_w9000_of_match);
+
+static int wacom_w9000_read(struct i2c_client *client, u8 command, int len, char *data)
+{
+	struct i2c_msg xfer[2];
+	bool retried = false;
+	int ret;
+
+	/* Write register */
+	xfer[0].addr = client->addr;
+	xfer[0].flags = 0;
+	xfer[0].len = 1;
+	xfer[0].buf = &command;
+
+	/* Read data */
+	xfer[1].addr = client->addr;
+	xfer[1].flags = I2C_M_RD;
+	xfer[1].len = len;
+	xfer[1].buf = data;
+
+retry:
+	ret = i2c_transfer(client->adapter, xfer, 2);
+	if (ret == 2) {
+		ret = 0;
+	} else if (!retried) {
+		retried = true;
+		goto retry;
+	} else {
+		if (ret >= 0)
+			ret = -EIO;
+		dev_err(&client->dev, "%s: i2c transfer failed (%d)\n", __func__, ret);
+	}
+
+	return ret;
+}
+
+static int wacom_w9000_query(struct wacom_w9000_data *wacom_data)
+{
+	struct i2c_client *client = wacom_data->client;
+	struct device *dev = &wacom_data->client->dev;
+	bool retried = false;
+	int ret;
+	u8 data[COM_QUERY_NUM_MAX];
+
+retry:
+	ret = wacom_w9000_read(client, COM_QUERY, wacom_data->variant->com_query_num, data);
+	if (ret)
+		return ret;
+
+	if (data[0] == 0x0f) {
+		wacom_data->fw_version = get_unaligned_be16(&data[7]);
+	} else if (!retried) {
+		retried = true;
+		goto retry;
+	} else {
+		return -EIO;
+	}
+
+	dev_dbg(dev, "query: %X, %X, %X, %X, %X, %X, %X, %X, %X, %d\n", data[0], data[1], data[2],
+		data[3], data[4], data[5], data[6], data[7], data[8], retried);
+
+	wacom_data->prop.max_x = get_unaligned_be16(&data[1]);
+	wacom_data->prop.max_y = get_unaligned_be16(&data[3]);
+	wacom_data->max_pressure = get_unaligned_be16(&data[5]);
+
+	dev_dbg(dev, "max_x:%d, max_y:%d, max_pressure:%d, fw:0x%X", wacom_data->prop.max_x,
+		wacom_data->prop.max_y, wacom_data->max_pressure,
+		wacom_data->fw_version);
+
+	return 0;
+}
+
+static void wacom_w9000_coord(struct wacom_w9000_data *wacom_data)
+{
+	struct i2c_client *client = wacom_data->client;
+	struct device *dev = &wacom_data->client->dev;
+	int ret;
+	u8 data[COM_COORD_NUM_MAX];
+	bool touch, rubber, side_button;
+	u16 x, y, pressure;
+	u8 distance;
+
+	ret = i2c_master_recv(client, data, wacom_data->variant->com_coord_num);
+	if (ret != wacom_data->variant->com_coord_num) {
+		if (ret >= 0)
+			ret = -EIO;
+		dev_err(dev, "%s: i2c receive failed (%d)\n", __func__, ret);
+		return;
+	}
+
+	dev_dbg(dev, "data: %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X", data[0], data[1],
+		data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10],
+		data[11]);
+
+	if (data[0] & BIT(7)) {
+		wacom_data->pen_proximity = 1;
+
+		touch = !!(data[0] & BIT(4));
+		side_button = !!(data[0] & BIT(5));
+		rubber = !!(data[0] & BIT(6));
+
+		x = get_unaligned_be16(&data[1]);
+		y = get_unaligned_be16(&data[3]);
+		pressure = get_unaligned_be16(&data[5]);
+		distance = data[7];
+
+		if (!((x <= wacom_data->prop.max_x) && (y <= wacom_data->prop.max_y))) {
+			dev_warn(dev, "Coordinates out of range x=%d, y=%d", x, y);
+			return;
+		}
+
+		touchscreen_report_pos(wacom_data->input_dev, &wacom_data->prop, x, y, false);
+		input_report_abs(wacom_data->input_dev, ABS_PRESSURE, pressure);
+		input_report_abs(wacom_data->input_dev, ABS_DISTANCE, distance);
+		input_report_key(wacom_data->input_dev, BTN_STYLUS, side_button);
+		input_report_key(wacom_data->input_dev, BTN_TOUCH, touch);
+		input_report_key(wacom_data->input_dev, BTN_TOOL_PEN, !rubber);
+		input_report_key(wacom_data->input_dev, BTN_TOOL_RUBBER, rubber);
+		input_sync(wacom_data->input_dev);
+	} else {
+		if (wacom_data->pen_proximity) {
+			input_report_abs(wacom_data->input_dev, ABS_PRESSURE, 0);
+			input_report_abs(wacom_data->input_dev, ABS_DISTANCE, 0);
+			input_report_key(wacom_data->input_dev, BTN_STYLUS, 0);
+			input_report_key(wacom_data->input_dev, BTN_TOUCH, 0);
+			input_report_key(wacom_data->input_dev, BTN_TOOL_PEN, 0);
+			input_report_key(wacom_data->input_dev, BTN_TOOL_RUBBER, 0);
+			input_sync(wacom_data->input_dev);
+
+			wacom_data->pen_proximity = 0;
+		}
+	}
+}
+
+static irqreturn_t wacom_w9000_interrupt(int irq, void *dev_id)
+{
+	struct wacom_w9000_data *wacom_data = dev_id;
+
+	wacom_w9000_coord(wacom_data);
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t wacom_w9000_interrupt_pen_detect(int irq, void *dev_id)
+{
+	struct wacom_w9000_data *wacom_data = dev_id;
+
+	wacom_data->pen_detect = gpiod_get_value(wacom_data->pen_detect_gpio);
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t wacom_w9000_interrupt_pen_insert(int irq, void *dev_id)
+{
+	struct wacom_w9000_data *wacom_data = dev_id;
+	struct device *dev = &wacom_data->client->dev;
+	int ret;
+
+	wacom_data->pen_inserted = gpiod_get_value(wacom_data->pen_inserted_gpio);
+
+	input_report_switch(wacom_data->input_dev, SW_PEN_INSERTED, wacom_data->pen_inserted);
+	input_sync(wacom_data->input_dev);
+
+	if (!wacom_data->pen_inserted && !regulator_is_enabled(wacom_data->regulator)) {
+		ret = regulator_enable(wacom_data->regulator);
+		if (ret) {
+			dev_err(dev, "Failed to enable regulators: %d\n", ret);
+			return IRQ_HANDLED;
+		}
+		msleep(200);
+		enable_irq(wacom_data->irq);
+	} else if (wacom_data->pen_inserted && regulator_is_enabled(wacom_data->regulator)) {
+		disable_irq(wacom_data->irq);
+		regulator_disable(wacom_data->regulator);
+	}
+
+	dev_dbg(dev, "Pen inserted changed to %d", wacom_data->pen_inserted);
+
+	return IRQ_HANDLED;
+}
+
+static int wacom_w9000_open(struct input_dev *dev)
+{
+	struct wacom_w9000_data *wacom_data = input_get_drvdata(dev);
+	int ret;
+
+	if (!wacom_data->pen_inserted && !regulator_is_enabled(wacom_data->regulator)) {
+		ret = regulator_enable(wacom_data->regulator);
+		if (ret) {
+			dev_err(&wacom_data->client->dev, "Failed to enable regulators: %d\n",
+				ret);
+			return ret;
+		}
+		msleep(200);
+		enable_irq(wacom_data->irq);
+	}
+	return 0;
+}
+
+static void wacom_w9000_close(struct input_dev *dev)
+{
+	struct wacom_w9000_data *wacom_data = input_get_drvdata(dev);
+
+	if (regulator_is_enabled(wacom_data->regulator)) {
+		disable_irq(wacom_data->irq);
+		regulator_disable(wacom_data->regulator);
+	}
+}
+
+static int wacom_w9000_probe(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+	struct wacom_w9000_data *wacom_data;
+	struct input_dev *input_dev;
+	int ret;
+	u32 val;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		dev_err(dev, "i2c_check_functionality error\n");
+		return -EIO;
+	}
+
+	wacom_data = devm_kzalloc(dev, sizeof(struct wacom_w9000_data), GFP_KERNEL);
+	if (!wacom_data)
+		return -ENOMEM;
+
+	wacom_data->variant = i2c_get_match_data(client);
+
+	wacom_data->client = client;
+
+	input_dev = devm_input_allocate_device(dev);
+	if (!input_dev)
+		return -ENOMEM;
+	wacom_data->input_dev = input_dev;
+
+	wacom_data->irq = client->irq;
+	i2c_set_clientdata(client, wacom_data);
+
+	wacom_data->regulator = devm_regulator_get(dev, "vdd");
+	if (IS_ERR(wacom_data->regulator)) {
+		ret = PTR_ERR(wacom_data->regulator);
+		dev_err(dev, "Failed to get regulators %d\n", ret);
+		return ret;
+	}
+
+	/* Request flash-mode line and don't go into flash mode */
+	wacom_data->flash_mode_gpio = devm_gpiod_get_optional(dev, "flash-mode", GPIOD_OUT_LOW);
+	if (IS_ERR(wacom_data->flash_mode_gpio)) {
+		ret = PTR_ERR(wacom_data->flash_mode_gpio);
+		dev_err(dev, "Failed to get flash-mode gpio: %d\n", ret);
+		return ret;
+	}
+
+	/* Request pdct line  */
+	wacom_data->pen_detect_gpio = devm_gpiod_get_optional(dev, "pdct", GPIOD_IN);
+	if (IS_ERR(wacom_data->pen_detect_gpio)) {
+		ret = PTR_ERR(wacom_data->pen_detect_gpio);
+		dev_err(dev, "Failed to get pdct gpio: %d\n", ret);
+		return ret;
+	}
+
+	/* Request pen-insert line  */
+	wacom_data->pen_inserted_gpio = devm_gpiod_get_optional(dev, "pen-inserted", GPIOD_IN);
+	if (IS_ERR(wacom_data->pen_inserted_gpio)) {
+		ret = PTR_ERR(wacom_data->pen_inserted_gpio);
+		dev_err(dev, "Failed to get pen-insert gpio: %d\n", ret);
+		return ret;
+	}
+
+	ret = regulator_enable(wacom_data->regulator);
+	if (ret) {
+		dev_err(dev, "Failed to enable regulators: %d\n", ret);
+		return ret;
+	}
+
+	msleep(200);
+
+	ret = wacom_w9000_query(wacom_data);
+	if (ret)
+		goto err_disable_regulators;
+
+	input_dev->name = wacom_data->variant->name;
+	input_dev->id.bustype = BUS_I2C;
+	input_dev->dev.parent = dev;
+	input_dev->id.vendor = 0x56a;
+	input_dev->id.version = wacom_data->fw_version;
+	input_dev->open = wacom_w9000_open;
+	input_dev->close = wacom_w9000_close;
+
+	__set_bit(EV_KEY, input_dev->evbit);
+	__set_bit(EV_ABS, input_dev->evbit);
+	__set_bit(BTN_TOUCH, input_dev->keybit);
+	__set_bit(BTN_TOOL_PEN, input_dev->keybit);
+	__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
+	__set_bit(BTN_STYLUS, input_dev->keybit);
+
+	// Calculate x and y resolution from size in devicetree
+	ret = device_property_read_u32(dev, "touchscreen-x-mm", &val);
+	if (ret)
+		input_abs_set_res(input_dev, ABS_X, 100);
+	else
+		input_abs_set_res(input_dev, ABS_X, wacom_data->prop.max_x / val);
+	ret = device_property_read_u32(dev, "touchscreen-y-mm", &val);
+	if (ret)
+		input_abs_set_res(input_dev, ABS_Y, 100);
+	else
+		input_abs_set_res(input_dev, ABS_Y, wacom_data->prop.max_y / val);
+
+	input_set_abs_params(input_dev, ABS_X, 0, wacom_data->prop.max_x, 4, 0);
+	input_set_abs_params(input_dev, ABS_Y, 0, wacom_data->prop.max_y, 4, 0);
+	input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_data->max_pressure, 0, 0);
+	input_set_abs_params(input_dev, ABS_DISTANCE, 0, 255, 0, 0);
+
+	touchscreen_parse_properties(input_dev, false, &wacom_data->prop);
+
+	ret = devm_request_threaded_irq(dev, wacom_data->irq, NULL, wacom_w9000_interrupt,
+					IRQF_ONESHOT | IRQF_NO_AUTOEN, client->name, wacom_data);
+	if (ret) {
+		dev_err(dev, "Failed to register interrupt\n");
+		goto err_disable_regulators;
+	}
+
+	if (wacom_data->pen_detect_gpio) {
+		wacom_data->pen_detect_irq = gpiod_to_irq(wacom_data->pen_detect_gpio);
+		ret = devm_request_threaded_irq(dev, wacom_data->pen_detect_irq, NULL,
+						wacom_w9000_interrupt_pen_detect, IRQF_ONESHOT |
+						IRQF_NO_AUTOEN | IRQF_TRIGGER_RISING |
+						IRQF_TRIGGER_FALLING, "wacom_pdct", wacom_data);
+		if (ret) {
+			dev_err(dev, "Failed to register pdct interrupt\n");
+			goto err_disable_regulators;
+		}
+	}
+
+	if (wacom_data->pen_inserted_gpio) {
+		input_dev->evbit[0] |= BIT_MASK(EV_SW);
+		input_set_capability(input_dev, EV_SW, SW_PEN_INSERTED);
+		wacom_data->pen_insert_irq = gpiod_to_irq(wacom_data->pen_inserted_gpio);
+		ret = devm_request_threaded_irq(dev, wacom_data->pen_insert_irq, NULL,
+						wacom_w9000_interrupt_pen_insert, IRQF_ONESHOT |
+						IRQF_NO_AUTOEN | IRQF_TRIGGER_RISING |
+						IRQF_TRIGGER_FALLING, "wacom_pen_insert",
+						wacom_data);
+		if (ret) {
+			dev_err(dev, "Failed to register pen-insert interrupt\n");
+			goto err_disable_regulators;
+		}
+	}
+
+	input_set_drvdata(input_dev, wacom_data);
+
+	wacom_data->pen_inserted = gpiod_get_value(wacom_data->pen_inserted_gpio);
+	if (wacom_data->pen_inserted)
+		regulator_disable(wacom_data->regulator);
+	else
+		enable_irq(wacom_data->irq);
+
+	input_report_switch(wacom_data->input_dev, SW_PEN_INSERTED, wacom_data->pen_inserted);
+	input_sync(wacom_data->input_dev);
+
+	if (wacom_data->pen_inserted_gpio)
+		enable_irq(wacom_data->pen_insert_irq);
+
+	if (wacom_data->pen_detect_gpio)
+		enable_irq(wacom_data->pen_detect_irq);
+
+	ret = input_register_device(wacom_data->input_dev);
+	if (ret) {
+		dev_err(dev, "Failed to register input device: %d\n", ret);
+		goto err_disable_regulators;
+	}
+
+	return 0;
+
+err_disable_regulators:
+	regulator_disable(wacom_data->regulator);
+	return ret;
+}
+
+static void wacom_w9000_remove(struct i2c_client *client)
+{
+	struct wacom_w9000_data *wacom_data = i2c_get_clientdata(client);
+
+	if (regulator_is_enabled(wacom_data->regulator))
+		regulator_disable(wacom_data->regulator);
+}
+
+static int wacom_w9000_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct wacom_w9000_data *wacom_data = i2c_get_clientdata(client);
+	struct input_dev *input_dev = wacom_data->input_dev;
+
+	mutex_lock(&input_dev->mutex);
+
+	if (regulator_is_enabled(wacom_data->regulator)) {
+		disable_irq(wacom_data->irq);
+		regulator_disable(wacom_data->regulator);
+	}
+
+	mutex_unlock(&input_dev->mutex);
+
+	return 0;
+}
+
+static int wacom_w9000_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct wacom_w9000_data *wacom_data = i2c_get_clientdata(client);
+	struct input_dev *input_dev = wacom_data->input_dev;
+	int ret = 0;
+
+	mutex_lock(&input_dev->mutex);
+
+	if (!wacom_data->pen_inserted && !regulator_is_enabled(wacom_data->regulator)) {
+		ret = regulator_enable(wacom_data->regulator);
+		if (ret) {
+			dev_err(&wacom_data->client->dev, "Failed to enable regulators: %d\n",
+				ret);
+		} else {
+			msleep(200);
+			enable_irq(wacom_data->irq);
+		}
+	}
+
+	mutex_unlock(&input_dev->mutex);
+
+	return ret;
+}
+
+static DEFINE_SIMPLE_DEV_PM_OPS(wacom_w9000_pm, wacom_w9000_suspend, wacom_w9000_resume);
+
+static const struct i2c_device_id wacom_w9000_id[] = {
+	{ "w9007a_lt03" },
+	{ "w9007a_v1" },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, wacom_w9000_id);
+
+static struct i2c_driver wacom_w9000_driver = {
+	.driver = {
+		.name	= "wacom_w9000",
+		.of_match_table = wacom_w9000_of_match,
+		.pm	= pm_sleep_ptr(&wacom_w9000_pm),
+	},
+	.probe		= wacom_w9000_probe,
+	.remove		= wacom_w9000_remove,
+	.id_table	= wacom_w9000_id,
+};
+module_i2c_driver(wacom_w9000_driver);
+
+/* Module information */
+MODULE_AUTHOR("Hendrik Noack <hendrik-noack@gmx.de>");
+MODULE_DESCRIPTION("Wacom W9000-series penabled touchscreen driver");
+MODULE_LICENSE("GPL");
-- 
2.43.0

Re: [PATCH 1/2] dt-bindings: Input: Add Wacom W9000-series penabled touchscreens

[Rob Herring (Arm)]

On Mon, 27 Oct 2025 22:25:34 +0100, Hendrik Noack wrote:
> Add bindings for two Wacom W9007 variants which can be found in tablets.
> 
> Signed-off-by: Hendrik Noack <hendrik-noack@gmx.de>
> ---
>  .../input/touchscreen/wacom,w9000-series.yaml | 79 +++++++++++++++++++
>  1 file changed, 79 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml
> 

My bot found errors running 'make dt_binding_check' on your patch:

yamllint warnings/errors:

dtschema/dtc warnings/errors:
Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.example.dtb: /example-0/i2c/digitizer@56: failed to match any schema with compatible: ['wacom,wacom,w9007a_v1']

doc reference errors (make refcheckdocs):

See https://patchwork.ozlabs.org/project/devicetree-bindings/patch/20251027212535.4078-1-hendrik-noack@gmx.de

The base for the series is generally the latest rc1. A different dependency
should be noted in *this* patch.

If you already ran 'make dt_binding_check' and didn't see the above
error(s), then make sure 'yamllint' is installed and dt-schema is up to
date:

pip3 install dtschema --upgrade

Please check and re-submit after running the above command yourself. Note
that DT_SCHEMA_FILES can be set to your schema file to speed up checking
your schema. However, it must be unset to test all examples with your schema.

Re: [PATCH 1/2] dt-bindings: Input: Add Wacom W9000-series penabled touchscreens

[Krzysztof Kozlowski]

On Mon, Oct 27, 2025 at 10:25:34PM +0100, Hendrik Noack wrote:
> Add bindings for two Wacom W9007 variants which can be found in tablets.
> 
> Signed-off-by: Hendrik Noack <hendrik-noack@gmx.de>
> ---
>  .../input/touchscreen/wacom,w9000-series.yaml | 79 +++++++++++++++++++
>  1 file changed, 79 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml

Filename matching compatible,

> 
> diff --git a/Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml b/Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml
> new file mode 100644
> index 000000000000..93579ae0297e
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/input/touchscreen/wacom,w9000-series.yaml
> @@ -0,0 +1,79 @@
> +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
> +%YAML 1.2
> +---
> +$id: http://devicetree.org/schemas/input/touchscreen/wacom,w9000-series.yaml#
> +$schema: http://devicetree.org/meta-schemas/core.yaml#
> +
> +title: Wacom W9000-series penabled I2C touchscreen driver

Driver as Linux driver? if so, then drop.

> +
> +description:
> +  The W9000-series are penabled touchscreen controllers by Wacom.
> +
> +maintainers:
> +  - Hendrik Noack <hendrik-noack@gmx.de>
> +
> +allOf:
> +  - $ref: touchscreen.yaml#
> +
> +properties:
> +  compatible:
> +    enum:
> +      - wacom,w9007a_lt03
> +      - wacom,w9007a_v1

None of the compatibles use underscores. Please do not come up with
entirely different coding style than existing kernel.

Also, nothing explain here differences - not commit msg, not
description.

> +
> +  reg:
> +    maxItems: 1
> +
> +  interrupts:
> +    maxItems: 1
> +
> +  vdd-supply:
> +    description:
> +      Optional regulator for the VDD digital voltage.
> +
> +  pdct-gpios:
> +    maxItems: 1
> +    description:
> +      Optional GPIO specifier for the touchscreen's pdct pin.
> +
> +  flash-mode-gpios:
> +    maxItems: 1
> +    description:
> +      Optional GPIO specifier for the touchscreen's flash-mode pin.
> +
> +  pen-inserted-gpios:
> +    maxItems: 1
> +    description:
> +      Optional GPIO specifier for the touchscreen's pen-insert pin.
> +
> +required:
> +  - compatible
> +  - reg
> +  - interrupts
> +  - vdd-supply
> +
> +additionalProperties: false
> +
> +examples:
> +  - |
> +    #include <dt-bindings/interrupt-controller/irq.h>
> +    #include <dt-bindings/gpio/gpio.h>
> +    i2c {
> +      #address-cells = <1>;
> +      #size-cells = <0>;
> +      digitizer@56 {
> +        compatible = "wacom,wacom,w9007a_v1";
> +        reg = <0x56>;
> +        interrupt-parent = <&gpx3>;
> +        interrupts = <5 IRQ_TYPE_EDGE_RISING>;
> +
> +        vdd-supply = <&stylus_reg>;
> +
> +        pdct-gpios = <&gpd1 2 GPIO_ACTIVE_HIGH>;
> +        flash-mode-gpios = <&gpd1 3 GPIO_ACTIVE_HIGH>;
> +        pen-inserted-gpios = <&gpx0 0 GPIO_ACTIVE_LOW>;
> +
> +        touchscreen-x-mm = <262>;
> +        touchscreen-y-mm = <164>;

Never tested, after fixing compatible you will see errors. You need
unevaluatedProperties.

Best regards,
Krzysztof

Re: [PATCH 2/2] Input: Add support for Wacom W9000-series penabled touchscreens

[Krzysztof Kozlowski]

On Mon, Oct 27, 2025 at 10:25:35PM +0100, Hendrik Noack wrote:
> +
> +static const struct of_device_id wacom_w9000_of_match[] = {
> +	{ .compatible = "wacom,w9007a_lt03", .data = &wacom_w9007a_lt03, },
> +	{ .compatible = "wacom,w9007a_v1", .data = &wacom_w9007a_v1, },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(of, wacom_w9000_of_match);

This goes next to other ID table, around the probe.

> +
> +static int wacom_w9000_read(struct i2c_client *client, u8 command, int len, char *data)
> +{
> +	struct i2c_msg xfer[2];
> +	bool retried = false;
> +	int ret;
> +

...

> +
> +static int wacom_w9000_probe(struct i2c_client *client)
> +{
> +	struct device *dev = &client->dev;
> +	struct wacom_w9000_data *wacom_data;
> +	struct input_dev *input_dev;
> +	int ret;
> +	u32 val;
> +
> +	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
> +		dev_err(dev, "i2c_check_functionality error\n");
> +		return -EIO;
> +	}
> +
> +	wacom_data = devm_kzalloc(dev, sizeof(struct wacom_w9000_data), GFP_KERNEL);

sizeof(*)

Please use existing kernel coding style, not some downstream version.

> +	if (!wacom_data)
> +		return -ENOMEM;
> +
> +	wacom_data->variant = i2c_get_match_data(client);
> +
> +	wacom_data->client = client;
> +
> +	input_dev = devm_input_allocate_device(dev);
> +	if (!input_dev)
> +		return -ENOMEM;
> +	wacom_data->input_dev = input_dev;
> +
> +	wacom_data->irq = client->irq;
> +	i2c_set_clientdata(client, wacom_data);
> +
> +	wacom_data->regulator = devm_regulator_get(dev, "vdd");
> +	if (IS_ERR(wacom_data->regulator)) {
> +		ret = PTR_ERR(wacom_data->regulator);
> +		dev_err(dev, "Failed to get regulators %d\n", ret);
> +		return ret;

Nope. Look at all other drivers. Syntax is since some years return
dev_err_probe.

> +	}
> +
> +	/* Request flash-mode line and don't go into flash mode */
> +	wacom_data->flash_mode_gpio = devm_gpiod_get_optional(dev, "flash-mode", GPIOD_OUT_LOW);
> +	if (IS_ERR(wacom_data->flash_mode_gpio)) {
> +		ret = PTR_ERR(wacom_data->flash_mode_gpio);
> +		dev_err(dev, "Failed to get flash-mode gpio: %d\n", ret);
> +		return ret;

You must handle deferred probe. Please look at all other drivers how
they do it.

> +	}
> +
> +	/* Request pdct line  */
> +	wacom_data->pen_detect_gpio = devm_gpiod_get_optional(dev, "pdct", GPIOD_IN);
> +	if (IS_ERR(wacom_data->pen_detect_gpio)) {
> +		ret = PTR_ERR(wacom_data->pen_detect_gpio);
> +		dev_err(dev, "Failed to get pdct gpio: %d\n", ret);
> +		return ret;
> +	}
> +
> +	/* Request pen-insert line  */
> +	wacom_data->pen_inserted_gpio = devm_gpiod_get_optional(dev, "pen-inserted", GPIOD_IN);
> +	if (IS_ERR(wacom_data->pen_inserted_gpio)) {
> +		ret = PTR_ERR(wacom_data->pen_inserted_gpio);
> +		dev_err(dev, "Failed to get pen-insert gpio: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = regulator_enable(wacom_data->regulator);
> +	if (ret) {
> +		dev_err(dev, "Failed to enable regulators: %d\n", ret);
> +		return ret;
> +	}
> +
> +	msleep(200);
> +
> +	ret = wacom_w9000_query(wacom_data);
> +	if (ret)
> +		goto err_disable_regulators;
> +
> +	input_dev->name = wacom_data->variant->name;
> +	input_dev->id.bustype = BUS_I2C;
> +	input_dev->dev.parent = dev;
> +	input_dev->id.vendor = 0x56a;
> +	input_dev->id.version = wacom_data->fw_version;
> +	input_dev->open = wacom_w9000_open;
> +	input_dev->close = wacom_w9000_close;
> +
> +	__set_bit(EV_KEY, input_dev->evbit);
> +	__set_bit(EV_ABS, input_dev->evbit);
> +	__set_bit(BTN_TOUCH, input_dev->keybit);
> +	__set_bit(BTN_TOOL_PEN, input_dev->keybit);
> +	__set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
> +	__set_bit(BTN_STYLUS, input_dev->keybit);
> +
> +	// Calculate x and y resolution from size in devicetree
> +	ret = device_property_read_u32(dev, "touchscreen-x-mm", &val);
> +	if (ret)
> +		input_abs_set_res(input_dev, ABS_X, 100);
> +	else
> +		input_abs_set_res(input_dev, ABS_X, wacom_data->prop.max_x / val);
> +	ret = device_property_read_u32(dev, "touchscreen-y-mm", &val);
> +	if (ret)
> +		input_abs_set_res(input_dev, ABS_Y, 100);
> +	else
> +		input_abs_set_res(input_dev, ABS_Y, wacom_data->prop.max_y / val);
> +
> +	input_set_abs_params(input_dev, ABS_X, 0, wacom_data->prop.max_x, 4, 0);
> +	input_set_abs_params(input_dev, ABS_Y, 0, wacom_data->prop.max_y, 4, 0);
> +	input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_data->max_pressure, 0, 0);
> +	input_set_abs_params(input_dev, ABS_DISTANCE, 0, 255, 0, 0);
> +
> +	touchscreen_parse_properties(input_dev, false, &wacom_data->prop);
> +
> +	ret = devm_request_threaded_irq(dev, wacom_data->irq, NULL, wacom_w9000_interrupt,
> +					IRQF_ONESHOT | IRQF_NO_AUTOEN, client->name, wacom_data);
> +	if (ret) {
> +		dev_err(dev, "Failed to register interrupt\n");
> +		goto err_disable_regulators;
> +	}
> +
> +	if (wacom_data->pen_detect_gpio) {
> +		wacom_data->pen_detect_irq = gpiod_to_irq(wacom_data->pen_detect_gpio);

Why is this a GPIO? Your binding said this is GPIO, your code says this
is an interrupt.

> +		ret = devm_request_threaded_irq(dev, wacom_data->pen_detect_irq, NULL,
> +						wacom_w9000_interrupt_pen_detect, IRQF_ONESHOT |
> +						IRQF_NO_AUTOEN | IRQF_TRIGGER_RISING |
> +						IRQF_TRIGGER_FALLING, "wacom_pdct", wacom_data);
> +		if (ret) {
> +			dev_err(dev, "Failed to register pdct interrupt\n");
> +			goto err_disable_regulators;
> +		}
> +	}
> +
> +	if (wacom_data->pen_inserted_gpio) {
> +		input_dev->evbit[0] |= BIT_MASK(EV_SW);
> +		input_set_capability(input_dev, EV_SW, SW_PEN_INSERTED);
> +		wacom_data->pen_insert_irq = gpiod_to_irq(wacom_data->pen_inserted_gpio);

Same question here.

> +		ret = devm_request_threaded_irq(dev, wacom_data->pen_insert_irq, NULL,
> +						wacom_w9000_interrupt_pen_insert, IRQF_ONESHOT |
> +						IRQF_NO_AUTOEN | IRQF_TRIGGER_RISING |
> +						IRQF_TRIGGER_FALLING, "wacom_pen_insert",
> +						wacom_data);
> +		if (ret) {
> +			dev_err(dev, "Failed to register pen-insert interrupt\n");
> +			goto err_disable_regulators;
> +		}
> +	}
> +
> +	input_set_drvdata(input_dev, wacom_data);
> +
> +	wacom_data->pen_inserted = gpiod_get_value(wacom_data->pen_inserted_gpio);
> +	if (wacom_data->pen_inserted)
> +		regulator_disable(wacom_data->regulator);
> +	else
> +		enable_irq(wacom_data->irq);
> +
> +	input_report_switch(wacom_data->input_dev, SW_PEN_INSERTED, wacom_data->pen_inserted);
> +	input_sync(wacom_data->input_dev);
> +
> +	if (wacom_data->pen_inserted_gpio)
> +		enable_irq(wacom_data->pen_insert_irq);
> +
> +	if (wacom_data->pen_detect_gpio)
> +		enable_irq(wacom_data->pen_detect_irq);
> +
> +	ret = input_register_device(wacom_data->input_dev);
> +	if (ret) {
> +		dev_err(dev, "Failed to register input device: %d\n", ret);
> +		goto err_disable_regulators;
> +	}
> +
> +	return 0;
> +
> +err_disable_regulators:
> +	regulator_disable(wacom_data->regulator);
> +	return ret;
> +}
> +
> +static void wacom_w9000_remove(struct i2c_client *client)
> +{
> +	struct wacom_w9000_data *wacom_data = i2c_get_clientdata(client);
> +
> +	if (regulator_is_enabled(wacom_data->regulator))
> +		regulator_disable(wacom_data->regulator);
> +}
> +
> +static int wacom_w9000_suspend(struct device *dev)
> +{
> +	struct i2c_client *client = to_i2c_client(dev);
> +	struct wacom_w9000_data *wacom_data = i2c_get_clientdata(client);
> +	struct input_dev *input_dev = wacom_data->input_dev;
> +
> +	mutex_lock(&input_dev->mutex);
> +
> +	if (regulator_is_enabled(wacom_data->regulator)) {
> +		disable_irq(wacom_data->irq);
> +		regulator_disable(wacom_data->regulator);
> +	}
> +
> +	mutex_unlock(&input_dev->mutex);
> +
> +	return 0;
> +}
> +
> +static int wacom_w9000_resume(struct device *dev)
> +{
> +	struct i2c_client *client = to_i2c_client(dev);
> +	struct wacom_w9000_data *wacom_data = i2c_get_clientdata(client);
> +	struct input_dev *input_dev = wacom_data->input_dev;
> +	int ret = 0;
> +
> +	mutex_lock(&input_dev->mutex);
> +
> +	if (!wacom_data->pen_inserted && !regulator_is_enabled(wacom_data->regulator)) {
> +		ret = regulator_enable(wacom_data->regulator);
> +		if (ret) {
> +			dev_err(&wacom_data->client->dev, "Failed to enable regulators: %d\n",
> +				ret);
> +		} else {
> +			msleep(200);
> +			enable_irq(wacom_data->irq);
> +		}
> +	}
> +
> +	mutex_unlock(&input_dev->mutex);
> +
> +	return ret;
> +}
> +
> +static DEFINE_SIMPLE_DEV_PM_OPS(wacom_w9000_pm, wacom_w9000_suspend, wacom_w9000_resume);
> +
> +static const struct i2c_device_id wacom_w9000_id[] = {
> +	{ "w9007a_lt03" },
> +	{ "w9007a_v1" },

This does not match your OF table.

> +	{ }
> +};
> +MODULE_DEVICE_TABLE(i2c, wacom_w9000_id);
> +
> +static struct i2c_driver wacom_w9000_driver = {
> +	.driver = {
> +		.name	= "wacom_w9000",
> +		.of_match_table = wacom_w9000_of_match,
> +		.pm	= pm_sleep_ptr(&wacom_w9000_pm),
> +	},
> +	.probe		= wacom_w9000_probe,
> +	.remove		= wacom_w9000_remove,
> +	.id_table	= wacom_w9000_id,
> +};
> +module_i2c_driver(wacom_w9000_driver);
> +
> +/* Module information */
> +MODULE_AUTHOR("Hendrik Noack <hendrik-noack@gmx.de>");
> +MODULE_DESCRIPTION("Wacom W9000-series penabled touchscreen driver");
> +MODULE_LICENSE("GPL");
> -- 
> 2.43.0
> 

Re: [PATCH 2/2] Input: Add support for Wacom W9000-series penabled touchscreens

[Kernel GMX]

28.10.2025 08:44:34 Krzysztof Kozlowski <krzk@kernel.org>:

> On Mon, Oct 27, 2025 at 10:25:35PM +0100, Hendrik Noack wrote:
>> +
>> +static const struct of_device_id wacom_w9000_of_match[] = {
>> +   { .compatible = "wacom,w9007a_lt03", .data = &wacom_w9007a_lt03, },
>> +   { .compatible = "wacom,w9007a_v1", .data = &wacom_w9007a_v1, },
>> +   {},
>> +};
>> +MODULE_DEVICE_TABLE(of, wacom_w9000_of_match);
>
> This goes next to other ID table, around the probe.
>
>> +
>> +static int wacom_w9000_read(struct i2c_client *client, u8 command, int len, char *data)
>> +{
>> +   struct i2c_msg xfer[2];
>> +   bool retried = false;
>> +   int ret;
>> +
>
> ...
>
>> +
>> +static int wacom_w9000_probe(struct i2c_client *client)
>> +{
>> +   struct device *dev = &client->dev;
>> +   struct wacom_w9000_data *wacom_data;
>> +   struct input_dev *input_dev;
>> +   int ret;
>> +   u32 val;
>> +
>> +   if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
>> +       dev_err(dev, "i2c_check_functionality error\n");
>> +       return -EIO;
>> +   }
>> +
>> +   wacom_data = devm_kzalloc(dev, sizeof(struct wacom_w9000_data), GFP_KERNEL);
>
> sizeof(*)
>
> Please use existing kernel coding style, not some downstream version.
>

Okay, I was orienting myself on the atmel_mxt_ts driver and it had it like this.

>> +   if (!wacom_data)
>> +       return -ENOMEM;
>> +
>> +   wacom_data->variant = i2c_get_match_data(client);
>> +
>> +   wacom_data->client = client;
>> +
>> +   input_dev = devm_input_allocate_device(dev);
>> +   if (!input_dev)
>> +       return -ENOMEM;
>> +   wacom_data->input_dev = input_dev;
>> +
>> +   wacom_data->irq = client->irq;
>> +   i2c_set_clientdata(client, wacom_data);
>> +
>> +   wacom_data->regulator = devm_regulator_get(dev, "vdd");
>> +   if (IS_ERR(wacom_data->regulator)) {
>> +       ret = PTR_ERR(wacom_data->regulator);
>> +       dev_err(dev, "Failed to get regulators %d\n", ret);
>> +       return ret;
>
> Nope. Look at all other drivers. Syntax is since some years return
> dev_err_probe.
>
>> +   }
>> +
>> +   /* Request flash-mode line and don't go into flash mode */
>> +   wacom_data->flash_mode_gpio = devm_gpiod_get_optional(dev, "flash-mode", GPIOD_OUT_LOW);
>> +   if (IS_ERR(wacom_data->flash_mode_gpio)) {
>> +       ret = PTR_ERR(wacom_data->flash_mode_gpio);
>> +       dev_err(dev, "Failed to get flash-mode gpio: %d\n", ret);
>> +       return ret;
>
> You must handle deferred probe. Please look at all other drivers how
> they do it.
>
>> +   }
>> +
>> +   /* Request pdct line  */
>> +   wacom_data->pen_detect_gpio = devm_gpiod_get_optional(dev, "pdct", GPIOD_IN);
>> +   if (IS_ERR(wacom_data->pen_detect_gpio)) {
>> +       ret = PTR_ERR(wacom_data->pen_detect_gpio);
>> +       dev_err(dev, "Failed to get pdct gpio: %d\n", ret);
>> +       return ret;
>> +   }
>> +
>> +   /* Request pen-insert line  */
>> +   wacom_data->pen_inserted_gpio = devm_gpiod_get_optional(dev, "pen-inserted", GPIOD_IN);
>> +   if (IS_ERR(wacom_data->pen_inserted_gpio)) {
>> +       ret = PTR_ERR(wacom_data->pen_inserted_gpio);
>> +       dev_err(dev, "Failed to get pen-insert gpio: %d\n", ret);
>> +       return ret;
>> +   }
>> +
>> +   ret = regulator_enable(wacom_data->regulator);
>> +   if (ret) {
>> +       dev_err(dev, "Failed to enable regulators: %d\n", ret);
>> +       return ret;
>> +   }
>> +
>> +   msleep(200);
>> +
>> +   ret = wacom_w9000_query(wacom_data);
>> +   if (ret)
>> +       goto err_disable_regulators;
>> +
>> +   input_dev->name = wacom_data->variant->name;
>> +   input_dev->id.bustype = BUS_I2C;
>> +   input_dev->dev.parent = dev;
>> +   input_dev->id.vendor = 0x56a;
>> +   input_dev->id.version = wacom_data->fw_version;
>> +   input_dev->open = wacom_w9000_open;
>> +   input_dev->close = wacom_w9000_close;
>> +
>> +   __set_bit(EV_KEY, input_dev->evbit);
>> +   __set_bit(EV_ABS, input_dev->evbit);
>> +   __set_bit(BTN_TOUCH, input_dev->keybit);
>> +   __set_bit(BTN_TOOL_PEN, input_dev->keybit);
>> +   __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
>> +   __set_bit(BTN_STYLUS, input_dev->keybit);
>> +
>> +   // Calculate x and y resolution from size in devicetree
>> +   ret = device_property_read_u32(dev, "touchscreen-x-mm", &val);
>> +   if (ret)
>> +       input_abs_set_res(input_dev, ABS_X, 100);
>> +   else
>> +       input_abs_set_res(input_dev, ABS_X, wacom_data->prop.max_x / val);
>> +   ret = device_property_read_u32(dev, "touchscreen-y-mm", &val);
>> +   if (ret)
>> +       input_abs_set_res(input_dev, ABS_Y, 100);
>> +   else
>> +       input_abs_set_res(input_dev, ABS_Y, wacom_data->prop.max_y / val);
>> +
>> +   input_set_abs_params(input_dev, ABS_X, 0, wacom_data->prop.max_x, 4, 0);
>> +   input_set_abs_params(input_dev, ABS_Y, 0, wacom_data->prop.max_y, 4, 0);
>> +   input_set_abs_params(input_dev, ABS_PRESSURE, 0, wacom_data->max_pressure, 0, 0);
>> +   input_set_abs_params(input_dev, ABS_DISTANCE, 0, 255, 0, 0);
>> +
>> +   touchscreen_parse_properties(input_dev, false, &wacom_data->prop);
>> +
>> +   ret = devm_request_threaded_irq(dev, wacom_data->irq, NULL, wacom_w9000_interrupt,
>> +                   IRQF_ONESHOT | IRQF_NO_AUTOEN, client->name, wacom_data);
>> +   if (ret) {
>> +       dev_err(dev, "Failed to register interrupt\n");
>> +       goto err_disable_regulators;
>> +   }
>> +
>> +   if (wacom_data->pen_detect_gpio) {
>> +       wacom_data->pen_detect_irq = gpiod_to_irq(wacom_data->pen_detect_gpio);
>
> Why is this a GPIO? Your binding said this is GPIO, your code says this
> is an interrupt.

You are right, it's not necessary here.

>> +       ret = devm_request_threaded_irq(dev, wacom_data->pen_detect_irq, NULL,
>> +                       wacom_w9000_interrupt_pen_detect, IRQF_ONESHOT |
>> +                       IRQF_NO_AUTOEN | IRQF_TRIGGER_RISING |
>> +                       IRQF_TRIGGER_FALLING, "wacom_pdct", wacom_data);
>> +       if (ret) {
>> +           dev_err(dev, "Failed to register pdct interrupt\n");
>> +           goto err_disable_regulators;
>> +       }
>> +   }
>> +
>> +   if (wacom_data->pen_inserted_gpio) {
>> +       input_dev->evbit[0] |= BIT_MASK(EV_SW);
>> +       input_set_capability(input_dev, EV_SW, SW_PEN_INSERTED);
>> +       wacom_data->pen_insert_irq = gpiod_to_irq(wacom_data->pen_inserted_gpio);
>
> Same question here.
>

The driver needs to know the GPIO state to determine if the pen is inserted
so that it can enable or disable the regulator and main interrupt accordingly.
An interrupt for this GPIO is necessary for this evaluation to occur
on every signal change.

>> +       ret = devm_request_threaded_irq(dev, wacom_data->pen_insert_irq, NULL,
>> +                       wacom_w9000_interrupt_pen_insert, IRQF_ONESHOT |
>> +                       IRQF_NO_AUTOEN | IRQF_TRIGGER_RISING |
>> +                       IRQF_TRIGGER_FALLING, "wacom_pen_insert",
>> +                       wacom_data);
>> +       if (ret) {
>> +           dev_err(dev, "Failed to register pen-insert interrupt\n");
>> +           goto err_disable_regulators;
>> +       }
>> +   }
>> +

...

Thank you for you feedback, I will address the feedback in my next iteration.

Best regards,
Hendrik