Add a polling I2C touchscreen driver for Jadard JD9365TX in-cell
panels that do not wire an interrupt line on the FPC.

Signed-off-by: Hefei <[email protected]>
---
 drivers/input/touchscreen/Kconfig           |  12 +
 drivers/input/touchscreen/Makefile          |   1 +
 drivers/input/touchscreen/jadard_jd9365tx.c | 347 ++++++++++++++++++++
 3 files changed, 360 insertions(+)
 create mode 100644 drivers/input/touchscreen/jadard_jd9365tx.c

diff --git a/drivers/input/touchscreen/Kconfig 
b/drivers/input/touchscreen/Kconfig
index e2ee722..da425c8 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -540,6 +540,18 @@ config TOUCHSCREEN_IPROC
          To compile this driver as a module, choose M here: the
          module will be called bcm_iproc_tsc.
 
+config TOUCHSCREEN_JADARD_JD9365TX
+       tristate "Jadard JD9365TX in-cell touchscreen"
+       depends on I2C
+       help
+         Say Y here if you have a Jadard JD9365TX in-cell touchscreen.
+         The driver polls over I2C when no interrupt line is wired.
+
+         If unsure, say N.
+
+         To compile this driver as a module, choose M here: the
+         module will be called jadard_jd9365tx.
+
 config TOUCHSCREEN_S6SY761
        tristate "Samsung S6SY761 Touchscreen driver"
        depends on I2C
diff --git a/drivers/input/touchscreen/Makefile 
b/drivers/input/touchscreen/Makefile
index 58094f2..5846f4d 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -59,6 +59,7 @@ obj-$(CONFIG_TOUCHSCREEN_IMAGIS)      += imagis.o
 obj-$(CONFIG_TOUCHSCREEN_IMX6UL_TSC)   += imx6ul_tsc.o
 obj-$(CONFIG_TOUCHSCREEN_INEXIO)       += inexio.o
 obj-$(CONFIG_TOUCHSCREEN_IPROC)                += bcm_iproc_tsc.o
+obj-$(CONFIG_TOUCHSCREEN_JADARD_JD9365TX) += jadard_jd9365tx.o
 obj-$(CONFIG_TOUCHSCREEN_LPC32XX)      += lpc32xx_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MAX11801)     += max11801_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MXS_LRADC)     += mxs-lradc-ts.o
diff --git a/drivers/input/touchscreen/jadard_jd9365tx.c 
b/drivers/input/touchscreen/jadard_jd9365tx.c
new file mode 100644
index 0000000..eec8dc7
--- /dev/null
+++ b/drivers/input/touchscreen/jadard_jd9365tx.c
@@ -0,0 +1,347 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2026 VIEWE
+ *
+ * Jadard JD9365TX in-cell touchscreen (I2C @0x68, polling).
+ * Typical DSI FPC has no interrupt line.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/property.h>
+#include <linux/slab.h>
+
+#define JD_CHIP_ID                     0x9084
+#define JD_CHIP_ID_ALT                 0x9032
+#define JD_SOC_CHIP_ID2                        0x40008076
+#define JD_ERAM_BASE                   0x20011000
+#define JD_SECTION_READY_VAL           0xA55A
+#define JD_MAX_DSRAM_NUM               25
+#define JD_ESRAM_COORD_IDX             1
+#define JD_ESRAM_SECTION_NUM           6
+#define JD_DEFAULT_COORD_ADDR          0x20011120
+#define JD_TOUCH_DATA_SIZE             78
+#define JD_FINGER_DATA_SIZE            5
+#define JD_FINGER_NUM_ADDR             0
+#define JD_TOUCH_COORD_INFO_ADDR       3
+#define JD_MAX_POINTS                  10
+#define JD_DEFAULT_POLL_MS             16
+
+struct jadard_tp {
+       struct i2c_client *client;
+       struct input_dev *input;
+       struct touchscreen_properties prop;
+       u32 coord_addr;
+       u16 touch_data_size;
+       u16 max_points;
+       u16 abs_x_max;
+       u16 abs_y_max;
+       unsigned int poll_interval_ms;
+       bool ready;
+};
+
+static int jd_bus_write(struct i2c_client *client, const u8 *cmd, u8 cmd_len,
+                       const u8 *data, u16 data_len)
+{
+       u8 buf[64];
+       struct i2c_msg msg;
+       int ret;
+
+       if (cmd_len + data_len > sizeof(buf))
+               return -EINVAL;
+
+       memcpy(buf, cmd, cmd_len);
+       if (data_len)
+               memcpy(buf + cmd_len, data, data_len);
+
+       msg.addr = client->addr;
+       msg.flags = 0;
+       msg.len = cmd_len + data_len;
+       msg.buf = buf;
+
+       ret = i2c_transfer(client->adapter, &msg, 1);
+       return ret == 1 ? 0 : (ret < 0 ? ret : -EIO);
+}
+
+static int jd_bus_read(struct i2c_client *client, const u8 *cmd, u8 cmd_len,
+                      u8 *data, u16 data_len)
+{
+       struct i2c_msg msg[2];
+       int ret;
+
+       msg[0].addr = client->addr;
+       msg[0].flags = 0;
+       msg[0].len = cmd_len;
+       msg[0].buf = (u8 *)cmd;
+       msg[1].addr = client->addr;
+       msg[1].flags = I2C_M_RD;
+       msg[1].len = data_len;
+       msg[1].buf = data;
+
+       ret = i2c_transfer(client->adapter, msg, 2);
+       return ret == 2 ? 0 : (ret < 0 ? ret : -EIO);
+}
+
+static int jd_enter_backdoor(struct i2c_client *client)
+{
+       const u8 cmd[5] = { 0xF2, 0xAA, 0xF0, 0x0F, 0x55 };
+       const u8 data = 0x68;
+
+       return jd_bus_write(client, cmd, sizeof(cmd), &data, 1);
+}
+
+static int jd_read_reg(struct i2c_client *client, u32 addr, u8 *rdata, u16 
rlen)
+{
+       u8 cmd[6];
+
+       cmd[0] = 0xF3;
+       cmd[1] = (addr >> 24) & 0xFF;
+       cmd[2] = (addr >> 16) & 0xFF;
+       cmd[3] = (addr >> 8) & 0xFF;
+       cmd[4] = addr & 0xFF;
+       cmd[5] = 0x03;
+
+       return jd_bus_read(client, cmd, sizeof(cmd), rdata, rlen);
+}
+
+static int jd_get_chip_id(struct i2c_client *client, u16 *id)
+{
+       u8 rbuf[2];
+       int ret;
+
+       ret = jd_read_reg(client, JD_SOC_CHIP_ID2, rbuf, sizeof(rbuf));
+       if (ret)
+               return ret;
+
+       *id = (u16)((rbuf[1] << 8) | rbuf[0]);
+       return 0;
+}
+
+static bool jd_section_ready(struct i2c_client *client)
+{
+       u8 rbuf[2];
+       unsigned int waited = 0;
+
+       do {
+               msleep(2);
+               if (jd_read_reg(client, JD_ERAM_BASE, rbuf, sizeof(rbuf)))
+                       return false;
+               waited += 2;
+               if (((rbuf[1] << 8) | rbuf[0]) == JD_SECTION_READY_VAL)
+                       return true;
+       } while (waited < 100);
+
+       return false;
+}
+
+static int jd_resolve_coord_addr(struct jadard_tp *ts)
+{
+       u32 esram_num_addr = JD_ERAM_BASE + 4 + JD_MAX_DSRAM_NUM * 8;
+       u32 esram_sec_addr = esram_num_addr + 4;
+       u8 buf[JD_ESRAM_SECTION_NUM * 8];
+       u32 addr, len;
+       int ret;
+
+       ret = jd_read_reg(ts->client, esram_sec_addr, buf, sizeof(buf));
+       if (ret)
+               return ret;
+
+       addr = buf[JD_ESRAM_COORD_IDX * 8 + 0] |
+              (buf[JD_ESRAM_COORD_IDX * 8 + 1] << 8) |
+              (buf[JD_ESRAM_COORD_IDX * 8 + 2] << 16) |
+              (buf[JD_ESRAM_COORD_IDX * 8 + 3] << 24);
+       len = buf[JD_ESRAM_COORD_IDX * 8 + 4] |
+             (buf[JD_ESRAM_COORD_IDX * 8 + 5] << 8) |
+             (buf[JD_ESRAM_COORD_IDX * 8 + 6] << 16) |
+             (buf[JD_ESRAM_COORD_IDX * 8 + 7] << 24);
+
+       if (addr < JD_ERAM_BASE || addr >= JD_ERAM_BASE + 0x1000 ||
+           len == 0 || len > JD_TOUCH_DATA_SIZE)
+               return -EINVAL;
+
+       ts->coord_addr = addr;
+       ts->touch_data_size = (u16)len;
+       return 0;
+}
+
+static int jd_hw_init(struct jadard_tp *ts)
+{
+       u16 chip_id = 0;
+       int ret;
+
+       ret = jd_enter_backdoor(ts->client);
+       if (ret)
+               return ret;
+
+       ret = jd_get_chip_id(ts->client, &chip_id);
+       if (ret)
+               return ret;
+
+       if (chip_id != JD_CHIP_ID && chip_id != JD_CHIP_ID_ALT &&
+           (chip_id == 0 || chip_id == 0xFFFF))
+               return -ENODEV;
+
+       jd_enter_backdoor(ts->client);
+
+       if (jd_section_ready(ts->client) && !jd_resolve_coord_addr(ts))
+               return 0;
+
+       if (!ts->coord_addr)
+               ts->coord_addr = JD_DEFAULT_COORD_ADDR;
+       ts->touch_data_size = JD_TOUCH_DATA_SIZE;
+
+       return 0;
+}
+
+static void jd_report_touches(struct jadard_tp *ts, const u8 *buf)
+{
+       u8 finger_num = buf[JD_FINGER_NUM_ADDR];
+       unsigned int i;
+       bool any = false;
+
+       if (finger_num > ts->max_points)
+               finger_num = ts->max_points;
+
+       for (i = 0; i < ts->max_points; i++) {
+               const u8 *c = buf + JD_TOUCH_COORD_INFO_ADDR +
+                             i * JD_FINGER_DATA_SIZE;
+               u16 x = (c[0] << 8) | c[1];
+               u16 y = (c[2] << 8) | c[3];
+               u8 w = c[4];
+               bool down = false;
+
+               if (i < finger_num &&
+                   x <= ts->abs_x_max && y <= ts->abs_y_max &&
+                   x != 0xFFFF && y != 0xFFFF)
+                       down = true;
+
+               input_mt_slot(ts->input, i);
+               input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, down);
+
+               if (down) {
+                       touchscreen_report_pos(ts->input, &ts->prop, x, y, 
true);
+                       input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, w);
+                       any = true;
+               }
+       }
+
+       input_mt_sync_frame(ts->input);
+       input_report_key(ts->input, BTN_TOUCH, any);
+       input_sync(ts->input);
+}
+
+static void jd_poll(struct input_dev *input)
+{
+       struct jadard_tp *ts = input_get_drvdata(input);
+       u8 buf[JD_TOUCH_DATA_SIZE];
+       int ret;
+
+       if (!ts->ready) {
+               ret = jd_hw_init(ts);
+               if (ret)
+                       return;
+               ts->ready = true;
+       }
+
+       ret = jd_read_reg(ts->client, ts->coord_addr, buf, ts->touch_data_size);
+       if (!ret)
+               jd_report_touches(ts, buf);
+}
+
+static int jadard_tp_probe(struct i2c_client *client)
+{
+       struct device *dev = &client->dev;
+       struct jadard_tp *ts;
+       struct input_dev *input;
+       u32 val;
+       int ret;
+
+       ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
+       if (!ts)
+               return -ENOMEM;
+
+       ts->client = client;
+       ts->max_points = JD_MAX_POINTS;
+       ts->abs_x_max = 719;
+       ts->abs_y_max = 1279;
+       ts->poll_interval_ms = JD_DEFAULT_POLL_MS;
+       ts->touch_data_size = JD_TOUCH_DATA_SIZE;
+
+       if (!device_property_read_u32(dev, "poll-interval", &val) &&
+           val >= 8 && val <= 100)
+               ts->poll_interval_ms = val;
+
+       if (!of_property_read_u32(dev->of_node, "touchscreen-size-x", &val) && 
val)
+               ts->abs_x_max = val - 1;
+
+       if (!of_property_read_u32(dev->of_node, "touchscreen-size-y", &val) && 
val)
+               ts->abs_y_max = val - 1;
+
+       if (!of_property_read_u32(dev->of_node, "jadard,coord-addr", &val) && 
val)
+               ts->coord_addr = val;
+
+       input = devm_input_allocate_device(dev);
+       if (!input)
+               return -ENOMEM;
+
+       input->name = "Jadard JD9365TX Touchscreen";
+       input->id.bustype = BUS_I2C;
+       input->dev.parent = dev;
+
+       __set_bit(EV_ABS, input->evbit);
+       __set_bit(EV_KEY, input->evbit);
+       __set_bit(BTN_TOUCH, input->keybit);
+
+       input_set_abs_params(input, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);
+       input_set_abs_params(input, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);
+       input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
+
+       touchscreen_parse_properties(input, true, &ts->prop);
+
+       ret = input_mt_init_slots(input, ts->max_points, INPUT_MT_DIRECT);
+       if (ret)
+               return ret;
+
+       input_set_drvdata(input, ts);
+       ts->input = input;
+       i2c_set_clientdata(client, ts);
+
+       ret = input_setup_polling(input, jd_poll);
+       if (ret)
+               return ret;
+
+       input_set_poll_interval(input, ts->poll_interval_ms);
+
+       return input_register_device(input);
+}
+
+static const struct of_device_id jadard_tp_of_match[] = {
+       { .compatible = "jadard,jd9365tx" },
+       { }
+};
+MODULE_DEVICE_TABLE(of, jadard_tp_of_match);
+
+static const struct i2c_device_id jadard_tp_id[] = {
+       { "jd9365tx", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, jadard_tp_id);
+
+static struct i2c_driver jadard_tp_driver = {
+       .driver = {
+               .name = "jadard-tp-jd9365tx",
+               .of_match_table = jadard_tp_of_match,
+       },
+       .probe = jadard_tp_probe,
+       .id_table = jadard_tp_id,
+};
+module_i2c_driver(jadard_tp_driver);
+
+MODULE_AUTHOR("Hefei <[email protected]>");
+MODULE_DESCRIPTION("Jadard JD9365TX in-cell touchscreen");
+MODULE_LICENSE("GPL");
-- 
2.55.0.windows.5

Reply via email to