diff --git a/arch/arm/boot/dts/overlays/Makefile b/arch/arm/boot/dts/overlays/Makefile
index 56c93053f5979b..398c8d65de1940 100644
--- a/arch/arm/boot/dts/overlays/Makefile
+++ b/arch/arm/boot/dts/overlays/Makefile
@@ -338,6 +338,7 @@ dtbo-$(CONFIG_ARCH_BCM2835) += \
 	vc4-kms-dpi-panel.dtbo \
 	vc4-kms-dsi-7inch.dtbo \
 	vc4-kms-dsi-generic.dtbo \
+	vc4-kms-dsi-ili79600-10-1inch.dtbo \
 	vc4-kms-dsi-ili9881-5inch.dtbo \
 	vc4-kms-dsi-ili9881-7inch.dtbo \
 	vc4-kms-dsi-lt070me05000.dtbo \
diff --git a/arch/arm/boot/dts/overlays/README b/arch/arm/boot/dts/overlays/README
index b673ddf74565b4..a52af8dd618203 100644
--- a/arch/arm/boot/dts/overlays/README
+++ b/arch/arm/boot/dts/overlays/README
@@ -5731,6 +5731,21 @@ Params: clock-frequency         Display clock frequency (Hz)
                                 Only supported on Pi5 and CM
 
 
+Name:   vc4-kms-dsi-ili79600-10-1inch
+Info:   Enable the Raspberry Pi 10" ILI79600 based touchscreen panel.
+        Requires vc4-kms-v3d to be loaded.
+Load:   dtoverlay=vc4-kms-dsi-ili79600-10-1inch,<param>
+Params: sizex                   Touchscreen size x (default 1200)
+        sizey                   Touchscreen size y (default 1920)
+        invx                    Touchscreen inverted x axis
+        invy                    Touchscreen inverted y axis
+        swapxy                  Touchscreen swapped x y axis
+        disable_touch           Disables the touch screen overlay driver
+        rotation                Display rotation {0,90,180,270} (default 0)
+        dsi0                    Use DSI0 and i2c_csi_dsi0 (rather than
+                                the default DSI1 and i2c_csi_dsi).
+
+
 Name:   vc4-kms-dsi-ili9881-5inch
 Info:   Enable the Raspberry Pi 5" ILI9881 based touchscreen panel.
         Requires vc4-kms-v3d to be loaded.
diff --git a/arch/arm/boot/dts/overlays/vc4-kms-dsi-ili79600-10-1inch-overlay.dts b/arch/arm/boot/dts/overlays/vc4-kms-dsi-ili79600-10-1inch-overlay.dts
new file mode 100644
index 00000000000000..7aec9e59fcb878
--- /dev/null
+++ b/arch/arm/boot/dts/overlays/vc4-kms-dsi-ili79600-10-1inch-overlay.dts
@@ -0,0 +1,126 @@
+/*
+ * vc4-kms-dsi-ili79600-10-1inch-overlay.dts
+ */
+
+/dts-v1/;
+/plugin/;
+
+#include <dt-bindings/gpio/gpio.h>
+
+/ {
+	compatible = "brcm,bcm2835";
+
+	i2c_frag: fragment@0 {
+		target = <&i2c_csi_dsi>;
+		__overlay__ {
+			#address-cells = <1>;
+			#size-cells = <0>;
+			status = "okay";
+
+			display_mcu: display_mcu@45
+			{
+				compatible = "raspberrypi,v2-touchscreen-panel-regulator";
+				reg = <0x45>;
+				gpio-controller;
+				#gpio-cells = <2>;
+			};
+
+			touch: ts@41 {
+				compatible = "ilitek,ili79600a";
+				reg = <0x41>;
+
+				reset-gpio = <&display_mcu 1 GPIO_ACTIVE_LOW>;
+
+				touchscreen-size-x = < 1200 >;
+				touchscreen-size-y = < 1920 >;
+				vcc-supply = <&display_reg>;
+
+				panel = <&dsi_panel>;
+			};
+		};
+	};
+
+	dsi_frag: fragment@1 {
+		target = <&dsi1>;
+		__overlay__  {
+			#address-cells = <1>;
+			#size-cells = <0>;
+			status = "okay";
+
+			port {
+				dsi_out: endpoint {
+					remote-endpoint = <&panel_in>;
+				};
+			};
+
+			dsi_panel: dsi_panel@0 {
+				reg = <0>;
+				compatible = "raspberrypi,dsi-10-1inch";
+				power-supply = <&display_reg>;
+				backlight = <&display_mcu>;
+
+				port {
+					panel_in: endpoint {
+						remote-endpoint = <&dsi_out>;
+					};
+				};
+			};
+		};
+	};
+
+	fragment@2 {
+		target = <&i2c0if>;
+		__overlay__ {
+			status = "okay";
+		};
+	};
+
+	fragment@3 {
+		target = <&i2c0mux>;
+		__overlay__ {
+			status = "okay";
+		};
+	};
+
+	fragment@4 {
+		target-path = "/";
+		__overlay__ {
+			display_reg: display_reg@1 {
+				reg = <1>;
+				compatible = "regulator-fixed";
+				regulator-name = "display_reg_1";
+				gpio = <&display_mcu 0 GPIO_ACTIVE_HIGH>;
+				startup-delay-us = <50000>;
+				enable-active-high;
+			};
+		};
+	};
+
+	fragment@10 {
+		target = <&touch>;
+		__dormant__ {
+			touchscreen-inverted-x;
+		};
+	};
+
+	fragment@11 {
+		target = <&touch>;
+		__dormant__ {
+			touchscreen-inverted-y;
+		};
+	};
+
+	__overrides__ {
+		sizex = <&touch>,"touchscreen-size-x:0";
+		sizey = <&touch>,"touchscreen-size-y:0";
+		invx = <0>, "+10";
+		invy = <0>, "+11";
+		swapxy = <&touch>,"touchscreen-swapped-x-y?";
+		disable_touch = <&touch>, "status=disabled";
+		rotation = <&dsi_panel>, "rotation:0";
+		dsi0 = <&dsi_frag>, "target:0=",<&dsi0>,
+		       <&i2c_frag>, "target:0=",<&i2c_csi_dsi0>,
+		       <&display_reg>, "reg:0=0",
+		       <&display_reg>, "regulator-name=display_reg_0";
+	};
+};
diff --git a/arch/arm64/configs/bcm2711_defconfig b/arch/arm64/configs/bcm2711_defconfig
index d08c0795b3cec6..1920a748d17841 100644
--- a/arch/arm64/configs/bcm2711_defconfig
+++ b/arch/arm64/configs/bcm2711_defconfig
@@ -700,6 +700,7 @@ CONFIG_TOUCHSCREEN_EXC3000=m
 CONFIG_TOUCHSCREEN_GOODIX=m
 CONFIG_TOUCHSCREEN_ILI210X=m
 CONFIG_TOUCHSCREEN_ILITEK=m
+CONFIG_TOUCHSCREEN_ILITEK_V3=m
 CONFIG_TOUCHSCREEN_EDT_FT5X06=m
 CONFIG_TOUCHSCREEN_RASPBERRYPI_FW=m
 CONFIG_TOUCHSCREEN_USB_COMPOSITE=m
@@ -1070,6 +1071,7 @@ CONFIG_DRM=m
 CONFIG_DRM_LOAD_EDID_FIRMWARE=y
 CONFIG_DRM_UDL=m
 CONFIG_DRM_PANEL_LVDS=m
+CONFIG_DRM_PANEL_ILITEK_IL79600A=m
 CONFIG_DRM_PANEL_ILITEK_ILI9806E=m
 CONFIG_DRM_PANEL_ILITEK_ILI9806E_SPI=m
 CONFIG_DRM_PANEL_ILITEK_ILI9881C=m
diff --git a/arch/arm64/configs/bcm2712_defconfig b/arch/arm64/configs/bcm2712_defconfig
index 0c0771cfbb3a9b..50c328e3bdfd3c 100644
--- a/arch/arm64/configs/bcm2712_defconfig
+++ b/arch/arm64/configs/bcm2712_defconfig
@@ -703,6 +703,7 @@ CONFIG_TOUCHSCREEN_EXC3000=m
 CONFIG_TOUCHSCREEN_GOODIX=m
 CONFIG_TOUCHSCREEN_ILI210X=m
 CONFIG_TOUCHSCREEN_ILITEK=m
+CONFIG_TOUCHSCREEN_ILITEK_V3=m
 CONFIG_TOUCHSCREEN_EDT_FT5X06=m
 CONFIG_TOUCHSCREEN_RASPBERRYPI_FW=m
 CONFIG_TOUCHSCREEN_USB_COMPOSITE=m
@@ -1072,6 +1073,7 @@ CONFIG_DRM=m
 CONFIG_DRM_LOAD_EDID_FIRMWARE=y
 CONFIG_DRM_UDL=m
 CONFIG_DRM_PANEL_LVDS=m
+CONFIG_DRM_PANEL_ILITEK_IL79600A=m
 CONFIG_DRM_PANEL_ILITEK_ILI9806E=m
 CONFIG_DRM_PANEL_ILITEK_ILI9806E_SPI=m
 CONFIG_DRM_PANEL_ILITEK_ILI9881C=m
diff --git a/drivers/gpu/drm/panel/Kconfig b/drivers/gpu/drm/panel/Kconfig
index ce422834e2138a..edaaf7eb2f0948 100644
--- a/drivers/gpu/drm/panel/Kconfig
+++ b/drivers/gpu/drm/panel/Kconfig
@@ -228,6 +228,15 @@ config DRM_PANEL_HYDIS_HV101HD1
 
 	  If M is selected the module will be called panel-hydis-hv101hd1
 
+config DRM_PANEL_ILITEK_IL79600A
+	tristate "Ilitek ILI79960A-based panels"
+	depends on OF
+	depends on DRM_MIPI_DSI
+	depends on BACKLIGHT_CLASS_DEVICE
+	help
+	  Say Y if you want to enable support for panels based on the
+	  Ilitek ILI79960A controller.
+
 config DRM_PANEL_ILITEK_IL9322
 	tristate "Ilitek ILI9322 320x240 QVGA panels"
 	depends on OF && SPI
diff --git a/drivers/gpu/drm/panel/Makefile b/drivers/gpu/drm/panel/Makefile
index da8f5161268346..19871edb64366a 100644
--- a/drivers/gpu/drm/panel/Makefile
+++ b/drivers/gpu/drm/panel/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_DRM_PANEL_HIMAX_HX83112A) += panel-himax-hx83112a.o
 obj-$(CONFIG_DRM_PANEL_HIMAX_HX83112B) += panel-himax-hx83112b.o
 obj-$(CONFIG_DRM_PANEL_HIMAX_HX8394) += panel-himax-hx8394.o
 obj-$(CONFIG_DRM_PANEL_HYDIS_HV101HD1) += panel-hydis-hv101hd1.o
+obj-$(CONFIG_DRM_PANEL_ILITEK_IL79600A) += panel-ilitek-ili79600a.o
 obj-$(CONFIG_DRM_PANEL_ILITEK_IL9322) += panel-ilitek-ili9322.o
 obj-$(CONFIG_DRM_PANEL_ILITEK_ILI9341) += panel-ilitek-ili9341.o
 obj-$(CONFIG_DRM_PANEL_ILITEK_ILI9805) += panel-ilitek-ili9805.o
diff --git a/drivers/gpu/drm/panel/panel-ilitek-ili79600a.c b/drivers/gpu/drm/panel/panel-ilitek-ili79600a.c
new file mode 100644
index 00000000000000..b91ba5511284d7
--- /dev/null
+++ b/drivers/gpu/drm/panel/panel-ilitek-ili79600a.c
@@ -0,0 +1,467 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025, Raspberry Pi
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+
+#include <linux/gpio/consumer.h>
+#include <linux/regulator/consumer.h>
+
+#include <drm/drm_mipi_dsi.h>
+#include <drm/drm_modes.h>
+#include <drm/drm_panel.h>
+
+#include <video/mipi_display.h>
+
+struct ili79600a;
+
+struct ili79600a_desc {
+	int (*init)(struct ili79600a *ili);
+	const struct drm_display_mode *mode;
+	const unsigned long mode_flags;
+	unsigned int lanes;
+};
+
+struct ili79600a {
+	struct drm_panel	panel;
+	struct mipi_dsi_device	*dsi;
+	const struct ili79600a_desc	*desc;
+
+	struct regulator	*power;
+	struct gpio_desc	*reset;
+
+	enum drm_panel_orientation	orientation;
+};
+
+static inline struct ili79600a *panel_to_ili79600a(struct drm_panel *panel)
+{
+	return container_of(panel, struct ili79600a, panel);
+}
+
+/*
+ * The panel seems to accept some private DCS commands that map
+ * directly to registers.
+ *
+ * It is organised by page, with each page having its own set of
+ * registers, and the first page looks like it's holding the standard
+ * DCS commands.
+ *
+ * So before any attempt at sending a command or data, we have to be
+ * sure if we're in the right page or not.
+ */
+#define ILI79600A_DCS_SWITCH_PAGE	0xFF
+#define ili79600a_switch_page(ctx, page) \
+	mipi_dsi_dcs_write_seq_multi(ctx, ILI79600A_DCS_SWITCH_PAGE, \
+				     0x5A, 0xA5, (page))
+
+static int rpi_10_1_inch_init(struct ili79600a *ili)
+{
+	struct mipi_dsi_multi_context ctx = { .dsi = ili->dsi };
+
+	ili79600a_switch_page(&ctx, 0x01);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x00, 0x42);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x01, 0x11);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x02, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x03, 0x00);
+
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x04, 0x01);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x05, 0x11);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x06, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x07, 0x00);
+
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x08, 0x80);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x09, 0x01);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0a, 0x71);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0c, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0e, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0d, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0f, 0x00);
+
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x30, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x31, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x32, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x33, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x34, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x35, 0x01);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x36, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x37, 0x28);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x38, 0x29);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x39, 0x11);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3A, 0x13);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3B, 0x15);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3C, 0x17);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3D, 0x09);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3E, 0x0D);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3F, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x40, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x41, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x42, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x43, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x44, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x45, 0x02);
+
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x48, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x49, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4A, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4B, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4C, 0x07);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4D, 0x01);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4E, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4F, 0x28);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x50, 0x29);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x51, 0x10);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x52, 0x12);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x53, 0x14);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x54, 0x16);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x55, 0x08);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x56, 0x0C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x57, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x58, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x59, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x5A, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x5B, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x5C, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x5D, 0x02);
+
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x2C, 0xB0);
+
+	ili79600a_switch_page(&ctx, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x07, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x06, 0xD2);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x53, 0x1F);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x5E, 0x40);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x84, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x29, 0x3A);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x2A, 0x3B);
+
+	ili79600a_switch_page(&ctx, 0x03);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x20, 0x01);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x21, 0x3C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x22, 0xFA);
+
+	ili79600a_switch_page(&ctx, 0x12);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x87, 0x2C);
+
+	ili79600a_switch_page(&ctx, 0x05);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x61, 0x8F);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x6D, 0xBB);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x5A, 0x7C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x67, 0x7C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x54, 0x92);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x55, 0x92);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x40, 0xD2);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x46, 0x70);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x30, 0x47);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x7A, 0x89);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xA4, 0x0B);
+
+	ili79600a_switch_page(&ctx, 0x06);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xC0, 0x80);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xC1, 0x7);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xCA, 0x58);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xCB, 0x2);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xCE, 0x58);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xCF, 0x2);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x10, 0x0);
+
+	ili79600a_switch_page(&ctx, 0x0b);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x76, 0x55);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x78, 0x68);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x77, 0x0D);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x79, 0x60);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x7A, 0x10);
+
+	ili79600a_switch_page(&ctx, 0x08);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xE0, 0x00, 0x1E, 0x3F, 0x68, 0x7D,
+				     0x72, 0x86, 0x89, 0x92, 0x8E, 0xA5, 0xA8,
+				     0xAA, 0xBD, 0xB8, 0xBE, 0xC5, 0xD6, 0xCD,
+				     0xC3, 0xDA, 0xEB, 0xED);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xE1, 0x00, 0x1E, 0x3F, 0x68, 0x7D,
+				     0x72, 0x86, 0x89, 0x92, 0x8E, 0xA5, 0xA8,
+				     0xAA, 0xBD, 0xB8, 0xBE, 0xC5, 0xD6, 0xCD,
+				     0xC3, 0xDA, 0xEB, 0xED);
+
+	ili79600a_switch_page(&ctx, 0x14);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x85, 0xCC);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x87, 0x91);
+
+	ili79600a_switch_page(&ctx, 0x10);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x11, 0x3);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x12, 0x34);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x10, 0x1);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x13, 0x4);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x14, 0xBB);
+
+	ili79600a_switch_page(&ctx, 0x0b);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x94, 0x88);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x95, 0x23);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x96, 0x0B);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x97, 0x0B);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x98, 0xC6);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x99, 0xC6);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xA6, 0x47);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xA7, 0x77);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xA8, 0x5);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xA9, 0x5);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xAA, 0xBA);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xAB, 0xBA);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xBD, 0x92);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0xBE, 0xE0);
+
+	ili79600a_switch_page(&ctx, 0x0e);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0, 0x80);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x14, 0x3);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x12, 0x0);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x13, 0x4);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x11, 0x1);
+
+	ili79600a_switch_page(&ctx, 0x02);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x80, 0x11);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x82, 0x11);
+	ili79600a_switch_page(&ctx, 0x12);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x82, 0x2C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x85, 0x2C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x87, 0x2C);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x88, 0xEC);
+	ili79600a_switch_page(&ctx, 0x10);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x4, 0x1);
+	ili79600a_switch_page(&ctx, 0x11);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0C, 0x80);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x3C, 0x80);
+
+	ili79600a_switch_page(&ctx, 0x06);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0E, 0x0);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x0E, 0x3F);
+	mipi_dsi_dcs_write_seq_multi(&ctx, 0x10, 0x0);
+
+	ili79600a_switch_page(&ctx, 0x00);
+	mipi_dsi_dcs_write_seq_multi(&ctx, MIPI_DCS_SET_TEAR_ON, 0x0);
+
+	return ctx.accum_err;
+};
+
+static int ili79600a_prepare(struct drm_panel *panel)
+{
+	struct ili79600a *ili = panel_to_ili79600a(panel);
+	struct mipi_dsi_multi_context ctx = { .dsi = ili->dsi };
+	ktime_t reset_time, end;
+	s64 remaining;
+	int ret;
+
+	/* Power the panel */
+	ret = regulator_enable(ili->power);
+	if (ret)
+		return ret;
+	fsleep(20);
+
+	/* And reset it */
+	gpiod_set_value_cansleep(ili->reset, 1);
+	fsleep(20);
+
+	gpiod_set_value_cansleep(ili->reset, 0);
+	fsleep(20);
+
+	/* Software reset */
+	ili79600a_switch_page(&ctx, 0x00);
+
+	reset_time = ktime_get();
+	mipi_dsi_dcs_write(ili->dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
+	/* Must wait 5ms from releasing RESX or s/w reset) before sending other
+	 * commands.
+	 */
+	fsleep(5);
+
+	ret = ili->desc->init(ili);
+	if (ret < 0)
+		return ret;
+
+	/* Minimum 120ms between exiting reset and EXIT_SLEEP_MODE */
+	end = ktime_add_us(reset_time, 120000);
+	remaining = ktime_us_delta(end, ktime_get());
+
+	if (remaining > 0)
+		usleep_range(remaining, remaining + 1000);
+
+	mipi_dsi_dcs_write_seq_multi(&ctx, MIPI_DCS_EXIT_SLEEP_MODE, 0x0);
+	mipi_dsi_msleep(&ctx, 100);
+
+	if (ctx.accum_err)
+		return ctx.accum_err;
+
+	ret = mipi_dsi_dcs_set_display_on(ili->dsi);
+
+	return ret;
+}
+
+static int ili79600a_unprepare(struct drm_panel *panel)
+{
+	struct ili79600a *ctx = panel_to_ili79600a(panel);
+
+	mipi_dsi_dcs_set_display_off(ctx->dsi);
+	mipi_dsi_dcs_enter_sleep_mode(ctx->dsi);
+
+	regulator_disable(ctx->power);
+	gpiod_set_value_cansleep(ctx->reset, 1);
+
+	return 0;
+}
+
+static const struct drm_display_mode rpi_10_1_inch_default_mode = {
+	.clock = 166666,
+
+	.hdisplay	= 1200,
+	.hsync_start	= 1200 + 28,
+	.hsync_end	= 1200 + 28 + 10,
+	.htotal		= 1200 + 28 + 10 + 30,
+
+	.vdisplay	= 1920,
+	.vsync_start	= 1920 + 238,
+	.vsync_end	= 1920 + 238 + 4,
+	.vtotal		= 1920 + 238 + 4 + 28,
+
+	.width_mm	= 135,
+	.height_mm	= 216,
+};
+
+static int ili79600a_get_modes(struct drm_panel *panel,
+			       struct drm_connector *connector)
+{
+	struct ili79600a *ctx = panel_to_ili79600a(panel);
+	struct drm_display_mode *mode;
+
+	mode = drm_mode_duplicate(connector->dev, ctx->desc->mode);
+	if (!mode) {
+		dev_err(&ctx->dsi->dev, "failed to add mode %ux%ux@%u\n",
+			ctx->desc->mode->hdisplay,
+			ctx->desc->mode->vdisplay,
+			drm_mode_vrefresh(ctx->desc->mode));
+		return -ENOMEM;
+	}
+
+	drm_mode_set_name(mode);
+
+	mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
+	drm_mode_probed_add(connector, mode);
+
+	connector->display_info.width_mm = mode->width_mm;
+	connector->display_info.height_mm = mode->height_mm;
+
+	/*
+	 * TODO: Remove once all drm drivers call
+	 * drm_connector_set_orientation_from_panel()
+	 */
+	drm_connector_set_panel_orientation(connector, ctx->orientation);
+
+	return 1;
+}
+
+static enum drm_panel_orientation ili79600a_get_orientation(struct drm_panel *panel)
+{
+	struct ili79600a *ctx = panel_to_ili79600a(panel);
+
+	return ctx->orientation;
+}
+
+static const struct drm_panel_funcs ili79600a_funcs = {
+	.prepare	= ili79600a_prepare,
+	.unprepare	= ili79600a_unprepare,
+	.get_modes	= ili79600a_get_modes,
+	.get_orientation = ili79600a_get_orientation,
+};
+
+static int ili79600a_dsi_probe(struct mipi_dsi_device *dsi)
+{
+	struct ili79600a *ctx;
+	int ret;
+
+	ctx = devm_kzalloc(&dsi->dev, sizeof(*ctx), GFP_KERNEL);
+	if (!ctx)
+		return -ENOMEM;
+	mipi_dsi_set_drvdata(dsi, ctx);
+	ctx->dsi = dsi;
+	ctx->desc = of_device_get_match_data(&dsi->dev);
+
+	ctx->panel.prepare_prev_first = true;
+	drm_panel_init(&ctx->panel, &dsi->dev, &ili79600a_funcs,
+		       DRM_MODE_CONNECTOR_DSI);
+
+	ctx->power = devm_regulator_get(&dsi->dev, "power");
+	if (IS_ERR(ctx->power))
+		return dev_err_probe(&dsi->dev, PTR_ERR(ctx->power),
+				     "Couldn't get our power regulator\n");
+
+	ctx->reset = devm_gpiod_get_optional(&dsi->dev, "reset", GPIOD_OUT_LOW);
+	if (IS_ERR(ctx->reset))
+		return dev_err_probe(&dsi->dev, PTR_ERR(ctx->reset),
+				     "Couldn't get our reset GPIO\n");
+
+	ret = of_drm_get_panel_orientation(dsi->dev.of_node, &ctx->orientation);
+	if (ret) {
+		dev_err(&dsi->dev, "%pOF: failed to get orientation: %d\n",
+			dsi->dev.of_node, ret);
+		return ret;
+	}
+
+	ctx->panel.prepare_prev_first = true;
+
+	ret = drm_panel_of_backlight(&ctx->panel);
+	if (ret)
+		return ret;
+
+	drm_panel_add(&ctx->panel);
+
+	dsi->mode_flags = ctx->desc->mode_flags;
+	dsi->format = MIPI_DSI_FMT_RGB888;
+	dsi->lanes = ctx->desc->lanes;
+
+	ret = mipi_dsi_attach(dsi);
+	if (ret)
+		drm_panel_remove(&ctx->panel);
+
+	return ret;
+}
+
+static void ili79600a_dsi_remove(struct mipi_dsi_device *dsi)
+{
+	struct ili79600a *ctx = mipi_dsi_get_drvdata(dsi);
+
+	mipi_dsi_detach(dsi);
+	drm_panel_remove(&ctx->panel);
+
+	gpiod_set_value_cansleep(ctx->reset, 1);
+	regulator_disable(ctx->power);
+}
+
+static const struct ili79600a_desc rpi_10_1_inch_desc = {
+	.init = rpi_10_1_inch_init,
+	.mode = &rpi_10_1_inch_default_mode,
+	.mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE,
+	.lanes = 4,
+};
+
+static const struct of_device_id ili79600a_of_match[] = {
+	{ .compatible = "raspberrypi,dsi-10-1inch", &rpi_10_1_inch_desc },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, ili79600a_of_match);
+
+static struct mipi_dsi_driver ili79600a_dsi_driver = {
+	.probe	= ili79600a_dsi_probe,
+	.remove	= ili79600a_dsi_remove,
+	.driver = {
+		.name		= "ili79600a-dsi",
+		.of_match_table	= ili79600a_of_match,
+	},
+};
+module_mipi_dsi_driver(ili79600a_dsi_driver);
+
+MODULE_AUTHOR("Dave Stevenson <dave.stevenson@raspberrypi.com>");
+MODULE_DESCRIPTION("Ilitek ILI79600a Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 7d5b72ee07fa13..9d543ad267ce01 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -515,6 +515,19 @@ config TOUCHSCREEN_ILITEK
 	  To compile this driver as a module, choose M here: the
 	  module will be called ilitek_ts_i2c.
 
+config TOUCHSCREEN_ILITEK_V3
+	tristate "Ilitek I2C ILI79600 Series Touch ICs"
+	depends on I2C
+	help
+	  Say Y here if you have touchscreen with ILITEK "V3" touch IC,
+	  it supports 79600 and similar over I2C (the IC also supports
+	  SPI)
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called ilitek_v3_ts_i2c.
+
 config TOUCHSCREEN_IPROC
 	tristate "IPROC touch panel driver support"
 	depends on ARCH_BCM_IPROC || COMPILE_TEST
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index ab9abd15107883..53930469552ee8 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -54,6 +54,7 @@ obj-$(CONFIG_TOUCHSCREEN_HYNITRON_CSTXXX)	+= hynitron_cstxxx.o
 obj-$(CONFIG_TOUCHSCREEN_HYNITRON_CST816X)	+= hynitron-cst816x.o
 obj-$(CONFIG_TOUCHSCREEN_ILI210X)	+= ili210x.o
 obj-$(CONFIG_TOUCHSCREEN_ILITEK)	+= ilitek_ts_i2c.o
+obj-$(CONFIG_TOUCHSCREEN_ILITEK_V3)	+= ilitek_v3_ts_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_IMAGIS)	+= imagis.o
 obj-$(CONFIG_TOUCHSCREEN_IMX6UL_TSC)	+= imx6ul_tsc.o
 obj-$(CONFIG_TOUCHSCREEN_INEXIO)	+= inexio.o
diff --git a/drivers/input/touchscreen/ilitek_v3_ts_i2c.c b/drivers/input/touchscreen/ilitek_v3_ts_i2c.c
new file mode 100644
index 00000000000000..a02cd79b30d6ee
--- /dev/null
+++ b/drivers/input/touchscreen/ilitek_v3_ts_i2c.c
@@ -0,0 +1,761 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2026 Raspberry Pi
+ *
+ * Based on edt-ft5x06 driver.
+ */
+
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/regulator/consumer.h>
+
+#include <drm/drm_panel.h>
+
+#define ILI_V3_NAME_LEN			23
+#define ILI_V3_NAME_PREFIX_LEN		8
+
+#define ILI_V3_POLL_INTERVAL		17	/* 60fps */
+#define ILI_V3_POLL_SLEEP_INTERVAL	300	/* 3.3fps */
+#define RESET_DELAY_MS			(65 + 85)
+
+#define ILI_V3_TOUCH_PACKET_LEN		72
+#define ILI_V3_GESTURE_PACKET_LEN	221
+#define P5_X_DEMO_MODE_PACKET_INFO_LEN	3
+#define TDDI_PID_ADDR					0x4009C
+#define TDDI_SECOND_PID_ADDR				0x40098
+#define TDDI_OTP_ID_ADDR				0x400A0
+#define TDDI_ANA_ID_ADDR				0x400A4
+
+#define P5_X_DEMO_AXIS_PACKET_ID			0x5B
+#define P5_X_GESTURE_PACKET_ID				0xAA
+
+#define P5_X_NEW_CONTROL_FORMAT				0xF2
+#define P5_X_READ_DATA_CTRL				0xF6
+ #define P5_X_GET_TP_INFORMATION				0x20
+ #define P5_X_GET_KEY_INFORMATION				0x27
+ #define P5_X_GET_TOOL_VERSION					0x28
+ #define P5_X_GET_PANEL_INFORMATION				0x29
+ #define P5_X_GET_FW_VERSION					0x21
+ #define P5_X_GET_PROTOCOL_VERSION				0x22
+ #define P5_X_GET_CORE_VERSION					0x23
+ #define P5_X_GET_CORE_VERSION_NEW				0x24
+ #define P5_X_GET_REPORT_INFORMATION				0x2B
+ #define P5_X_GET_ALL_INFORMATION				0x2F
+ #define P5_X_GET_REPORT_FORMAT					0x37
+ #define P5_X_GET_BLOCK_INFOMATION				0x38
+ #define P5_X_MODE_CONTROL					0xF0
+
+#define MIN_FW_VERSION 0x8c000600U	/* Minimum of 140.0.6.0 */
+
+#define MAX_TOUCH_NUM			10
+
+struct ili_v3_ts_data {
+	struct i2c_client *client;
+	struct i2c_client *slave_addr;
+	struct input_dev *input;
+	struct touchscreen_properties prop;
+	unsigned int panel_width;
+	unsigned int panel_height;
+	struct regulator *vcc;
+	struct regulator *iovcc;
+
+	struct gpio_desc *reset_gpio;
+	struct gpio_desc *wake_gpio;
+
+	struct drm_panel_follower panel_follower;
+
+	/* Mutex to prevent suspend/resume interacting with polling */
+	struct mutex mutex;
+	int max_support_points;
+
+	char name[ILI_V3_NAME_PREFIX_LEN + ILI_V3_NAME_LEN];
+
+	int finger;
+	int curt_touch[MAX_TOUCH_NUM];
+	int prev_touch[MAX_TOUCH_NUM];
+	u8 touch_num;
+	int last_touch;
+	bool asleep;
+};
+
+struct ili_v3_i2c_chip_data {
+	int  max_support_points;
+};
+
+struct ilitek_touch_info {
+	u16 id;
+	u16 x;
+	u16 y;
+	u16 pressure;
+};
+
+struct ilitek_fw_info {
+	u8 cmd;
+	u8 dummy1;
+	u8 min_x;
+	u8 min_y;
+	u16 max_x;
+	u16 max_y;
+	u8 xch_num;
+	u8 ych_num;
+	u8 dummy2;
+	u8 dummy3;
+	u8 stx;
+	u8 srx;
+	u8 dummy4;
+	u8 dummy5;
+	u8 fw_ver[4];	/* Offset 16-19 */
+	u8 fw_mp_ver[4];	/* Offset 20-23 */
+	u8 dummy6;
+	u8 core_ver[4];	/* Offset 25-28 */
+	u8 dummy6a;
+	u8 dummy6b;
+	u8 dummy6c;
+	u32 dummy7;	/* Offset 32-35 */
+	u32 dummy8;	/* Offset 36-39 */
+	u32 dummy9;	/* Offset 40-43 */
+	u8 dummy10;
+	u8 dummy10a;
+	u8 panel_info_cmd;	/* Offset 46 */
+	u8 panel_width_high;
+	u8 panel_width_low;
+	u8 panel_height_high;
+	u8 panel_height_low;
+	u8 panel_trans_xy;	/* Offset 51 */
+};
+
+static int ili_v3_i2c_transfer(struct i2c_client *client, u8 *write_buf,
+			       int write_len, u8 *read_buf, int read_len)
+{
+	struct i2c_msg msgs[2];
+	int ret = 0;
+
+	if (write_len && write_buf) {
+		msgs[0].flags = 0;
+		msgs[0].addr  = client->addr;
+		msgs[0].len   = write_len;
+		msgs[0].buf   = write_buf;
+		ret = i2c_transfer(client->adapter, msgs, 1);
+		if (ret >= 0)
+			ret = (ret == 1 ? 0 : -EIO);
+		fsleep(1000);
+	}
+
+	if (!ret && read_len && read_buf) {
+		msgs[0].flags = I2C_M_RD;
+		msgs[0].addr  = client->addr;
+		msgs[0].len   = read_len;
+		msgs[0].buf   = read_buf;
+		ret = i2c_transfer(client->adapter, msgs, 1);
+		if (ret >= 0)
+			ret = (ret == 1 ? 0 : -EIO);
+		fsleep(1000);
+	}
+
+	if (ret)
+		dev_dbg(&client->dev, "Error transferring %d / %d : %d\n",
+			write_len, read_len, ret);
+	return ret;
+}
+
+static int ili_v3_i2c_read_u32_reg(struct i2c_client *client, u32 reg, u32 *val)
+{
+	u8 wr_buf[4];
+	int ret;
+
+	wr_buf[0] = 0x25;
+	wr_buf[1] = (char)((reg & 0x000000FF) >> 0);
+	wr_buf[2] = (char)((reg & 0x0000FF00) >> 8);
+	wr_buf[3] = (char)((reg & 0x00FF0000) >> 16);
+
+	ret = ili_v3_i2c_transfer(client, wr_buf, sizeof(wr_buf), (u8 *)val,
+				  sizeof(*val));
+
+	return ret;
+}
+
+static int ili_v3_i2c_write_u32_reg(struct i2c_client *client, u32 reg, u32 val)
+{
+	u8 wr_buf[8];
+	int ret, i;
+
+	wr_buf[0] = 0x25;
+	wr_buf[1] = (u8)((reg & 0x000000FF) >> 0);
+	wr_buf[2] = (u8)((reg & 0x0000FF00) >> 8);
+	wr_buf[3] = (u8)((reg & 0x00FF0000) >> 16);
+
+	for (i = 0; i < 4; i++)
+		wr_buf[i + 4] = (u8)(val >> (8 * i));
+
+	ret = ili_v3_i2c_transfer(client, wr_buf, sizeof(wr_buf), NULL, 0);
+
+	return ret;
+}
+
+static u8 ili_v3_calc_checksum(const u8 *packet, int len)
+{
+	int i;
+	s32 sum = 0;
+
+	for (i = 0; i < len; i++)
+		sum += packet[i];
+
+	return (u8)((-sum) & 0xFF);
+}
+
+static void ili_v3_report_ap_mode(struct ili_v3_ts_data *tsdata, u8 *buf,
+				  int len)
+{
+	struct ilitek_touch_info touch_info[MAX_TOUCH_NUM] = {0};
+	int i = 0;
+	u32 xop = 0, yop = 0;
+
+	tsdata->finger = 0;
+
+	for (i = 0; i < MAX_TOUCH_NUM; i++) {
+		if (buf[5 * i + 1 + P5_X_DEMO_MODE_PACKET_INFO_LEN] == 0xFF &&
+		    buf[5 * i + 2 + P5_X_DEMO_MODE_PACKET_INFO_LEN] == 0xFF &&
+		    buf[5 * i + 3 + P5_X_DEMO_MODE_PACKET_INFO_LEN] == 0xFF &&
+		    buf[5 * i + 4 + P5_X_DEMO_MODE_PACKET_INFO_LEN] == 0xFF) {
+			tsdata->curt_touch[i] = 0;
+			continue;
+		}
+		xop = ((buf[5 * i + 1 + P5_X_DEMO_MODE_PACKET_INFO_LEN] << 8) |
+		       (buf[5 * i + 2 + P5_X_DEMO_MODE_PACKET_INFO_LEN]));
+		yop = ((buf[5 * i + 3 + P5_X_DEMO_MODE_PACKET_INFO_LEN] << 8) |
+		       (buf[5 * i + 4 + P5_X_DEMO_MODE_PACKET_INFO_LEN]));
+
+		touch_info[tsdata->finger].x = xop;
+		touch_info[tsdata->finger].y = yop;
+
+		touch_info[tsdata->finger].id = i;
+
+		touch_info[tsdata->finger].pressure = 1;
+
+		tsdata->finger++;
+		tsdata->curt_touch[i] = 1;
+	}
+
+	if (tsdata->finger) {
+		for (i = 0; i < tsdata->finger; i++) {
+			input_report_key(tsdata->input, BTN_TOUCH, 1);
+			input_mt_slot(tsdata->input, touch_info[i].id);
+			input_mt_report_slot_state(tsdata->input,
+						   MT_TOOL_FINGER, true);
+			touchscreen_report_pos(tsdata->input, &tsdata->prop,
+					       touch_info[i].x, touch_info[i].y,
+					       true);
+			input_report_key(tsdata->input, BTN_TOOL_FINGER, 1);
+		}
+		for (i = 0; i < MAX_TOUCH_NUM; i++) {
+			if (tsdata->curt_touch[i] == 0 &&
+			    tsdata->prev_touch[i] == 1) {
+				input_mt_slot(tsdata->input, i);
+				input_mt_report_slot_state(tsdata->input,
+							   MT_TOOL_FINGER,
+							   false);
+			}
+			tsdata->prev_touch[i] = tsdata->curt_touch[i];
+		}
+		input_sync(tsdata->input);
+		tsdata->last_touch = tsdata->finger;
+	} else {
+		if (tsdata->last_touch) {
+			for (i = 0; i < MAX_TOUCH_NUM; i++) {
+				if (tsdata->curt_touch[i] == 0 &&
+				    tsdata->prev_touch[i] == 1) {
+					input_mt_slot(tsdata->input, i);
+					input_mt_report_slot_state(tsdata->input,
+								   MT_TOOL_FINGER,
+								   false);
+				}
+				tsdata->prev_touch[i] = tsdata->curt_touch[i];
+			}
+			input_report_key(tsdata->input, BTN_TOUCH, 0);
+			input_report_key(tsdata->input, BTN_TOOL_FINGER, 0);
+			input_sync(tsdata->input);
+			tsdata->last_touch = 0;
+		}
+	}
+}
+
+static void ili_v3_handle_gesture(struct ili_v3_ts_data *tsdata)
+{
+	/*
+	 * Gestures are currently only being used in low power mode to wake up,
+	 * as this touch controller doesn't generate touch data whilst the
+	 * display is disabled.
+	 * Generate the most minimal event possible that should wake up the
+	 * display.
+	 */
+	input_report_key(tsdata->input, BTN_TOUCH, 1);
+	input_mt_slot(tsdata->input, 0);
+	input_mt_report_slot_state(tsdata->input,
+				   MT_TOOL_FINGER, true);
+	input_report_key(tsdata->input, BTN_TOOL_FINGER, 1);
+	input_sync(tsdata->input);
+
+	input_mt_slot(tsdata->input, 0);
+	input_mt_report_slot_state(tsdata->input,
+				   MT_TOOL_FINGER,
+				   false);
+	input_report_key(tsdata->input, BTN_TOUCH, 0);
+	input_report_key(tsdata->input, BTN_TOOL_FINGER, 0);
+	input_sync(tsdata->input);
+}
+
+static irqreturn_t ili_v3_ts_isr(int irq, void *dev_id)
+{
+	struct ili_v3_ts_data *tsdata = dev_id;
+	u8 checksum, len, expected_len;
+	u8 rdbuf[ILI_V3_GESTURE_PACKET_LEN];
+	u8 len_offset = 2;
+
+	mutex_lock(&tsdata->mutex);
+
+	len = tsdata->asleep ? ILI_V3_GESTURE_PACKET_LEN : ILI_V3_TOUCH_PACKET_LEN;
+	ili_v3_i2c_transfer(tsdata->client, NULL, 0, rdbuf, len);
+
+	switch (rdbuf[0]) {
+	case P5_X_DEMO_AXIS_PACKET_ID:
+		expected_len = ILI_V3_TOUCH_PACKET_LEN;
+		break;
+	case P5_X_GESTURE_PACKET_ID:
+		expected_len = ILI_V3_GESTURE_PACKET_LEN;
+		len_offset = 3;
+		break;
+
+	default:
+		goto out;
+	}
+
+	if (expected_len != rdbuf[len_offset])
+		dev_err(&tsdata->client->dev, "buffer len %u when %u was expected, cmd %02x\n",
+			rdbuf[len_offset], expected_len, rdbuf[0]);
+
+	checksum = ili_v3_calc_checksum(rdbuf, rdbuf[len_offset]);
+
+	if (checksum) {
+		dev_err(&tsdata->client->dev, "checksum failed cmd %02x len %u\n",
+			rdbuf[0], rdbuf[len_offset]);
+		goto out;
+	}
+
+	switch (rdbuf[0]) {
+	case P5_X_DEMO_AXIS_PACKET_ID:
+		ili_v3_report_ap_mode(tsdata, rdbuf, ILI_V3_TOUCH_PACKET_LEN);
+		break;
+	case P5_X_GESTURE_PACKET_ID:
+		if (!tsdata->asleep)
+			break;
+
+		ili_v3_handle_gesture(tsdata);
+		break;
+	}
+
+out:
+	mutex_unlock(&tsdata->mutex);
+
+	return IRQ_HANDLED;
+}
+
+static void ili_v3_ts_work_i2c_poll(struct input_dev *input)
+{
+	struct ili_v3_ts_data *tsdata = input_get_drvdata(input);
+
+	ili_v3_ts_isr(0, tsdata);
+}
+
+static int ili_v3_ts_identify(struct ili_v3_ts_data *tsdata)
+{
+	struct i2c_client *client = tsdata->client;
+	char *model_name = tsdata->name;
+
+	snprintf(model_name, ILI_V3_NAME_PREFIX_LEN + 1, "%s ",
+		 dev_name(&client->dev));
+	model_name += strlen(model_name);
+
+	snprintf(model_name, ILI_V3_NAME_LEN, "ili_v3");
+
+	return 0;
+}
+
+static int ili_v3_init(struct ili_v3_ts_data *tsdata)
+{
+	static u8 stop_msg[2] = { 0x10, 0x10 };
+	static u8 cmd_open_msg[4] = { 0x25, 0x62, 0x10, 0x18 };
+	static u8 slave_mode[5] = { 0x25, 0x00, 0x10, 0x04, 0x01};
+	static u8 slave_mode2[5] = { 0x25, 0x03, 0x10, 0x04, 0x00};
+	static u8 read_protocol_ver[2] = {P5_X_READ_DATA_CTRL,
+					  P5_X_GET_PROTOCOL_VERSION};
+	static u8 read_all_info[1] = {P5_X_GET_ALL_INFORMATION};
+	static u8 set_tp_data_len[3] = {P5_X_NEW_CONTROL_FORMAT, 0x00, 0x03};
+	struct i2c_client *master_client = tsdata->client;
+	struct i2c_client *slave_client = tsdata->slave_addr;
+	u8 rd_buf[97];
+	struct ilitek_fw_info *fw_info = (struct ilitek_fw_info *)rd_buf;
+	u32 value;
+
+	if (tsdata->reset_gpio) {
+		usleep_range(5000, 6000);
+		/* Come out of reset */
+		gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
+		msleep(RESET_DELAY_MS);
+	}
+
+	ili_v3_i2c_transfer(master_client, stop_msg, sizeof(stop_msg), NULL, 0);
+
+	ili_v3_i2c_transfer(master_client, cmd_open_msg, sizeof(cmd_open_msg), NULL, 0);
+
+	ili_v3_i2c_transfer(slave_client, slave_mode, sizeof(slave_mode), NULL, 0);
+	ili_v3_i2c_transfer(slave_client, slave_mode2, sizeof(slave_mode2), NULL, 0);
+
+	ili_v3_i2c_transfer(master_client, cmd_open_msg, sizeof(cmd_open_msg), NULL, 0);
+
+	ili_v3_i2c_transfer(master_client, slave_mode, sizeof(slave_mode), NULL, 0);
+	ili_v3_i2c_transfer(master_client, slave_mode2, sizeof(slave_mode2), NULL, 0);
+
+	ili_v3_i2c_write_u32_reg(master_client, 0x051024, 0xa5a5a5a5);
+	ili_v3_i2c_read_u32_reg(master_client, 0x051024, &value);
+	if (value != 0xa5a5a5a5)
+		dev_err(&master_client->dev, "dummy read didn't match - %08x\n",
+			value);
+
+	ili_v3_i2c_read_u32_reg(slave_client, TDDI_PID_ADDR, &value);
+	dev_info(&master_client->dev, "Slave PIDADDR %08x\n", value);
+	ili_v3_i2c_read_u32_reg(slave_client, TDDI_SECOND_PID_ADDR, &value);
+	dev_info(&master_client->dev, "Slave TDDI_SECOND_PID_ADDR %08x\n", value);
+
+	ili_v3_i2c_read_u32_reg(master_client, TDDI_PID_ADDR, &value);
+	dev_info(&master_client->dev, "Master PIDADDR %08x\n", value);
+	ili_v3_i2c_read_u32_reg(master_client, TDDI_SECOND_PID_ADDR, &value);
+	dev_info(&master_client->dev, "Master TDDI_SECOND_PID_ADDR %08x\n", value);
+	ili_v3_i2c_read_u32_reg(master_client, TDDI_OTP_ID_ADDR, &value);
+	dev_info(&master_client->dev, "Master TDDI_OTP_ID_ADDR %08x\n", value);
+	ili_v3_i2c_read_u32_reg(master_client, TDDI_ANA_ID_ADDR, &value);
+	dev_info(&master_client->dev, "Master TDDI_ANA_ID_ADDR %08x\n", value);
+
+	if (tsdata->reset_gpio) {
+		mdelay(1);
+		gpiod_set_value_cansleep(tsdata->reset_gpio, 1);
+		mdelay(5);
+		gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
+		msleep(RESET_DELAY_MS);
+	}
+
+	ili_v3_i2c_transfer(master_client, read_protocol_ver, 2, NULL, 0);
+	ili_v3_i2c_transfer(master_client, &read_protocol_ver[1], 1, rd_buf, 4);
+	dev_info(&master_client->dev, "protocol version is %08x\n",
+		 *((u32 *)rd_buf));
+
+	ili_v3_i2c_transfer(master_client, read_all_info, 1, rd_buf, 97);
+
+	if (be32_to_cpu(*(unsigned int *)fw_info->fw_ver) < MIN_FW_VERSION)
+		dev_err(&master_client->dev, "Firmware version %u.%u.%u.%u is older than expected. Minimum %u.%u.%u.%u\n",
+			fw_info->fw_ver[0], fw_info->fw_ver[1],
+			fw_info->fw_ver[2], fw_info->fw_ver[3],
+			(MIN_FW_VERSION >> 24) & 0xff, (MIN_FW_VERSION >> 16) & 0xff,
+			(MIN_FW_VERSION >> 8) & 0xff, MIN_FW_VERSION & 0xff);
+
+	dev_info(&master_client->dev, "FW AP Version %u.%u.%u.%u\n",
+		 fw_info->fw_ver[0], fw_info->fw_ver[1], fw_info->fw_ver[2],
+		 fw_info->fw_ver[3]);
+	dev_info(&master_client->dev, "FW MP Version %u.%u.%u.%u\n",
+		 fw_info->fw_mp_ver[0], fw_info->fw_mp_ver[1],
+		 fw_info->fw_mp_ver[2], fw_info->fw_mp_ver[3]);
+	dev_info(&master_client->dev, "Core Version %u.%u.%u.%u\n",
+		 fw_info->core_ver[0], fw_info->core_ver[1],
+		 fw_info->core_ver[2], fw_info->core_ver[3]);
+
+	if (fw_info->panel_info_cmd == P5_X_GET_PANEL_INFORMATION) {
+		tsdata->panel_width = (fw_info->panel_width_high << 8) |
+				      fw_info->panel_width_low;
+		tsdata->panel_height = (fw_info->panel_height_high << 8) |
+				       fw_info->panel_height_low;
+
+		dev_info(&master_client->dev, "Configured size %u x %u%s\n",
+			 tsdata->panel_width, tsdata->panel_height,
+			 fw_info->panel_trans_xy ? " swapxy" : "");
+	}
+
+	ili_v3_i2c_transfer(master_client, set_tp_data_len, sizeof(set_tp_data_len),
+			    NULL, 0);
+
+	ili_v3_ts_identify(tsdata);
+
+	return 0;
+}
+
+static void ili_v3_disable_regulators(void *arg)
+{
+	struct ili_v3_ts_data *data = arg;
+
+	regulator_disable(data->vcc);
+	regulator_disable(data->iovcc);
+}
+
+static int ili_v3_ts_suspend(struct drm_panel_follower *follower)
+{
+	struct ili_v3_ts_data *tsdata = container_of(follower,
+						     struct ili_v3_ts_data,
+						     panel_follower);
+	static u8 pll_wakeup[] = { 0xA3 };
+	static u8 gesture_symbol_msg[] = { 0x01, 0x0a, 0x08, 0xff, 0xff, 0xff };
+	static u8 gesture_msg[] = { 0x01, 0x0a, 0x02 };
+
+	mutex_lock(&tsdata->mutex);
+
+	input_set_poll_interval(tsdata->input, ILI_V3_POLL_SLEEP_INTERVAL);
+
+	ili_v3_i2c_transfer(tsdata->client, pll_wakeup, sizeof(pll_wakeup),
+			    NULL, 0);
+
+	ili_v3_i2c_transfer(tsdata->client, gesture_symbol_msg,
+			    sizeof(gesture_symbol_msg), NULL, 0);
+	ili_v3_i2c_transfer(tsdata->client, gesture_msg, sizeof(gesture_msg),
+			    NULL, 0);
+
+	tsdata->asleep = true;
+	mutex_unlock(&tsdata->mutex);
+
+	return 0;
+}
+
+static int ili_v3_ts_resume(struct drm_panel_follower *follower)
+{
+	struct ili_v3_ts_data *tsdata = container_of(follower,
+						     struct ili_v3_ts_data,
+						     panel_follower);
+	mutex_lock(&tsdata->mutex);
+
+	tsdata->asleep = false;
+
+	gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
+	mdelay(1);
+	gpiod_set_value_cansleep(tsdata->reset_gpio, 1);
+	mdelay(5);
+	gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
+	msleep(RESET_DELAY_MS);
+
+	input_set_poll_interval(tsdata->input, ILI_V3_POLL_INTERVAL);
+
+	mutex_unlock(&tsdata->mutex);
+
+	return 0;
+}
+
+static const struct drm_panel_follower_funcs ili_v3_follower_funcs = {
+	.panel_prepared = ili_v3_ts_resume,
+	.panel_unpreparing = ili_v3_ts_suspend,
+};
+
+static int ili_v3_ts_probe(struct i2c_client *client)
+{
+	const struct i2c_device_id *id = i2c_client_get_device_id(client);
+	const struct ili_v3_i2c_chip_data *chip_data;
+	struct ili_v3_ts_data *tsdata;
+	struct input_dev *input;
+	unsigned long irq_flags;
+	int error;
+
+	tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL);
+	if (!tsdata)
+		return -ENOMEM;
+
+	tsdata->client = client;
+	i2c_set_clientdata(client, tsdata);
+
+	chip_data = device_get_match_data(&client->dev);
+	if (!chip_data)
+		chip_data = (const struct ili_v3_i2c_chip_data *)id->driver_data;
+	if (!chip_data || !chip_data->max_support_points) {
+		dev_err(&client->dev, "invalid or missing chip data\n");
+		return -EINVAL;
+	}
+
+	tsdata->max_support_points = chip_data->max_support_points;
+
+	tsdata->vcc = devm_regulator_get(&client->dev, "vcc");
+	if (IS_ERR(tsdata->vcc))
+		return dev_err_probe(&client->dev, PTR_ERR(tsdata->vcc),
+				     "failed to request regulator\n");
+
+	tsdata->iovcc = devm_regulator_get(&client->dev, "iovcc");
+	if (IS_ERR(tsdata->iovcc)) {
+		error = PTR_ERR(tsdata->iovcc);
+		if (error != -EPROBE_DEFER)
+			dev_err(&client->dev,
+				"failed to request iovcc regulator: %d\n", error);
+		return error;
+	}
+
+	tsdata->slave_addr = i2c_new_dummy_device(client->adapter, 0x4f);
+	if (IS_ERR(tsdata->slave_addr))
+		return PTR_ERR(tsdata->slave_addr);
+
+	error = regulator_enable(tsdata->iovcc);
+	if (error < 0) {
+		dev_err(&client->dev, "failed to enable iovcc: %d\n", error);
+		goto fail_release_i2c;
+	}
+
+	/* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
+	usleep_range(10, 100);
+
+	error = regulator_enable(tsdata->vcc);
+	if (error < 0) {
+		dev_err(&client->dev, "failed to enable vcc: %d\n", error);
+		regulator_disable(tsdata->iovcc);
+		goto fail_release_i2c;
+	}
+	msleep(100);
+	error = devm_add_action_or_reset(&client->dev,
+					 ili_v3_disable_regulators,
+					 tsdata);
+	if (error) {
+		regulator_disable(tsdata->iovcc);
+		regulator_disable(tsdata->vcc);
+		goto fail_release_i2c;
+	}
+
+	tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev,
+						     "reset", GPIOD_OUT_HIGH);
+	if (IS_ERR(tsdata->reset_gpio)) {
+		error = PTR_ERR(tsdata->reset_gpio);
+		dev_err(&client->dev,
+			"Failed to request GPIO reset pin, error %d\n", error);
+		goto fail_release_i2c;
+	}
+
+	mutex_init(&tsdata->mutex);
+	tsdata->client = client;
+	i2c_set_clientdata(client, tsdata);
+
+	error = ili_v3_init(tsdata);
+	if (error) {
+		dev_err(&client->dev, "touchscreen probe failed\n");
+		goto fail_release_i2c;
+	}
+
+	tsdata->panel_follower.funcs = &ili_v3_follower_funcs;
+
+	input = devm_input_allocate_device(&client->dev);
+	if (!input) {
+		dev_err(&client->dev, "failed to allocate input device.\n");
+		error = -ENOMEM;
+		goto fail_reset_gpio;
+	}
+	tsdata->input = input;
+
+	input->name = tsdata->name;
+	input->id.bustype = BUS_I2C;
+	input->dev.parent = &client->dev;
+	input_set_drvdata(input, tsdata);
+
+	input_set_abs_params(input, ABS_MT_POSITION_X,
+			     0, tsdata->panel_width - 1, 0, 0);
+	input_set_abs_params(input, ABS_MT_POSITION_Y,
+			     0, tsdata->panel_height - 1, 0, 0);
+
+	touchscreen_parse_properties(input, true, &tsdata->prop);
+
+	error = input_mt_init_slots(input, tsdata->max_support_points,
+				    INPUT_MT_DIRECT);
+	if (error) {
+		dev_err(&client->dev, "Unable to init MT slots.\n");
+		goto fail_reset_gpio;
+	}
+
+	if (client->irq) {
+		irq_flags = irq_get_trigger_type(client->irq);
+		if (irq_flags == IRQF_TRIGGER_NONE)
+			irq_flags = IRQF_TRIGGER_FALLING;
+		irq_flags |= IRQF_ONESHOT;
+
+		error = devm_request_threaded_irq(&client->dev, client->irq,
+						  NULL, ili_v3_ts_isr,
+						  irq_flags, client->name,
+						  tsdata);
+		if (error) {
+			dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
+			goto fail_reset_gpio;
+		}
+	} else {
+		error = input_setup_polling(input, ili_v3_ts_work_i2c_poll);
+		if (error) {
+			dev_err(&client->dev, "could not set up polling mode, %d\n",
+				error);
+			goto fail_reset_gpio;
+		}
+
+		input_set_poll_interval(input, ILI_V3_POLL_INTERVAL);
+	}
+
+	error = input_register_device(input);
+	if (error)
+		goto fail_reset_gpio;
+
+	error = drm_panel_add_follower(&client->dev, &tsdata->panel_follower);
+	if (error) {
+		dev_err(&client->dev, "Failed to add panel follower - %d\n", error);
+		goto fail_reset_gpio;
+	}
+
+	return 0;
+
+fail_reset_gpio:
+	gpiod_set_value_cansleep(tsdata->reset_gpio, 1);
+fail_release_i2c:
+	i2c_unregister_device(tsdata->slave_addr);
+
+	return error;
+}
+
+static void ili_v3_remove(struct i2c_client *client)
+{
+	struct ili_v3_ts_data *tsdata = i2c_get_clientdata(client);
+
+	gpiod_set_value_cansleep(tsdata->reset_gpio, 1);
+	drm_panel_remove_follower(&tsdata->panel_follower);
+	i2c_unregister_device(tsdata->slave_addr);
+}
+
+static const struct ili_v3_i2c_chip_data ili_v3_data = {
+	.max_support_points = 10,
+};
+
+static const struct i2c_device_id ili_v3_ts_id[] = {
+	{ .name = "ili79600a", .driver_data = (long)&ili_v3_data },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(i2c, ili_v3_ts_id);
+
+static const struct of_device_id ili_v3_of_match[] = {
+	{ .compatible = "ilitek,ili79600a", .data = &ili_v3_data },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, ili_v3_of_match);
+
+static struct i2c_driver ili_v3_ts_driver = {
+	.driver = {
+		.name = "ilitek_v3",
+		.of_match_table = ili_v3_of_match,
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
+	},
+	.id_table = ili_v3_ts_id,
+	.probe    = ili_v3_ts_probe,
+	.remove   = ili_v3_remove,
+};
+
+module_i2c_driver(ili_v3_ts_driver);
+
+MODULE_AUTHOR("Dave Stevenson <dave.stevenson@raspberrypi.com>");
+MODULE_DESCRIPTION("Ilitek V3 I2C Touchscreen Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/rpi-panel-v2-regulator.c b/drivers/regulator/rpi-panel-v2-regulator.c
index 30b78aa75ee386..f9446dd92ea6eb 100644
--- a/drivers/regulator/rpi-panel-v2-regulator.c
+++ b/drivers/regulator/rpi-panel-v2-regulator.c
@@ -48,7 +48,10 @@ static int rpi_panel_v2_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
 		return regmap_write(regmap, REG_PWM, 0);
 
 	duty = pwm_get_relative_duty_cycle(state, PWM_BL_MASK);
-	return regmap_write(regmap, REG_PWM, duty | PWM_BL_ENABLE);
+	if (duty)
+		duty |= PWM_BL_ENABLE;
+
+	return regmap_write(regmap, REG_PWM, duty);
 }
 
 static const struct pwm_ops rpi_panel_v2_pwm_ops = {