[PATCH v2 0/7] Add u-boot splash screen support for AM62x.

[PATCH v2 0/7] Add u-boot splash screen support for AM62x.

[Nikhil M Jain]

Enable TI Display Subsystem(TIDSS) driver as UCLASS_VIDEO. Enable
splash screen support, to display TI logo during boot-up. Tested
on microtips panel (Model No: 13-101HIEBCAF0-S) supported by AM62x.

The changes in patch 4 depends on the patch sent for addition of
am62x.env file to set environment variables for AM62x.

link: https://lore.kernel.org/u-boot/20230124155023.GI631605@bill-the-cat/

Changes in v2:
- Added smaller logo files  
- Dropped uclass_get_device_by_name in board_init  
- Add test for decode_panel_timing  

link to v1: https://lore.kernel.org/u-boot/20230123080615.9217-1-n-jain1@ti.com/

Nikhil M Jain (7):
  drivers: core: ofnode: Add panel timing decode.
  test: dm: test-fdt: Add decode_panel_timing test
  drivers: video: simple_panel: make simple panel independent of
    backlight
  drivers: video: tidss: TIDSS video driver support for AM62x
  board: ti: am62x: am62x: Add splash screen env variables
  board: ti: am62x: evm: Add splash screen support
  tools: logos: Add TI logo files

 MAINTAINERS                      |   1 +
 arch/sandbox/dts/test.dts        |  18 +
 board/ti/am62x/am62x.env         |   5 +
 board/ti/am62x/evm.c             |  25 +-
 drivers/core/ofnode.c            |  47 ++
 drivers/core/read.c              |   6 +
 drivers/video/Kconfig            |   2 +
 drivers/video/Makefile           |   1 +
 drivers/video/simple_panel.c     |   7 +-
 drivers/video/tidss/Kconfig      |  18 +
 drivers/video/tidss/Makefile     |  12 +
 drivers/video/tidss/tidss_drv.c  | 943 +++++++++++++++++++++++++++++++
 drivers/video/tidss/tidss_drv.h  | 137 +++++
 drivers/video/tidss/tidss_regs.h | 292 ++++++++++
 include/dm/ofnode.h              |  12 +
 include/dm/read.h                |  14 +
 test/dm/test-fdt.c               |  35 ++
 tools/logos/ti.bmp               | Bin 0 -> 160770 bytes
 tools/logos/ti.gz                | Bin 0 -> 12285 bytes
 19 files changed, 1570 insertions(+), 5 deletions(-)
 create mode 100644 drivers/video/tidss/Kconfig
 create mode 100644 drivers/video/tidss/Makefile
 create mode 100644 drivers/video/tidss/tidss_drv.c
 create mode 100644 drivers/video/tidss/tidss_drv.h
 create mode 100644 drivers/video/tidss/tidss_regs.h
 create mode 100644 tools/logos/ti.bmp
 create mode 100644 tools/logos/ti.gz

-- 
2.34.1

[PATCH v2 1/7] drivers: core: ofnode: Add panel timing decode.

[Nikhil M Jain]

ofnode_decode_display_timing supports reading timing parameters from
subnode of display-timings node, for displays supporting multiple
resolution, in case if a display supports single resolution, it fails
reading directly from display-timings node, to support it
ofnode_decode_panel_timing is added.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
---
 drivers/core/ofnode.c | 47 +++++++++++++++++++++++++++++++++++++++++++
 drivers/core/read.c   |  6 ++++++
 include/dm/ofnode.h   | 12 +++++++++++
 include/dm/read.h     | 14 +++++++++++++
 4 files changed, 79 insertions(+)

diff --git a/drivers/core/ofnode.c b/drivers/core/ofnode.c
index 4d56b1a767..d08578e9c4 100644
--- a/drivers/core/ofnode.c
+++ b/drivers/core/ofnode.c
@@ -991,6 +991,53 @@ int ofnode_decode_display_timing(ofnode parent, int index,
 	return ret;
 }
 
+int ofnode_decode_panel_timing(ofnode parent,
+			       struct display_timing *dt)
+{
+	ofnode timings;
+	u32 val = 0;
+	int ret = 0;
+
+	timings = ofnode_find_subnode(parent, "panel-timings");
+	if (!ofnode_valid(timings))
+		return -EINVAL;
+	memset(dt, 0, sizeof(*dt));
+	ret |= decode_timing_property(timings, "hback-porch", &dt->hback_porch);
+	ret |= decode_timing_property(timings, "hfront-porch", &dt->hfront_porch);
+	ret |= decode_timing_property(timings, "hactive", &dt->hactive);
+	ret |= decode_timing_property(timings, "hsync-len", &dt->hsync_len);
+	ret |= decode_timing_property(timings, "vback-porch", &dt->vback_porch);
+	ret |= decode_timing_property(timings, "vfront-porch", &dt->vfront_porch);
+	ret |= decode_timing_property(timings, "vactive", &dt->vactive);
+	ret |= decode_timing_property(timings, "vsync-len", &dt->vsync_len);
+	ret |= decode_timing_property(timings, "clock-frequency", &dt->pixelclock);
+	dt->flags = 0;
+	if (!ofnode_read_u32(timings, "vsync-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
+		    DISPLAY_FLAGS_VSYNC_LOW;
+	}
+	if (!ofnode_read_u32(timings, "hsync-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
+		    DISPLAY_FLAGS_HSYNC_LOW;
+	}
+	if (!ofnode_read_u32(timings, "de-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
+		    DISPLAY_FLAGS_DE_LOW;
+	}
+	if (!ofnode_read_u32(timings, "pixelclk-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
+		DISPLAY_FLAGS_PIXDATA_NEGEDGE;
+	}
+	if (ofnode_read_bool(timings, "interlaced"))
+		dt->flags |= DISPLAY_FLAGS_INTERLACED;
+	if (ofnode_read_bool(timings, "doublescan"))
+		dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
+	if (ofnode_read_bool(timings, "doubleclk"))
+		dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
+
+	return ret;
+}
+
 const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
 {
 	if (ofnode_is_np(node))
diff --git a/drivers/core/read.c b/drivers/core/read.c
index 3e5fea87d8..e0543bbad5 100644
--- a/drivers/core/read.c
+++ b/drivers/core/read.c
@@ -420,6 +420,12 @@ int dev_decode_display_timing(const struct udevice *dev, int index,
 	return ofnode_decode_display_timing(dev_ofnode(dev), index, config);
 }
 
+int dev_decode_panel_timing(const struct udevice *dev,
+			    struct display_timing *config)
+{
+	return ofnode_decode_panel_timing(dev_ofnode(dev), config);
+}
+
 ofnode dev_get_phy_node(const struct udevice *dev)
 {
 	return ofnode_get_phy_node(dev_ofnode(dev));
diff --git a/include/dm/ofnode.h b/include/dm/ofnode.h
index fa9865602d..3f6b0843c5 100644
--- a/include/dm/ofnode.h
+++ b/include/dm/ofnode.h
@@ -974,6 +974,18 @@ struct display_timing;
 int ofnode_decode_display_timing(ofnode node, int index,
 				 struct display_timing *config);
 
+/**
+ * ofnode_decode_panel_timing() - decode display timings
+ *
+ * Decode panel timings from the supplied 'panel-timings' node.
+ *
+ * @node:	'display-timing' node containing the timing subnodes
+ * @config:	Place to put timings
+ * Return: 0 if OK, -FDT_ERR_NOTFOUND if not found
+ */
+int ofnode_decode_panel_timing(ofnode node,
+			       struct display_timing *config);
+
 /**
  * ofnode_get_property() - get a pointer to the value of a node property
  *
diff --git a/include/dm/read.h b/include/dm/read.h
index cc4f16196f..107d28e956 100644
--- a/include/dm/read.h
+++ b/include/dm/read.h
@@ -784,6 +784,20 @@ int dev_read_pci_bus_range(const struct udevice *dev, struct resource *res);
 int dev_decode_display_timing(const struct udevice *dev, int index,
 			      struct display_timing *config);
 
+/**
+ * dev_decode_panel_timing() - decode panel timings
+ *
+ * Decode display timings from the supplied 'panel-timings' node.
+ *
+ * @dev: device to read DT display timings from. The node linked to the device
+ *       contains a child node called 'display-timings' which in turn contains
+ *       one or more display timing nodes.
+ * @config: place to put timings
+ * Return: 0 if OK, -FDT_ERR_NOTFOUND if not found
+ */
+int dev_decode_panel_timing(const struct udevice *dev,
+			    struct display_timing *config);
+
 /**
  * dev_get_phy_node() - Get PHY node for a MAC (if not fixed-link)
  *
-- 
2.34.1

[PATCH v2 2/7] test: dm: test-fdt: Add decode_panel_timing test

[Nikhil M Jain]

To test decode_panel_timing add a panel-timings node
and a DM test for decode panel timingd by matching
the panel timing node parameters.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
---
 arch/sandbox/dts/test.dts | 18 ++++++++++++++++++
 test/dm/test-fdt.c        | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+)

diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
index 8c05927670..f98f0152ee 100644
--- a/arch/sandbox/dts/test.dts
+++ b/arch/sandbox/dts/test.dts
@@ -342,6 +342,24 @@
 				vsync-len = <13>;
 			};
 		};
+		panel-timings {
+			clock-frequency = <6500000>;
+			hactive = <240>;
+			vactive = <320>;
+			hfront-porch = <6>;
+			hback-porch = <7>;
+			hsync-len = <1>;
+			vback-porch = <5>;
+			vfront-porch = <8>;
+			vsync-len = <2>;
+			hsync-active = <1>;
+			vsync-active = <0>;
+			de-active = <1>;
+			pixelclk-active = <1>;
+			interlaced;
+			doublescan;
+			doubleclk;
+		};
 	};
 
 	junk {
diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index 7cd2d04612..b02c088060 100644
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -1157,6 +1157,41 @@ static int dm_test_decode_display_timing(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_decode_display_timing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
+/* Test dev_decode_panel_timing() */
+static int dm_test_decode_panel_timing(struct unit_test_state *uts)
+{
+	struct udevice *dev;
+	struct display_timing timing;
+
+	ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
+	ut_asserteq_str("a-test", dev->name);
+
+	ut_assertok(dev_decode_panel_timing(dev, &timing));
+	ut_assert(timing.hactive.typ == 240);
+	ut_assert(timing.hback_porch.typ == 7);
+	ut_assert(timing.hfront_porch.typ == 6);
+	ut_assert(timing.hsync_len.typ == 1);
+	ut_assert(timing.vactive.typ == 320);
+	ut_assert(timing.vback_porch.typ == 5);
+	ut_assert(timing.vfront_porch.typ == 8);
+	ut_assert(timing.vsync_len.typ == 2);
+	ut_assert(timing.pixelclock.typ == 6500000);
+	ut_assert(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH);
+	ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_LOW));
+	ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH));
+	ut_assert(timing.flags & DISPLAY_FLAGS_VSYNC_LOW);
+	ut_assert(timing.flags & DISPLAY_FLAGS_DE_HIGH);
+	ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_LOW));
+	ut_assert(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE);
+	ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE));
+	ut_assert(timing.flags & DISPLAY_FLAGS_INTERLACED);
+	ut_assert(timing.flags & DISPLAY_FLAGS_DOUBLESCAN);
+	ut_assert(timing.flags & DISPLAY_FLAGS_DOUBLECLK);
+
+	return 0;
+}
+DM_TEST(dm_test_decode_panel_timing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+
 /* Test read_resourcee() */
 static int dm_test_read_resource(struct unit_test_state *uts)
 {
-- 
2.34.1

[PATCH v2 3/7] drivers: video: simple_panel: make simple panel independent of backlight

[Nikhil M Jain]

This patch updates the necessary Kconfigs to make simple panel
driver independent of backlight driver  and compiling backlight
related code in simple-panel driver conditionally to when user
has set CONFIG_BACKLIGHT.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
---
 drivers/video/simple_panel.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/drivers/video/simple_panel.c b/drivers/video/simple_panel.c
index c8f7022ea6..91c91ee75d 100644
--- a/drivers/video/simple_panel.c
+++ b/drivers/video/simple_panel.c
@@ -63,12 +63,15 @@ static int simple_panel_of_to_plat(struct udevice *dev)
 				return ret;
 		}
 	}
+
 	ret = uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
-					   "backlight", &priv->backlight);
+						   "backlight", &priv->backlight);
 	if (ret) {
 		debug("%s: Cannot get backlight: ret=%d\n", __func__, ret);
-		return log_ret(ret);
+		if (ret != -ENOENT)
+			return log_ret(ret);
 	}
+
 	ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
 				   GPIOD_IS_OUT);
 	if (ret) {
-- 
2.34.1

[PATCH v2 4/7] drivers: video: tidss: TIDSS video driver support for AM62x

[Nikhil M Jain]

Added tidss video driver support which enables display
on oldi panel using AM62x, it creates a simple pipeline
framebuffer==>vidl1==>ovr1==>vp1==>oldi_panel and
calculates clock rates for panel from panel node in
device tree.

To compile TIDSS when user sets CONFIG_VIDEO_TIDSS
add rule in Makefile. Include tidss folder location
in Kconfig.

TIDSS is ported from linux kernel version 5.10.145

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
---
 MAINTAINERS                      |   1 +
 drivers/video/Kconfig            |   2 +
 drivers/video/Makefile           |   1 +
 drivers/video/tidss/Kconfig      |  18 +
 drivers/video/tidss/Makefile     |  12 +
 drivers/video/tidss/tidss_drv.c  | 943 +++++++++++++++++++++++++++++++
 drivers/video/tidss/tidss_drv.h  | 137 +++++
 drivers/video/tidss/tidss_regs.h | 292 ++++++++++
 8 files changed, 1406 insertions(+)
 create mode 100644 drivers/video/tidss/Kconfig
 create mode 100644 drivers/video/tidss/Makefile
 create mode 100644 drivers/video/tidss/tidss_drv.c
 create mode 100644 drivers/video/tidss/tidss_drv.h
 create mode 100644 drivers/video/tidss/tidss_regs.h

diff --git a/MAINTAINERS b/MAINTAINERS
index 2dd2b46fcd..ceb694679f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -645,6 +645,7 @@ F:	drivers/soc/ti/
 F:	drivers/sysreset/sysreset-ti-sci.c
 F:	drivers/thermal/ti-bandgap.c
 F:	drivers/timer/omap-timer.c
+F:	drivers/video/tidss/
 F:	drivers/watchdog/omap_wdt.c
 F:	include/linux/pruss_driver.h
 F:	include/linux/soc/ti/
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 440b161b84..40465ebea7 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -634,6 +634,8 @@ config VIDEO_SANDBOX_SDL
 
 source "drivers/video/stm32/Kconfig"
 
+source "drivers/video/tidss/Kconfig"
+
 config VIDEO_TEGRA20
 	bool "Enable LCD support on Tegra20"
 	depends on OF_CONTROL
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 40a871d638..4c14cc2663 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -26,6 +26,7 @@ obj-${CONFIG_EXYNOS_FB} += exynos/
 obj-${CONFIG_VIDEO_ROCKCHIP} += rockchip/
 obj-${CONFIG_VIDEO_STM32} += stm32/
 obj-${CONFIG_VIDEO_TEGRA124} += tegra124/
+obj-${CONFIG_VIDEO_TIDSS} += tidss/
 
 obj-$(CONFIG_ATMEL_HLCD) += atmel_hlcdfb.o
 obj-$(CONFIG_ATMEL_LCD) += atmel_lcdfb.o
diff --git a/drivers/video/tidss/Kconfig b/drivers/video/tidss/Kconfig
new file mode 100644
index 0000000000..2a5e56ea4e
--- /dev/null
+++ b/drivers/video/tidss/Kconfig
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# (C) Copyright 2023 Texas Instruments Incorporated - https://www.ti.com/
+# Nikhil M Jain, n-jain1@ti.com
+#
+# based on the linux tidss driver, which is
+#
+# (C) Copyright 2018 Texas Instruments Incorporated - https://www.ti.com/
+# Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
+
+menuconfig VIDEO_TIDSS
+	bool "Enable TIDSS video support"
+	depends on VIDEO
+	help
+	  TIDSS supports  video output options LVDS and
+	  DPI . This option enables these supports which can be used on
+	  devices which have OLDI or HDMI display connected.
+
diff --git a/drivers/video/tidss/Makefile b/drivers/video/tidss/Makefile
new file mode 100644
index 0000000000..f4f8c6c470
--- /dev/null
+++ b/drivers/video/tidss/Makefile
@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: GPL-2.0+
+#
+# (C) Copyright 2023 Texas Instruments Incorporated - https://www.ti.com/
+# Nikhil M Jain, n-jain1@ti.com
+#
+# based on the linux tidss driver, which is
+#
+# (C) Copyright 2018 Texas Instruments Incorporated - https://www.ti.com/
+# Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
+
+
+obj-${CONFIG_VIDEO_TIDSS} = tidss_drv.o
diff --git a/drivers/video/tidss/tidss_drv.c b/drivers/video/tidss/tidss_drv.c
new file mode 100644
index 0000000000..078e3e82e3
--- /dev/null
+++ b/drivers/video/tidss/tidss_drv.c
@@ -0,0 +1,943 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * (C) Copyright 2023 Texas Instruments Incorporated - https://www.ti.com/
+ * Nikhil M Jain, n-jain1@ti.com
+ *
+ * based on the linux tidss driver, which is
+ *
+ * (C) Copyright 2018 Texas Instruments Incorporated - https://www.ti.com/
+ * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <clk.h>
+#include <log.h>
+#include <video.h>
+#include <errno.h>
+#include <panel.h>
+#include <reset.h>
+#include <malloc.h>
+#include <fdtdec.h>
+#include <syscon.h>
+#include <regmap.h>
+#include <cpu_func.h>
+#include <media_bus_format.h>
+
+#include <asm/io.h>
+#include <asm/cache.h>
+#include <asm/utils.h>
+#include <asm/bitops.h>
+
+#include <dm/devres.h>
+#include <dm/of_access.h>
+#include <dm/device_compat.h>
+#include <dm/device-internal.h>
+
+#include <linux/bug.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/iopoll.h>
+
+#include "tidss_drv.h"
+#include "tidss_regs.h"
+
+DECLARE_GLOBAL_DATA_PTR;
+
+/* Panel parameters */
+enum {
+	LCD_MAX_WIDTH		= 1920,
+	LCD_MAX_HEIGHT		= 1200,
+	LCD_MAX_LOG2_BPP	= VIDEO_BPP32,
+};
+
+static const u16 *dss_common_regmap;
+
+static const u16 tidss_am62x_common_regs[DSS_COMMON_REG_TABLE_LEN] = {
+	[DSS_REVISION_OFF] =			0x4,
+	[DSS_SYSCONFIG_OFF] =			0x8,
+	[DSS_SYSSTATUS_OFF] =			0x20,
+	[DSS_IRQ_EOI_OFF] =			0x24,
+	[DSS_IRQSTATUS_RAW_OFF] =		0x28,
+	[DSS_IRQSTATUS_OFF] =			0x2c,
+	[DSS_IRQENABLE_SET_OFF] =		0x30,
+	[DSS_IRQENABLE_CLR_OFF] =		0x40,
+	[DSS_VID_IRQENABLE_OFF] =		0x44,
+	[DSS_VID_IRQSTATUS_OFF] =		0x58,
+	[DSS_VP_IRQENABLE_OFF] =		0x70,
+	[DSS_VP_IRQSTATUS_OFF] =		0x7c,
+
+	[WB_IRQENABLE_OFF] =			0x88,
+	[WB_IRQSTATUS_OFF] =			0x8c,
+
+	[DSS_GLOBAL_MFLAG_ATTRIBUTE_OFF] =	0x90,
+	[DSS_GLOBAL_OUTPUT_ENABLE_OFF] =	0x94,
+	[DSS_GLOBAL_BUFFER_OFF] =		0x98,
+	[DSS_CBA_CFG_OFF] =			0x9c,
+	[DSS_DBG_CONTROL_OFF] =		0xa0,
+	[DSS_DBG_STATUS_OFF] =		0xa4,
+	[DSS_CLKGATING_DISABLE_OFF] =		0xa8,
+	[DSS_SECURE_DISABLE_OFF] =		0xac,
+};
+
+/* TIDSS AM62x Features */
+const struct dss_features dss_am625_feats = {
+	.max_pclk_khz = {
+		[DSS_VP_DPI] = 165000,
+		[DSS_VP_OLDI] = 165000,
+	},
+
+	.subrev = DSS_AM625,
+
+	.common = "common",
+	.common_regs = tidss_am62x_common_regs,
+
+	.num_vps = 2,
+	.vp_name = { "vp1", "vp2" },
+	.ovr_name = { "ovr1", "ovr2" },
+	.vpclk_name =  { "vp1", "vp2" },
+	.vp_bus_type = { DSS_VP_OLDI, DSS_VP_DPI },
+
+	.vp_feat = { .color = {
+			.has_ctm = true,
+			.gamma_size = 256,
+			.gamma_type = TIDSS_GAMMA_8BIT,
+		},
+	},
+
+	.num_planes = 2,
+	/* note: vid is plane_id 0 and vidl1 is plane_id 1 */
+	.vid_name = { "vidl1", "vid1" },
+	.vid_lite = { true, false },
+	.vid_order = { 1, 0 },
+};
+
+/* Wrapper functions to write and read TI_DSS registers */
+static void dss_write(struct tidss_drv_priv *priv, u16 reg, u32 val)
+{
+	writel(val, priv->base_common + reg);
+}
+
+static u32 dss_read(struct tidss_drv_priv *priv, u16 reg)
+{
+	return readl(priv->base_common + reg);
+}
+
+static void dss_vid_write(struct tidss_drv_priv *priv, u32 hw_plane, u16 reg, u32 val)
+{
+	void __iomem *base = priv->base_vid[hw_plane];
+
+	writel(val, base + reg);
+}
+
+static u32 dss_vid_read(struct tidss_drv_priv *priv, u32 hw_plane, u16 reg)
+{
+	void __iomem *base = priv->base_vid[hw_plane];
+
+	return readl(base + reg);
+}
+
+static void dss_ovr_write(struct tidss_drv_priv *priv, u32 hw_videoport,
+			  u16 reg, u32 val)
+{
+	void __iomem *base = priv->base_ovr[hw_videoport];
+
+	writel(val, base + reg);
+}
+
+static u32 dss_ovr_read(struct tidss_drv_priv *priv, u32 hw_videoport, u16 reg)
+{
+	void __iomem *base = priv->base_ovr[hw_videoport];
+
+	return readl(base + reg);
+}
+
+static void dss_vp_write(struct tidss_drv_priv *priv, u32 hw_videoport,
+			 u16 reg, u32 val)
+{
+	void __iomem *base = priv->base_vp[hw_videoport];
+
+	writel(val, base + reg);
+}
+
+static u32 dss_vp_read(struct tidss_drv_priv *priv, u32 hw_videoport, u16 reg)
+{
+	void __iomem *base = priv->base_vp[hw_videoport];
+
+	return readl(base + reg);
+}
+
+/* generate mask on a register */
+static u32 FLD_MASK(u32 start, u32 end)
+{
+	return ((1 << (start - end + 1)) - 1) << end;
+}
+
+/* set the given val in specified range */
+static u32 FLD_VAL(u32 val, u32 start, u32 end)
+{
+	return (val << end) & FLD_MASK(start, end);
+}
+
+/* return the value in the specified range */
+static u32 FLD_GET(u32 val, u32 start, u32 end)
+{
+	return (val & FLD_MASK(start, end)) >> end;
+}
+
+/* modify the value of the specified range */
+static u32 FLD_MOD(u32 orig, u32 val, u32 start, u32 end)
+{
+	return (orig & ~FLD_MASK(start, end)) | FLD_VAL(val, start, end);
+}
+
+/* read and modify common register region of DSS*/
+__maybe_unused
+static u32 REG_GET(struct tidss_drv_priv *priv, u32 idx, u32 start, u32 end)
+{
+	return FLD_GET(dss_read(priv, idx), start, end);
+}
+
+static void REG_FLD_MOD(struct tidss_drv_priv *priv, u32 idx, u32 val,
+			u32 start, u32 end)
+{
+	dss_write(priv, idx, FLD_MOD(dss_read(priv, idx), val,
+				     start, end));
+}
+
+/* read and modify planes vid1 and vid2 register of DSS*/
+static u32 VID_REG_GET(struct tidss_drv_priv *priv, u32 hw_plane, u32 idx,
+		       u32 start, u32 end)
+{
+	return FLD_GET(dss_vid_read(priv, hw_plane, idx), start, end);
+}
+
+static void VID_REG_FLD_MOD(struct tidss_drv_priv *priv, u32 hw_plane, u32 idx,
+			    u32 val, u32 start, u32 end)
+{
+	dss_vid_write(priv, hw_plane, idx,
+		      FLD_MOD(dss_vid_read(priv, hw_plane, idx),
+			      val, start, end));
+}
+
+/* read and modify port vid1 and vid2 registers of DSS*/
+__maybe_unused
+static u32 VP_REG_GET(struct tidss_drv_priv *priv, u32 vp, u32 idx,
+		      u32 start, u32 end)
+{
+	return FLD_GET(dss_vp_read(priv, vp, idx), start, end);
+}
+
+static void VP_REG_FLD_MOD(struct tidss_drv_priv *priv, u32 vp, u32 idx, u32 val,
+			   u32 start, u32 end)
+{
+	dss_vp_write(priv, vp, idx, FLD_MOD(dss_vp_read(priv, vp, idx),
+					    val, start, end));
+}
+
+/* read and modify overlay ovr1 and ovr2 registers of DSS*/
+__maybe_unused
+static u32 OVR_REG_GET(struct tidss_drv_priv *priv, u32 ovr, u32 idx,
+		       u32 start, u32 end)
+{
+	return FLD_GET(dss_ovr_read(priv, ovr, idx), start, end);
+}
+
+static void OVR_REG_FLD_MOD(struct tidss_drv_priv *priv, u32 ovr, u32 idx,
+			    u32 val, u32 start, u32 end)
+{
+	dss_ovr_write(priv, ovr, idx, FLD_MOD(dss_ovr_read(priv, ovr, idx),
+					      val, start, end));
+}
+
+static void dss_oldi_tx_power(struct tidss_drv_priv *priv, bool power)
+{
+	u32 val;
+
+	if (WARN_ON(!priv->oldi_io_ctrl))
+		return;
+
+	if (priv->feat->subrev == DSS_AM625) {
+		if (power) {
+			switch (priv->oldi_mode) {
+			case OLDI_SINGLE_LINK_SINGLE_MODE:
+				/* Power down OLDI TX 1 */
+				val = OLDI1_PWRDN_TX;
+				break;
+			case OLDI_DUAL_LINK:
+				/* No Power down */
+				val = 0;
+			break;
+			default:
+				/* Power down both the OLDI TXes */
+				val = OLDI_BANDGAP_PWR | OLDI0_PWRDN_TX | OLDI1_PWRDN_TX;
+				break;
+			}
+		} else {
+			val = OLDI_BANDGAP_PWR | OLDI0_PWRDN_TX | OLDI1_PWRDN_TX;
+		}
+		regmap_update_bits(priv->oldi_io_ctrl, OLDI_PD_CTRL,
+				   OLDI_BANDGAP_PWR | OLDI0_PWRDN_TX | OLDI1_PWRDN_TX, val);
+	}
+}
+
+static void dss_set_num_datalines(struct tidss_drv_priv *priv,
+				  u32 hw_videoport)
+{
+	int v;
+	u32 num_lines = priv->bus_format->data_width;
+
+	switch (num_lines) {
+	case 12:
+		v = 0; break;
+	case 16:
+		v = 1; break;
+	case 18:
+		v = 2; break;
+	case 24:
+		v = 3; break;
+	case 30:
+		v = 4; break;
+	case 36:
+		v = 5; break;
+	default:
+		WARN_ON(1);
+		v = 3;
+	}
+
+	VP_REG_FLD_MOD(priv, hw_videoport, DSS_VP_CONTROL, v, 10, 8);
+}
+
+static void dss_enable_oldi(struct tidss_drv_priv *priv, u32 hw_videoport)
+{
+	u32 oldi_cfg = 0;
+	u32 oldi_reset_bit = BIT(5 + hw_videoport);
+	int count = 0;
+
+	/*
+	 * For the moment MASTERSLAVE, and SRC bits of DSS_VP_DSS_OLDI_CFG are
+	 * set statically to 0.
+	 */
+
+	if (priv->bus_format->data_width == 24)
+		oldi_cfg |= BIT(8); /* MSB */
+	else if (priv->bus_format->data_width != 18)
+		dev_warn(priv->dev, "%s: %d port width not supported\n",
+			 __func__, priv->bus_format->data_width);
+
+	oldi_cfg |= BIT(7); /* DEPOL */
+
+	oldi_cfg = FLD_MOD(oldi_cfg, priv->bus_format->oldi_mode_reg_val, 3, 1);
+
+	oldi_cfg |= BIT(12); /* SOFTRST */
+
+	oldi_cfg |= BIT(0); /* ENABLE */
+
+	switch (priv->oldi_mode) {
+	case OLDI_MODE_OFF:
+		oldi_cfg &= ~BIT(0); /* DISABLE */
+		break;
+
+	case OLDI_SINGLE_LINK_SINGLE_MODE:
+		/* All configuration is done for this mode.  */
+		break;
+
+	case OLDI_SINGLE_LINK_DUPLICATE_MODE:
+		oldi_cfg |= BIT(5); /* DUPLICATE MODE */
+		break;
+
+	case OLDI_DUAL_LINK:
+		oldi_cfg |= BIT(11); /* DUALMODESYNC */
+		oldi_cfg |= BIT(3); /* data-mapping field also indicates dual-link mode */
+		break;
+
+	default:
+		dev_warn(priv->dev, "%s: Incorrect oldi mode. Returning.\n",
+			 __func__);
+		return;
+	}
+
+	dss_vp_write(priv, hw_videoport, DSS_VP_DSS_OLDI_CFG, oldi_cfg);
+
+	while (!(oldi_reset_bit & dss_read(priv, DSS_SYSSTATUS)) &&
+	       count < 10000)
+		count++;
+
+	if (!(oldi_reset_bit & dss_read(priv, DSS_SYSSTATUS)))
+		dev_warn(priv->dev, "%s: timeout waiting OLDI reset done\n",
+			 __func__);
+}
+
+static const struct dss_color_lut dss_vp_gamma_default_lut[] = {
+	{ .red = 0, .green = 0, .blue = 0, },
+	{ .red = U16_MAX, .green = U16_MAX, .blue = U16_MAX, },
+};
+
+static void dss_vp_write_gamma_table(struct tidss_drv_priv *priv,
+				     u32 hw_videoport)
+{
+	u32 *table = priv->vp_data[hw_videoport].gamma_table;
+	u32 hwlen = priv->feat->vp_feat.color.gamma_size;
+	unsigned int i;
+
+	dev_dbg(priv->dev, "%s: hw_videoport %d\n", __func__, hw_videoport);
+
+	for (i = 0; i < hwlen; ++i) {
+		u32 v = table[i];
+
+		v |= i << 24;
+
+		dss_vp_write(priv, hw_videoport, DSS_VP_GAMMA_TABLE, v);
+	}
+}
+
+static void dss_vp_set_gamma(struct tidss_drv_priv *priv,
+			     u32 hw_videoport, const struct dss_color_lut *lut,
+			     unsigned int length)
+{
+	u32 *table = priv->vp_data[hw_videoport].gamma_table;
+	u32 hwlen = priv->feat->vp_feat.color.gamma_size;
+	u32 hwbits;
+	unsigned int i;
+
+	dev_dbg(priv->dev, "%s: hw_videoport %d, lut len %u, hw len %u\n",
+		__func__, hw_videoport, length, hwlen);
+
+	if (priv->feat->vp_feat.color.gamma_type == TIDSS_GAMMA_10BIT)
+		hwbits = 10;
+	else
+		hwbits = 8;
+
+	lut = dss_vp_gamma_default_lut;
+	length = ARRAY_SIZE(dss_vp_gamma_default_lut);
+
+	for (i = 0; i < length - 1; ++i) {
+		unsigned int first = i * (hwlen - 1) / (length - 1);
+		unsigned int last = (i + 1) * (hwlen - 1) / (length - 1);
+		unsigned int w = last - first;
+		u16 r, g, b;
+		unsigned int j;
+
+		if (w == 0)
+			continue;
+
+		for (j = 0; j <= w; j++) {
+			r = (lut[i].red * (w - j) + lut[i + 1].red * j) / w;
+			g = (lut[i].green * (w - j) + lut[i + 1].green * j) / w;
+			b = (lut[i].blue * (w - j) + lut[i + 1].blue * j) / w;
+
+			r >>= 16 - hwbits;
+			g >>= 16 - hwbits;
+			b >>= 16 - hwbits;
+
+			table[first + j] = (r << (hwbits * 2)) |
+				(g << hwbits) | b;
+		}
+	}
+
+	dss_vp_write_gamma_table(priv, hw_videoport);
+}
+
+void dss_vp_enable(struct tidss_drv_priv *priv, u32 hw_videoport, struct display_timing *timing)
+{
+	bool align, onoff, rf, ieo, ipc, ihs, ivs;
+	u32 hsw, hfp, hbp, vsw, vfp, vbp;
+
+	dss_set_num_datalines(priv, hw_videoport);
+
+	/* panel parameters to set clocks for video port*/
+	hfp = timing->hfront_porch.typ;
+	hsw = timing->hsync_len.typ;
+	hbp = timing->hback_porch.typ;
+	vfp = timing->vfront_porch.typ;
+	vsw = timing->vsync_len.typ;
+	vbp = timing->vback_porch.typ;
+
+	dss_vp_write(priv, hw_videoport, DSS_VP_TIMING_H,
+		     FLD_VAL(hsw - 1, 7, 0) |
+		     FLD_VAL(hfp - 1, 19, 8) | FLD_VAL(hbp - 1, 31, 20));
+
+	dss_vp_write(priv, hw_videoport, DSS_VP_TIMING_V,
+		     FLD_VAL(vsw - 1, 7, 0) |
+		     FLD_VAL(vfp, 19, 8) | FLD_VAL(vbp, 31, 20));
+
+	ivs = !!(timing->flags & (1 << 3));
+
+	ihs = !!(timing->flags & (1 << 1));
+
+	ieo = 0;
+
+	ipc = 0;
+
+	/* always use the 'rf' setting */
+	onoff = true;
+
+	rf = true;
+
+	/* always use aligned syncs */
+	align = true;
+
+	/* always use DE_HIGH for OLDI */
+	if (priv->feat->vp_bus_type[hw_videoport] == DSS_VP_OLDI)
+		ieo = false;
+
+	dss_vp_write(priv, hw_videoport, DSS_VP_POL_FREQ,
+		     FLD_VAL(align, 18, 18) |
+		     FLD_VAL(onoff, 17, 17) |
+		     FLD_VAL(rf, 16, 16) |
+		     FLD_VAL(ieo, 15, 15) |
+		     FLD_VAL(ipc, 14, 14) |
+		     FLD_VAL(ihs, 13, 13) |
+		     FLD_VAL(ivs, 12, 12));
+
+	dss_vp_write(priv, hw_videoport, DSS_VP_SIZE_SCREEN,
+		     FLD_VAL(timing->hactive.typ - 1, 11, 0) |
+		     FLD_VAL(timing->vactive.typ - 1, 27, 16));
+
+	VP_REG_FLD_MOD(priv, hw_videoport, DSS_VP_CONTROL, 1, 0, 0);
+}
+
+enum c8_to_c12_mode { C8_TO_C12_REPLICATE, C8_TO_C12_MAX, C8_TO_C12_MIN };
+
+static u16 c8_to_c12(u8 c8, enum c8_to_c12_mode mode)
+{
+	u16 c12;
+
+	c12 = c8 << 4;
+
+	switch (mode) {
+	case C8_TO_C12_REPLICATE:
+		/* Copy c8 4 MSB to 4 LSB for full scale c12 */
+		c12 |= c8 >> 4;
+		break;
+	case C8_TO_C12_MAX:
+		c12 |= 0xF;
+		break;
+	default:
+	case C8_TO_C12_MIN:
+		break;
+	}
+
+	return c12;
+}
+
+static u64 argb8888_to_argb12121212(u32 argb8888, enum c8_to_c12_mode m)
+{
+	u8 a, r, g, b;
+	u64 v;
+
+	a = (argb8888 >> 24) & 0xff;
+	r = (argb8888 >> 16) & 0xff;
+	g = (argb8888 >> 8) & 0xff;
+	b = (argb8888 >> 0) & 0xff;
+
+	v = ((u64)c8_to_c12(a, m) << 36) | ((u64)c8_to_c12(r, m) << 24) |
+		((u64)c8_to_c12(g, m) << 12) | (u64)c8_to_c12(b, m);
+
+	return v;
+}
+
+static void dss_vp_set_default_color(struct tidss_drv_priv *priv,
+				     u32 hw_videoport, u32 default_color)
+{
+	u64 v;
+
+	v = argb8888_to_argb12121212(default_color, C8_TO_C12_REPLICATE);
+	dss_ovr_write(priv, hw_videoport,
+		      DSS_OVR_DEFAULT_COLOR, v & 0xffffffff);
+	dss_ovr_write(priv, hw_videoport,
+		      DSS_OVR_DEFAULT_COLOR2, (v >> 32) & 0xffff);
+}
+
+int dss_vp_enable_clk(struct tidss_drv_priv *priv, u32 hw_videoport)
+{
+	int ret = clk_prepare_enable(&priv->vp_clk[hw_videoport]);
+
+	if (ret)
+		dev_dbg(priv->dev, "%s: enabling clk failed: %d\n", __func__,
+			ret);
+
+	return ret;
+}
+
+void dss_vp_prepare(struct tidss_drv_priv *priv, u32 hw_videoport)
+{
+	dss_vp_set_gamma(priv, hw_videoport, NULL, 0);
+	dss_vp_set_default_color(priv, 0, 0);
+
+	if (priv->feat->vp_bus_type[hw_videoport] == DSS_VP_OLDI) {
+		dss_oldi_tx_power(priv, true);
+		dss_enable_oldi(priv, hw_videoport);
+	}
+}
+
+static
+unsigned int dss_pclk_diff(unsigned long rate, unsigned long real_rate)
+{
+	int r = rate / 100, rr = real_rate / 100;
+
+	return (unsigned int)(abs(((rr - r) * 100) / r));
+}
+
+int dss_vp_set_clk_rate(struct tidss_drv_priv *priv, u32 hw_videoport,
+			unsigned long rate)
+{
+	int r;
+	unsigned long new_rate;
+
+	/*
+	 * For AM625 OLDI video ports, the requested pixel clock needs to take into account the
+	 * serial clock required for the serialization of DPI signals into LVDS signals. The
+	 * incoming pixel clock on the OLDI video port gets divided by 7 whenever OLDI enable bit
+	 * gets set.
+	 */
+	if (priv->feat->vp_bus_type[hw_videoport] == DSS_VP_OLDI &&
+	    priv->feat->subrev == DSS_AM625)
+		rate *= 7;
+
+	r = clk_set_rate(&priv->vp_clk[hw_videoport], rate);
+
+	new_rate = clk_get_rate(&priv->vp_clk[hw_videoport]);
+
+	if (dss_pclk_diff(rate, new_rate) > 5)
+		dev_warn(priv->dev,
+			 "vp%d: Clock rate %lu differs over 5%% from requested %lu\n",
+			 hw_videoport, new_rate, rate);
+
+	dev_dbg(priv->dev, "vp%d: new rate %lu Hz (requested %lu Hz)\n",
+		hw_videoport, clk_get_rate(&priv->vp_clk[hw_videoport]), rate);
+	return 0;
+}
+
+static void dss_ovr_set_plane(struct tidss_drv_priv *priv,
+			      u32 hw_plane, u32 hw_ovr,
+			      u32 x, u32 y, u32 layer)
+{
+	OVR_REG_FLD_MOD(priv, hw_ovr, DSS_OVR_ATTRIBUTES(layer),
+			0x1, 4, 1);
+	OVR_REG_FLD_MOD(priv, hw_ovr, DSS_OVR_ATTRIBUTES(layer),
+			x, 17, 6);
+	OVR_REG_FLD_MOD(priv, hw_ovr, DSS_OVR_ATTRIBUTES(layer),
+			y, 30, 19);
+}
+
+void dss_ovr_enable_layer(struct tidss_drv_priv *priv,
+			  u32 hw_ovr, u32 layer, bool enable)
+{
+	OVR_REG_FLD_MOD(priv, hw_ovr, DSS_OVR_ATTRIBUTES(layer),
+			!!enable, 0, 0);
+}
+
+static void dss_vid_csc_enable(struct tidss_drv_priv *priv, u32 hw_plane,
+			       bool enable)
+{
+	VID_REG_FLD_MOD(priv, hw_plane, DSS_VID_ATTRIBUTES, !!enable, 9, 9);
+}
+
+int dss_plane_setup(struct tidss_drv_priv *priv, u32 hw_plane, u32 hw_videoport)
+{
+	VID_REG_FLD_MOD(priv, hw_plane, DSS_VID_ATTRIBUTES,
+			priv->pixel_format, 6, 1);
+
+	dss_vid_write(priv, hw_plane, DSS_VID_PICTURE_SIZE,
+		      ((LCD_MAX_WIDTH - 1) | ((LCD_MAX_HEIGHT - 1) << 16)));
+
+	dss_vid_csc_enable(priv, hw_plane, false);
+
+	dss_vid_write(priv, hw_plane, DSS_VID_GLOBAL_ALPHA, 0xFF);
+
+	VID_REG_FLD_MOD(priv, hw_plane, DSS_VID_ATTRIBUTES, 1, 28, 28);
+	return 0;
+}
+
+int dss_plane_enable(struct tidss_drv_priv *priv, u32 hw_plane, bool enable)
+{
+	VID_REG_FLD_MOD(priv, hw_plane, DSS_VID_ATTRIBUTES, !!enable, 0, 0);
+
+	return 0;
+}
+
+static u32 dss_vid_get_fifo_size(struct tidss_drv_priv *priv, u32 hw_plane)
+{
+	return VID_REG_GET(priv, hw_plane, DSS_VID_BUF_SIZE_STATUS, 15, 0);
+}
+
+static void dss_vid_set_mflag_threshold(struct tidss_drv_priv *priv,
+					u32 hw_plane, u32 low, u32 high)
+{
+	dss_vid_write(priv, hw_plane, DSS_VID_MFLAG_THRESHOLD,
+		      FLD_VAL(high, 31, 16) | FLD_VAL(low, 15, 0));
+}
+
+static
+void dss_vid_set_buf_threshold(struct tidss_drv_priv *priv,
+			       u32 hw_plane, u32 low, u32 high)
+{
+	dss_vid_write(priv, hw_plane, DSS_VID_BUF_THRESHOLD,
+		      FLD_VAL(high, 31, 16) | FLD_VAL(low, 15, 0));
+}
+
+static void dss_plane_init(struct tidss_drv_priv *priv)
+{
+	unsigned int hw_plane;
+	u32 cba_lo_pri = 1;
+	u32 cba_hi_pri = 0;
+
+	REG_FLD_MOD(priv, DSS_CBA_CFG, cba_lo_pri, 2, 0);
+	REG_FLD_MOD(priv, DSS_CBA_CFG, cba_hi_pri, 5, 3);
+
+	/* MFLAG_CTRL = ENABLED */
+	REG_FLD_MOD(priv, DSS_GLOBAL_MFLAG_ATTRIBUTE, 2, 1, 0);
+	/* MFLAG_START = MFLAGNORMALSTARTMODE */
+	REG_FLD_MOD(priv, DSS_GLOBAL_MFLAG_ATTRIBUTE, 0, 6, 6);
+
+	for (hw_plane = 0; hw_plane < priv->feat->num_planes; hw_plane++) {
+		u32 size = dss_vid_get_fifo_size(priv, hw_plane);
+		u32 thr_low, thr_high;
+		u32 mflag_low, mflag_high;
+		u32 preload;
+
+		thr_high = size - 1;
+		thr_low = size / 2;
+
+		mflag_high = size * 2 / 3;
+		mflag_low = size / 3;
+
+		preload = thr_low;
+
+		dev_dbg(priv->dev,
+			"%s: bufsize %u, buf_threshold %u/%u, mflag threshold %u/%u preload %u\n",
+			priv->feat->vid_name[hw_plane],
+			size,
+			thr_high, thr_low,
+			mflag_high, mflag_low,
+			preload);
+
+		dss_vid_set_buf_threshold(priv, hw_plane,
+					  thr_low, thr_high);
+		dss_vid_set_mflag_threshold(priv, hw_plane,
+					    mflag_low, mflag_high);
+
+		dss_vid_write(priv, hw_plane, DSS_VID_PRELOAD, preload);
+
+		/* Prefech up to PRELOAD value */
+		VID_REG_FLD_MOD(priv, hw_plane, DSS_VID_ATTRIBUTES, 0,
+				19, 19);
+	}
+}
+
+static void dss_vp_init(struct tidss_drv_priv *priv)
+{
+	unsigned int i;
+
+	/* Enable the gamma Shadow bit-field for all VPs*/
+	for (i = 0; i < priv->feat->num_vps; i++)
+		VP_REG_FLD_MOD(priv, i, DSS_VP_CONFIG, 1, 2, 2);
+}
+
+static int dss_init_am65x_oldi_io_ctrl(struct udevice *dev,
+				       struct tidss_drv_priv *priv)
+{
+	struct udevice *syscon;
+	struct regmap *regmap;
+	int ret = 0;
+
+	ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, "ti,am65x-oldi-io-ctrl",
+					   &syscon);
+	if (ret) {
+		debug("unable to find ti,am65x-oldi-io-ctrl syscon device (%d)\n", ret);
+		return ret;
+	}
+
+	/* get grf-reg base address */
+	regmap = syscon_get_regmap(syscon);
+	if (!regmap) {
+		debug("unable to find rockchip grf regmap\n");
+		return -ENODEV;
+	}
+	priv->oldi_io_ctrl = regmap;
+	return 0;
+}
+
+static int tidss_drv_probe(struct udevice *dev)
+{
+	struct video_uc_plat *uc_plat = dev_get_uclass_plat(dev);
+	struct video_priv *uc_priv = dev_get_uclass_priv(dev);
+	struct tidss_drv_priv *priv = dev_get_priv(dev);
+	struct udevice *panel = NULL;
+	struct display_timing timings;
+	unsigned int i;
+	int ret = 0;
+	const char *mode;
+
+	priv->dev = dev;
+
+	priv->feat = &dss_am625_feats;
+
+    /*
+     * set your plane format based on your bmp image
+     * Supported 24bpp and 32bpp bmpimages
+     */
+
+	priv->pixel_format = DSS_FORMAT_XRGB8888;
+
+	dss_common_regmap = priv->feat->common_regs;
+
+	ret = uclass_first_device_err(UCLASS_PANEL, &panel);
+	if (ret) {
+		if (ret != -ENODEV)
+			dev_err(dev, "panel device error %d\n", ret);
+		return ret;
+	}
+
+	ret = panel_get_display_timing(panel, &timings);
+	if (ret) {
+		ret = ofnode_decode_panel_timing(dev_ofnode(panel),
+						 &timings);
+		if (ret) {
+			dev_err(dev, "decode display timing error %d\n", ret);
+			return ret;
+		}
+	}
+
+	mode = ofnode_read_string(dev_ofnode(panel), "data-mapping");
+	if (!mode) {
+		debug("%s: Could not read mode property\n", dev->name);
+		return -EINVAL;
+	}
+
+	uc_priv->bpix = VIDEO_BPP32;
+
+	if (!strcmp(mode, "vesa-24"))
+		priv->bus_format = &dss_bus_formats[7];
+	else
+		priv->bus_format = &dss_bus_formats[8];
+
+	/* Common address */
+	priv->base_common = dev_remap_addr_index(dev, 0);
+	if (!priv->base_common)
+		return -EINVAL;
+
+	/* plane address setup and enable */
+	for (i = 0; i < priv->feat->num_planes; i++) {
+		priv->base_vid[i] = dev_remap_addr_index(dev, i + 2);
+		if (!priv->base_vid[i])
+			return -EINVAL;
+	}
+
+	dss_vid_write(priv, 0, DSS_VID_BA_0, uc_plat->base & 0xffffffff);
+	dss_vid_write(priv, 0, DSS_VID_BA_EXT_0, (u64)uc_plat->base >> 32);
+	dss_vid_write(priv, 0, DSS_VID_BA_1, uc_plat->base & 0xffffffff);
+	dss_vid_write(priv, 0, DSS_VID_BA_EXT_1, (u64)uc_plat->base >> 32);
+
+	ret = dss_plane_setup(priv, 0, 0);
+	if (ret) {
+		dss_plane_enable(priv, 0, false);
+			return ret;
+	}
+
+	dss_plane_enable(priv, 0, true);
+	dss_plane_init(priv);
+
+	/* video port address clocks and enable */
+	for (i = 0; i < priv->feat->num_vps; i++) {
+		priv->base_ovr[i] = dev_remap_addr_index(dev, i + 4);
+		priv->base_vp[i] = dev_remap_addr_index(dev, i + 6);
+	}
+
+	ret = clk_get_by_name(dev, "vp1", &priv->vp_clk[0]);
+	if (ret) {
+		dev_err(dev, "video port %d clock enable error %d\n", i, ret);
+		return ret;
+	}
+
+	dss_ovr_set_plane(priv, 1, 0, 0, 0, 0);
+	dss_ovr_enable_layer(priv, 0, 0, true);
+
+	/* Video Port cloks */
+	dss_vp_enable_clk(priv, 0);
+
+	dss_vp_set_clk_rate(priv, 0, timings.pixelclock.typ * 1000);
+
+	priv->oldi_mode = OLDI_MODE_OFF;
+	uc_priv->xsize = timings.hactive.typ;
+	uc_priv->ysize = timings.vactive.typ;
+	if (priv->feat->subrev == DSS_AM65X || priv->feat->subrev == DSS_AM625) {
+		priv->oldi_mode = OLDI_DUAL_LINK;
+		if (priv->oldi_mode) {
+			ret = dss_init_am65x_oldi_io_ctrl(dev, priv);
+			if (ret)
+				return ret;
+		}
+	}
+
+	dss_vp_prepare(priv, 0);
+	dss_vp_enable(priv, 0, &timings);
+	dss_vp_init(priv);
+
+	ret = clk_get_by_name(dev, "fck", &priv->fclk);
+	if (ret) {
+		dev_err(dev, "peripheral clock get error %d\n", ret);
+		return ret;
+	}
+
+	ret = clk_enable(&priv->fclk);
+	if (ret) {
+		dev_err(dev, "peripheral clock enable error %d\n", ret);
+		return ret;
+	}
+
+	if (IS_ERR(&priv->fclk)) {
+		dev_err(dev, "%s: Failed to get fclk: %ld\n",
+			__func__, PTR_ERR(&priv->fclk));
+		return PTR_ERR(&priv->fclk);
+	}
+
+	dev_dbg(dev, "DSS fclk %lu Hz\n", clk_get_rate(&priv->fclk));
+
+	video_set_flush_dcache(dev, true);
+	return 0;
+}
+
+static int tidss_drv_remove(struct udevice *dev)
+{
+	u32 val;
+	int ret;
+	struct tidss_drv_priv *priv = dev_get_priv(dev);
+
+	priv->base_common = dev_remap_addr_index(dev, 0);
+	REG_FLD_MOD(priv, DSS_SYSCONFIG, 1, 1, 1);
+	/* Wait for reset to complete */
+	ret = readl_poll_timeout(priv->base_common + DSS_SYSSTATUS,
+				 val, val & 1, 5000);
+	if (ret) {
+		dev_warn(priv->dev, "failed to reset priv\n");
+		return ret;
+	}
+	return 0;
+}
+
+static int tidss_drv_bind(struct udevice *dev)
+{
+	struct video_uc_plat *uc_plat = dev_get_uclass_plat(dev);
+
+	uc_plat->size = ((LCD_MAX_WIDTH * LCD_MAX_HEIGHT *
+			  (1 << LCD_MAX_LOG2_BPP)) >> 3) + 0x20;
+	return 0;
+}
+
+static const struct udevice_id tidss_drv_ids[] = {
+	{ .compatible = "ti,am625-dss" },
+	{ }
+};
+
+U_BOOT_DRIVER(tidss_drv) = {
+	.name = "tidss_drv",
+	.id = UCLASS_VIDEO,
+	.of_match = tidss_drv_ids,
+	.bind = tidss_drv_bind,
+	.probe = tidss_drv_probe,
+	.remove = tidss_drv_remove,
+	.priv_auto = sizeof(struct tidss_drv_priv),
+	.flags = DM_FLAG_OS_PREPARE,
+};
diff --git a/drivers/video/tidss/tidss_drv.h b/drivers/video/tidss/tidss_drv.h
new file mode 100644
index 0000000000..e229d975ff
--- /dev/null
+++ b/drivers/video/tidss/tidss_drv.h
@@ -0,0 +1,137 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * (C) Copyright 2023 Texas Instruments Incorporated - https://www.ti.com/
+ * Nikhil M Jain, n-jain1@ti.com
+ *
+ * based on the linux tidss driver, which is
+ *
+ * (C) Copyright 2018 Texas Instruments Incorporated - https://www.ti.com/
+ * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
+ */
+
+#ifndef __TIDSS_DRV_H__
+#define __TIDSS_DRV_H__
+
+#include <media_bus_format.h>
+
+#define TIDSS_MAX_PORTS 4
+#define TIDSS_MAX_PLANES 4
+
+enum dss_vp_bus_type {
+	DSS_VP_DPI,		/* DPI output */
+	DSS_VP_OLDI,		/* OLDI (LVDS) output */
+	DSS_VP_INTERNAL,	/* SoC internal routing */
+	DSS_VP_MAX_BUS_TYPE,
+};
+
+enum dss_oldi_modes {
+	OLDI_MODE_OFF,				/* OLDI turned off / tied off in IP. */
+	OLDI_SINGLE_LINK_SINGLE_MODE,		/* Single Output over OLDI 0. */
+	OLDI_SINGLE_LINK_DUPLICATE_MODE,	/* Duplicate Output over OLDI 0 and 1. */
+	OLDI_DUAL_LINK,				/* Combined Output over OLDI 0 and 1. */
+};
+
+struct dss_features_scaling {
+	u32 in_width_max_5tap_rgb;
+	u32 in_width_max_3tap_rgb;
+	u32 in_width_max_5tap_yuv;
+	u32 in_width_max_3tap_yuv;
+	u32 upscale_limit;
+	u32 downscale_limit_5tap;
+	u32 downscale_limit_3tap;
+	u32 xinc_max;
+};
+
+enum tidss_gamma_type { TIDSS_GAMMA_8BIT, TIDSS_GAMMA_10BIT };
+
+/* choose specific DSS based on the board */
+enum dss_subrevision {
+	DSS_K2G,
+	DSS_AM65X,
+	DSS_J721E,
+	DSS_AM625,
+};
+
+struct tidss_vp_feat {
+	struct tidss_vp_color_feat {
+		u32 gamma_size;
+		enum tidss_gamma_type gamma_type;
+		bool has_ctm;
+	} color;
+};
+
+struct dss_color_lut {
+	/*
+	 * Data is U0.16 fixed point format.
+	 */
+	__u16 red;
+	__u16 green;
+	__u16 blue;
+	__u16 reserved;
+};
+
+struct dss_vp_data {
+	u32 *gamma_table;
+};
+
+struct dss_features {
+	int min_pclk_khz;
+	int max_pclk_khz[DSS_VP_MAX_BUS_TYPE];
+
+	struct dss_features_scaling scaling;
+
+	enum dss_subrevision subrev;
+
+	const char *common;
+	const u16 *common_regs;
+	u32 num_vps;
+	const char *vp_name[TIDSS_MAX_PORTS]; /* Should match dt reg names */
+	const char *ovr_name[TIDSS_MAX_PORTS]; /* Should match dt reg names */
+	const char *vpclk_name[TIDSS_MAX_PORTS]; /* Should match dt clk names */
+	const enum dss_vp_bus_type vp_bus_type[TIDSS_MAX_PORTS];
+	struct tidss_vp_feat vp_feat;
+	u32 num_planes;
+	const char *vid_name[TIDSS_MAX_PLANES]; /* Should match dt reg names */
+	bool vid_lite[TIDSS_MAX_PLANES];
+	u32 vid_order[TIDSS_MAX_PLANES];
+};
+
+enum dss_oldi_mode_reg_val { SPWG_18 = 0, JEIDA_24 = 1, SPWG_24 = 2 };
+
+struct dss_bus_format {
+	u32 bus_fmt;
+	u32 data_width;
+	bool is_oldi_fmt;
+	enum dss_oldi_mode_reg_val oldi_mode_reg_val;
+};
+
+static struct dss_bus_format dss_bus_formats[] = {
+	{ MEDIA_BUS_FMT_RGB444_1X12,		12, false, 0 },
+	{ MEDIA_BUS_FMT_RGB565_1X16,		16, false, 0 },
+	{ MEDIA_BUS_FMT_RGB666_1X18,		18, false, 0 },
+	{ MEDIA_BUS_FMT_RGB888_1X24,		24, false, 0 },
+	{ MEDIA_BUS_FMT_RGB101010_1X30,		30, false, 0 },
+	{ MEDIA_BUS_FMT_RGB121212_1X36,		36, false, 0 },
+	{ MEDIA_BUS_FMT_RGB666_1X7X3_SPWG,	18, true, SPWG_18 },
+	{ MEDIA_BUS_FMT_RGB888_1X7X4_SPWG,	24, true, SPWG_24 },
+	{ MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA,	24, true, JEIDA_24 },
+};
+
+struct tidss_drv_priv {
+	struct udevice *dev;
+	void __iomem *base_common; /* common register region of dss*/
+	void __iomem *base_vid[TIDSS_MAX_PLANES]; /* plane register region of dss*/
+	void __iomem *base_ovr[TIDSS_MAX_PORTS]; /* overlay register region of dss*/
+	void __iomem *base_vp[TIDSS_MAX_PORTS]; /* video port register region of dss*/
+	struct regmap *oldi_io_ctrl;
+	struct clk vp_clk[TIDSS_MAX_PORTS];
+	const struct dss_features *feat;
+	struct clk fclk;
+	struct dss_vp_data vp_data[TIDSS_MAX_PORTS];
+	enum dss_oldi_modes oldi_mode;
+	struct dss_bus_format *bus_format;
+	u32 pixel_format;
+	u32 memory_bandwidth_limit;
+};
+
+#endif
diff --git a/drivers/video/tidss/tidss_regs.h b/drivers/video/tidss/tidss_regs.h
new file mode 100644
index 0000000000..440db8d1c7
--- /dev/null
+++ b/drivers/video/tidss/tidss_regs.h
@@ -0,0 +1,292 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * (C) Copyright 2023 Texas Instruments Incorporated - https://www.ti.com/
+ * Nikhil M Jain, n-jain1@ti.com
+ *
+ * based on the linux tidss driver, which is
+ *
+ * Copyright (C) 2016-2018 Texas Instruments Incorporated - https://www.ti.com/
+ * Author: Jyri Sarha <jsarha@ti.com>
+ */
+
+#ifndef __TIDSS_REGS_H
+#define __TIDSS_REGS_H
+
+enum dss_common_regs {
+	NOT_APPLICABLE_OFF = 0,
+	DSS_REVISION_OFF,
+	DSS_SYSCONFIG_OFF,
+	DSS_SYSSTATUS_OFF,
+	DSS_IRQ_EOI_OFF,
+	DSS_IRQSTATUS_RAW_OFF,
+	DSS_IRQSTATUS_OFF,
+	DSS_IRQENABLE_SET_OFF,
+	DSS_IRQENABLE_CLR_OFF,
+	DSS_VID_IRQENABLE_OFF,
+	DSS_VID_IRQSTATUS_OFF,
+	DSS_VP_IRQENABLE_OFF,
+	DSS_VP_IRQSTATUS_OFF,
+	WB_IRQENABLE_OFF,
+	WB_IRQSTATUS_OFF,
+	DSS_GLOBAL_MFLAG_ATTRIBUTE_OFF,
+	DSS_GLOBAL_OUTPUT_ENABLE_OFF,
+	DSS_GLOBAL_BUFFER_OFF,
+	DSS_CBA_CFG_OFF,
+	DSS_DBG_CONTROL_OFF,
+	DSS_DBG_STATUS_OFF,
+	DSS_CLKGATING_DISABLE_OFF,
+	DSS_SECURE_DISABLE_OFF,
+	FBDC_REVISION_1_OFF,
+	FBDC_REVISION_2_OFF,
+	FBDC_REVISION_3_OFF,
+	FBDC_REVISION_4_OFF,
+	FBDC_REVISION_5_OFF,
+	FBDC_REVISION_6_OFF,
+	FBDC_COMMON_CONTROL_OFF,
+	FBDC_CONSTANT_COLOR_0_OFF,
+	FBDC_CONSTANT_COLOR_1_OFF,
+	DSS_CONNECTIONS_OFF,
+	DSS_MSS_VP1_OFF,
+	DSS_MSS_VP3_OFF,
+	DSS_COMMON_REG_TABLE_LEN,
+};
+
+/*
+ * dss_common_regmap should be defined as const u16 * and pointing
+ * to a valid dss common register map for the platform, before the
+ * macros bellow can be used.
+ */
+
+#define REG(r) (dss_common_regmap[r ## _OFF])
+
+#define DSS_REVISION			REG(DSS_REVISION)
+#define DSS_SYSCONFIG			REG(DSS_SYSCONFIG)
+#define DSS_SYSSTATUS			REG(DSS_SYSSTATUS)
+#define DSS_IRQ_EOI			REG(DSS_IRQ_EOI)
+#define DSS_IRQSTATUS_RAW		REG(DSS_IRQSTATUS_RAW)
+#define DSS_IRQSTATUS			REG(DSS_IRQSTATUS)
+#define DSS_IRQENABLE_SET		REG(DSS_IRQENABLE_SET)
+#define DSS_IRQENABLE_CLR		REG(DSS_IRQENABLE_CLR)
+#define DSS_VID_IRQENABLE(n)		(REG(DSS_VID_IRQENABLE) + (n) * 4)
+#define DSS_VID_IRQSTATUS(n)		(REG(DSS_VID_IRQSTATUS) + (n) * 4)
+#define DSS_VP_IRQENABLE(n)		(REG(DSS_VP_IRQENABLE) + (n) * 4)
+#define DSS_VP_IRQSTATUS(n)		(REG(DSS_VP_IRQSTATUS) + (n) * 4)
+#define WB_IRQENABLE			REG(WB_IRQENABLE)
+#define WB_IRQSTATUS			REG(WB_IRQSTATUS)
+
+#define DSS_GLOBAL_MFLAG_ATTRIBUTE	REG(DSS_GLOBAL_MFLAG_ATTRIBUTE)
+#define DSS_GLOBAL_OUTPUT_ENABLE	REG(DSS_GLOBAL_OUTPUT_ENABLE)
+#define DSS_GLOBAL_BUFFER		REG(DSS_GLOBAL_BUFFER)
+#define DSS_CBA_CFG			REG(DSS_CBA_CFG)
+#define DSS_DBG_CONTROL		REG(DSS_DBG_CONTROL)
+#define DSS_DBG_STATUS		REG(DSS_DBG_STATUS)
+#define DSS_CLKGATING_DISABLE		REG(DSS_CLKGATING_DISABLE)
+#define DSS_SECURE_DISABLE		REG(DSS_SECURE_DISABLE)
+
+#define FBDC_REVISION_1			REG(FBDC_REVISION_1)
+#define FBDC_REVISION_2			REG(FBDC_REVISION_2)
+#define FBDC_REVISION_3			REG(FBDC_REVISION_3)
+#define FBDC_REVISION_4			REG(FBDC_REVISION_4)
+#define FBDC_REVISION_5			REG(FBDC_REVISION_5)
+#define FBDC_REVISION_6			REG(FBDC_REVISION_6)
+#define FBDC_COMMON_CONTROL		REG(FBDC_COMMON_CONTROL)
+#define FBDC_CONSTANT_COLOR_0		REG(FBDC_CONSTANT_COLOR_0)
+#define FBDC_CONSTANT_COLOR_1		REG(FBDC_CONSTANT_COLOR_1)
+#define DSS_CONNECTIONS		REG(DSS_CONNECTIONS)
+#define DSS_MSS_VP1			REG(DSS_MSS_VP1)
+#define DSS_MSS_VP3			REG(DSS_MSS_VP3)
+
+/* VID */
+
+#define DSS_VID_ACCUH_0		0x0
+#define DSS_VID_ACCUH_1		0x4
+#define DSS_VID_ACCUH2_0		0x8
+#define DSS_VID_ACCUH2_1		0xc
+#define DSS_VID_ACCUV_0		0x10
+#define DSS_VID_ACCUV_1		0x14
+#define DSS_VID_ACCUV2_0		0x18
+#define DSS_VID_ACCUV2_1		0x1c
+#define DSS_VID_ATTRIBUTES		0x20
+#define DSS_VID_ATTRIBUTES2		0x24
+#define DSS_VID_BA_0			0x28
+#define DSS_VID_BA_1			0x2c
+#define DSS_VID_BA_UV_0		0x30
+#define DSS_VID_BA_UV_1		0x34
+#define DSS_VID_BUF_SIZE_STATUS	0x38
+#define DSS_VID_BUF_THRESHOLD		0x3c
+#define DSS_VID_CSC_COEF(n)		(0x40 + (n) * 4)
+
+#define DSS_VID_FIRH			0x5c
+#define DSS_VID_FIRH2			0x60
+#define DSS_VID_FIRV			0x64
+#define DSS_VID_FIRV2			0x68
+
+#define DSS_VID_FIR_COEFS_H0		0x6c
+#define DSS_VID_FIR_COEF_H0(phase)	(0x6c + (phase) * 4)
+#define DSS_VID_FIR_COEFS_H0_C	0x90
+#define DSS_VID_FIR_COEF_H0_C(phase)	(0x90 + (phase) * 4)
+
+#define DSS_VID_FIR_COEFS_H12		0xb4
+#define DSS_VID_FIR_COEF_H12(phase)	(0xb4 + (phase) * 4)
+#define DSS_VID_FIR_COEFS_H12_C	0xf4
+#define DSS_VID_FIR_COEF_H12_C(phase)	(0xf4 + (phase) * 4)
+
+#define DSS_VID_FIR_COEFS_V0		0x134
+#define DSS_VID_FIR_COEF_V0(phase)	(0x134 + (phase) * 4)
+#define DSS_VID_FIR_COEFS_V0_C	0x158
+#define DSS_VID_FIR_COEF_V0_C(phase)	(0x158 + (phase) * 4)
+
+#define DSS_VID_FIR_COEFS_V12		0x17c
+#define DSS_VID_FIR_COEF_V12(phase)	(0x17c + (phase) * 4)
+#define DSS_VID_FIR_COEFS_V12_C	0x1bc
+#define DSS_VID_FIR_COEF_V12_C(phase)	(0x1bc + (phase) * 4)
+
+#define DSS_VID_GLOBAL_ALPHA		0x1fc
+#define DSS_VID_K2G_IRQENABLE		0x200 /* K2G */
+#define DSS_VID_K2G_IRQSTATUS		0x204 /* K2G */
+#define DSS_VID_MFLAG_THRESHOLD	0x208
+#define DSS_VID_PICTURE_SIZE		0x20c
+#define DSS_VID_PIXEL_INC		0x210
+#define DSS_VID_K2G_POSITION		0x214 /* K2G */
+#define DSS_VID_PRELOAD		0x218
+#define DSS_VID_ROW_INC		0x21c
+#define DSS_VID_SIZE			0x220
+#define DSS_VID_BA_EXT_0		0x22c
+#define DSS_VID_BA_EXT_1		0x230
+#define DSS_VID_BA_UV_EXT_0		0x234
+#define DSS_VID_BA_UV_EXT_1		0x238
+#define DSS_VID_CSC_COEF7		0x23c
+#define DSS_VID_ROW_INC_UV		0x248
+#define DSS_VID_CLUT			0x260
+#define DSS_VID_SAFETY_ATTRIBUTES	0x2a0
+#define DSS_VID_SAFETY_CAPT_SIGNATURE	0x2a4
+#define DSS_VID_SAFETY_POSITION	0x2a8
+#define DSS_VID_SAFETY_REF_SIGNATURE	0x2ac
+#define DSS_VID_SAFETY_SIZE		0x2b0
+#define DSS_VID_SAFETY_LFSR_SEED	0x2b4
+#define DSS_VID_LUMAKEY		0x2b8
+#define DSS_VID_DMA_BUFSIZE		0x2bc /* J721E */
+
+/* OVR */
+
+#define DSS_OVR_CONFIG		0x0
+#define DSS_OVR_VIRTVP		0x4 /* J721E */
+#define DSS_OVR_DEFAULT_COLOR		0x8
+#define DSS_OVR_DEFAULT_COLOR2	0xc
+#define DSS_OVR_TRANS_COLOR_MAX	0x10
+#define DSS_OVR_TRANS_COLOR_MAX2	0x14
+#define DSS_OVR_TRANS_COLOR_MIN	0x18
+#define DSS_OVR_TRANS_COLOR_MIN2	0x1c
+#define DSS_OVR_ATTRIBUTES(n)		(0x20 + (n) * 4)
+#define DSS_OVR_ATTRIBUTES2(n)	(0x34 + (n) * 4) /* J721E */
+/* VP */
+
+#define  DSS_VP_CONFIG				0x0
+#define DSS_VP_CONTROL			0x4
+#define DSS_VP_CSC_COEF0			0x8
+#define DSS_VP_CSC_COEF1			0xc
+#define DSS_VP_CSC_COEF2			0x10
+#define DSS_VP_DATA_CYCLE_0			0x14
+#define DSS_VP_DATA_CYCLE_1			0x18
+#define DSS_VP_K2G_GAMMA_TABLE		0x20 /* K2G */
+#define DSS_VP_K2G_IRQENABLE			0x3c /* K2G */
+#define DSS_VP_K2G_IRQSTATUS			0x40 /* K2G */
+#define DSS_VP_DATA_CYCLE_2			0x1c
+#define DSS_VP_LINE_NUMBER			0x44
+#define DSS_VP_POL_FREQ			0x4c
+#define DSS_VP_SIZE_SCREEN			0x50
+#define DSS_VP_TIMING_H			0x54
+#define DSS_VP_TIMING_V			0x58
+#define DSS_VP_CSC_COEF3			0x5c
+#define DSS_VP_CSC_COEF4			0x60
+#define DSS_VP_CSC_COEF5			0x64
+#define DSS_VP_CSC_COEF6			0x68
+#define DSS_VP_CSC_COEF7			0x6c
+#define DSS_VP_SAFETY_ATTRIBUTES_0		0x70
+#define DSS_VP_SAFETY_ATTRIBUTES_1		0x74
+#define DSS_VP_SAFETY_ATTRIBUTES_2		0x78
+#define DSS_VP_SAFETY_ATTRIBUTES_3		0x7c
+#define DSS_VP_SAFETY_CAPT_SIGNATURE_0	0x90
+#define DSS_VP_SAFETY_CAPT_SIGNATURE_1	0x94
+#define DSS_VP_SAFETY_CAPT_SIGNATURE_2	0x98
+#define DSS_VP_SAFETY_CAPT_SIGNATURE_3	0x9c
+#define DSS_VP_SAFETY_POSITION_0		0xb0
+#define DSS_VP_SAFETY_POSITION_1		0xb4
+#define DSS_VP_SAFETY_POSITION_2		0xb8
+#define DSS_VP_SAFETY_POSITION_3		0xbc
+#define DSS_VP_SAFETY_REF_SIGNATURE_0		0xd0
+#define DSS_VP_SAFETY_REF_SIGNATURE_1		0xd4
+#define DSS_VP_SAFETY_REF_SIGNATURE_2		0xd8
+#define DSS_VP_SAFETY_REF_SIGNATURE_3		0xdc
+#define DSS_VP_SAFETY_SIZE_0			0xf0
+#define DSS_VP_SAFETY_SIZE_1			0xf4
+#define DSS_VP_SAFETY_SIZE_2			0xf8
+#define DSS_VP_SAFETY_SIZE_3			0xfc
+#define DSS_VP_SAFETY_LFSR_SEED		0x110
+#define DSS_VP_GAMMA_TABLE			0x120
+#define DSS_VP_DSS_OLDI_CFG			0x160
+#define DSS_VP_DSS_OLDI_STATUS		0x164
+#define DSS_VP_DSS_OLDI_LB			0x168
+#define DSS_VP_DSS_MERGE_SPLIT		0x16c /* J721E */
+#define DSS_VP_DSS_DMA_THREADSIZE		0x170 /* J721E */
+#define DSS_VP_DSS_DMA_THREADSIZE_STATUS	0x174 /* J721E */
+
+/*
+ * OLDI IO_CTRL register offsets. On AM654 the registers are found
+ * from CTRL_MMR0, there the syscon regmap should map 0x14 bytes from
+ * CTRLMMR0P1_OLDI_DAT0_IO_CTRL to CTRLMMR0P1_OLDI_CLK_IO_CTRL
+ * register range.
+ */
+#define OLDI_DAT0_IO_CTRL			0x00
+#define OLDI_DAT1_IO_CTRL			0x04
+#define OLDI_DAT2_IO_CTRL			0x08
+#define OLDI_DAT3_IO_CTRL			0x0C
+#define OLDI_CLK_IO_CTRL			0x10
+
+/* Only for AM625 OLDI TX */
+#define OLDI_PD_CTRL				0x100
+#define OLDI_LB_CTRL				0x104
+
+#define OLDI_BANDGAP_PWR			BIT(8)
+#define OLDI_PWRDN_TX				BIT(8)
+#define OLDI0_PWRDN_TX				BIT(0)
+#define OLDI1_PWRDN_TX				BIT(1)
+
+/* Supported plane formats */
+#define DSS_FORMAT_ARGB4444 0x0
+#define DSS_FORMAT_ABGR4444 0x1
+#define DSS_FORMAT_RGBA4444 0x2
+
+#define DSS_FORMAT_RGB565 0x3
+#define DSS_FORMAT_BGR565 0x4
+
+#define DSS_FORMAT_ARGB1555 0x5
+#define DSS_FORMAT_ABGR1555 0x6
+
+#define DSS_FORMAT_ARGB8888 0x7
+#define DSS_FORMAT_ABGR8888 0x8
+#define DSS_FORMAT_RGBA8888 0x9
+#define DSS_FORMAT_BGRA8888 0xa
+
+#define DSS_FORMAT_RGB888 0xb
+#define DSS_FORMAT_BGR888 0xc
+
+#define DSS_FORMAT_ARGB2101010 0xe
+#define DSS_FORMAT_ABGR2101010 0xf
+
+#define DSS_FORMAT_XRGB4444 0x20
+#define DSS_FORMAT_XBGR4444 0x21
+#define DSS_FORMAT_RGBX4444 0x22
+
+#define DSS_FORMAT_XRGB1555 0x25
+#define DSS_FORMAT_XBGR1555 0x26
+
+#define DSS_FORMAT_XRGB8888 0x27
+#define DSS_FORMAT_XBGR8888 0x28
+#define DSS_FORMAT_RGBX8888 0x29
+#define DSS_FORMAT_BGRX8888 0x2a
+
+#define DSS_FORMAT_XRGB2101010 0x2e,
+#define DSS_FORMAT_XBGR2101010 0x2f,
+
+#endif /* __TIDSS_DSS_REGS_H */
-- 
2.34.1

[PATCH v2 5/7] board: ti: am62x: am62x: Add splash screen env variables

[Nikhil M Jain]

Set splash screen related env variables. Default splash source is
set to mmc where user is expected to keep bmp in compressed format
with name ti.gz on first partition of mmc.

Splash file will be uncompressed to DDR at address 0x82000000 and
splash position is set to middle of screen.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
---
 board/ti/am62x/am62x.env | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/board/ti/am62x/am62x.env b/board/ti/am62x/am62x.env
index 3d4ab84fa3..128191f621 100644
--- a/board/ti/am62x/am62x.env
+++ b/board/ti/am62x/am62x.env
@@ -103,3 +103,8 @@ get_kern_mmc=load mmc ${bootpart} ${loadaddr}
 get_fit_mmc=load mmc ${bootpart} ${addr_fit}
 	${bootdir}/${name_fit}
 partitions=name=rootfs,start=0,size=-,uuid=${uuid_gpt_rootfs}
+
+splashfile=ti.gz
+splashimage=0x82000000
+splashpos=m,m
+splashsource=mmc
-- 
2.34.1

[PATCH v2 6/7] board: ti: am62x: evm: Add splash screen support

[Nikhil M Jain]

Splash screen function needs splash source information
to load image and display it, splash_location provides
the necessary info, Set default_splash_location to MMC
at partition 1:1. Probe DSS for splash screen display.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
---
 board/ti/am62x/evm.c | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/board/ti/am62x/evm.c b/board/ti/am62x/evm.c
index d65ee1d696..f53e766438 100644
--- a/board/ti/am62x/evm.c
+++ b/board/ti/am62x/evm.c
@@ -7,17 +7,36 @@
  *
  */
 
-#include <asm/io.h>
+#include <env.h>
 #include <spl.h>
-#include <dm/uclass.h>
+#include <video.h>
+#include <splash.h>
 #include <k3-ddrss.h>
 #include <fdt_support.h>
+#include <asm/io.h>
 #include <asm/arch/hardware.h>
 #include <asm/arch/sys_proto.h>
-#include <env.h>
+#include <dm/uclass.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
+#ifdef CONFIG_SPLASH_SCREEN
+	static struct splash_location default_splash_locations[] = {
+		{
+			.name		= "mmc",
+			.storage	= SPLASH_STORAGE_MMC,
+			.flags		= SPLASH_STORAGE_FS,
+			.devpart	= "1:1",
+		},
+	};
+
+int splash_screen_prepare(void)
+{
+	return splash_source_load(default_splash_locations,
+				ARRAY_SIZE(default_splash_locations));
+}
+#endif
+
 int board_init(void)
 {
 	return 0;
-- 
2.34.1

[PATCH v2 7/7] tools: logos: Add TI logo files

[Nikhil M Jain]

The default splashfile name saved is ti.gz. User can use these
logo files and use it to test splash screen.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
---
 tools/logos/ti.bmp | Bin 0 -> 160770 bytes
 tools/logos/ti.gz  | Bin 0 -> 12285 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tools/logos/ti.bmp
 create mode 100644 tools/logos/ti.gz

diff --git a/tools/logos/ti.bmp b/tools/logos/ti.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..7fee6e81e07576efedf6fbb045c7b8c3335f8e08
GIT binary patch
literal 160770
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

literal 0
HcmV?d00001

diff --git a/tools/logos/ti.gz b/tools/logos/ti.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3a5b45e0358fe374563ae277afc36d00aa620c1d
GIT binary patch
literal 12285
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
WZU3*j%PDxwEs^l$+!^09r~U_*!;3}$

literal 0
HcmV?d00001

-- 
2.34.1

Re: [PATCH v2 2/7] test: dm: test-fdt: Add decode_panel_timing test

[Simon Glass]

On Tue, 31 Jan 2023 at 03:05, Nikhil M Jain <n-jain1@ti.com> wrote:
>
> To test decode_panel_timing add a panel-timings node
> and a DM test for decode panel timingd by matching
> the panel timing node parameters.
>
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  arch/sandbox/dts/test.dts | 18 ++++++++++++++++++
>  test/dm/test-fdt.c        | 35 +++++++++++++++++++++++++++++++++++
>  2 files changed, 53 insertions(+)
>

Reviewed-by: Simon Glass <sjg@chromium.org>

Re: [PATCH v2 1/7] drivers: core: ofnode: Add panel timing decode.

[Simon Glass]

On Tue, 31 Jan 2023 at 03:05, Nikhil M Jain <n-jain1@ti.com> wrote:
>
> ofnode_decode_display_timing supports reading timing parameters from
> subnode of display-timings node, for displays supporting multiple
> resolution, in case if a display supports single resolution, it fails
> reading directly from display-timings node, to support it
> ofnode_decode_panel_timing is added.
>
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  drivers/core/ofnode.c | 47 +++++++++++++++++++++++++++++++++++++++++++
>  drivers/core/read.c   |  6 ++++++
>  include/dm/ofnode.h   | 12 +++++++++++
>  include/dm/read.h     | 14 +++++++++++++
>  4 files changed, 79 insertions(+)

Reviewed-by: Simon Glass <sjg@chromium.org>

(missing change log)

Re: [EXTERNAL] Re: [PATCH v2 1/7] drivers: core: ofnode: Add panel timing decode.

[Nikhil M Jain]

Hi Simon,

On 31/01/23 19:46, Simon Glass wrote:
> On Tue, 31 Jan 2023 at 03:05, Nikhil M Jain <n-jain1@ti.com> wrote:
>> ofnode_decode_display_timing supports reading timing parameters from
>> subnode of display-timings node, for displays supporting multiple
>> resolution, in case if a display supports single resolution, it fails
>> reading directly from display-timings node, to support it
>> ofnode_decode_panel_timing is added.
>>
>> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
>> ---
>>   drivers/core/ofnode.c | 47 +++++++++++++++++++++++++++++++++++++++++++
>>   drivers/core/read.c   |  6 ++++++
>>   include/dm/ofnode.h   | 12 +++++++++++
>>   include/dm/read.h     | 14 +++++++++++++
>>   4 files changed, 79 insertions(+)
> Reviewed-by: Simon Glass <sjg@chromium.org>
>
> (missing change log)

Changes:

Added dev_decode_panel timing declaration and definition.

Thanks

[PATCH v3 1/7] drivers: core: ofnode: Add panel timing decode.

[Anatolij Gustschin]

From: Nikhil M Jain <n-jain1@ti.com>

ofnode_decode_display_timing supports reading timing parameters from
subnode of display-timings node, for displays supporting multiple
resolution, in case if a display supports single resolution, it fails
reading directly from display-timings node, to support it
ofnode_decode_panel_timing is added.

Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
---
Changes in v3:
 - add static inline dev_decode_panel_timing() in include/dm/read.h
   to fix sandbox test errors when CONFIG_DM_DEV_READ_INLINE enabled

 drivers/core/ofnode.c | 47 +++++++++++++++++++++++++++++++++++++++++++
 drivers/core/read.c   |  6 ++++++
 include/dm/ofnode.h   | 12 +++++++++++
 include/dm/read.h     | 20 ++++++++++++++++++
 4 files changed, 85 insertions(+)

diff --git a/drivers/core/ofnode.c b/drivers/core/ofnode.c
index 4d56b1a767..d08578e9c4 100644
--- a/drivers/core/ofnode.c
+++ b/drivers/core/ofnode.c
@@ -991,6 +991,53 @@ int ofnode_decode_display_timing(ofnode parent, int index,
 	return ret;
 }
 
+int ofnode_decode_panel_timing(ofnode parent,
+			       struct display_timing *dt)
+{
+	ofnode timings;
+	u32 val = 0;
+	int ret = 0;
+
+	timings = ofnode_find_subnode(parent, "panel-timings");
+	if (!ofnode_valid(timings))
+		return -EINVAL;
+	memset(dt, 0, sizeof(*dt));
+	ret |= decode_timing_property(timings, "hback-porch", &dt->hback_porch);
+	ret |= decode_timing_property(timings, "hfront-porch", &dt->hfront_porch);
+	ret |= decode_timing_property(timings, "hactive", &dt->hactive);
+	ret |= decode_timing_property(timings, "hsync-len", &dt->hsync_len);
+	ret |= decode_timing_property(timings, "vback-porch", &dt->vback_porch);
+	ret |= decode_timing_property(timings, "vfront-porch", &dt->vfront_porch);
+	ret |= decode_timing_property(timings, "vactive", &dt->vactive);
+	ret |= decode_timing_property(timings, "vsync-len", &dt->vsync_len);
+	ret |= decode_timing_property(timings, "clock-frequency", &dt->pixelclock);
+	dt->flags = 0;
+	if (!ofnode_read_u32(timings, "vsync-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
+		    DISPLAY_FLAGS_VSYNC_LOW;
+	}
+	if (!ofnode_read_u32(timings, "hsync-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
+		    DISPLAY_FLAGS_HSYNC_LOW;
+	}
+	if (!ofnode_read_u32(timings, "de-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
+		    DISPLAY_FLAGS_DE_LOW;
+	}
+	if (!ofnode_read_u32(timings, "pixelclk-active", &val)) {
+		dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
+		DISPLAY_FLAGS_PIXDATA_NEGEDGE;
+	}
+	if (ofnode_read_bool(timings, "interlaced"))
+		dt->flags |= DISPLAY_FLAGS_INTERLACED;
+	if (ofnode_read_bool(timings, "doublescan"))
+		dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
+	if (ofnode_read_bool(timings, "doubleclk"))
+		dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
+
+	return ret;
+}
+
 const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
 {
 	if (ofnode_is_np(node))
diff --git a/drivers/core/read.c b/drivers/core/read.c
index 3e5fea87d8..e0543bbad5 100644
--- a/drivers/core/read.c
+++ b/drivers/core/read.c
@@ -420,6 +420,12 @@ int dev_decode_display_timing(const struct udevice *dev, int index,
 	return ofnode_decode_display_timing(dev_ofnode(dev), index, config);
 }
 
+int dev_decode_panel_timing(const struct udevice *dev,
+			    struct display_timing *config)
+{
+	return ofnode_decode_panel_timing(dev_ofnode(dev), config);
+}
+
 ofnode dev_get_phy_node(const struct udevice *dev)
 {
 	return ofnode_get_phy_node(dev_ofnode(dev));
diff --git a/include/dm/ofnode.h b/include/dm/ofnode.h
index fa9865602d..3f6b0843c5 100644
--- a/include/dm/ofnode.h
+++ b/include/dm/ofnode.h
@@ -974,6 +974,18 @@ struct display_timing;
 int ofnode_decode_display_timing(ofnode node, int index,
 				 struct display_timing *config);
 
+/**
+ * ofnode_decode_panel_timing() - decode display timings
+ *
+ * Decode panel timings from the supplied 'panel-timings' node.
+ *
+ * @node:	'display-timing' node containing the timing subnodes
+ * @config:	Place to put timings
+ * Return: 0 if OK, -FDT_ERR_NOTFOUND if not found
+ */
+int ofnode_decode_panel_timing(ofnode node,
+			       struct display_timing *config);
+
 /**
  * ofnode_get_property() - get a pointer to the value of a node property
  *
diff --git a/include/dm/read.h b/include/dm/read.h
index cc4f16196f..56ac076c9f 100644
--- a/include/dm/read.h
+++ b/include/dm/read.h
@@ -784,6 +784,20 @@ int dev_read_pci_bus_range(const struct udevice *dev, struct resource *res);
 int dev_decode_display_timing(const struct udevice *dev, int index,
 			      struct display_timing *config);
 
+/**
+ * dev_decode_panel_timing() - decode panel timings
+ *
+ * Decode display timings from the supplied 'panel-timings' node.
+ *
+ * @dev: device to read DT display timings from. The node linked to the device
+ *       contains a child node called 'display-timings' which in turn contains
+ *       one or more display timing nodes.
+ * @config: place to put timings
+ * Return: 0 if OK, -FDT_ERR_NOTFOUND if not found
+ */
+int dev_decode_panel_timing(const struct udevice *dev,
+			    struct display_timing *config);
+
 /**
  * dev_get_phy_node() - Get PHY node for a MAC (if not fixed-link)
  *
@@ -1183,6 +1197,12 @@ static inline int dev_decode_display_timing(const struct udevice *dev,
 	return ofnode_decode_display_timing(dev_ofnode(dev), index, config);
 }
 
+static inline int dev_decode_panel_timing(const struct udevice *dev,
+					  struct display_timing *config)
+{
+	return ofnode_decode_panel_timing(dev_ofnode(dev), config);
+}
+
 static inline ofnode dev_get_phy_node(const struct udevice *dev)
 {
 	return ofnode_get_phy_node(dev_ofnode(dev));
-- 
2.17.1

Re: [PATCH v3 1/7] drivers: core: ofnode: Add panel timing decode.

[Anatolij Gustschin]

On Sat,  4 Feb 2023 18:41:25 +0100
Anatolij Gustschin agust@denx.de wrote:
...
> ---
> Changes in v3:
>  - add static inline dev_decode_panel_timing() in include/dm/read.h
>    to fix sandbox test errors when CONFIG_DM_DEV_READ_INLINE enabled
> 
>  drivers/core/ofnode.c | 47 +++++++++++++++++++++++++++++++++++++++++++
>  drivers/core/read.c   |  6 ++++++
>  include/dm/ofnode.h   | 12 +++++++++++
>  include/dm/read.h     | 20 ++++++++++++++++++
>  4 files changed, 85 insertions(+)

applied to u-boot-video/master, thanks!

--
Anatolij

Re: [PATCH v2 2/7] test: dm: test-fdt: Add decode_panel_timing test

[Anatolij Gustschin]

On Tue, 31 Jan 2023 15:35:15 +0530
Nikhil M Jain n-jain1@ti.com wrote:

> To test decode_panel_timing add a panel-timings node
> and a DM test for decode panel timingd by matching
> the panel timing node parameters.
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  arch/sandbox/dts/test.dts | 18 ++++++++++++++++++
>  test/dm/test-fdt.c        | 35 +++++++++++++++++++++++++++++++++++
>  2 files changed, 53 insertions(+)

applied to u-boot-video/master, thanks!

--
Anatolij

Re: [PATCH v2 3/7] drivers: video: simple_panel: make simple panel independent of backlight

[Anatolij Gustschin]

On Tue, 31 Jan 2023 15:35:16 +0530
Nikhil M Jain n-jain1@ti.com wrote:

> This patch updates the necessary Kconfigs to make simple panel
> driver independent of backlight driver  and compiling backlight
> related code in simple-panel driver conditionally to when user
> has set CONFIG_BACKLIGHT.
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> Reviewed-by: Simon Glass <sjg@chromium.org>
> ---
>  drivers/video/simple_panel.c | 7 +++++--
>  1 file changed, 5 insertions(+), 2 deletions(-)

applied to u-boot-video/master, thanks!

--
Anatolij

Re: [PATCH v2 4/7] drivers: video: tidss: TIDSS video driver support for AM62x

[Anatolij Gustschin]

On Tue, 31 Jan 2023 15:35:17 +0530
Nikhil M Jain n-jain1@ti.com wrote:

> Added tidss video driver support which enables display
> on oldi panel using AM62x, it creates a simple pipeline
> framebuffer==>vidl1==>ovr1==>vp1==>oldi_panel and  
> calculates clock rates for panel from panel node in
> device tree.
> 
> To compile TIDSS when user sets CONFIG_VIDEO_TIDSS
> add rule in Makefile. Include tidss folder location
> in Kconfig.
> 
> TIDSS is ported from linux kernel version 5.10.145
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  MAINTAINERS                      |   1 +
>  drivers/video/Kconfig            |   2 +
>  drivers/video/Makefile           |   1 +
>  drivers/video/tidss/Kconfig      |  18 +
>  drivers/video/tidss/Makefile     |  12 +
>  drivers/video/tidss/tidss_drv.c  | 943 +++++++++++++++++++++++++++++++
>  drivers/video/tidss/tidss_drv.h  | 137 +++++
>  drivers/video/tidss/tidss_regs.h | 292 ++++++++++
>  8 files changed, 1406 insertions(+)
>  create mode 100644 drivers/video/tidss/Kconfig
>  create mode 100644 drivers/video/tidss/Makefile
>  create mode 100644 drivers/video/tidss/tidss_drv.c
>  create mode 100644 drivers/video/tidss/tidss_drv.h
>  create mode 100644 drivers/video/tidss/tidss_regs.h

applied to u-boot-video/master, thanks!

--
Anatolij

Re: [PATCH v2 6/7] board: ti: am62x: evm: Add splash screen support

[Anatolij Gustschin]

On Tue, 31 Jan 2023 15:35:19 +0530
Nikhil M Jain n-jain1@ti.com wrote:

> Splash screen function needs splash source information
> to load image and display it, splash_location provides
> the necessary info, Set default_splash_location to MMC
> at partition 1:1. Probe DSS for splash screen display.
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  board/ti/am62x/evm.c | 25 ++++++++++++++++++++++---
>  1 file changed, 22 insertions(+), 3 deletions(-)

applied to u-boot-video/master after fixing coding style, thanks!

--
Anatolij

Re: [PATCH v2 7/7] tools: logos: Add TI logo files

[Anatolij Gustschin]

On Tue, 31 Jan 2023 15:35:20 +0530
Nikhil M Jain n-jain1@ti.com wrote:

> The default splashfile name saved is ti.gz. User can use these
> logo files and use it to test splash screen.
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  tools/logos/ti.bmp | Bin 0 -> 160770 bytes
>  tools/logos/ti.gz  | Bin 0 -> 12285 bytes
>  2 files changed, 0 insertions(+), 0 deletions(-)
>  create mode 100644 tools/logos/ti.bmp
>  create mode 100644 tools/logos/ti.gz

applied to u-boot-video/master, thanks!

--
Anatolij

Re: [PATCH v2 5/7] board: ti: am62x: am62x: Add splash screen env variables

[Anatolij Gustschin]

On Tue, 31 Jan 2023 15:35:18 +0530
Nikhil M Jain n-jain1@ti.com wrote:

> Set splash screen related env variables. Default splash source is
> set to mmc where user is expected to keep bmp in compressed format
> with name ti.gz on first partition of mmc.
> 
> Splash file will be uncompressed to DDR at address 0x82000000 and
> splash position is set to middle of screen.
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>
> ---
>  board/ti/am62x/am62x.env | 5 +++++
>  1 file changed, 5 insertions(+)

This patch does not apply, there is no board/ti/am62x/am62x.env.

I think we first need below patch applied (assigned to Tom):

  http://patchwork.ozlabs.org/project/uboot/patch/20230124051602.32351-2-n-jain1@ti.com/

@Tom: could you please apply it ? Thanks!

--
Anatolij

Re: [PATCH v2 5/7] board: ti: am62x: am62x: Add splash screen env variables

[Tom Rini]

[-- Attachment #1: Type: text/plain, Size: 473 bytes --]

On Tue, Jan 31, 2023 at 03:35:18PM +0530, Nikhil M Jain wrote:

> Set splash screen related env variables. Default splash source is
> set to mmc where user is expected to keep bmp in compressed format
> with name ti.gz on first partition of mmc.
> 
> Splash file will be uncompressed to DDR at address 0x82000000 and
> splash position is set to middle of screen.
> 
> Signed-off-by: Nikhil M Jain <n-jain1@ti.com>

Applied to u-boot/master, thanks!

-- 
Tom

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 659 bytes --]