linux-phy.lists.infradead.org archive mirror
 help / color / mirror / Atom feed
From: Cody Kang via B4 Relay <devnull+codykang.hk.gmail.com@kernel.org>
To: "David Airlie" <airlied@gmail.com>,
	"Simona Vetter" <simona@ffwll.ch>,
	"Maarten Lankhorst" <maarten.lankhorst@linux.intel.com>,
	"Maxime Ripard" <mripard@kernel.org>,
	"Thomas Zimmermann" <tzimmermann@suse.de>,
	"Rob Herring" <robh@kernel.org>,
	"Krzysztof Kozlowski" <krzk+dt@kernel.org>,
	"Conor Dooley" <conor+dt@kernel.org>,
	"Yixun Lan" <dlan@kernel.org>,
	"Troy Mitchell" <troy.mitchell@linux.spacemit.com>,
	"Vinod Koul" <vkoul@kernel.org>,
	"Neil Armstrong" <neil.armstrong@linaro.org>,
	"Manivannan Sadhasivam" <mani@kernel.org>,
	"Haylen Chu" <heylenay@4d2.org>,
	"Michael Turquette" <mturquette@baylibre.com>,
	"Stephen Boyd" <sboyd@kernel.org>,
	"Brian Masney" <bmasney+clk@redhat.com>,
	"Philipp Zabel" <p.zabel@pengutronix.de>,
	"Paul Walmsley" <pjw@kernel.org>,
	"Palmer Dabbelt" <palmer@dabbelt.com>,
	"Albert Ou" <aou@eecs.berkeley.edu>,
	"Alexandre Ghiti" <alex@ghiti.fr>, "Yao Zi" <me@ziyao.cc>,
	"Uwe Kleine-König" <u.kleine-koenig@baylibre.com>,
	"Guodong Xu" <docular.xu@gmail.com>,
	"Icenowy Zheng" <uwu@icenowy.me>,
	"Jerome Brunet" <jbrunet+clk@baylibre.com>,
	"Sarah Emery" <sarah.emery@canonical.com>,
	"Ze Huang" <ze.huang@oss.qualcomm.com>,
	"Dmitry Baryshkov" <lumag@kernel.org>
Cc: Cody Kang <codykang@vsit.ai>,
	dri-devel@lists.freedesktop.org,
	 linux-riscv@lists.infradead.org, devicetree@vger.kernel.org,
	 spacemit@lists.linux.dev, linux-kernel@vger.kernel.org,
	 linux-phy@lists.infradead.org, linux-clk@vger.kernel.org
Subject: [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend
Date: Sat, 21 Nov 2026 15:40:48 +0800	[thread overview]
Message-ID: <20261121-k3-display-v3-9-ec419e8e96b8@gmail.com> (raw)
In-Reply-To: <20261121-k3-display-v3-0-ec419e8e96b8@gmail.com>

From: Cody Kang <codykang@vsit.ai>

Add the register-level programming of one Saturn instance: clock and
reset bring-up, scene control and timing generator setup, RDMA channel
and composer layer programming, RDMA line-buffer sizing, interrupt
dispatch and the CFG_RDY/vsync handshake that paces commits. The KMS
layer calls the backend directly.

Signed-off-by: Cody Kang <codykang@vsit.ai>

---
v3:
- drop the tracepoints (Thomas Zimmermann)
- drop the ops table and inline the forwarding helpers (Thomas
  Zimmermann)
- drop the constant-fill path; the plane always uses RDMA channel 0
  (Thomas Zimmermann)
- size the RDMA line buffer per plane instead of arbitrating between
  channels (Thomas Zimmermann)
- submit only the compose list from the CRTC flush; the planes' lists
  are no longer sorted and submitted there (Thomas Zimmermann)
- arm the commit's event from the CFG_RDY interrupt and deliver it
  through the vblank machinery (Thomas Zimmermann)
- leave the DPU's pixel clock at the rate it has; on DP and eDP the PHY
  PLL is the pixel clock (Guodong Xu)
- return IRQ_NONE when no status bit was pending, disable the clocks in
  reverse enable order, drop a stray dma_rmb() and definitions nothing
  reads
- commit message: drop the reference to an upcoming patch
v2:
- drop the dead INT_VSYNC_UPDATE clear; the enum member goes away in
  patch 08 (Sashiko)
- drop the cmdlist parameter from saturn_hee_crtc_cmdlist(), matching
  the crtc_cmdlist op change in patch 08
---
 drivers/gpu/drm/spacemit/dpu/dpu_saturn.c          | 353 +++++++++++
 drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c      | 670 +++++++++++++++++++++
 drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.c       |  66 ++
 drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.h       |  16 +
 drivers/gpu/drm/spacemit/dpu/saturn_regs/ops_hee.h |  47 ++
 5 files changed, 1152 insertions(+)

diff --git a/drivers/gpu/drm/spacemit/dpu/dpu_saturn.c b/drivers/gpu/drm/spacemit/dpu/dpu_saturn.c
new file mode 100644
index 0000000000000..704e64fb9ec7e
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/dpu_saturn.c
@@ -0,0 +1,353 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/iopoll.h>
+#include <linux/regmap.h>
+#include <linux/timer.h>
+#include <linux/types.h>
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_fourcc.h>
+#include <drm/drm_print.h>
+#include <drm/drm_vblank.h>
+
+#include "../spacemit_cmdlist.h"
+#include "../spacemit_dmmu.h"
+#include "../spacemit_dpu_ids.h"
+#include "../spacemit_dpu_reg.h"
+#include "../spacemit_drm.h"
+#include "dpu_saturn.h"
+#include "saturn_regs/ops_hee.h"
+
+static const struct dpu_format_id primary_fmts[] = {
+	{ DRM_FORMAT_XRGB8888, 8, 32 },
+	{ DRM_FORMAT_ARGB8888, 4, 32 },
+	{ DRM_FORMAT_XBGR8888, 9, 32 },
+	{ DRM_FORMAT_ABGR8888, 5, 32 },
+	{ DRM_FORMAT_RGBX8888, 10, 32 },
+	{ DRM_FORMAT_RGBA8888, 6, 32 },
+	{ DRM_FORMAT_BGRX8888, 11, 32 },
+	{ DRM_FORMAT_BGRA8888, 7, 32 },
+	{ DRM_FORMAT_ABGR2101010, 1, 32 },
+	{ DRM_FORMAT_RGB888, 12, 24 },
+	{ DRM_FORMAT_BGR888, 13, 24 },
+	{ DRM_FORMAT_RGB565, 22, 16 },
+	{ DRM_FORMAT_BGR565, 23, 16 },
+};
+
+/* Read channels per instance. */
+#define SATURN_HEE_RDMA_NUM	4
+
+/* A commit whose CFG_RDY is not taken within this time is reported. */
+#define SATURN_CFG_RDY_TIMEOUT_MS	3000
+
+/* Wait for the previous CFG_RDY to be consumed before the block is set up. */
+#define SATURN_CFG_IDLE_POLL_US		100
+#define SATURN_CFG_IDLE_TIMEOUT_US	(200 * USEC_PER_MSEC)
+
+static const u32 saturn_hee_fbcmem_sizes[] = {
+	89600, /* 87.5 KiB */
+	15360, /* 15 KiB */
+};
+
+const struct spacemit_hw_device spacemit_k3_saturn_dpu = {
+	.rdma_nums = SATURN_HEE_RDMA_NUM,
+	.n_formats = ARRAY_SIZE(primary_fmts),
+	.formats = primary_fmts,
+	.n_fbcmems = ARRAY_SIZE(saturn_hee_fbcmem_sizes),
+	.fbcmem_sizes = saturn_hee_fbcmem_sizes,
+};
+
+void saturn_enable_irq_mask(struct spacemit_crtc *a_crtc, bool enable,
+			    u32 offset, u32 mask)
+{
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+
+	if (!priv->clocks_on)
+		return;
+
+	regmap_update_bits(hwdev->regmap, offset, mask, enable ? mask : 0);
+}
+
+int spacemit_dpu_parse_clocks(struct device *dev, struct dpu_clk_context *clk_ctx)
+{
+	clk_ctx->pxclk = devm_clk_get(dev, "pxclk");
+	if (IS_ERR(clk_ctx->pxclk))
+		return dev_err_probe(dev, PTR_ERR(clk_ctx->pxclk),
+				     "failed to get pxclk\n");
+
+	clk_ctx->mclk = devm_clk_get(dev, "mclk");
+	if (IS_ERR(clk_ctx->mclk))
+		return dev_err_probe(dev, PTR_ERR(clk_ctx->mclk),
+				     "failed to get mclk\n");
+
+	clk_ctx->escclk = devm_clk_get(dev, "escclk");
+	if (IS_ERR(clk_ctx->escclk))
+		return dev_err_probe(dev, PTR_ERR(clk_ctx->escclk),
+				     "failed to get escclk\n");
+
+	clk_ctx->aclk = devm_clk_get(dev, "aclk");
+	if (IS_ERR(clk_ctx->aclk))
+		return dev_err_probe(dev, PTR_ERR(clk_ctx->aclk),
+				     "failed to get aclk\n");
+
+	clk_ctx->dscclk = devm_clk_get(dev, "dscclk");
+	if (IS_ERR(clk_ctx->dscclk))
+		return dev_err_probe(dev, PTR_ERR(clk_ctx->dscclk),
+				     "failed to get dscclk\n");
+
+	return 0;
+}
+
+/*
+ * Bring @clk to the rate nearest @rate. A clock that refuses is reported and
+ * left as it is: the rates are targets, not requirements.
+ */
+static void spacemit_dpu_clk_set_rate(struct device *dev, struct clk *clk,
+				      unsigned long rate, const char *name)
+{
+	long rounded = clk_round_rate(clk, rate);
+	int ret;
+
+	if (rounded < 0) {
+		dev_warn_ratelimited(dev, "%s: no rate near %lu Hz: %ld\n",
+				     name, rate, rounded);
+		return;
+	}
+
+	ret = clk_set_rate(clk, rounded);
+	if (ret)
+		dev_warn_ratelimited(dev, "%s: failed to set %ld Hz: %d\n",
+				     name, rounded, ret);
+}
+
+int spacemit_dpu_enable_clocks(struct spacemit_drm_private *priv)
+{
+	struct dpu_clk_context *clk_ctx = &priv->clk_ctx;
+	int ret;
+
+	/*
+	 * Rate left alone: the mode's pixel clock is the DP PHY's PLL. This
+	 * input only has to run for the "lcd" reset to reach the DPU.
+	 */
+	ret = clk_prepare_enable(clk_ctx->pxclk);
+	if (ret)
+		goto err;
+
+	ret = clk_prepare_enable(clk_ctx->mclk);
+	if (ret)
+		goto err_pxclk;
+	spacemit_dpu_clk_set_rate(priv->dev, clk_ctx->mclk, DPU_MCLK_DEFAULT,
+				  "mclk");
+
+	/* The escape clock only has to run for the "esc" reset to propagate. */
+	ret = clk_prepare_enable(clk_ctx->escclk);
+	if (ret)
+		goto err_mclk;
+
+	ret = clk_prepare_enable(clk_ctx->aclk);
+	if (ret)
+		goto err_escclk;
+	spacemit_dpu_clk_set_rate(priv->dev, clk_ctx->aclk, DPU_AXICLK_DEFAULT,
+				  "aclk");
+
+	ret = clk_prepare_enable(clk_ctx->dscclk);
+	if (ret)
+		goto err_aclk;
+
+	return 0;
+
+err_aclk:
+	clk_disable_unprepare(clk_ctx->aclk);
+err_escclk:
+	clk_disable_unprepare(clk_ctx->escclk);
+err_mclk:
+	clk_disable_unprepare(clk_ctx->mclk);
+err_pxclk:
+	clk_disable_unprepare(clk_ctx->pxclk);
+err:
+	dev_err(priv->dev, "failed to enable DPU clocks: %d\n", ret);
+	return ret;
+}
+
+void spacemit_dpu_disable_clocks(struct spacemit_drm_private *priv)
+{
+	struct dpu_clk_context *clk_ctx = &priv->clk_ctx;
+
+	clk_disable_unprepare(clk_ctx->dscclk);
+	clk_disable_unprepare(clk_ctx->aclk);
+	clk_disable_unprepare(clk_ctx->escclk);
+	clk_disable_unprepare(clk_ctx->mclk);
+	clk_disable_unprepare(clk_ctx->pxclk);
+}
+
+u8 spacemit_plane_hw_get_format_id(u32 format)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(primary_fmts); i++) {
+		if (primary_fmts[i].format == format)
+			return primary_fmts[i].id;
+	}
+
+	return SPACEMIT_DPU_INVALID_FORMAT_ID;
+}
+
+/* Complete a commit whose lists the engine will not confirm any more. */
+void spacemit_dpu_complete_event(struct spacemit_crtc *a_crtc)
+{
+	struct drm_crtc *crtc = &a_crtc->crtc;
+	struct drm_pending_vblank_event *event;
+	unsigned long flags;
+
+	spin_lock_irqsave(&crtc->dev->event_lock, flags);
+	event = a_crtc->event;
+	a_crtc->event = NULL;
+	if (event)
+		drm_crtc_send_vblank_event(crtc, event);
+	spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
+
+	if (event)
+		drm_crtc_vblank_put(crtc);
+}
+
+void spacemit_cfg_rdy_timer_handler(struct timer_list *t)
+{
+	struct spacemit_crtc *a_crtc = timer_container_of(a_crtc, t,
+							  cfg_rdy_timer);
+
+	drm_err_ratelimited(a_crtc->crtc.dev, "CFG_RDY handshake timeout\n");
+	/* A CFG_RDY that still comes belongs to no commit any more. */
+	saturn_hee_enable_irq(a_crtc, INT_CFG_RDY, false);
+	spacemit_dpu_complete_event(a_crtc);
+}
+
+void spacemit_dpu_init(struct spacemit_crtc *a_crtc,
+		       const struct drm_display_mode *mode)
+{
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	u32 val;
+
+	if (!priv->clocks_on)
+		return;
+
+	if (read_poll_timeout(saturn_hee_get_cfg_rdy, val, val == 0,
+			      SATURN_CFG_IDLE_POLL_US,
+			      SATURN_CFG_IDLE_TIMEOUT_US, false, a_crtc, hwdev))
+		drm_err(a_crtc->crtc.dev, "wait for cfg ready timed out\n");
+
+	saturn_hee_dpu_init(a_crtc, mode);
+}
+
+void spacemit_dpu_uninit(struct spacemit_crtc *a_crtc)
+{
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+
+	if (!priv->clocks_on)
+		return;
+
+	saturn_hee_irq_enable(a_crtc, false);
+}
+
+/* The read channels of the planes this CRTC scans out after the commit. */
+u32 saturn_conf_dpuctrl_rdma(struct drm_atomic_commit *state,
+			     const struct drm_crtc_state *crtc_state)
+{
+	struct drm_plane *plane;
+	u32 rdma_en = 0;
+
+	drm_for_each_plane_mask(plane, crtc_state->crtc->dev,
+				crtc_state->plane_mask) {
+		const struct drm_plane_state *plane_state =
+				drm_atomic_get_new_plane_state(state, plane);
+
+		/* A plane the commit does not touch keeps its current state. */
+		if (!plane_state)
+			plane_state = plane->state;
+		if (plane_state->visible)
+			rdma_en |= BIT(to_spacemit_plane(plane)->rdma_id);
+	}
+
+	return rdma_en;
+}
+
+/* Returns false when none of the pending status bits was this CRTC's. */
+bool spacemit_dpu_online_isr(struct spacemit_crtc *a_crtc)
+{
+	u32 irq_raw, irq_bit, irq_ur_bit, handled;
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+
+	irq_raw = saturn_hee_get_int_sts(hwdev);
+	irq_bit = saturn_hee_get_irq_bit(INT_UNDERRUN);
+	irq_ur_bit = irq_raw & irq_bit;
+	handled = irq_ur_bit;
+	if (irq_ur_bit && !a_crtc->ur_reported) {
+		saturn_hee_clr_int_sts(a_crtc, irq_ur_bit);
+		drm_err_ratelimited(a_crtc->crtc.dev, "underrun\n");
+		a_crtc->ur_reported = true;
+	}
+	irq_bit = saturn_hee_get_irq_bit(INT_CFG_RDY);
+	if (irq_raw & irq_bit) {
+		saturn_hee_clr_int_sts(a_crtc, irq_bit);
+		timer_delete(&a_crtc->cfg_rdy_timer);
+		a_crtc->ur_reported = false;
+		saturn_hee_enable_irq(a_crtc, INT_CFG_RDY, false);
+		handled |= irq_bit;
+
+		/* The lists are taken: the next vblank completes the commit. */
+		spin_lock(&a_crtc->crtc.dev->event_lock);
+		if (a_crtc->event) {
+			drm_crtc_arm_vblank_event(&a_crtc->crtc, a_crtc->event);
+			a_crtc->event = NULL;
+		}
+		spin_unlock(&a_crtc->crtc.dev->event_lock);
+	}
+	irq_bit = saturn_hee_get_irq_bit(INT_VSYNC);
+	if (irq_raw & irq_bit) {
+		saturn_hee_clr_int_sts(a_crtc, irq_bit);
+		drm_crtc_handle_vblank(&a_crtc->crtc);
+		handled |= irq_bit;
+	}
+	irq_bit = saturn_hee_get_irq_bit(INT_REST) | irq_ur_bit;
+	if (irq_raw & irq_bit) {
+		saturn_hee_clr_int_sts(a_crtc, irq_bit);
+		handled |= irq_raw & irq_bit;
+	}
+
+	return handled;
+}
+
+void spacemit_dpu_run(struct drm_crtc *crtc, struct drm_atomic_commit *state)
+{
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+
+	saturn_hee_conf_dpuctrl(crtc, state);
+
+	/* flush all config register writes before CFG_RDY is raised */
+	mb();
+
+	/* Ack first: one left by a commit that timed out is not this one's. */
+	saturn_hee_clr_int_sts(a_crtc, saturn_hee_get_irq_bit(INT_CFG_RDY));
+	saturn_hee_enable_irq(a_crtc, INT_CFG_RDY, true);
+
+	mod_timer(&a_crtc->cfg_rdy_timer,
+		  jiffies + msecs_to_jiffies(SATURN_CFG_RDY_TIMEOUT_MS));
+	saturn_hee_cfg_ready(a_crtc, hwdev);
+
+	if (unlikely(a_crtc->is_1st_f)) {
+		drm_dbg(a_crtc->crtc.dev, "DPU start\n");
+		a_crtc->is_1st_f = false;
+		saturn_hee_sw_start(a_crtc, hwdev);
+	}
+}
+
diff --git a/drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c b/drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c
new file mode 100644
index 0000000000000..1a194fe7cc7ba
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c
@@ -0,0 +1,670 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/regmap.h>
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_blend.h>
+#include <drm/drm_framebuffer.h>
+#include <drm/drm_print.h>
+
+#include "../spacemit_cmdlist.h"
+#include "../spacemit_dmmu.h"
+#include "../spacemit_dpu_ids.h"
+#include "../spacemit_dpu_reg.h"
+#include "dpu_saturn.h"
+#include "saturn_fbcmem.h"
+#include "saturn_regs/ops_hee.h"
+#include "saturn_regs/reg_map_hee.h"
+
+#define SATURN_WRITE_TBU_REGS(hwdev, base, reg_id, cl_tbu) \
+do {\
+	dpu_write(hwdev, MMU_TBU_REG, base, tbu_base_addr##reg_id##_low, \
+		  tbu->ttb_pa[reg_id] & 0xFFFFFFFF, cl_tbu); \
+	dpu_write(hwdev, MMU_TBU_REG, base, tbu_base_addr##reg_id##_high, \
+		  (tbu->ttb_pa[reg_id] >> 32) & 0xFFF, cl_tbu); \
+	dpu_write(hwdev, MMU_TBU_REG, base, tbu_va##reg_id, \
+		 (tbu->tbu_va[reg_id] >> 12), cl_tbu); \
+	dpu_write(hwdev, MMU_TBU_REG, base, \
+		  tbu_size##reg_id, tbu->ttb_size[reg_id], cl_tbu); \
+	dpu_write(hwdev, MMU_TBU_REG, base, \
+		  vsync_update_en, 1, cl_tbu); \
+} while (0)
+
+#define SATURN_WRITE_RDMA_ADDR_REG(hwdev, reg_id, rdma_id, addr, cl_rdma) \
+do { \
+	dpu_write(hwdev, RDMA_PATH_X_REG, RDMA_BASE_ADDR[rdma_id], \
+		  base_addr##reg_id##_low_ly0, (addr) & 0xFFFFFFFF, cl_rdma); \
+	dpu_write(hwdev, RDMA_PATH_X_REG, RDMA_BASE_ADDR[rdma_id], \
+		  base_addr##reg_id##_high_ly0, ((addr) >> 32) & 0xFFF, \
+		  cl_rdma); \
+} while (0)
+
+static const u32 RDMA_BASE_ADDR[] = {
+	RDMA0_BASE_ADDR,
+	RDMA1_BASE_ADDR,
+	RDMA2_BASE_ADDR,
+	RDMA3_BASE_ADDR,
+};
+
+static const u32 MMU_TBU_BASE_ADDR_ARRAY[] = {
+	TBU0_ADDR, TBU1_ADDR, TBU2_ADDR, TBU3_ADDR,
+	TBU4_ADDR, TBU5_ADDR, TBU6_ADDR, TBU7_ADDR,
+};
+
+void saturn_hee_enable_irq(struct spacemit_crtc *a_crtc,
+			   enum spacemit_dpu_irq irq_id, bool enable)
+{
+	saturn_enable_irq_mask(a_crtc, enable,
+			       DPU_INT_BASE_ADDR + DPU_ONLINE_IRQ_MSK,
+			       saturn_hee_get_irq_bit(irq_id));
+}
+
+void saturn_hee_cfg_ready(struct spacemit_crtc *a_crtc,
+			  struct spacemit_hw_device *hwdev)
+{
+	u32 base = DPU_SCENE_CTL_ADDR(COMPOSER1);
+
+	saturn_hee_enable_irq(a_crtc, INT_UNDERRUN, true);
+	a_crtc->ur_mask_armed = true;
+	dpu_write(hwdev, DPU_CTL_REG, base, both_cfg_rdy, 1);
+}
+
+void saturn_hee_sw_start(struct spacemit_crtc *a_crtc,
+			 struct spacemit_hw_device *hwdev)
+{
+	u32 base;
+
+	base = DPU_SCENE_CTL_ADDR(COMPOSER1);
+	dpu_write_reg(hwdev, DPU_CTL_REG, base, sw_start, 1);
+}
+
+static void saturn_init_tmg(struct spacemit_crtc *a_crtc,
+			    const struct drm_display_mode *mode)
+{
+	u32 base = TMG0_BASE_ADDR;
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	u16 vfp, vbp, vsync, hfp, hbp, hsync;
+	void __iomem *tmg_addr;
+	u32 value;
+
+	tmg_addr = hwdev->base + TMG0_BASE_ADDR;
+
+	hsync = mode->hsync_end - mode->hsync_start;
+	hbp = mode->htotal - mode->hsync_end;
+	hfp = mode->hsync_start - mode->hdisplay;
+	vsync = mode->vsync_end - mode->vsync_start;
+	vbp = mode->vtotal - mode->vsync_end;
+	vfp = mode->vsync_start - mode->vdisplay;
+	drm_dbg(a_crtc->crtc.dev, "timing " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
+
+	dpu_write(hwdev, TMG_REG, base, disp_ready_man_en, 0);
+	dpu_write(hwdev, TMG_REG, base, background_r, 0);
+	dpu_write(hwdev, TMG_REG, base, background_g, 0x0);
+	dpu_write(hwdev, TMG_REG, base, background_b, 0xff);
+	dpu_write(hwdev, TMG_REG, base, eof_1st_ln_dly_num, vfp - 7);
+	dpu_write(hwdev, TMG_REG, base, eof_2nd_ln_dly_num, vfp - 6);
+	dpu_write(hwdev, TMG_REG, base, split_en, 0);
+	dpu_write(hwdev, TMG_REG, base, cmd_screen, 0);
+	dpu_write(hwdev, TMG_REG, base, cmd_wait_en, 0);
+	dpu_write(hwdev, TMG_REG, base, cmd_wait_te, 0);
+	dpu_write(hwdev, TMG_REG, base, sof_pre_ln_num, 0);
+	dpu_write(hwdev, TMG_REG, base, hfp, hfp);
+	dpu_write(hwdev, TMG_REG, base, hbp, hbp);
+	dpu_write(hwdev, TMG_REG, base, vfp, vfp);
+	dpu_write(hwdev, TMG_REG, base, vbp, vbp);
+	dpu_write(hwdev, TMG_REG, base, hsync_width, hsync);
+	dpu_write(hwdev, TMG_REG, base, vsync_width, vsync);
+	dpu_write(hwdev, TMG_REG, base, hsp, 1);
+	dpu_write(hwdev, TMG_REG, base, vsp, 1);
+	dpu_write(hwdev, TMG_REG, base, h_active, mode->hdisplay);
+	dpu_write(hwdev, TMG_REG, base, v_active, mode->vdisplay);
+	dpu_write(hwdev, TMG_REG, base, fm_timing_en, 1);
+	/* The pipeline always hands RGB888 to the DP/eDP encoder. */
+	dpu_write(hwdev, TMG_REG, base, user, OUTFMT_RGB888);
+
+	value = readl(tmg_addr + 4 * dpu_field_word(TMG_REG, vfp));
+	value &= ~dpu_field_mask(TMG_REG, vfp);
+	value |= vfp;
+	writel(value, tmg_addr + 4 * dpu_field_word(TMG_REG, vfp));
+
+	dpu_write(hwdev, TMG_REG, base, vsync_align_with_hsync, 1);
+}
+
+static void saturn_init_regs(struct spacemit_crtc *a_crtc,
+			     const struct drm_display_mode *mode)
+{
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	u32 base;
+
+	base = CMP1_BASE_ADDR;
+	dpu_write(hwdev, CMPS_X_REG, base, bg_color_b, 0x0);
+	dpu_write(hwdev, CMPS_X_REG, base, bg_color_r, 0x0);
+	dpu_write(hwdev, CMPS_X_REG, base, bg_color_g, 0x0);
+	dpu_write(hwdev, CMPS_X_REG, base, bg_color_a, 0xFF);
+	dpu_write(hwdev, CMPS_X_REG, base, module_enable, 1);
+	dpu_write(hwdev, CMPS_X_REG, base, layer00_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer01_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer02_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer03_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer04_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer05_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer06_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer07_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer08_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer09_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer10_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer11_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer12_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer13_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer14_en, 0);
+	dpu_write(hwdev, CMPS_X_REG, base, layer15_en, 0);
+
+	base = EE_ADDR;
+	dpu_write(hwdev, EE_REG, base, m_benable, 0);
+
+	saturn_init_tmg(a_crtc, mode);
+}
+
+static void saturn_setup_dma_top(struct spacemit_crtc *a_crtc)
+{
+	u32 base = DMA_TOP_BASE_ADDR;
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+
+	dpu_write(hwdev, DMA_TOP_REG, base, image_rr_ratio, 0x10);
+	dpu_write(hwdev, DMA_TOP_REG, base, pixel_num_th, 4);
+
+	dpu_write(hwdev, DMA_TOP_REG, base, rdma_timeout_limit, 0xFFFE);
+	dpu_write(hwdev, DMA_TOP_REG, base, wdma_timeout_limit, 0xFFFF);
+}
+
+static void saturn_setup_mmu_top(struct spacemit_crtc *a_crtc)
+{
+	unsigned int rd_outs_num = RD_OUTS_NUM / 2;
+	u32 base = MMU_TOP_BASE_ADDR;
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+
+	dpu_write(hwdev, MMU_TOP_REG, base, rdma_timelimit, RDMA_TIMELIMIT);
+
+	dpu_write(hwdev, MMU_TOP_REG, base, sram0_tlb_axi_port_sel, 0);
+	dpu_write(hwdev, MMU_TOP_REG, base, sram1_tlb_axi_port_sel, 0);
+	dpu_write(hwdev, MMU_TOP_REG, base, dmac0_rd_outs_num, rd_outs_num);
+	dpu_write(hwdev, MMU_TOP_REG, base, dmac1_rd_outs_num, rd_outs_num);
+}
+
+void saturn_hee_irq_enable(struct spacemit_crtc *a_crtc, bool enable)
+{
+	u32 offset = DPU_INT_BASE_ADDR + DPU_ONLINE_IRQ_MSK;
+	u32 mask;
+
+	mask = saturn_hee_get_irq_bit(INT_UNDERRUN) |
+	       saturn_hee_get_irq_bit(INT_CFG_RDY);
+	if (enable) {
+		struct spacemit_drm_private *priv =
+				a_crtc->crtc.dev->dev_private;
+
+		/*
+		 * Ack first: a surviving status bit would fire as the mask
+		 * opens.
+		 */
+		regmap_write(priv->hwdev->regmap,
+			     DPU_INT_BASE_ADDR + DPU_ONLINE_IRQ_STS, mask);
+	}
+	saturn_enable_irq_mask(a_crtc, enable, offset, mask);
+	a_crtc->ur_mask_armed = enable;
+}
+
+void saturn_hee_dpu_init(struct spacemit_crtc *a_crtc,
+			 const struct drm_display_mode *mode)
+{
+	saturn_init_regs(a_crtc, mode);
+	saturn_setup_dma_top(a_crtc);
+	saturn_setup_mmu_top(a_crtc);
+	saturn_hee_irq_enable(a_crtc, true);
+}
+
+#define SATURN_WRITE_COMPOSER_LAYER(id_name) \
+do {\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _colorkey_en,	\
+		  0, cl_cmp);					\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _blend_mode,	\
+		  blend_mode, cl_cmp);				\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _blend_sel,	\
+		  alpha_sel, cl_cmp);				\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _layer_alpha,	\
+		  alpha, cl_cmp);					\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _alpha_ratio,	\
+		  0, cl_cmp);					\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _area_left,	\
+		  crtc_x, cl_cmp);					\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _area_top,	\
+		  crtc_y, cl_cmp);					\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _area_right,	\
+		  crtc_x + crtc_w - 1, cl_cmp);			\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _area_bottom,	\
+		  crtc_y + crtc_h - 1, cl_cmp);			\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _solid_en,	\
+		  0, cl_cmp);				\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _dma_id,	\
+		  rdma_id, cl_cmp);			\
+	dpu_write(hwdev, CMPS_X_REG, base, layer ## id_name ## _en, 1, cl_cmp); \
+} while (0)
+
+static void saturn_write_fbcmem_regs(struct spacemit_hw_device *hwdev,
+				     struct drm_plane_state *state, u32 base,
+				     struct cmdlist_regs *cl_rdma)
+{
+	u32 size = to_spacemit_plane_state(state)->fbcmem_size;
+	u32 val;
+
+	/* The plane owns the front of its bank: the base address stays 0. */
+	val = FIELD_PREP(dpu_field_mask(RDMA_PATH_X_REG, fbc_mem_map), 1) |
+	      FIELD_PREP(dpu_field_mask(RDMA_PATH_X_REG, fbc_mem_size), size);
+	dpu_write_word(hwdev, base,
+		       dpu_field_word(RDMA_PATH_X_REG, fbc_mem_size), val,
+		       cl_rdma);
+}
+
+void saturn_hee_plane_update_hw_channel(struct drm_plane *plane,
+					struct drm_plane_state *state,
+					const struct drm_display_mode *mode)
+{
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(state->crtc);
+	struct drm_framebuffer *fb = state->fb;
+	struct spacemit_plane_state *spacemit_plane_state =
+			to_spacemit_plane_state(state);
+	struct cmdlist_regs *cl_cmp = a_crtc->cl_cmp;
+	u32 rdma_id = to_spacemit_plane(plane)->rdma_id;
+	u8 alpha = state->alpha >> 8;
+	u16 pixel_alpha = state->pixel_blend_mode;
+	u32 src_w, src_h, src_x, src_y;
+	u32 crtc_w, crtc_h, crtc_x, crtc_y;
+	u32 alpha_sel, blend_mode = 0;
+	u32 base;
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	struct cmdlist_regs *cl_rdma = to_spacemit_plane(plane)->cl_rdma;
+
+	/* Clipped by drm_atomic_helper_check_plane_state(); src is 16.16. */
+	src_x = state->src.x1 >> 16;
+	src_y = state->src.y1 >> 16;
+	src_w = drm_rect_width(&state->src) >> 16;
+	src_h = drm_rect_height(&state->src) >> 16;
+
+	crtc_x = state->dst.x1;
+	crtc_y = state->dst.y1;
+	crtc_w = drm_rect_width(&state->dst);
+	crtc_h = drm_rect_height(&state->dst);
+
+	drm_dbg(plane->dev, "crtc_x %u crtc_y %u\n", crtc_x, crtc_y);
+
+	base = RDMA_BASE_ADDR[rdma_id];
+	/* linear scanout only: the FBC decode path is not exposed */
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, layer_mode, 0, cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, layer_cmpsr_id, COMPOSER1,
+		  cl_rdma);
+	/*
+	 * force online-mode routing whatever the bootloader left behind
+	 */
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, is_offline, 0, cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, is_two_layers, 0, cl_rdma);
+
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, img_width_ly0, fb->width,
+		  cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, img_height_ly0, fb->height,
+		  cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, bbox_start_x_ly0, src_x,
+		  cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, bbox_start_y_ly0, src_y,
+		  cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, bbox_end_x_ly0,
+		  src_x + src_w - 1, cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, bbox_end_y_ly0,
+		  src_y + src_h - 1, cl_rdma);
+
+	saturn_write_fbcmem_regs(hwdev, state, base, cl_rdma);
+
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, rot_mode_ly0, 0, cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, uv_swap, 0, cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, pixel_format,
+		  spacemit_plane_state->format, cl_rdma);
+
+	switch (pixel_alpha) {
+	case DRM_MODE_BLEND_COVERAGE:
+		blend_mode = 0x0;
+		break;
+	case DRM_MODE_BLEND_PREMULTI:
+		blend_mode = 0x1;
+		break;
+	case DRM_MODE_BLEND_PIXEL_NONE:
+		blend_mode = 0x0;
+		break;
+	default:
+		drm_err(plane->dev, "unsupported blend mode for pixel alpha\n");
+	}
+
+	if (fb->format->has_alpha && pixel_alpha != DRM_MODE_BLEND_PIXEL_NONE) {
+		if (alpha != 0xff)
+			alpha_sel = 0x2;
+		else
+			alpha_sel = 0x1;
+	} else {
+		blend_mode = 0x0;
+		alpha_sel = 0x0;
+	}
+
+	base = CMP1_BASE_ADDR;
+	dpu_write(hwdev, CMPS_X_REG, base, dst_w, mode->hdisplay, cl_cmp);
+	dpu_write(hwdev, CMPS_X_REG, base, dst_h, mode->vdisplay, cl_cmp);
+
+	SATURN_WRITE_COMPOSER_LAYER(00);
+	spacemit_cmdlist_regs_packing(spacemit_crtc_to_cl(state->crtc), CMDLIST_MOD_COMP,
+				      cl_cmp);
+}
+
+void saturn_hee_plane_disable_hw_channel(struct drm_plane *plane,
+					 struct drm_crtc *crtc)
+{
+	u32 base = CMP1_BASE_ADDR;
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	struct cmdlist_regs *cl_cmp = to_spacemit_crtc(crtc)->cl_cmp;
+
+	dpu_write(hwdev, CMPS_X_REG, base, layer00_en, 0, cl_cmp);
+
+	spacemit_cmdlist_regs_packing(spacemit_crtc_to_cl(crtc), CMDLIST_MOD_COMP,
+				      cl_cmp);
+}
+
+void saturn_hee_conf_dpuctrl(struct drm_crtc *crtc,
+			     struct drm_atomic_commit *state)
+{
+	struct drm_crtc_state *crtc_state =
+			drm_atomic_get_new_crtc_state(state, crtc);
+	u32 rdma_en;
+	u32 base;
+	u32 pp_base = POST_PIPE_ADDR;
+	struct spacemit_drm_private *priv = crtc->dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+	const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
+	struct cmdlist_regs *pp_cl = a_crtc->cl_pp;
+
+	base = DPU_SCENE_CTL_ADDR(COMPOSER1);
+	rdma_en = saturn_conf_dpuctrl_rdma(state, crtc_state);
+
+	/* The post-pipe needs its input size even when it processes nothing. */
+	dpu_write_word(hwdev, pp_base, 0, 0, pp_cl);
+	dpu_write(hwdev, POSTPIPE_REG, pp_base, m_inwidth, mode->hdisplay,
+		  pp_cl);
+	dpu_write(hwdev, POSTPIPE_REG, pp_base, m_inheight, mode->vdisplay,
+		  pp_cl);
+
+	spacemit_cmdlist_regs_packing(spacemit_crtc_to_cl(crtc), CMDLIST_MOD_COMP, pp_cl);
+
+	dpu_write(hwdev, DPU_CTL_REG, base, nml_scl_en, 0);
+	dpu_write(hwdev, DPU_CTL_REG, base, nml_rch_en, rdma_en);
+	dpu_write(hwdev, DPU_CTL_REG, base, timing_inter0, 8);
+	dpu_write(hwdev, DPU_CTL_REG, base, timing_inter1, 8);
+	dpu_write(hwdev, DPU_CTL_REG, base, video_mod, 1);
+	dpu_write(hwdev, DPU_CTL_REG, base, dbg_mod, 0);
+
+	dpu_write(hwdev, DPU_CTL_REG, base, nml_outctl_en, 0x1);
+	dpu_write(hwdev, DPU_CTL_REG, base, nml_frm_timing_en, 2);
+
+	spacemit_cmdlist_submit_crtc(a_crtc);
+}
+
+u32 saturn_hee_get_cfg_rdy(struct spacemit_crtc *a_crtc,
+			   struct spacemit_hw_device *hwdev)
+{
+	u32 base = DPU_SCENE_CTL_ADDR(COMPOSER1);
+
+	return dpu_read_word(hwdev, base,
+			     dpu_field_word(DPU_CTL_REG, both_cfg_rdy));
+}
+
+u32 saturn_hee_get_int_sts(struct spacemit_hw_device *hwdev)
+{
+	return dpu_read_word(hwdev, DPU_INT_BASE_ADDR, DPU_ONLINE_IRQ_STS / 4);
+}
+
+static const struct spacemit_crtc_irq_bitfield {
+	enum spacemit_dpu_irq irq_id;
+	u32 irq_bit;
+} irq_list[] = {
+	[INT_UNDERRUN] = {INT_UNDERRUN, DPU_INT_FRM_TIMING_UNFLOW},
+	[INT_CFG_RDY] = {INT_CFG_RDY, DPU_INT_CFG_RDY_CLR},
+	[INT_VSYNC] = {INT_VSYNC, DPU_INT_FRM_TIMING_VSYNC},
+	[INT_EOF] = {INT_EOF, DPU_INT_FRM_TIMING_EOF},
+	[INT_REST] = {INT_REST, DPU_REST_INT_BITS},
+};
+
+u32 saturn_hee_get_irq_bit(enum spacemit_dpu_irq irq_id)
+{
+	return irq_list[irq_id].irq_bit;
+}
+
+void saturn_hee_clr_int_sts(struct spacemit_crtc *a_crtc, u32 data)
+{
+	struct spacemit_drm_private *priv = a_crtc->crtc.dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+
+	regmap_write(hwdev->regmap, DPU_INT_BASE_ADDR + DPU_ONLINE_IRQ_STS,
+		     data);
+	if ((saturn_hee_get_irq_bit(INT_UNDERRUN) & data) &&
+	    a_crtc->ur_mask_armed) {
+		saturn_hee_enable_irq(a_crtc, INT_UNDERRUN, false);
+		a_crtc->ur_mask_armed = false;
+	}
+}
+
+void saturn_hee_enable_cmdlist(struct spacemit_crtc *a_crtc, struct spacemit_hw_device *hwdev,
+			       int id, bool enable)
+{
+	u32 base = DPU_SCENE_CTL_ADDR(COMPOSER1);
+	u32 val;
+
+	dpu_write_reg_arr(hwdev, DPU_CTL_TOP_REG, DPU_CTRL_BASE_ADDR,
+			  dpu_ctl_top_reg_0, id, cmdlist_rch_en,
+			  enable ? 1 : 0);
+	/* One layer per channel: clear its vertical-reuse bit. */
+	val = dpu_read_reg(hwdev, DPU_CTL_REG, base, nml_rch_vrt_reuse);
+	val &= ~BIT(id);
+	dpu_write(hwdev, DPU_CTL_REG, base, nml_rch_vrt_reuse, val);
+}
+
+void saturn_hee_cfg_cmdlist(struct spacemit_hw_device *hwdev, int id, u32 chy,
+			    u32 addrl, u32 addrh)
+{
+	dpu_write_reg_arr(hwdev, CMDLIST_REG, CMDLIST_BASE_ADDR,
+			  cmdlist_reg_48, id, cmdlist_ch_y_first, chy);
+	dpu_write_reg_arr(hwdev, CMDLIST_REG, CMDLIST_BASE_ADDR,
+			  cmdlist_reg_0, id, cmdlist_ch_start_addrl, addrl);
+	dpu_write_reg_arr(hwdev, CMDLIST_REG, CMDLIST_BASE_ADDR,
+			  cmdlist_reg_16, id, cmdlist_ch_start_addrh, addrh);
+}
+
+void saturn_hee_rdma_dmmu(struct spacemit_hw_device *hwdev, u8 tbu_id, struct tbu_instance *tbu,
+			  struct drm_framebuffer *fb,
+			  struct cmdlist_regs *cl_rdma,
+			  struct drm_plane *plane)
+{
+	u32 base, val;
+	u8 rdma_id = tbu_id / 2;
+	struct cmdlist_regs *cl_tbu = to_spacemit_plane(plane)->cl_tbu;
+
+	SATURN_WRITE_RDMA_ADDR_REG(hwdev, 0, rdma_id, tbu->tbu_va[0], cl_rdma);
+	SATURN_WRITE_RDMA_ADDR_REG(hwdev, 1, rdma_id, tbu->tbu_va[1], cl_rdma);
+	SATURN_WRITE_RDMA_ADDR_REG(hwdev, 2, rdma_id, tbu->tbu_va[2], cl_rdma);
+
+	base = RDMA_BASE_ADDR[rdma_id];
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, rdma_stride0_layer0,
+		  fb->pitches[0], cl_rdma);
+	dpu_write(hwdev, RDMA_PATH_X_REG, base, rdma_stride1_layer0,
+		  fb->pitches[1], cl_rdma);
+
+	base = MMU_TBU_BASE_ADDR_ARRAY[tbu_id];
+	SATURN_WRITE_TBU_REGS(hwdev, base, 0, cl_tbu);
+	SATURN_WRITE_TBU_REGS(hwdev, base, 1, cl_tbu);
+	SATURN_WRITE_TBU_REGS(hwdev, base, 2, cl_tbu);
+
+	/* Linear scanout of one plane: the mode and plane count stay 0. */
+	val = FIELD_PREP(dpu_field_mask(MMU_TBU_REG, tbu_en), 1) |
+	      FIELD_PREP(dpu_field_mask(MMU_TBU_REG, tbu_burst_limit_en), 1) |
+	      FIELD_PREP(dpu_field_mask(MMU_TBU_REG, tlb_fetch_active_en), 1) |
+	      FIELD_PREP(dpu_field_mask(MMU_TBU_REG, tbu_qos), DPU_QOS_URGENT);
+	dpu_write_word(hwdev, base, dpu_field_word(MMU_TBU_REG, tbu_en), val,
+		       cl_tbu);
+	spacemit_cmdlist_regs_packing(spacemit_plane_to_cl(plane), CMDLIST_MOD_DMMU, cl_tbu);
+}
+
+struct cmdlist_header {
+	u64 next_list_addr : 39;
+	/* reserved */
+	u32: 1;
+	u32 nod_len : 16;
+	/* 1: the last cmdlist node, 2: pending node, otherwise 0 */
+	u32 nod_type : 2;
+	u32 next_nod_secu : 1;
+	u64 wait_event_low    : 5;
+	u64 wait_event    : 59;
+	/* reserved */
+	u32: 5;
+};
+
+struct cmdlist_row {
+	u32 module_cfg_addr   : 19;
+	u32 module_cfg_strobe : 12;
+	/* the last row tag = 1, else tag = 0. */
+	u32 row_eof_tag       : 1;
+	u32 module_regs[3];
+};
+
+/* DMA stream layout consumed by the cmdlist engine; it relies on the sizes. */
+static_assert(sizeof(struct cmdlist_header) == CMDLIST_HEADER_SIZE);
+static_assert(sizeof(struct cmdlist_row) == 16);
+
+#define CL_HEADER_SZ sizeof(struct cmdlist_header)
+#define CL_ROW_SZ    sizeof(struct cmdlist_row)
+
+#define CMDLIST_RDMA_CFG_RDY(ch) BIT(ch)
+#define CMDLIST_CMPS_CFG_RDY(ch) BIT((ch) + 20)
+
+#define CMDLIST_WAIT_EVENT_BIT_RDMA_RELOAD BIT(4)
+#define CMDLIST_WAIT_EVENT_BIT_CMPS_RELOAD BIT(6)
+
+/* Returns false, without writing, when the row would overrun the buffer. */
+bool saturn_hee_cmdlist_fill_data_row(struct cmdlist *cl, u32 strobe,
+				      u32 offset, u32 value[])
+{
+	struct cmdlist_row *row;
+	u8 i;
+
+	if (CL_HEADER_SZ + (cl->nod_len + 1) * CL_ROW_SZ > cl->size)
+		return false;
+
+	/* The buffer is reused: write the whole row, end tag included. */
+	row = (struct cmdlist_row *)((char *)cl->va + CL_HEADER_SZ) + cl->nod_len;
+	*row = (struct cmdlist_row) {
+		.module_cfg_addr = offset >> 2,
+		.module_cfg_strobe = strobe,
+	};
+
+	for (i = 0; i < CMDLIST_ROW_REGS; i++) {
+		if (strobe & CMDLIST_REG_STROBE(i))
+			row->module_regs[i] = value[i];
+	}
+
+	return true;
+}
+
+/*
+ * Close a list: the compose-start row (plane lists only), the CFG_RDY row that
+ * ends it, and the header. A list is a single node, so the header never
+ * chains to another.
+ */
+void saturn_hee_cmdlist_fill_conf_row(struct cmdlist *cl, u32 ch_y)
+{
+	struct cmdlist_header *header;
+	struct cmdlist_row *row;
+	struct drm_device *drm;
+	u8 rch_id = 0;
+	u32 wait_event_bits = 0, cfg_rdy_bits = 0;
+
+	if (cl->type == CMDLIST_PLANE) {
+		rch_id = to_spacemit_plane(cl->plane)->rdma_id;
+		drm = cl->plane->dev;
+	} else {
+		drm = cl->crtc->dev;
+	}
+
+	/* At most two rows are appended below; bail before overrunning. */
+	if (drm_WARN_ONCE(drm, CL_HEADER_SZ + (cl->nod_len + 2) * CL_ROW_SZ > cl->size,
+			  "cmdlist buffer full (type %u, rows %u)\n",
+			  cl->type, cl->nod_len))
+		return;
+
+	header = (struct cmdlist_header *)(cl->va);
+	row = (struct cmdlist_row *)((char *)header + CL_HEADER_SZ + cl->nod_len * CL_ROW_SZ);
+
+	if (cl->type == CMDLIST_PLANE) {
+		/* The composer must start fetching 24 lines ahead of the layer. */
+		*row = (struct cmdlist_row) {
+			.module_cfg_addr = (DPU_CTRL_BASE_ADDR +
+					    CMDLIST_CH_START_CMPS_Y + rch_id * 4) >> 2,
+			.module_cfg_strobe = CMDLIST_REG_STROBE(0),
+			.module_regs[0] = ch_y >= 24 ? ch_y - 24 : 0,
+		};
+		cl->nod_len++;
+		row++;
+	}
+
+	if (cl->mode_mask & CMDLIST_MOD_RDMA) {
+		wait_event_bits |= CMDLIST_WAIT_EVENT_BIT_RDMA_RELOAD;
+		cfg_rdy_bits |= CMDLIST_RDMA_CFG_RDY(rch_id);
+	}
+	if (cl->mode_mask & CMDLIST_MOD_COMP) {
+		wait_event_bits |= CMDLIST_WAIT_EVENT_BIT_CMPS_RELOAD;
+		cfg_rdy_bits |= CMDLIST_CMPS_CFG_RDY(COMPOSER1);
+	}
+	*row = (struct cmdlist_row) {
+		.module_cfg_addr = (DPU_CTRL_BASE_ADDR + CMDLIST_CFG_READY) >> 2,
+		.module_cfg_strobe = CMDLIST_REG_STROBE(0),
+		.row_eof_tag = 1,
+		.module_regs[0] = cfg_rdy_bits,
+	};
+	cl->nod_len++;
+
+	header->nod_type = 1;			/* last (and only) node */
+	header->nod_len = cl->nod_len + 1;	/* include header */
+	header->wait_event_low = wait_event_bits & 0x1F;
+	header->wait_event = wait_event_bits >> 5;
+}
+
+void saturn_hee_crtc_cmdlist(struct spacemit_hw_device *hwdev, dma_addr_t pa,
+			     u8 crtc_id)
+{
+	u8 ch = hwdev->rdma_nums + 2 + crtc_id;
+	u32 val;
+
+	dpu_write_reg_arr(hwdev, CMDLIST_REG, CMDLIST_BASE_ADDR, cmdlist_reg_48,
+			  ch, cmdlist_ch_y_first, 0);
+	val = (lower_32_bits(pa) & CMDLIST_ADDRL_ALIGN_MASK) >>
+	      CMDLIST_ADDRL_ALIGN_BITS;
+	dpu_write_reg_arr(hwdev, CMDLIST_REG, CMDLIST_BASE_ADDR, cmdlist_reg_0,
+			  ch, cmdlist_ch_start_addrl, val);
+	dpu_write_reg_arr(hwdev, CMDLIST_REG, CMDLIST_BASE_ADDR, cmdlist_reg_16,
+			  ch, cmdlist_ch_start_addrh, upper_32_bits(pa));
+	dpu_write_reg_arr(hwdev, DPU_CTL_TOP_REG, DPU_CTRL_BASE_ADDR,
+			  dpu_ctl_top_reg_10, COMPOSER1, cmdlist_cmps_top_en, 1);
+	dpu_write_reg_arr(hwdev, DPU_CTL_TOP_REG, DPU_CTRL_BASE_ADDR,
+			  dpu_ctl_top_reg_10, COMPOSER1, cmdlist_cmps_other_en, 1);
+}
diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.c b/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.c
new file mode 100644
index 0000000000000..47dda7180f323
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.c
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/stddef.h>
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_fourcc.h>
+#include <drm/drm_framebuffer.h>
+#include <drm/drm_mode.h>
+
+#include "../spacemit_cmdlist.h"
+#include "saturn_fbcmem.h"
+
+static int saturn_raw_plane_mem_size(u32 drm_4cc_fmt, u32 plane_crop_width,
+				     u32 *output_mem_size)
+{
+	const struct drm_format_info *info;
+	u32 ret_mem_size;
+	u32 line_bytes;
+
+	info = drm_format_info(drm_4cc_fmt);
+	if (info->num_planes != 1 || info->is_yuv)
+		return -EINVAL;
+
+	/* The crop width is at most the 16-bit image width, so this fits. */
+	line_bytes = drm_format_info_min_pitch(info, 0, plane_crop_width);
+	if (!line_bytes)
+		return -EINVAL;
+
+	/* The hardware requires 64-byte rounding. */
+	ret_mem_size = roundup(line_bytes, 64);
+	ret_mem_size = ret_mem_size / 32;
+
+	if (output_mem_size)
+		*output_mem_size = ret_mem_size;
+
+	return 0;
+}
+
+/*
+ * Size the plane's share of the RDMA line buffer. Each pair of read
+ * channels owns one bank; the primary plane is alone on channel 0 and takes
+ * the front of bank 0, so the only check is that it fits.
+ */
+int saturn_cal_layer_fbcmem_size(struct drm_plane *plane,
+				 struct drm_plane_state *state)
+{
+	struct spacemit_plane_state *pstate = to_spacemit_plane_state(state);
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	struct spacemit_plane *p = to_spacemit_plane(plane);
+	u32 bank = priv->hwdev->fbcmem_sizes[p->rdma_id / 2] / FBCMEM_UNIT;
+	u32 drm_4cc_fmt = pstate->state.fb->format->format;
+	u32 crop_w = drm_rect_width(&pstate->state.src) >> 16;
+	int ret;
+
+	/* Only linear sizing: the compressed path is not exposed. */
+	ret = saturn_raw_plane_mem_size(drm_4cc_fmt, crop_w,
+					&pstate->fbcmem_size);
+	if (ret)
+		return ret;
+
+	return pstate->fbcmem_size > bank ? -ENOSPC : 0;
+}
diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.h b/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.h
new file mode 100644
index 0000000000000..ea9189ea738d5
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/saturn_fbcmem.h
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _SATURN_FBCMEM_H_
+#define _SATURN_FBCMEM_H_
+
+#include <drm/drm_plane.h>
+
+#include "../spacemit_crtc.h"
+#include "../spacemit_dpu_reg.h"
+#include "dpu_saturn.h"
+
+#define FBCMEM_UNIT	(32) /* fbcmem is 32 bytes per unit */
+
+int saturn_cal_layer_fbcmem_size(struct drm_plane *plane,
+				 struct drm_plane_state *state);
+
+#endif
diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_regs/ops_hee.h b/drivers/gpu/drm/spacemit/dpu/saturn_regs/ops_hee.h
new file mode 100644
index 0000000000000..58501261fae9d
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/saturn_regs/ops_hee.h
@@ -0,0 +1,47 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _SATURN_OPS_HEE_H_
+#define _SATURN_OPS_HEE_H_
+
+#include "../../spacemit_crtc.h"
+
+void saturn_hee_enable_irq(struct spacemit_crtc *a_crtc,
+			   enum spacemit_dpu_irq irq_id, bool enable);
+void saturn_hee_cfg_ready(struct spacemit_crtc *a_crtc,
+			  struct spacemit_hw_device *hwdev);
+void saturn_hee_sw_start(struct spacemit_crtc *a_crtc,
+			 struct spacemit_hw_device *hwdev);
+void saturn_hee_dpu_init(struct spacemit_crtc *a_crtc,
+			 const struct drm_display_mode *mode);
+void saturn_hee_plane_update_hw_channel(struct drm_plane *plane,
+					struct drm_plane_state *state,
+					const struct drm_display_mode *mode);
+void saturn_hee_plane_disable_hw_channel(struct drm_plane *plane,
+					 struct drm_crtc *crtc);
+void saturn_hee_irq_enable(struct spacemit_crtc *a_crtc, bool enable);
+void saturn_hee_conf_dpuctrl(struct drm_crtc *crtc,
+			     struct drm_atomic_commit *state);
+u32 saturn_hee_get_cfg_rdy(struct spacemit_crtc *a_crtc,
+			   struct spacemit_hw_device *hwdev);
+u32 saturn_hee_get_int_sts(struct spacemit_hw_device *hwdev);
+u32 saturn_hee_get_irq_bit(enum spacemit_dpu_irq irq_id);
+void saturn_hee_clr_int_sts(struct spacemit_crtc *a_crtc, u32 data);
+void saturn_hee_enable_cmdlist(struct spacemit_crtc *a_crtc,
+			       struct spacemit_hw_device *hwdev, int id,
+			       bool enable);
+void saturn_hee_cfg_cmdlist(struct spacemit_hw_device *hwdev, int id, u32 chy,
+			    u32 addrl, u32 addrh);
+void saturn_hee_rdma_dmmu(struct spacemit_hw_device *hwdev, u8 tbu_id,
+			  struct tbu_instance *tbu, struct drm_framebuffer *fb,
+			  struct cmdlist_regs *cl_rdma,
+			  struct drm_plane *plane);
+bool saturn_hee_cmdlist_fill_data_row(struct cmdlist *cl, u32 strobe,
+				      u32 offset, u32 value[]);
+void saturn_hee_cmdlist_fill_conf_row(struct cmdlist *cl, u32 ch_y);
+void saturn_hee_crtc_cmdlist(struct spacemit_hw_device *hwdev, dma_addr_t pa,
+			     u8 crtc_id);
+#endif

-- 
2.43.0



-- 
linux-phy mailing list
linux-phy@lists.infradead.org
https://lists.infradead.org/mailman/listinfo/linux-phy

  parent reply	other threads:[~2026-11-21  7:41 UTC|newest]

Thread overview: 23+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 01/17] dt-bindings: display: spacemit: add K3 Saturn DPU controller Cody Kang via B4 Relay
2026-11-21  7:44   ` sashiko-bot
2026-11-21  7:40 ` [PATCH v3 02/17] dt-bindings: phy: add SpacemiT K3 Innosilicon DP PHY Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 03/17] dt-bindings: display: spacemit: add K3 Innosilicon DP/eDP controller Cody Kang via B4 Relay
2026-11-21  7:45   ` sashiko-bot
2026-11-21  7:40 ` [PATCH v3 04/17] dt-bindings: soc: spacemit: allow eDP/DP PHY PLL pixel clocks on K3 APMU Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 05/17] phy: spacemit: add Innosilicon DP TX PHY driver Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 06/17] clk: spacemit: k3: parent eDP/DP pixel clock to the PHY PLL Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 07/17] drm/spacemit: add Saturn DPU register model Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 08/17] drm/spacemit: add Saturn DPU core types, cmdlist and display MMU Cody Kang via B4 Relay
2026-11-21  7:40 ` Cody Kang via B4 Relay [this message]
2026-11-21  8:01   ` [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend sashiko-bot
2026-11-21  7:40 ` [PATCH v3 10/17] drm/spacemit: add Saturn DPU KMS pipeline Cody Kang via B4 Relay
2026-11-21  8:06   ` sashiko-bot
2026-11-21  7:40 ` [PATCH v3 11/17] drm/spacemit: add Saturn DPU DRM device driver Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver Cody Kang via B4 Relay
2026-11-21  8:08   ` sashiko-bot
2026-11-21  7:40 ` [PATCH v3 13/17] MAINTAINERS: add SpacemiT K3 display driver entry Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 14/17] riscv: dts: spacemit: k3: add display nodes Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 15/17] riscv: dts: spacemit: k3-pico-itx: enable the DisplayPort output Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 16/17] riscv: dts: spacemit: k3-com260-ifx: " Cody Kang via B4 Relay
2026-11-21  7:40 ` [PATCH v3 17/17] riscv: defconfig: spacemit: k3: enable display driver Cody Kang via B4 Relay

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261121-k3-display-v3-9-ec419e8e96b8@gmail.com \
    --to=devnull+codykang.hk.gmail.com@kernel.org \
    --cc=airlied@gmail.com \
    --cc=alex@ghiti.fr \
    --cc=aou@eecs.berkeley.edu \
    --cc=bmasney+clk@redhat.com \
    --cc=codykang.hk@gmail.com \
    --cc=codykang@vsit.ai \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=dlan@kernel.org \
    --cc=docular.xu@gmail.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=heylenay@4d2.org \
    --cc=jbrunet+clk@baylibre.com \
    --cc=krzk+dt@kernel.org \
    --cc=linux-clk@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-phy@lists.infradead.org \
    --cc=linux-riscv@lists.infradead.org \
    --cc=lumag@kernel.org \
    --cc=maarten.lankhorst@linux.intel.com \
    --cc=mani@kernel.org \
    --cc=me@ziyao.cc \
    --cc=mripard@kernel.org \
    --cc=mturquette@baylibre.com \
    --cc=neil.armstrong@linaro.org \
    --cc=p.zabel@pengutronix.de \
    --cc=palmer@dabbelt.com \
    --cc=pjw@kernel.org \
    --cc=robh@kernel.org \
    --cc=sarah.emery@canonical.com \
    --cc=sboyd@kernel.org \
    --cc=simona@ffwll.ch \
    --cc=spacemit@lists.linux.dev \
    --cc=troy.mitchell@linux.spacemit.com \
    --cc=tzimmermann@suse.de \
    --cc=u.kleine-koenig@baylibre.com \
    --cc=uwu@icenowy.me \
    --cc=vkoul@kernel.org \
    --cc=ze.huang@oss.qualcomm.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).