dri-devel Archive on lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support
@ 2026-11-21  7:40 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
                   ` (16 more replies)
  0 siblings, 17 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

This series adds display support for the SpacemiT K3 [2], a RISC-V SoC:
a new DRM driver, a new PHY driver and three new bindings.

The display path is three blocks deep:

  Saturn DPU -> Innosilicon DP/eDP controller -> Innosilicon DP PHY

New readers will find an introduction to this hardware in the v2 cover
letter [3].

In v3, two major changes, thanks to Thomas Zimmermann for the review
that led to these:

- The DPU driver lost its internal layers: the callback tables, the
  tracepoints and the command-list grouping are gone.
- Page-flip events go through the vblank machinery, and the DPU is
  powered through runtime PM.

The rest of the v3 changes please see below, with details in each patch's
changelog.

v2 ships in the Ubuntu 26.10 RISC-V kernel [4]. Thanks to Sarah Emery
for two fixes found there.

Thanks to Ze Huang for testing v2 on the K3 Pico-ITX. The Tested-by is
not carried, because the DRM driver changed too much in v3.

Ze, Sarah: if you have time to run v3, a retest would be very welcome.

Sashiko AI review contributed total review comments: 51 items, which I
accepted: 19 items.

v3 repeated the full v1 test matrix on both boards, in built-in and
modular configurations, with the module load/unload rounds of v2, plus
page-flip and DPMS rounds and unloading the modules while a client is
running.

About the series:

The DPU driver arrives as five staged patches (7 to 11) to keep each one
a reasonable size. It becomes buildable with patch 11. Bisect safe.

This series supports a single primary plane per CRTC and linear RGB
scanout (no plane scaling, rotation, YUV or writeback). It does not
support DSI, DSC or DP audio, and link rates are capped at HBR2.

Based on v7.4-rc1.

Testing this series needs a SpacemiT u-boot carrying display support:
the branch at [1], or a later official release.

Tested on two K3 boards:

  - Pico-ITX: an eDP panel and an external DisplayPort monitor.
  - CoM260-IFX: DisplayPort only, no eDP.

Note: The eDP panel DTS enablement is not part of this series; a separate
      series will follow showing how eDP can be verified.

[1] https://github.com/spacemit-com/uboot-for-k3-display-verify/tree/k3-br-v1.0.y
[2] https://www.spacemit.com/community/document/info?lang=en&nodepath=hardware/key_stone/k3
[3] https://lore.kernel.org/r/20260809-k3-display-v2-0-327d7910bf71@gmail.com
[4] https://launchpad.net/ubuntu/+source/linux-riscv/7.2.0-5.5.2

Changes in v3:
- drop the tracepoints, the hardware callback tables and the
  constant-fill path; the Saturn register code is called directly
  (Thomas Zimmermann)
- one command list per channel, allocated once and submitted by its
  owner; the grouping, sorting and chaining of lists is gone (Thomas
  Zimmermann)
- deliver the commit's event through the vblank machinery, armed from
  the CFG_RDY interrupt (Thomas Zimmermann)
- power the DPU through runtime PM, and stop the boot loader's pipeline
  at probe instead of at the first modeset (Thomas Zimmermann)
- add prepare_fb: the display MMU table is built once per GEM object
  and the buffer's fences are waited for (Thomas Zimmermann)
- program the plane from the clipped rectangles, and size its line
  buffer in atomic_check (Thomas Zimmermann)
- wrap only the hardware access in drm_dev_enter() (Thomas Zimmermann);
  release the drm_device when the aggregate unbinds
- map scanout buffers write-combining; fail AUX transfers fast when HPD
  is low (Sarah Emery)
- reject modes above 3840x2160, and bound framebuffers by what the RDMA
  registers can address (Icenowy Zheng)
- let the panel supply the modes on eDP (Guodong Xu)
- leave the DPU's pixel clock at the rate it has; on DP and eDP the PHY
  PLL is the pixel clock (Guodong Xu)
- do not advertise a gamma table (Guodong Xu)
- DT: order the display nodes by unit address; the Pico-ITX message
  names the Type-C receptacle's DP alternate mode (Icenowy Zheng)
- clk: the commit message names the binding that documents the two
  clock inputs (Jerome Brunet)
- MAINTAINERS: add Guodong Xu as maintainer; list Cody Kang with the
  vsit.ai address
- rebased onto v7.4-rc1: atomic_create_state replaces .reset
- commit messages of patches 5, 7, 8, 9, 11, 12, 14 and 16 reworded
- picked up Rob Herring's Reviewed-by on patch 4
- Link to v2: https://patch.msgid.link/20260809-k3-display-v2-0-327d7910bf71@gmail.com

Changes in v2:
- unbind: keep the online IRQ alive until the teardown commits have
  drained; module unload no longer rides two watchdog timeouts
- bridge teardown on devres: reset via
  devm_reset_control_get_exclusive_deasserted(), pxclk disable as a
  devm action ordered against the PHY child (Philipp Zabel, Yao Zi)
- all five DPU reset lines behind one reset_control_bulk_* pair
  (Philipp Zabel, Guodong Xu)
- bindings: port@1 is now required; the CoM260 board describes its DP
  receptacle with a dp-connector node; redundant minItems dropped
  (Rob Herring)
- possible_crtcs derived from the input endpoint only
- EDID reads through the AUX I2C adapter; write-1-to-clear interrupt
  acks by plain write; assorted dead code dropped
- picked up Rob Herring's Reviewed-by on patches 1-3
- Link to v1: https://lore.kernel.org/r/20260725-k3-display-v1-0-6de34d80e86c@gmail.com

Signed-off-by: Cody Kang <codykang@vsit.ai>
---
Cody Kang (17):
      dt-bindings: display: spacemit: add K3 Saturn DPU controller
      dt-bindings: phy: add SpacemiT K3 Innosilicon DP PHY
      dt-bindings: display: spacemit: add K3 Innosilicon DP/eDP controller
      dt-bindings: soc: spacemit: allow eDP/DP PHY PLL pixel clocks on K3 APMU
      phy: spacemit: add Innosilicon DP TX PHY driver
      clk: spacemit: k3: parent eDP/DP pixel clock to the PHY PLL
      drm/spacemit: add Saturn DPU register model
      drm/spacemit: add Saturn DPU core types, cmdlist and display MMU
      drm/spacemit: add Saturn DPU hardware backend
      drm/spacemit: add Saturn DPU KMS pipeline
      drm/spacemit: add Saturn DPU DRM device driver
      drm/spacemit: add Innosilicon DP/eDP controller bridge driver
      MAINTAINERS: add SpacemiT K3 display driver entry
      riscv: dts: spacemit: k3: add display nodes
      riscv: dts: spacemit: k3-pico-itx: enable the DisplayPort output
      riscv: dts: spacemit: k3-com260-ifx: enable the DisplayPort output
      riscv: defconfig: spacemit: k3: enable display driver

 .../display/spacemit/spacemit,k3-inno-dp.yaml      |  141 ++
 .../display/spacemit/spacemit,k3-saturn-dpu.yaml   |  132 ++
 .../bindings/phy/spacemit,k3-inno-dp-phy.yaml      |   48 +
 .../bindings/soc/spacemit/spacemit,k1-syscon.yaml  |   21 +-
 MAINTAINERS                                        |   11 +
 arch/riscv/boot/dts/spacemit/k3-com260-ifx.dts     |   27 +
 arch/riscv/boot/dts/spacemit/k3-display.dtsi       |  166 ++
 arch/riscv/boot/dts/spacemit/k3-pico-itx.dts       |   11 +
 arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi       |   22 +
 arch/riscv/configs/defconfig                       |    2 +
 drivers/clk/spacemit/ccu-k3.c                      |    4 +-
 drivers/gpu/drm/Kconfig                            |    1 +
 drivers/gpu/drm/Makefile                           |    1 +
 drivers/gpu/drm/spacemit/Kconfig                   |   37 +
 drivers/gpu/drm/spacemit/Makefile                  |   15 +
 drivers/gpu/drm/spacemit/dpu/dpu_saturn.c          |  353 ++++
 drivers/gpu/drm/spacemit/dpu/dpu_saturn.h          |   36 +
 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/dpu_int.h |   25 +
 drivers/gpu/drm/spacemit/dpu/saturn_regs/ops_hee.h |   47 +
 .../gpu/drm/spacemit/dpu/saturn_regs/reg_map_hee.h |   65 +
 .../drm/spacemit/dpu/saturn_regs/saturn_fields.h   |  312 +++
 drivers/gpu/drm/spacemit/spacemit_cmdlist.c        |  198 ++
 drivers/gpu/drm/spacemit/spacemit_cmdlist.h        |  133 ++
 drivers/gpu/drm/spacemit/spacemit_crtc.c           |  589 ++++++
 drivers/gpu/drm/spacemit/spacemit_crtc.h           |  133 ++
 drivers/gpu/drm/spacemit/spacemit_dmmu.c           |  119 ++
 drivers/gpu/drm/spacemit/spacemit_dmmu.h           |   80 +
 drivers/gpu/drm/spacemit/spacemit_dpu_ids.h        |   26 +
 drivers/gpu/drm/spacemit/spacemit_dpu_reg.h        |   99 +
 drivers/gpu/drm/spacemit/spacemit_drm.c            |  204 ++
 drivers/gpu/drm/spacemit/spacemit_drm.h            |   62 +
 drivers/gpu/drm/spacemit/spacemit_inno_dp.c        | 2186 ++++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_inno_dp.h        |  328 +++
 drivers/gpu/drm/spacemit/spacemit_planes.c         |  332 +++
 drivers/phy/spacemit/Kconfig                       |   13 +
 drivers/phy/spacemit/Makefile                      |    1 +
 drivers/phy/spacemit/phy-k3-inno-dp.c              |  951 +++++++++
 40 files changed, 7680 insertions(+), 3 deletions(-)
---
base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4
change-id: 20260713-k3-display-e8ffed67e936

Best regards,
--  
Cody Kang <codykang.hk@gmail.com>



^ permalink raw reply	[flat|nested] 23+ messages in thread

* [PATCH v3 01/17] dt-bindings: display: spacemit: add K3 Saturn DPU controller
  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 ` 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
                   ` (15 subsequent siblings)
  16 siblings, 1 reply; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Document the Saturn display processing unit found on the SpacemiT K3 SoC.
The K3 instantiates two of them, one per display path. They share a
compatible: an instance differs only in which register window, interrupt,
clock and reset lines it takes.

Reviewed-by: Rob Herring (Arm) <robh@kernel.org>
Signed-off-by: Cody Kang <codykang@vsit.ai>

---
v3:
- no change
v2:
- add Reviewed-by: Rob Herring (Arm)
---
 .../display/spacemit/spacemit,k3-saturn-dpu.yaml   | 132 +++++++++++++++++++++
 1 file changed, 132 insertions(+)

diff --git a/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-saturn-dpu.yaml b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-saturn-dpu.yaml
new file mode 100644
index 0000000000000..97ea9da4b68e4
--- /dev/null
+++ b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-saturn-dpu.yaml
@@ -0,0 +1,132 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/display/spacemit/spacemit,k3-saturn-dpu.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: SpacemiT K3 Saturn Display Processing Unit
+
+maintainers:
+  - Cody Kang <codykang.hk@gmail.com>
+
+description:
+  The Saturn DPU is the display processing unit of the SpacemiT K3 SoC. It
+  composes the display planes and drives the timing for one display path. Its
+  output goes to a DisplayPort or embedded DisplayPort controller. The K3 has
+  two instances.
+
+properties:
+  compatible:
+    const: spacemit,k3-saturn-dpu
+
+  reg:
+    maxItems: 1
+
+  interrupts:
+    items:
+      - description: Online (live display) compose path.
+      - description: Offline (writeback) compose path.
+
+  interrupt-names:
+    items:
+      - const: online
+      - const: offline
+
+  clocks:
+    items:
+      - description: Pixel clock.
+      - description: Memory clock for the compose pipeline.
+      - description: AXI bus clock.
+      - description: DSI escape clock.
+      - description: DSC clock.
+
+  clock-names:
+    items:
+      - const: pxclk
+      - const: mclk
+      - const: aclk
+      - const: escclk
+      - const: dscclk
+
+  resets:
+    items:
+      - description: Memory clock domain.
+      - description: LCD domain, shared with the downstream controller.
+      - description: DSI escape clock domain.
+      - description: AXI clock domain.
+      - description: DSC domain.
+
+  reset-names:
+    items:
+      - const: mclk
+      - const: lcd
+      - const: esc
+      - const: aclk
+      - const: dsc
+
+  ports:
+    $ref: /schemas/graph.yaml#/properties/ports
+
+    properties:
+      port@0:
+        $ref: /schemas/graph.yaml#/properties/port
+        description: Video output to the DisplayPort or eDP controller.
+
+    required:
+      - port@0
+
+required:
+  - compatible
+  - reg
+  - interrupts
+  - interrupt-names
+  - clocks
+  - clock-names
+  - resets
+  - reset-names
+  - ports
+
+additionalProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/clock/spacemit,k3-clocks.h>
+    #include <dt-bindings/reset/spacemit,k3-resets.h>
+    #include <dt-bindings/interrupt-controller/irq.h>
+
+    soc {
+        #address-cells = <2>;
+        #size-cells = <2>;
+
+        dpu@c0340000 {
+            compatible = "spacemit,k3-saturn-dpu";
+            reg = <0x0 0xc0340000 0x0 0x54000>;
+            interrupts = <90 IRQ_TYPE_LEVEL_HIGH>,
+                         <89 IRQ_TYPE_LEVEL_HIGH>;
+            interrupt-names = "online", "offline";
+            clocks = <&syscon_apmu CLK_APMU_LCD_PXCLK>,
+                     <&syscon_apmu CLK_APMU_LCD_MCLK>,
+                     <&syscon_apmu CLK_APMU_DPU_ACLK>,
+                     <&syscon_apmu CLK_APMU_DSI_ESC>,
+                     <&syscon_apmu CLK_APMU_LCD_DSC>;
+            clock-names = "pxclk", "mclk", "aclk", "escclk", "dscclk";
+            resets = <&syscon_apmu RESET_APMU_LCD_MCLK>,
+                     <&syscon_apmu RESET_APMU_LCD>,
+                     <&syscon_apmu RESET_APMU_DSI_ESC>,
+                     <&syscon_apmu RESET_APMU_DPU_ACLK>,
+                     <&syscon_apmu RESET_APMU_LCD_DSCCLK>;
+            reset-names = "mclk", "lcd", "esc", "aclk", "dsc";
+
+            ports {
+                #address-cells = <1>;
+                #size-cells = <0>;
+
+                port@0 {
+                    reg = <0>;
+                    endpoint {
+                        remote-endpoint = <&edp0_in>;
+                    };
+                };
+            };
+        };
+    };

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 02/17] dt-bindings: phy: add SpacemiT K3 Innosilicon DP PHY
  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:40 ` 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
                   ` (14 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

The SpacemiT K3 DisplayPort controller drives its four transmit lanes
through an integrated Innosilicon DP PHY, one PHY per controller. Add a
binding so the controller can reference its transmit PHY and the pixel
clock the PHY's PLL sources.

The PHY's registers are interleaved with its parent controller's inside
one MMIO window, so it owns neither a reg nor a reset and is modelled as
a child of the controller.

It exposes its PLL-generated pixel clock through #clock-cells, so the
APMU pixel-clock mux can select it as a parent through the clock
framework.

Reviewed-by: Rob Herring (Arm) <robh@kernel.org>
Signed-off-by: Cody Kang <codykang@vsit.ai>

---
v3:
- no change
v2:
- add Reviewed-by: Rob Herring (Arm)
---
 .../bindings/phy/spacemit,k3-inno-dp-phy.yaml      | 48 ++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/Documentation/devicetree/bindings/phy/spacemit,k3-inno-dp-phy.yaml b/Documentation/devicetree/bindings/phy/spacemit,k3-inno-dp-phy.yaml
new file mode 100644
index 0000000000000..f8f1ef3729511
--- /dev/null
+++ b/Documentation/devicetree/bindings/phy/spacemit,k3-inno-dp-phy.yaml
@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/phy/spacemit,k3-inno-dp-phy.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: SpacemiT K3 Innosilicon DisplayPort PHY
+
+maintainers:
+  - Cody Kang <codykang.hk@gmail.com>
+
+description:
+  Innosilicon four-lane DisplayPort transmit PHY integrated in the SpacemiT
+  K3 SoC, one per DisplayPort controller. Its registers are interleaved with
+  the controller's own inside a single register window, so it is described as
+  a child of the controller and owns neither a reg nor a reset.
+
+  The PHY provides the pixel clock its PLL generates, which the APMU
+  pixel-clock mux takes as one of its inputs.
+
+properties:
+  compatible:
+    const: spacemit,k3-inno-dp-phy
+
+  "#phy-cells":
+    const: 0
+
+  "#clock-cells":
+    const: 0
+
+  clock-output-names:
+    maxItems: 1
+
+required:
+  - compatible
+  - "#phy-cells"
+  - "#clock-cells"
+
+additionalProperties: false
+
+examples:
+  - |
+    phy {
+        compatible = "spacemit,k3-inno-dp-phy";
+        #phy-cells = <0>;
+        #clock-cells = <0>;
+        clock-output-names = "edp0_pll_pxclk";
+    };

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 03/17] dt-bindings: display: spacemit: add K3 Innosilicon DP/eDP controller
  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:40 ` [PATCH v3 02/17] dt-bindings: phy: add SpacemiT K3 Innosilicon DP PHY Cody Kang via B4 Relay
@ 2026-11-21  7:40 ` 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
                   ` (13 subsequent siblings)
  16 siblings, 1 reply; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Both K3 instances are the same IP and share one compatible; which one
behaves as eDP is decided by what its downstream port is wired to, not by
which register window it sits in, so the binding does not distinguish them.

Reviewed-by: Rob Herring (Arm) <robh@kernel.org>
Signed-off-by: Cody Kang <codykang@vsit.ai>

---
v3:
- no change
v2:
- make port@1 required (Rob Herring)
- add Reviewed-by: Rob Herring (Arm)
---
 .../display/spacemit/spacemit,k3-inno-dp.yaml      | 141 +++++++++++++++++++++
 1 file changed, 141 insertions(+)

diff --git a/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-inno-dp.yaml b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-inno-dp.yaml
new file mode 100644
index 0000000000000..491d25730da9f
--- /dev/null
+++ b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-inno-dp.yaml
@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/display/spacemit/spacemit,k3-inno-dp.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: SpacemiT K3 Innosilicon DisplayPort / embedded DisplayPort Controller
+
+maintainers:
+  - Cody Kang <codykang.hk@gmail.com>
+
+description:
+  Innosilicon DisplayPort transmit controller integrated in the SpacemiT K3
+  SoC. The K3 has two instances of the same block sharing one compatible;
+  each acts as embedded or external DisplayPort depending on whether its
+  output port drives a panel or a connector.
+
+properties:
+  compatible:
+    const: spacemit,k3-inno-dp
+
+  reg:
+    maxItems: 1
+
+  interrupts:
+    maxItems: 1
+    description: Link and hot-plug events.
+
+  clocks:
+    items:
+      - description: Pixel clock for the controller.
+      - description:
+          Pixel clock generated by the DP PHY PLL; the pixel clock above is
+          parented onto it in use.
+
+  clock-names:
+    items:
+      - const: pxclk
+      - const: pll
+
+  resets:
+    maxItems: 1
+    description: Controller-wide reset signal.
+
+  phys:
+    maxItems: 1
+    description: Phandle to the K3 Innosilicon DP PHY.
+
+  phy-names:
+    items:
+      - const: dp
+
+  ports:
+    $ref: /schemas/graph.yaml#/properties/ports
+
+    properties:
+      port@0:
+        $ref: /schemas/graph.yaml#/properties/port
+        description: Video input from the DPU.
+
+      port@1:
+        $ref: /schemas/graph.yaml#/properties/port
+        description: Output to the panel or to the DisplayPort connector.
+
+    required:
+      - port@0
+      - port@1
+
+  aux-bus:
+    $ref: /schemas/display/dp-aux-bus.yaml#
+    description:
+      The DisplayPort AUX bus. Present when the output drives an embedded
+      panel, which is described as a child of this node and identifies itself
+      over AUX. Absent when the output is a connector.
+
+  phy:
+    $ref: /schemas/phy/spacemit,k3-inno-dp-phy.yaml#
+    description:
+      The DisplayPort PHY. Its registers live inside this controller's
+      register window, so it is described here as a child node.
+
+required:
+  - compatible
+  - reg
+  - interrupts
+  - clocks
+  - clock-names
+  - resets
+  - phys
+  - phy-names
+  - ports
+
+additionalProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/clock/spacemit,k3-clocks.h>
+    #include <dt-bindings/reset/spacemit,k3-resets.h>
+    #include <dt-bindings/interrupt-controller/irq.h>
+
+    soc {
+        #address-cells = <2>;
+        #size-cells = <2>;
+
+        edp@cac84000 {
+            compatible = "spacemit,k3-inno-dp";
+            reg = <0x0 0xcac84000 0x0 0x4000>;
+            interrupts = <132 IRQ_TYPE_LEVEL_HIGH>;
+            clocks = <&syscon_apmu CLK_APMU_EDP0_PXCLK>, <&edp0_phy>;
+            clock-names = "pxclk", "pll";
+            resets = <&syscon_apmu RESET_APMU_EDP0>;
+            phys = <&edp0_phy>;
+            phy-names = "dp";
+
+            edp0_phy: phy {
+                compatible = "spacemit,k3-inno-dp-phy";
+                #phy-cells = <0>;
+                #clock-cells = <0>;
+                clock-output-names = "edp0_pll_pxclk";
+            };
+
+            ports {
+                #address-cells = <1>;
+                #size-cells = <0>;
+
+                port@0 {
+                    reg = <0>;
+                    endpoint {
+                        remote-endpoint = <&dpu0_out>;
+                    };
+                };
+
+                port@1 {
+                    reg = <1>;
+                    endpoint {
+                        remote-endpoint = <&panel_in>;
+                    };
+                };
+            };
+        };
+    };

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 04/17] dt-bindings: soc: spacemit: allow eDP/DP PHY PLL pixel clocks on K3 APMU
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (2 preceding siblings ...)
  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:40 ` 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
                   ` (12 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

The APMU's eDP pixel-clock muxes select the DP PHY PLLs as parents, so the
K3 syscon takes two clock inputs the other variants do not have.

Gate them behind the K3 compatible instead of widening the shared clock
list, so a non-K3 syscon cannot silently accept clocks it has no mux for.

Reviewed-by: Rob Herring (Arm) <robh@kernel.org>
Signed-off-by: Cody Kang <codykang@vsit.ai>

---
v3:
- add Reviewed-by: Rob Herring (Arm)
v2:
- drop the redundant minItems: 4; four is already the minimum
  (Rob Herring)
---
 .../bindings/soc/spacemit/spacemit,k1-syscon.yaml   | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/Documentation/devicetree/bindings/soc/spacemit/spacemit,k1-syscon.yaml b/Documentation/devicetree/bindings/soc/spacemit/spacemit,k1-syscon.yaml
index d3a7c93c3c54f..a6ef456fe14be 100644
--- a/Documentation/devicetree/bindings/soc/spacemit/spacemit,k1-syscon.yaml
+++ b/Documentation/devicetree/bindings/soc/spacemit/spacemit,k1-syscon.yaml
@@ -31,14 +31,18 @@ properties:
     maxItems: 1
 
   clocks:
-    maxItems: 4
+    minItems: 4
+    maxItems: 6
 
   clock-names:
+    minItems: 4
     items:
       - const: osc
       - const: vctcxo_1m
       - const: vctcxo_3m
       - const: vctcxo_24m
+      - const: edp0_pll_pxclk
+      - const: edp1_pll_pxclk
 
   "#clock-cells":
     const: 1
@@ -95,6 +99,21 @@ allOf:
         - clocks
         - clock-names
         - "#clock-cells"
+  # Only the K3 APMU exposes the two eDP/DP PHY PLL pixel clocks as extra
+  # inputs (parents of its eDP pixel-clock muxes); every other variant has
+  # the four base oscillator inputs only.
+  - if:
+      not:
+        properties:
+          compatible:
+            contains:
+              const: spacemit,k3-syscon-apmu
+    then:
+      properties:
+        clocks:
+          maxItems: 4
+        clock-names:
+          maxItems: 4
 
 additionalProperties: false
 

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 05/17] phy: spacemit: add Innosilicon DP TX PHY driver
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (3 preceding siblings ...)
  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 ` 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
                   ` (11 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

The PHY's registers are interleaved into its parent DP controller's MMIO
window rather than a window of its own, so it probes as a child of the
controller, carries no reg or reset, and reaches its registers through
the controller's regmap.

It registers its pixel PLL as a clock provider. That lets the display
controller ask for a mode's pixel rate through clk_set_rate(), and it
lets the APMU pixel-clock mux parent to the PHY through the clock
framework. Without it the controller would have to program the PHY's
pixel PLL itself.

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

---
v3:
- park the pixel PLL when the lane enable write fails
- share one pixel PLL lookup between determine_rate and set_rate
- describe the lane trim fields with GENMASK() and FIELD_PREP()
- drop redundant checks and initialisers
- commit message: reword why the PHY is a clock provider
v2:
- drop the mod_devicetable.h include (Uwe Kleine-Koenig)
- unwind the lanes and pixel PLL on the power_on lock-timeout paths
  (Sashiko)
- document why power_off keeps the MPLL up: it feeds the 16 MHz AUX
  reference, and AUX must survive link drops (Sashiko)
- register the PHY and clock providers last in probe (Sashiko)
---
 drivers/phy/spacemit/Kconfig          |  13 +
 drivers/phy/spacemit/Makefile         |   1 +
 drivers/phy/spacemit/phy-k3-inno-dp.c | 951 ++++++++++++++++++++++++++++++++++
 3 files changed, 965 insertions(+)

diff --git a/drivers/phy/spacemit/Kconfig b/drivers/phy/spacemit/Kconfig
index b5f36621b2075..6b6071c965d9e 100644
--- a/drivers/phy/spacemit/Kconfig
+++ b/drivers/phy/spacemit/Kconfig
@@ -42,3 +42,16 @@ config PHY_SPACEMIT_K3_COMBO_PHY
 	  driver takes care of enabling and clock setup and will be used
 	  by K3 dwc3 driver.
 	  If unsure, say N.
+
+config PHY_SPACEMIT_K3_INNO_DP
+	tristate "SpacemiT K3 Innosilicon DisplayPort PHY driver"
+	depends on (ARCH_SPACEMIT || COMPILE_TEST) && OF
+	depends on COMMON_CLK
+	select GENERIC_PHY
+	select REGMAP
+	help
+	  Enable support for the Innosilicon DisplayPort transmit PHY
+	  integrated in the SpacemiT K3 SoC. The PHY shares its MMIO window
+	  with its parent DP/eDP controller (drivers/gpu/drm/spacemit/) and
+	  exposes lane / rate / vswing / pre-emphasis control through the
+	  generic PHY framework.
diff --git a/drivers/phy/spacemit/Makefile b/drivers/phy/spacemit/Makefile
index f679c1851b4f0..cdd88d9cc18bc 100644
--- a/drivers/phy/spacemit/Makefile
+++ b/drivers/phy/spacemit/Makefile
@@ -3,3 +3,4 @@ obj-$(CONFIG_PHY_SPACEMIT_K1_PCIE)		+= phy-k1-pcie.o
 obj-$(CONFIG_PHY_SPACEMIT_K1_USB2)		+= phy-k1-usb2.o
 obj-$(CONFIG_PHY_SPACEMIT_K3_COMBO_PHY)		+= phy-k3-combo.o
 obj-$(CONFIG_PHY_SPACEMIT_K3_COMMON_OPS)	+= phy-k3-common.o
+obj-$(CONFIG_PHY_SPACEMIT_K3_INNO_DP)		+= phy-k3-inno-dp.o
diff --git a/drivers/phy/spacemit/phy-k3-inno-dp.c b/drivers/phy/spacemit/phy-k3-inno-dp.c
new file mode 100644
index 0000000000000..31d5c0cb5afba
--- /dev/null
+++ b/drivers/phy/spacemit/phy-k3-inno-dp.c
@@ -0,0 +1,951 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * SpacemiT K3 Innosilicon DisplayPort PHY driver.
+ *
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ */
+
+#include <linux/bitfield.h>
+#include <linux/bitops.h>
+#include <linux/clk-provider.h>
+#include <linux/delay.h>
+#include <linux/iopoll.h>
+#include <linux/math.h>
+#include <linux/math64.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/phy/phy.h>
+#include <linux/phy/phy-dp.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+
+/* Offsets are into the parent controller's MMIO window */
+#define DPTX_PHY_CTRL			0x0100
+#define DPTX_PHY_CTRL_XMIT_EN		GENMASK(20, 17)
+#define DPTX_PHY_CTRL_NUM_LANES		GENMASK(6, 5)
+#define DPTX_PHY_CTRL_RATE		GENMASK(1, 0)
+
+/* One 6-bit slot per lane; only the low 4 bits of each slot are used. */
+#define DPTX_PHY_LANE_TRIM		0x0104
+#define DPTX_PHY_LANE_BITS_PER		6
+#define DPTX_PHY_LANE_PREEMP		GENMASK(1, 0)	/* within a lane slot */
+#define DPTX_PHY_LANE_VSWING		GENMASK(3, 2)
+
+/* MPLL is the link PLL (lane rate) */
+#define DPTX_ANA_MPLL			0x0180
+#define DPTX_ANA_MPLL_FBDIV_LBIT	GENMASK(31, 24)
+#define DPTX_ANA_MPLL_FBDIV_HBIT	GENMASK(19, 16)
+#define DPTX_ANA_MPLL_PREDIV		GENMASK(13, 8)
+#define DPTX_ANA_MPLL_LOCKED		BIT(7)
+#define DPTX_ANA_MPLL_DACPD		BIT(5)
+#define DPTX_ANA_MPLL_DSMPD		BIT(4)
+#define DPTX_ANA_MPLL_PD		BIT(0)
+
+#define DPTX_ANA_MPLL_FRAC		0x0184
+#define DPTX_ANA_MPLL_FRAC_LBIT		GENMASK(23, 16)
+#define DPTX_ANA_MPLL_FRAC_MBIT		GENMASK(15, 8)
+#define DPTX_ANA_MPLL_FRAC_HBIT		GENMASK(7, 0)
+
+#define DPTX_ANA_MPLL_DIV		0x0188
+#define DPTX_ANA_MPLL_VCOCLK_DIV8_EN	BIT(16)
+#define DPTX_ANA_MPLL_POSTDIVEN		BIT(11)
+#define DPTX_ANA_MPLL_POSTDIV		GENMASK(10, 8)
+
+/* PREPLL is the pixel PLL exposed as a clock. */
+#define DPTX_ANA_PREPLL			0x0190
+#define DPTX_ANA_PREPLL_FBDIV2_LBIT	GENMASK(31, 24)
+#define DPTX_ANA_PREPLL_FBDIV2_HBIT	GENMASK(19, 16)
+#define DPTX_ANA_PREPLL_PREDIV		GENMASK(13, 8)
+#define DPTX_ANA_PREPLL_LOCKED		BIT(7)
+#define DPTX_ANA_PREPLL_DACPD		BIT(5)
+#define DPTX_ANA_PREPLL_DSMPD		BIT(4)
+#define DPTX_ANA_PREPLL_PCLK_NORMAL	BIT(1)
+#define DPTX_ANA_PREPLL_PD		BIT(0)
+
+#define DPTX_ANA_PREPLL_DIV		0x0194
+#define DPTX_ANA_PREPLL_PRECLK_DIVM	GENMASK(17, 16)
+#define DPTX_ANA_PREPLL_PRECLK_DIVAUX	GENMASK(12, 8)
+
+#define DPTX_ANA_PREPLL_CTRL		0x0198
+#define DPTX_ANA_PREPLL_PCLKDIV5_EN	BIT(31)
+#define DPTX_ANA_PREPLL_PCLK_DIVAUX	GENMASK(28, 24)
+#define DPTX_ANA_PREPLL_LOCK_BYPEN	BIT(17)
+#define DPTX_ANA_PREPLL_HDMI_EN		BIT(9)
+#define DPTX_ANA_PREPLL_DP_EN		BIT(8)
+
+#define DPTX_ANA_PREPLL_FRAC		0x019c
+#define DPTX_ANA_PREPLL_FRAC2_LBIT	GENMASK(23, 16)
+#define DPTX_ANA_PREPLL_FRAC2_MBIT	GENMASK(15, 8)
+#define DPTX_ANA_PREPLL_FRAC2_HBIT	GENMASK(7, 0)
+
+#define DPTX_ANA_TX_CTRL		0x01a0
+#define DPTX_ANA_MPLL_CLKDIV_16M	GENMASK(13, 8)
+
+/* PRECLK_DIVM register value -> divide factor */
+static const u8 k3_inno_dp_divm_factors[] = { 1, 2, 3, 5 };
+
+#define DPTX_VCO_MIN_KHZ		1000000
+#define DPTX_VCO_MAX_KHZ		3000000
+#define DPTX_PLL_FRAC_MOD		BIT(24)
+#define DPTX_PLL_ERR_TOLERANCE		10
+
+struct k3_inno_dp_phy {
+	struct device	*dev;
+	struct regmap	*regmap;
+	struct phy	*phy;
+	u8		lanes;		/* tracks last set_lanes */
+
+	struct clk_hw	pxclk_hw;	/* the PREPLL's pixel clock */
+	unsigned long	pxclk_rate;	/* last programmed PREPLL rate */
+	u32		ref_clk_khz;	/* PLL reference */
+};
+
+static int k3_inno_dp_phy_power_on(struct phy *phy)
+{
+	struct k3_inno_dp_phy *p = phy_get_drvdata(phy);
+	u32 lane_en;
+	u32 val;
+	int ret;
+
+	switch (p->lanes) {
+	case 1:
+		lane_en = 0x1;
+		break;
+	case 2:
+		lane_en = 0x3;
+		break;
+	case 4:
+	default:
+		lane_en = 0xf;
+		break;
+	}
+
+	ret = regmap_write_bits(p->regmap, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PD, 0);
+	if (ret)
+		return ret;
+	ret = regmap_write_bits(p->regmap, DPTX_ANA_PREPLL,
+				DPTX_ANA_PREPLL_PD, 0);
+	if (ret)
+		return ret;
+	usleep_range(2000, 4000);
+
+	ret = regmap_write_bits(p->regmap, DPTX_PHY_CTRL,
+				DPTX_PHY_CTRL_XMIT_EN,
+				FIELD_PREP(DPTX_PHY_CTRL_XMIT_EN, lane_en));
+	if (ret)
+		goto err_power_down;
+	usleep_range(2000, 4000);
+
+	ret = regmap_read_poll_timeout(p->regmap, DPTX_ANA_MPLL, val,
+				       val & DPTX_ANA_MPLL_LOCKED,
+				       2000, 10 * 1000);
+	if (ret) {
+		dev_err(p->dev, "DP PHY core PLL lock timed out\n");
+		goto err_power_down;
+	}
+
+	ret = regmap_read_poll_timeout(p->regmap, DPTX_ANA_PREPLL, val,
+				       val & DPTX_ANA_PREPLL_LOCKED,
+				       2000, 10 * 1000);
+	if (ret) {
+		dev_err(p->dev, "DP PHY pixel PLL lock timed out\n");
+		goto err_power_down;
+	}
+
+	return 0;
+
+	/*
+	 * The PHY core does not call power_off after a failed power_on, so
+	 * park what power_off parks. Not the MPLL: see power_off.
+	 */
+err_power_down:
+	regmap_write_bits(p->regmap, DPTX_PHY_CTRL, DPTX_PHY_CTRL_XMIT_EN, 0);
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD,
+			  DPTX_ANA_PREPLL_PD);
+	return ret;
+}
+
+/*
+ * Asymmetric with power_on on purpose: the MPLL stays up because it also
+ * feeds the 16 MHz AUX reference (DPTX_ANA_MPLL_CLKDIV_16M), and AUX must
+ * keep working while the link is down (EDID, DPCD, panel detection). The
+ * controller parks the PHY through here on every link drop, including
+ * right after bind.
+ */
+static int k3_inno_dp_phy_power_off(struct phy *phy)
+{
+	struct k3_inno_dp_phy *p = phy_get_drvdata(phy);
+
+	regmap_write_bits(p->regmap, DPTX_PHY_CTRL, DPTX_PHY_CTRL_XMIT_EN, 0);
+	usleep_range(2000, 4000);
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD,
+			  DPTX_ANA_PREPLL_PD);
+	usleep_range(2000, 4000);
+
+	return 0;
+}
+
+static int k3_inno_dp_phy_set_lanes(struct k3_inno_dp_phy *p, u8 lanes)
+{
+	u32 val;
+	int ret;
+
+	switch (lanes) {
+	case 1:
+		val = 0;
+		break;
+	case 2:
+		val = 1;
+		break;
+	case 4:
+		val = 2;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	ret = regmap_write_bits(p->regmap, DPTX_PHY_CTRL,
+				DPTX_PHY_CTRL_NUM_LANES,
+				FIELD_PREP(DPTX_PHY_CTRL_NUM_LANES, val));
+	if (ret)
+		return ret;
+
+	p->lanes = lanes;
+	return 0;
+}
+
+struct k3_inno_dp_mpll_cfg {
+	unsigned int link_rate;		/* Mbps per lane */
+	u8 prediv;
+	u16 fbdiv;
+	u32 frac;
+	u8 postdiv;
+	u8 postdiv_en;
+	u8 frac_pd;
+	u8 vcoclk_div8_en;
+	u8 clk_16mdiv;
+};
+
+static const struct k3_inno_dp_mpll_cfg k3_inno_dp_mpll_cfgs[] = {
+	{
+		.link_rate	= 1620,
+		.prediv		= 0x02,
+		.fbdiv		= 0x87,
+		.frac		= 0,
+		.postdiv	= 0,
+		.postdiv_en	= 1,
+		.frac_pd	= 0x3,
+		.vcoclk_div8_en	= 1,
+		.clk_16mdiv	= 12,
+	}, {
+		.link_rate	= 2700,
+		.prediv		= 0x02,
+		.fbdiv		= 0xe1,
+		.frac		= 0,
+		.postdiv	= 0,
+		.postdiv_en	= 1,
+		.frac_pd	= 0x3,
+		.vcoclk_div8_en	= 1,
+		.clk_16mdiv	= 21,
+	}, {
+		.link_rate	= 5400,
+		.prediv		= 0x02,
+		.fbdiv		= 0xe1,
+		.frac		= 0,
+		.postdiv	= 0,
+		.postdiv_en	= 0,
+		.frac_pd	= 0x3,
+		.vcoclk_div8_en	= 0,
+		.clk_16mdiv	= 42,
+	},
+};
+
+static void k3_inno_dp_phy_program_mpll(struct k3_inno_dp_phy *p,
+					const struct k3_inno_dp_mpll_cfg *cfg)
+{
+	struct regmap *rm = p->regmap;
+
+	/*
+	 * Shared with an unwired HDMI path: select DP first, otherwise the
+	 * PLLs still lock but nothing reaches the lanes and AUX times out.
+	 */
+	regmap_write_bits(rm, DPTX_ANA_PREPLL_CTRL, DPTX_ANA_PREPLL_DP_EN,
+			  DPTX_ANA_PREPLL_DP_EN);
+	regmap_write_bits(rm, DPTX_ANA_PREPLL_CTRL, DPTX_ANA_PREPLL_HDMI_EN, 0);
+
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PD,
+			  FIELD_PREP(DPTX_ANA_MPLL_PD, 1));
+	usleep_range(2000, 4000);
+
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PREDIV,
+			  FIELD_PREP(DPTX_ANA_MPLL_PREDIV, cfg->prediv));
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_FBDIV_LBIT,
+			  FIELD_PREP(DPTX_ANA_MPLL_FBDIV_LBIT, cfg->fbdiv & 0xff));
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_FBDIV_HBIT,
+			  FIELD_PREP(DPTX_ANA_MPLL_FBDIV_HBIT, (cfg->fbdiv >> 8) & 0xf));
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_DACPD,
+			  FIELD_PREP(DPTX_ANA_MPLL_DACPD, (cfg->frac_pd >> 1) & 0x1));
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_DSMPD,
+			  FIELD_PREP(DPTX_ANA_MPLL_DSMPD, cfg->frac_pd & 0x1));
+
+	regmap_write_bits(rm, DPTX_ANA_MPLL_FRAC, DPTX_ANA_MPLL_FRAC_LBIT,
+			  FIELD_PREP(DPTX_ANA_MPLL_FRAC_LBIT, cfg->frac & 0xff));
+	regmap_write_bits(rm, DPTX_ANA_MPLL_FRAC, DPTX_ANA_MPLL_FRAC_MBIT,
+			  FIELD_PREP(DPTX_ANA_MPLL_FRAC_MBIT, (cfg->frac >> 8) & 0xff));
+	regmap_write_bits(rm, DPTX_ANA_MPLL_FRAC, DPTX_ANA_MPLL_FRAC_HBIT,
+			  FIELD_PREP(DPTX_ANA_MPLL_FRAC_HBIT, (cfg->frac >> 16) & 0xff));
+
+	regmap_write_bits(rm, DPTX_ANA_MPLL_DIV, DPTX_ANA_MPLL_POSTDIV,
+			  FIELD_PREP(DPTX_ANA_MPLL_POSTDIV, cfg->postdiv));
+	regmap_write_bits(rm, DPTX_ANA_MPLL_DIV, DPTX_ANA_MPLL_POSTDIVEN,
+			  FIELD_PREP(DPTX_ANA_MPLL_POSTDIVEN, cfg->postdiv_en));
+	regmap_write_bits(rm, DPTX_ANA_MPLL_DIV, DPTX_ANA_MPLL_VCOCLK_DIV8_EN,
+			  FIELD_PREP(DPTX_ANA_MPLL_VCOCLK_DIV8_EN, cfg->vcoclk_div8_en));
+
+	regmap_write_bits(rm, DPTX_ANA_TX_CTRL, DPTX_ANA_MPLL_CLKDIV_16M,
+			  FIELD_PREP(DPTX_ANA_MPLL_CLKDIV_16M, cfg->clk_16mdiv));
+
+	regmap_write_bits(rm, DPTX_ANA_PREPLL_CTRL, DPTX_ANA_PREPLL_LOCK_BYPEN,
+			  FIELD_PREP(DPTX_ANA_PREPLL_LOCK_BYPEN, 1));
+
+	regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PD,
+			  FIELD_PREP(DPTX_ANA_MPLL_PD, 0));
+	usleep_range(2000, 4000);
+}
+
+static int k3_inno_dp_phy_set_rate(struct k3_inno_dp_phy *p,
+				   unsigned int link_rate)
+{
+	u32 sel;
+
+	switch (link_rate) {
+	case 1620:
+		sel = 0;
+		break;
+	case 2700:
+		sel = 1;
+		break;
+	case 5400:
+		sel = 2;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	/* The table is indexed by the rate select value. */
+	k3_inno_dp_phy_program_mpll(p, &k3_inno_dp_mpll_cfgs[sel]);
+
+	return regmap_write_bits(p->regmap, DPTX_PHY_CTRL,
+				 DPTX_PHY_CTRL_RATE,
+				 FIELD_PREP(DPTX_PHY_CTRL_RATE, sel));
+}
+
+static int k3_inno_dp_phy_set_voltages(struct k3_inno_dp_phy *p,
+				       struct phy_configure_opts_dp *opts)
+{
+	u8 lane;
+	int ret;
+
+	for (lane = 0; lane < opts->lanes; lane++) {
+		unsigned int shift = lane * DPTX_PHY_LANE_BITS_PER;
+		u32 mask = (DPTX_PHY_LANE_VSWING | DPTX_PHY_LANE_PREEMP) << shift;
+		u32 val = (FIELD_PREP(DPTX_PHY_LANE_VSWING, opts->voltage[lane]) |
+			   FIELD_PREP(DPTX_PHY_LANE_PREEMP, opts->pre[lane])) << shift;
+
+		ret = regmap_write_bits(p->regmap, DPTX_PHY_LANE_TRIM, mask,
+					val);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int k3_inno_dp_phy_configure(struct phy *phy,
+				    union phy_configure_opts *opts)
+{
+	struct k3_inno_dp_phy *p = phy_get_drvdata(phy);
+	int ret;
+
+	if (opts->dp.set_lanes) {
+		ret = k3_inno_dp_phy_set_lanes(p, opts->dp.lanes);
+		if (ret)
+			return ret;
+	}
+
+	if (opts->dp.set_rate) {
+		ret = k3_inno_dp_phy_set_rate(p, opts->dp.link_rate);
+		if (ret)
+			return ret;
+	}
+
+	if (opts->dp.set_voltages) {
+		ret = k3_inno_dp_phy_set_voltages(p, &opts->dp);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int k3_inno_dp_better_cfg(bool new_valid, bool new_is_int, u8 new_pre, u32 new_vco,
+				 bool best_valid, bool best_is_int, u8 best_pre, u32 best_vco)
+{
+	if (!new_valid)
+		return 0;
+	if (!best_valid)
+		return 1;
+
+	if (new_is_int && !best_is_int)
+		return 1;
+	if (!new_is_int && best_is_int)
+		return 0;
+
+	if (new_pre < best_pre)
+		return 1;
+	if (new_pre > best_pre)
+		return 0;
+
+	if (new_vco > best_vco)
+		return 1;
+
+	return 0;
+}
+
+struct k3_inno_dp_prepll_cfg {
+	u32 target_pclk_khz;
+	u32 vco_freq_khz;
+	u8 prediv;
+	u16 fbdiv;
+	u32 frac_pd;
+	u32 frac;
+	u8 div5_en;
+	u8 divm;
+	u8 divaux;
+	u8 divp;
+	u32 actual_pclk_khz;
+	bool valid;
+};
+
+static const struct k3_inno_dp_prepll_cfg k3_inno_dp_prepll_cfgs[] = {
+	{ 614400, 2460000, 0x05, 512,  0x3, 0x0, 0x0, 0x1, 0x01, 0x1, 614400, true },
+	{ 594000, 2376000, 0x01, 99,   0x3, 0x0, 0x0, 0x1, 0x01, 0x1, 594000, true },
+	{ 551040, 2760000, 0x05, 574,  0x3, 0x0, 0x1, 0x0, 0x00, 0x0, 551040, true },
+	{ 533250, 2130000, 0x08, 711,  0x3, 0x0, 0x0, 0x1, 0x01, 0x1, 533250, true },
+	{ 443250, 1770000, 0x08, 591,  0x3, 0x0, 0x0, 0x1, 0x01, 0x1, 443250, true },
+	{ 375000, 3000000, 0x01, 125,  0x3, 0x0, 0x0, 0x0, 0x04, 0x1, 375000, true },
+	{ 372000, 2980000, 0x01, 124,  0x3, 0x0, 0x0, 0x0, 0x04, 0x1, 372000, true },
+	{ 348500, 2790000, 0x06, 697,  0x3, 0x0, 0x0, 0x0, 0x04, 0x1, 348500, true },
+	{ 307200, 1540000, 0x01, 64,   0x3, 0x0, 0x1, 0x0, 0x00, 0x0, 307200, true },
+	{ 297000, 2376000, 0x01, 99,   0x3, 0x0, 0x0, 0x0, 0x04, 0x1, 297000, true },
+	{ 280000, 1680000, 0x01, 70,   0x3, 0x0, 0x0, 0x2, 0x01, 0x1, 280000, true },
+	{ 277440, 2770000, 0x05, 578,  0x3, 0x0, 0x0, 0x3, 0x01, 0x1, 277440, true },
+	{ 245760, 2457600, 0x05, 512,  0x3, 0x0, 0x0, 0x3, 0x01, 0x1, 245760, true },
+	{ 241500, 1932000, 0x02, 161,  0x3, 0x0, 0x0, 0x0, 0x04, 0x1, 241500, true },
+	{ 236000, 2830000, 0x01, 118,  0x3, 0x0, 0x0, 0x0, 0x06, 0x1, 236000, true },
+	{ 204800, 2048000, 0x03, 256,  0x3, 0x0, 0x0, 0x3, 0x01, 0x1, 204800, true },
+	{ 193250, 2320000, 0x08, 773,  0x3, 0x0, 0x0, 0x0, 0x06, 0x1, 193250, true },
+	{ 189000, 1510000, 0x01,  63,  0x3, 0x0, 0x0, 0x0, 0x04, 0x1, 189000, true },
+	{ 187500, 3000000, 0x01, 125,  0x3, 0x0, 0x0, 0x0, 0x08, 0x1, 187500, true },
+	{ 162000, 2592000, 0x01, 108,  0x3, 0x0, 0x0, 0x0, 0x08, 0x1, 162000, true },
+	{ 156000, 2810000, 0x01, 117,  0x3, 0x0, 0x0, 0x0, 0x09, 0x1, 156000, true },
+	{ 150000, 3000000, 0x01, 125,  0x3, 0x0, 0x0, 0x0, 0x0a, 0x1, 150000, true },
+	{ 148500, 2376000, 0x01, 99,   0x3, 0x0, 0x0, 0x0, 0x08, 0x1, 148500, true },
+	{ 146000, 1750000, 0x01, 73,   0x3, 0x0, 0x0, 0x0, 0x06, 0x1, 146000, true },
+	{ 142860, 2860000, 0x14, 2381, 0x3, 0x0, 0x0, 0x0, 0x0a, 0x1, 142860, true },
+	{ 140000, 2520000, 0x01, 105,  0x3, 0x0, 0x0, 0x0, 0x09, 0x1, 140000, true },
+	{ 138500, 2220000, 0x03, 277,  0x3, 0x0, 0x0, 0x0, 0x08, 0x1, 138500, true },
+	{ 122000, 2930000, 0x01, 122,  0x3, 0x0, 0x0, 0x0, 0x0c, 0x1, 122000, true },
+	{ 121750, 2920000, 0x04, 487,  0x3, 0x0, 0x0, 0x0, 0x0c, 0x1, 121750, true },
+	{ 108000, 2810000, 0x01, 117,  0x3, 0x0, 0x0, 0x0, 0x0d, 0x1, 108000, true },
+	{ 106500, 1700000, 0x01,  71,  0x3, 0x0, 0x0, 0x0, 0x08, 0x1, 106500, true },
+	{ 83500,  2000000, 0x02, 167,  0x3, 0x0, 0x0, 0x0, 0x0c, 0x1, 83500,  true },
+	{ 79500,  2540000, 0x01, 106,  0x3, 0x0, 0x0, 0x0, 0x10, 0x1, 79500,  true },
+	{ 75000,  3000000, 0x01, 125,  0x3, 0x0, 0x0, 0x0, 0x14, 0x1, 75000,  true },
+	{ 74250,  2376000, 0x01,  99,  0x3, 0x0, 0x0, 0x0, 0x10, 0x1, 74250,  true },
+	{ 65000,  1560000, 0x01,  65,  0x3, 0x0, 0x0, 0x0, 0x0c, 0x1, 65000,  true },
+	{ 40000,  2880000, 0x01, 120,  0x3, 0x0, 0x0, 0x0, 0x12, 0x2, 40000,  true },
+	{ 27000,  2810000, 0x01, 117,  0x3, 0x0, 0x0, 0x0, 0x1a, 0x2, 27000,  true },
+	{ 25600,  2300000, 0x01,  96,  0x3, 0x0, 0x0, 0x0, 0x0f, 0x3, 25600,  true },
+	{ 25200,  2520000, 0x01, 105,  0x3, 0x0, 0x0, 0x0, 0x19, 0x2, 25200,  true },
+};
+
+static u32 k3_inno_dp_pll_rate_khz(u8 pre, u16 fb, u32 frac,
+				   u32 ref_clk_khz, u32 total_div)
+{
+	u64 vco_hz;
+	u64 ref_hz = (u64)ref_clk_khz * 1000;
+	u64 int_part;
+	u64 frac_part;
+
+	/* Integer part: (Ref * FB) / Pre */
+	int_part = ref_hz * fb;
+	int_part += (pre / 2);
+	do_div(int_part, pre);
+
+	/* Fractional part: (Ref * Frac) / (Pre * 2^24) */
+	frac_part = ref_hz * frac;
+
+	frac_part += (pre / 2);
+	do_div(frac_part, pre);
+
+	frac_part += (DPTX_PLL_FRAC_MOD / 2);
+	do_div(frac_part, DPTX_PLL_FRAC_MOD);
+
+	vco_hz = int_part + frac_part;
+
+	/* Final Rate = VCO / total_div */
+	vco_hz += (total_div / 2);
+	do_div(vco_hz, total_div);
+
+	vco_hz += 500;
+	do_div(vco_hz, 1000);
+
+	return (u32)vco_hz;
+}
+
+static int k3_inno_dp_prepll_div_total(const struct k3_inno_dp_prepll_cfg *cfg,
+				       u32 *div_total)
+{
+	if (!cfg->valid)
+		return -EINVAL;
+
+	/* div5_en fixes div_total at 5; divp is unused on this path */
+	if (cfg->div5_en) {
+		*div_total = 5;
+		return 0;
+	}
+
+	if (!cfg->divp)
+		return -EINVAL;
+
+	if (cfg->divaux == 1) {
+		if (cfg->divm >= ARRAY_SIZE(k3_inno_dp_divm_factors))
+			return -EINVAL;
+
+		*div_total = 2 * k3_inno_dp_divm_factors[cfg->divm] * cfg->divp;
+		return 0;
+	}
+
+	if (cfg->divaux < 2)
+		return -EINVAL;
+
+	*div_total = 2 * cfg->divaux * cfg->divp;
+	return 0;
+}
+
+static bool k3_inno_dp_prepll_cfg_matches(const struct k3_inno_dp_prepll_cfg *cfg,
+					  u32 target_pclk_khz,
+					 u32 ref_clk_khz)
+{
+	u32 div_total;
+	u32 actual_pclk_khz;
+
+	if (k3_inno_dp_prepll_div_total(cfg, &div_total))
+		return false;
+
+	actual_pclk_khz = k3_inno_dp_pll_rate_khz(cfg->prediv, cfg->fbdiv,
+						  cfg->frac, ref_clk_khz,
+						  div_total);
+
+	if (cfg->actual_pclk_khz &&
+	    abs_diff(actual_pclk_khz,
+		     cfg->actual_pclk_khz) > DPTX_PLL_ERR_TOLERANCE)
+		return false;
+
+	return abs_diff(actual_pclk_khz,
+				    target_pclk_khz) <= DPTX_PLL_ERR_TOLERANCE;
+}
+
+static const struct k3_inno_dp_prepll_cfg *k3_inno_dp_find_prepll_cfg(u32 pclk_khz,
+								      u32 ref_clk_khz)
+{
+	const struct k3_inno_dp_prepll_cfg *best_match = NULL;
+	u32 min_diff = U32_MAX;
+	int num_configs = ARRAY_SIZE(k3_inno_dp_prepll_cfgs);
+
+	for (int i = 0; i < num_configs; i++) {
+		u32 current_target = k3_inno_dp_prepll_cfgs[i].target_pclk_khz;
+		u32 diff = abs_diff(pclk_khz, current_target);
+
+		if (diff == 0 && k3_inno_dp_prepll_cfg_matches(&k3_inno_dp_prepll_cfgs[i],
+							       pclk_khz, ref_clk_khz)) {
+			return &k3_inno_dp_prepll_cfgs[i];
+		}
+
+		if ((pclk_khz / 100) == (current_target / 100) &&
+		    k3_inno_dp_prepll_cfg_matches(&k3_inno_dp_prepll_cfgs[i],
+						  pclk_khz, ref_clk_khz)) {
+			return &k3_inno_dp_prepll_cfgs[i];
+		}
+
+		if (diff < min_diff && diff < 500 &&
+		    k3_inno_dp_prepll_cfg_matches(&k3_inno_dp_prepll_cfgs[i],
+						  pclk_khz, ref_clk_khz)) {
+			min_diff = diff;
+			best_match = &k3_inno_dp_prepll_cfgs[i];
+		}
+	}
+
+	return best_match;
+}
+
+static int k3_inno_dp_solve_frac(u32 target_vco_khz, u32 ref_clk_khz,
+				 u8 *best_pre, u16 *best_fb, u32 *best_frac)
+{
+	u64 min_err = ~0ULL;
+	int found = 0;
+	bool best_is_int = false;
+	int pre;
+
+	for (pre = 1; pre <= 63; pre++) {
+		u64 ref_clk_hz = (u64)ref_clk_khz * 1000;
+		u64 target_vco_hz = (u64)target_vco_khz * 1000;
+
+		/*
+		 * Calculate required multiplier: Mult = (TargetVCO * Pre) / Ref
+		 */
+		u64 num = target_vco_hz * pre;
+		u64 den = ref_clk_hz;
+		u64 remainder;
+		u64 fb_val;
+		u64 frac_val;
+		u64 vco_int, vco_frac;
+		u64 actual_vco;
+		u64 diff;
+		bool current_is_int;
+
+		fb_val = num;
+		remainder = do_div(fb_val, (u32)den);
+
+		if (fb_val > 4095)
+			continue;
+
+		/* Frac = (Remainder * 2^24 + Ref/2) / Ref */
+		frac_val = remainder * DPTX_PLL_FRAC_MOD;
+		frac_val += (den / 2);
+		do_div(frac_val, (u32)den);
+
+		if (frac_val > 0xFFFFFF)
+			frac_val = 0xFFFFFF;
+
+		/* VCO = (Ref * FB / Pre) + (Ref * Frac / (Pre * 2^24)) */
+		vco_int = ref_clk_hz * fb_val;
+		do_div(vco_int, pre);
+		vco_frac = ref_clk_hz * frac_val;
+		do_div(vco_frac, pre);
+		do_div(vco_frac, DPTX_PLL_FRAC_MOD);
+
+		actual_vco = vco_int + vco_frac;
+
+		diff = abs_diff(actual_vco, target_vco_hz);
+		current_is_int = (frac_val == 0);
+
+		if (diff < min_err) {
+			min_err = diff;
+			*best_pre = pre;
+			*best_fb = (u16)fb_val;
+			*best_frac = (u32)frac_val;
+			best_is_int = current_is_int;
+			found = 1;
+		} else if (diff == min_err) {
+			if (current_is_int && !best_is_int) {
+				*best_pre = pre;
+				*best_fb = (u16)fb_val;
+				*best_frac = (u32)frac_val;
+				best_is_int = true;
+				found = 1;
+			}
+		}
+	}
+
+	return found ? 0 : -EINVAL;
+}
+
+/* divaux must be 1 for the DivM path and > 1 for the DivAux path. */
+static void k3_inno_dp_try_prepll(u32 target_pclk_khz, u32 ref_clk_khz,
+				  u32 div_total, u8 div5_en, u8 divaux,
+				  u8 divm, u8 divp,
+				  struct k3_inno_dp_prepll_cfg *best)
+{
+	struct k3_inno_dp_prepll_cfg curr = {0};
+	u32 target_vco = target_pclk_khz * div_total;
+	u32 actual_pclk;
+	u32 frac;
+	u16 fb;
+	u8 pre;
+
+	if (target_vco < DPTX_VCO_MIN_KHZ || target_vco > DPTX_VCO_MAX_KHZ)
+		return;
+
+	if (k3_inno_dp_solve_frac(target_vco, ref_clk_khz, &pre, &fb, &frac))
+		return;
+
+	actual_pclk = k3_inno_dp_pll_rate_khz(pre, fb, frac, ref_clk_khz,
+					      div_total);
+	if (abs_diff(actual_pclk, target_pclk_khz) > DPTX_PLL_ERR_TOLERANCE)
+		return;
+
+	curr.valid = true;
+	curr.vco_freq_khz = target_vco;
+	curr.actual_pclk_khz = actual_pclk;
+	curr.prediv = pre;
+	curr.fbdiv = fb;
+	curr.frac = frac;
+	curr.frac_pd = (frac == 0) ? 3 : 0;
+	curr.div5_en = div5_en;
+	curr.divaux = divaux;
+	curr.divm = divm;
+	curr.divp = divp;
+
+	if (k3_inno_dp_better_cfg(curr.valid, curr.frac == 0, curr.prediv,
+				  curr.vco_freq_khz, best->valid,
+				    best->frac == 0, best->prediv,
+				    best->vco_freq_khz))
+		*best = curr;
+}
+
+static int k3_inno_dp_solve_prepll(u32 target_pclk_khz, u32 ref_clk_khz,
+				   struct k3_inno_dp_prepll_cfg *cfg)
+{
+	struct k3_inno_dp_prepll_cfg best = {0};
+	int pclk_div;
+	int i;
+
+	/* Strategy 1: Div5 path (VCO = PCLK * 5) */
+	k3_inno_dp_try_prepll(target_pclk_khz, ref_clk_khz, 5, 1, 0, 0, 0,
+			      &best);
+
+	for (pclk_div = 1; pclk_div <= 31; pclk_div++) {
+		/* Strategy 2: DivM path */
+		for (i = 0; i < ARRAY_SIZE(k3_inno_dp_divm_factors); i++)
+			k3_inno_dp_try_prepll(target_pclk_khz, ref_clk_khz,
+					      2 * k3_inno_dp_divm_factors[i] * pclk_div, 0, 1,
+					      i, pclk_div, &best);
+
+		/* Strategy 3: DivAux path */
+		for (i = 2; i <= 31; i++)
+			k3_inno_dp_try_prepll(target_pclk_khz, ref_clk_khz,
+					      2 * i * pclk_div,
+					      0, i, 0, pclk_div, &best);
+	}
+
+	if (!best.valid)
+		return -EINVAL;
+
+	*cfg = best;
+	return 0;
+}
+
+static void k3_inno_dp_program_prepll(struct k3_inno_dp_phy *p,
+				      const struct k3_inno_dp_prepll_cfg *cfg)
+{
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PD, 1));
+	usleep_range(2000, 4000);
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PREDIV,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PREDIV, cfg->prediv));
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL,
+			  DPTX_ANA_PREPLL_FBDIV2_LBIT,
+			  FIELD_PREP(DPTX_ANA_PREPLL_FBDIV2_LBIT, cfg->fbdiv & 0xFF));
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL,
+			  DPTX_ANA_PREPLL_FBDIV2_HBIT,
+			  FIELD_PREP(DPTX_ANA_PREPLL_FBDIV2_HBIT, (cfg->fbdiv >> 8) & 0xF));
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_DACPD,
+			  FIELD_PREP(DPTX_ANA_PREPLL_DACPD, (cfg->frac_pd >> 1) & 0x1));
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_DSMPD,
+			  FIELD_PREP(DPTX_ANA_PREPLL_DSMPD, cfg->frac_pd & 0x1));
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_FRAC,
+			  DPTX_ANA_PREPLL_FRAC2_LBIT,
+			  FIELD_PREP(DPTX_ANA_PREPLL_FRAC2_LBIT, cfg->frac & 0xFF));
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_FRAC,
+			  DPTX_ANA_PREPLL_FRAC2_MBIT,
+			  FIELD_PREP(DPTX_ANA_PREPLL_FRAC2_MBIT, (cfg->frac >> 8) & 0xFF));
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_FRAC,
+			  DPTX_ANA_PREPLL_FRAC2_HBIT,
+			  FIELD_PREP(DPTX_ANA_PREPLL_FRAC2_HBIT, (cfg->frac >> 16) & 0xFF));
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_DIV,
+			  DPTX_ANA_PREPLL_PRECLK_DIVM,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PRECLK_DIVM, cfg->divm));
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_DIV,
+			  DPTX_ANA_PREPLL_PRECLK_DIVAUX,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PRECLK_DIVAUX, cfg->divaux));
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_CTRL,
+			  DPTX_ANA_PREPLL_PCLKDIV5_EN,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PCLKDIV5_EN, cfg->div5_en));
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL_CTRL,
+			  DPTX_ANA_PREPLL_PCLK_DIVAUX,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PCLK_DIVAUX, cfg->divp));
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL,
+			  DPTX_ANA_PREPLL_PCLK_NORMAL,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PCLK_NORMAL, 1));
+	usleep_range(2000, 4000);
+
+	regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD,
+			  FIELD_PREP(DPTX_ANA_PREPLL_PD, 0));
+	usleep_range(2000, 4000);
+}
+
+#define to_k3_inno_dp_phy_clk(_hw) \
+	container_of(_hw, struct k3_inno_dp_phy, pxclk_hw)
+
+static unsigned long k3_inno_dp_pxclk_recalc_rate(struct clk_hw *hw,
+						  unsigned long parent_rate)
+{
+	struct k3_inno_dp_phy *p = to_k3_inno_dp_phy_clk(hw);
+
+	return p->pxclk_rate;
+}
+
+/* The table setting for @rate when there is one, else a solved one. */
+static int k3_inno_dp_prepll_cfg_for_rate(struct k3_inno_dp_phy *p,
+					  unsigned long rate,
+					  struct k3_inno_dp_prepll_cfg *cfg)
+{
+	const struct k3_inno_dp_prepll_cfg *found;
+	u32 khz = div_u64(rate, 1000);
+
+	found = k3_inno_dp_find_prepll_cfg(khz, p->ref_clk_khz);
+	if (!found)
+		return k3_inno_dp_solve_prepll(khz, p->ref_clk_khz, cfg);
+
+	*cfg = *found;
+	return 0;
+}
+
+static int k3_inno_dp_pxclk_determine_rate(struct clk_hw *hw,
+					   struct clk_rate_request *req)
+{
+	struct k3_inno_dp_phy *p = to_k3_inno_dp_phy_clk(hw);
+	struct k3_inno_dp_prepll_cfg cfg;
+	int ret;
+
+	ret = k3_inno_dp_prepll_cfg_for_rate(p, req->rate, &cfg);
+	if (ret)
+		return ret;
+
+	req->rate = (unsigned long)cfg.actual_pclk_khz * 1000;
+
+	return 0;
+}
+
+static int k3_inno_dp_pxclk_set_rate(struct clk_hw *hw, unsigned long rate,
+				     unsigned long parent_rate)
+{
+	struct k3_inno_dp_phy *p = to_k3_inno_dp_phy_clk(hw);
+	struct k3_inno_dp_prepll_cfg cfg;
+	int ret;
+
+	ret = k3_inno_dp_prepll_cfg_for_rate(p, rate, &cfg);
+	if (ret) {
+		dev_err(p->dev, "no PLL setting for %lu Hz\n", rate);
+		return ret;
+	}
+
+	k3_inno_dp_program_prepll(p, &cfg);
+	p->pxclk_rate = (unsigned long)cfg.actual_pclk_khz * 1000;
+
+	return 0;
+}
+
+/*
+ * No prepare/enable ops: power_on starts the pixel PLL and power_off parks
+ * it. set_rate powers the PLL down to reprogram the dividers and leaves it
+ * running afterwards, whether or not the PHY is powered; the next power_off
+ * parks it again.
+ */
+static const struct clk_ops k3_inno_dp_pxclk_ops = {
+	.recalc_rate	= k3_inno_dp_pxclk_recalc_rate,
+	.determine_rate	= k3_inno_dp_pxclk_determine_rate,
+	.set_rate	= k3_inno_dp_pxclk_set_rate,
+};
+
+static const struct phy_ops k3_inno_dp_phy_ops = {
+	.power_on	= k3_inno_dp_phy_power_on,
+	.power_off	= k3_inno_dp_phy_power_off,
+	.configure	= k3_inno_dp_phy_configure,
+	.owner		= THIS_MODULE,
+};
+
+static int k3_inno_dp_phy_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct k3_inno_dp_phy *p;
+	struct phy_provider *provider;
+	struct clk_init_data init = {};
+	int ret;
+
+	p = devm_kzalloc(dev, sizeof(*p), GFP_KERNEL);
+	if (!p)
+		return -ENOMEM;
+
+	p->dev = dev;
+
+	p->regmap = dev_get_regmap(dev->parent, "dp");
+	if (!p->regmap)
+		return dev_err_probe(dev, -ENODEV,
+				     "parent DP regmap not available\n");
+
+	p->phy = devm_phy_create(dev, dev->of_node, &k3_inno_dp_phy_ops);
+	if (IS_ERR(p->phy))
+		return dev_err_probe(dev, PTR_ERR(p->phy),
+				     "failed to create DP PHY\n");
+
+	phy_set_drvdata(p->phy, p);
+
+	/* PHY takes a 24 MHz reference clock */
+	p->ref_clk_khz = 24000;
+
+	/* Named by clock-output-names when given, else after the device. */
+	of_property_read_string(dev->of_node, "clock-output-names", &init.name);
+	if (!init.name)
+		init.name = dev_name(dev);
+	init.ops = &k3_inno_dp_pxclk_ops;
+	p->pxclk_hw.init = &init;
+
+	ret = devm_clk_hw_register(dev, &p->pxclk_hw);
+	if (ret)
+		return dev_err_probe(dev, ret,
+				     "failed to register pixel clock\n");
+
+	ret = devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get,
+					  &p->pxclk_hw);
+	if (ret)
+		return dev_err_probe(dev, ret,
+				     "failed to add pixel clock provider\n");
+
+	/* Providers last: nothing may resolve a half-initialized PHY. */
+	provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
+	if (IS_ERR(provider))
+		return dev_err_probe(dev, PTR_ERR(provider),
+				     "failed to register PHY provider\n");
+
+	return 0;
+}
+
+static const struct of_device_id k3_inno_dp_phy_of_match[] = {
+	{ .compatible = "spacemit,k3-inno-dp-phy" },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, k3_inno_dp_phy_of_match);
+
+static struct platform_driver k3_inno_dp_phy_driver = {
+	.probe = k3_inno_dp_phy_probe,
+	.driver = {
+		.name		= "spacemit-k3-inno-dp-phy",
+		.of_match_table	= k3_inno_dp_phy_of_match,
+	},
+};
+module_platform_driver(k3_inno_dp_phy_driver);
+
+MODULE_DESCRIPTION("SpacemiT K3 Innosilicon DisplayPort PHY driver");
+MODULE_AUTHOR("Cody Kang <codykang.hk@gmail.com>");
+MODULE_LICENSE("GPL");

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 06/17] clk: spacemit: k3: parent eDP/DP pixel clock to the PHY PLL
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (4 preceding siblings ...)
  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 ` 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
                   ` (10 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

The APMU eDP/DP pixel-clock muxes took their second parent from an
input named external_clk, which no binding documents and no device
tree supplies. Their real parents are the DP PHY PLLs, which now
exist as clocks, and the K3 APMU binding lists them as the inputs
edp0_pll_pxclk and edp1_pll_pxclk. Point each mux at its PLL input
and let the pixel clock reach the controller through the clock
framework.

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

---
v3:
- commit message: name the binding that documents the two clock inputs
  (Jerome Brunet)
v2:
- no change
---
 drivers/clk/spacemit/ccu-k3.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/clk/spacemit/ccu-k3.c b/drivers/clk/spacemit/ccu-k3.c
index 39df15c8a3e6d..8782e55926d99 100644
--- a/drivers/clk/spacemit/ccu-k3.c
+++ b/drivers/clk/spacemit/ccu-k3.c
@@ -1038,13 +1038,13 @@ CCU_FACTOR_DEFINE(ufs_refclk, CCU_PARENT_HW(pll1_d64_38p4), 2, 1);
 
 static const struct clk_parent_data edp0_pclk_parents[] = {
 	CCU_PARENT_HW(lcd_pxclk),
-	CCU_PARENT_NAME(external_clk),
+	CCU_PARENT_NAME(edp0_pll_pxclk),
 };
 CCU_MUX_GATE_DEFINE(edp0_pxclk, edp0_pclk_parents, APMU_LCD_EDP_CTRL, 2, 1, BIT(1), 0);
 
 static const struct clk_parent_data edp1_pclk_parents[] = {
 	CCU_PARENT_HW(dsi4ln2_lcd_pxclk),
-	CCU_PARENT_NAME(external_clk),
+	CCU_PARENT_NAME(edp1_pll_pxclk),
 };
 CCU_MUX_GATE_DEFINE(edp1_pxclk, edp1_pclk_parents, APMU_LCD_EDP_CTRL, 18, 1, BIT(17), 0);
 

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 07/17] drm/spacemit: add Saturn DPU register model
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (5 preceding siblings ...)
  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 ` 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
                   ` (9 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

The Saturn display processing unit is programmed through a set of
register blocks (composer, RDMA, timing generator, cmdlist engine,
display MMU) laid out identically in both DPU instances of the K3.
Add the block address map, the per-field word offset and mask tables
consumed by the field accessors, the interrupt bit layout and the
compositor and output-format ID encodings. The address map describes
the whole IP block on purpose, including blocks the driver does not
touch; the field tables carry the fields the driver programs, with
each block's full word count kept as its NWORDS extent.

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

---
v3:
- write single-bit register fields as BIT()
- name the include guards after their files
- commit message: reworded
v2:
- no change
---
 drivers/gpu/drm/spacemit/dpu/saturn_regs/dpu_int.h |  25 ++
 .../gpu/drm/spacemit/dpu/saturn_regs/reg_map_hee.h |  65 +++++
 .../drm/spacemit/dpu/saturn_regs/saturn_fields.h   | 312 +++++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_dpu_ids.h        |  26 ++
 4 files changed, 428 insertions(+)

diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_regs/dpu_int.h b/drivers/gpu/drm/spacemit/dpu/saturn_regs/dpu_int.h
new file mode 100644
index 0000000000000..24a22538f47b1
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/saturn_regs/dpu_int.h
@@ -0,0 +1,25 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef DPU_INT_H
+#define DPU_INT_H
+
+#include <linux/bits.h>
+
+#define DPU_INT_CMDLIST_CH_FRM_CFG_DONE_MASK	(0xff)
+#define DPU_INT_CMDLIST_CH_FRM_CFG_DONE		(DPU_INT_CMDLIST_CH_FRM_CFG_DONE_MASK << 11)
+#define DPU_INT_FRM_TIMING_UNFLOW		BIT(8)
+#define DPU_INT_CFG_RDY_CLR			BIT(5)
+#define DPU_INT_FRM_TIMING_CFG_LINE		BIT(4)
+#define DPU_INT_FRM_TIMING_CFG_EOF		(BIT(2) | BIT(3))
+#define DPU_INT_FRM_TIMING_EOF			BIT(1)
+#define DPU_INT_FRM_TIMING_VSYNC		BIT(0)
+#define DPU_REST_INT_BITS			(DPU_INT_FRM_TIMING_CFG_EOF | \
+						 DPU_INT_FRM_TIMING_CFG_LINE | \
+						 DPU_INT_FRM_TIMING_EOF | \
+						 DPU_INT_CMDLIST_CH_FRM_CFG_DONE)
+
+#endif /* DPU_INT_H */
diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_regs/reg_map_hee.h b/drivers/gpu/drm/spacemit/dpu/saturn_regs/reg_map_hee.h
new file mode 100644
index 0000000000000..9c7d90aaf3a41
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/saturn_regs/reg_map_hee.h
@@ -0,0 +1,65 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _SATURN_REG_MAP_HEE_H_
+#define _SATURN_REG_MAP_HEE_H_
+
+#include "dpu_int.h"
+
+/* Block base addresses */
+
+#define DPU_TOP_BASE_ADDR 0x0
+#define DPU_CTRL_BASE_ADDR 0x3c0 /* dpu_ctl_top start address */
+#define CMDLIST_BASE_ADDR 0x500
+#define DPU_INT_BASE_ADDR 0x700
+
+#define DPU_ONLINE_IRQ_MSK	(3 * 4)
+#define DPU_ONLINE_IRQ_STS	(12 * 4)
+
+#define DMA_TOP_BASE_ADDR (RDMA0_BASE_ADDR + 0x280)
+
+#define RDMA0_BASE_ADDR (0x00001000)
+#define RDMA1_BASE_ADDR (RDMA0_BASE_ADDR + 0x1000)
+#define RDMA2_BASE_ADDR (RDMA0_BASE_ADDR + 0xa000)
+#define RDMA3_BASE_ADDR (RDMA0_BASE_ADDR + 0xb000)
+
+#define MMU_BASE_ADDR (0x1100)
+#define MMU_TOP_BASE_ADDR (MMU_BASE_ADDR + 0x100)
+
+#define TBU0_ADDR 0x1100
+#define TBU1_ADDR 0x1180
+#define TBU2_ADDR 0x2100
+#define TBU3_ADDR 0x2180
+#define TBU4_ADDR 0xb100
+#define TBU5_ADDR 0xb180
+#define TBU6_ADDR 0xc100
+#define TBU7_ADDR 0xc180
+
+#define CMP0_BASE_ADDR 0x00018000
+#define CMP1_BASE_ADDR (CMP0_BASE_ADDR + 0x18000)
+#define CMP2_BASE_ADDR (CMP0_BASE_ADDR + 0x30000)
+
+#define PREPIPE_SCAL0_BASE_ADDR 0x14000
+#define PREPIPE_SCAL1_BASE_ADDR 0x14400
+#define PREPIPE_SCAL2_BASE_ADDR 0x14800
+#define PREPIPE_SCAL3_BASE_ADDR 0x14c00
+
+#define POST_PIPE_ADDR (CMP1_BASE_ADDR + 0x300)
+
+#define EE_ADDR (CMP1_BASE_ADDR + 0xd00)
+
+#define DPU_SCENE_CTL_BASE_ADDR (0x300)
+#define DPU_SCENE_CTL_SIZE 0x40
+#define DPU_SCENE_CTL_ADDR(i) (DPU_SCENE_CTL_BASE_ADDR + (i) * DPU_SCENE_CTL_SIZE)
+
+#define TMG0_BASE_ADDR (0x00051000 + 0x200)
+
+/* Byte offsets from DPU_CTRL_BASE_ADDR */
+#define CMDLIST_CH_Y                 0x188
+#define CMDLIST_CH_START_CMPS_Y      0x90
+#define CMDLIST_CFG_READY            0x34
+
+#endif
diff --git a/drivers/gpu/drm/spacemit/dpu/saturn_regs/saturn_fields.h b/drivers/gpu/drm/spacemit/dpu/saturn_regs/saturn_fields.h
new file mode 100644
index 0000000000000..6303c91b7481b
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/saturn_regs/saturn_fields.h
@@ -0,0 +1,312 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ * Saturn DPU register field map: word offset and mask per field, consumed by
+ * the accessors in spacemit_dpu_reg.h and spacemit_cmdlist.h.
+ */
+
+#ifndef SATURN_FIELDS_H
+#define SATURN_FIELDS_H
+
+#include <linux/bits.h>
+
+/* CMDLIST_REG: 128 x 32-bit registers */
+#define CMDLIST_REG__NWORDS	128
+#define CMDLIST_REG__cmdlist_reg_0__cmdlist_ch_start_addrl_WORD(i)	(0 + (i))
+#define CMDLIST_REG__cmdlist_reg_0__cmdlist_ch_start_addrl_MASK	GENMASK(31, 4)
+#define CMDLIST_REG__cmdlist_reg_16__cmdlist_ch_start_addrh_WORD(i)	(16 + (i))
+#define CMDLIST_REG__cmdlist_reg_16__cmdlist_ch_start_addrh_MASK	GENMASK(5, 0)
+#define CMDLIST_REG__cmdlist_reg_48__cmdlist_ch_y_first_WORD(i)	(48 + (i))
+#define CMDLIST_REG__cmdlist_reg_48__cmdlist_ch_y_first_MASK	GENMASK(24, 12)
+
+/* CMPS_X_REG: 146 x 32-bit registers */
+#define CMPS_X_REG__NWORDS	146
+#define CMPS_X_REG__module_enable_WORD	0
+#define CMPS_X_REG__module_enable_MASK	BIT(0)
+#define CMPS_X_REG__dst_w_WORD	1
+#define CMPS_X_REG__dst_w_MASK	GENMASK(15, 0)
+#define CMPS_X_REG__dst_h_WORD	1
+#define CMPS_X_REG__dst_h_MASK	GENMASK(31, 16)
+#define CMPS_X_REG__bg_color_r_WORD	2
+#define CMPS_X_REG__bg_color_r_MASK	GENMASK(9, 0)
+#define CMPS_X_REG__bg_color_g_WORD	3
+#define CMPS_X_REG__bg_color_g_MASK	GENMASK(9, 0)
+#define CMPS_X_REG__bg_color_b_WORD	4
+#define CMPS_X_REG__bg_color_b_MASK	GENMASK(9, 0)
+#define CMPS_X_REG__bg_color_a_WORD	5
+#define CMPS_X_REG__bg_color_a_MASK	GENMASK(7, 0)
+#define CMPS_X_REG__layer00_area_left_WORD	8
+#define CMPS_X_REG__layer00_area_left_MASK	GENMASK(15, 0)
+#define CMPS_X_REG__layer00_area_right_WORD	8
+#define CMPS_X_REG__layer00_area_right_MASK	GENMASK(31, 16)
+#define CMPS_X_REG__layer00_area_top_WORD	9
+#define CMPS_X_REG__layer00_area_top_MASK	GENMASK(15, 0)
+#define CMPS_X_REG__layer00_area_bottom_WORD	9
+#define CMPS_X_REG__layer00_area_bottom_MASK	GENMASK(31, 16)
+#define CMPS_X_REG__layer00_solid_color_r_WORD	10
+#define CMPS_X_REG__layer00_solid_color_r_MASK	GENMASK(9, 0)
+#define CMPS_X_REG__layer00_solid_color_g_WORD	11
+#define CMPS_X_REG__layer00_solid_color_g_MASK	GENMASK(9, 0)
+#define CMPS_X_REG__layer00_solid_color_b_WORD	12
+#define CMPS_X_REG__layer00_solid_color_b_MASK	GENMASK(9, 0)
+#define CMPS_X_REG__layer00_solid_color_a_WORD	13
+#define CMPS_X_REG__layer00_solid_color_a_MASK	GENMASK(7, 0)
+#define CMPS_X_REG__layer00_blend_mode_WORD	13
+#define CMPS_X_REG__layer00_blend_mode_MASK	GENMASK(15, 14)
+#define CMPS_X_REG__layer00_colorkey_en_WORD	13
+#define CMPS_X_REG__layer00_colorkey_en_MASK	BIT(18)
+#define CMPS_X_REG__layer00_en_WORD	14
+#define CMPS_X_REG__layer00_en_MASK	BIT(0)
+#define CMPS_X_REG__layer00_blend_sel_WORD	14
+#define CMPS_X_REG__layer00_blend_sel_MASK	GENMASK(2, 1)
+#define CMPS_X_REG__layer00_solid_en_WORD	14
+#define CMPS_X_REG__layer00_solid_en_MASK	BIT(3)
+#define CMPS_X_REG__layer00_dma_id_WORD	14
+#define CMPS_X_REG__layer00_dma_id_MASK	GENMASK(7, 4)
+#define CMPS_X_REG__layer00_layer_alpha_WORD	14
+#define CMPS_X_REG__layer00_layer_alpha_MASK	GENMASK(15, 8)
+#define CMPS_X_REG__layer00_alpha_ratio_WORD	14
+#define CMPS_X_REG__layer00_alpha_ratio_MASK	GENMASK(23, 16)
+#define CMPS_X_REG__layer01_en_WORD	21
+#define CMPS_X_REG__layer01_en_MASK	BIT(0)
+#define CMPS_X_REG__layer02_en_WORD	28
+#define CMPS_X_REG__layer02_en_MASK	BIT(0)
+#define CMPS_X_REG__layer03_en_WORD	35
+#define CMPS_X_REG__layer03_en_MASK	BIT(0)
+#define CMPS_X_REG__layer04_en_WORD	42
+#define CMPS_X_REG__layer04_en_MASK	BIT(0)
+#define CMPS_X_REG__layer05_en_WORD	49
+#define CMPS_X_REG__layer05_en_MASK	BIT(0)
+#define CMPS_X_REG__layer06_en_WORD	56
+#define CMPS_X_REG__layer06_en_MASK	BIT(0)
+#define CMPS_X_REG__layer07_en_WORD	63
+#define CMPS_X_REG__layer07_en_MASK	BIT(0)
+#define CMPS_X_REG__layer08_en_WORD	70
+#define CMPS_X_REG__layer08_en_MASK	BIT(0)
+#define CMPS_X_REG__layer09_en_WORD	77
+#define CMPS_X_REG__layer09_en_MASK	BIT(0)
+#define CMPS_X_REG__layer10_en_WORD	84
+#define CMPS_X_REG__layer10_en_MASK	BIT(0)
+#define CMPS_X_REG__layer11_en_WORD	91
+#define CMPS_X_REG__layer11_en_MASK	BIT(0)
+#define CMPS_X_REG__layer12_en_WORD	98
+#define CMPS_X_REG__layer12_en_MASK	BIT(0)
+#define CMPS_X_REG__layer13_en_WORD	105
+#define CMPS_X_REG__layer13_en_MASK	BIT(0)
+#define CMPS_X_REG__layer14_en_WORD	112
+#define CMPS_X_REG__layer14_en_MASK	BIT(0)
+#define CMPS_X_REG__layer15_en_WORD	119
+#define CMPS_X_REG__layer15_en_MASK	BIT(0)
+
+/* DMA_TOP_REG: 25 x 32-bit registers */
+#define DMA_TOP_REG__NWORDS	25
+#define DMA_TOP_REG__image_rr_ratio_WORD	1
+#define DMA_TOP_REG__image_rr_ratio_MASK	GENMASK(7, 0)
+#define DMA_TOP_REG__pixel_num_th_WORD	1
+#define DMA_TOP_REG__pixel_num_th_MASK	GENMASK(14, 9)
+#define DMA_TOP_REG__rdma_timeout_limit_WORD	2
+#define DMA_TOP_REG__rdma_timeout_limit_MASK	GENMASK(15, 0)
+#define DMA_TOP_REG__wdma_timeout_limit_WORD	2
+#define DMA_TOP_REG__wdma_timeout_limit_MASK	GENMASK(31, 16)
+
+/* DPU_CTL_REG: 15 x 32-bit registers */
+#define DPU_CTL_REG__NWORDS	15
+#define DPU_CTL_REG__nml_rch_en_WORD	0
+#define DPU_CTL_REG__nml_rch_en_MASK	GENMASK(9, 0)
+#define DPU_CTL_REG__nml_scl_en_WORD	0
+#define DPU_CTL_REG__nml_scl_en_MASK	GENMASK(13, 10)
+#define DPU_CTL_REG__nml_outctl_en_WORD	0
+#define DPU_CTL_REG__nml_outctl_en_MASK	BIT(18)
+#define DPU_CTL_REG__nml_frm_timing_en_WORD	0
+#define DPU_CTL_REG__nml_frm_timing_en_MASK	GENMASK(25, 23)
+#define DPU_CTL_REG__both_cfg_rdy_WORD	2
+#define DPU_CTL_REG__both_cfg_rdy_MASK	BIT(0)
+#define DPU_CTL_REG__video_mod_WORD	3
+#define DPU_CTL_REG__video_mod_MASK	BIT(0)
+#define DPU_CTL_REG__dbg_mod_WORD	3
+#define DPU_CTL_REG__dbg_mod_MASK	BIT(1)
+#define DPU_CTL_REG__timing_inter0_WORD	3
+#define DPU_CTL_REG__timing_inter0_MASK	GENMASK(7, 2)
+#define DPU_CTL_REG__timing_inter1_WORD	3
+#define DPU_CTL_REG__timing_inter1_MASK	GENMASK(13, 8)
+#define DPU_CTL_REG__sw_start_WORD	4
+#define DPU_CTL_REG__sw_start_MASK	BIT(0)
+#define DPU_CTL_REG__nml_rch_vrt_reuse_WORD	7
+#define DPU_CTL_REG__nml_rch_vrt_reuse_MASK	GENMASK(9, 0)
+
+/* DPU_CTL_TOP_REG: 53 x 32-bit registers */
+#define DPU_CTL_TOP_REG__NWORDS	53
+#define DPU_CTL_TOP_REG__dpu_ctl_top_reg_0__cmdlist_rch_en_WORD(i)	(0 + (i))
+#define DPU_CTL_TOP_REG__dpu_ctl_top_reg_0__cmdlist_rch_en_MASK	BIT(0)
+#define DPU_CTL_TOP_REG__dpu_ctl_top_reg_10__cmdlist_cmps_other_en_WORD(i)	(10 + (i))
+#define DPU_CTL_TOP_REG__dpu_ctl_top_reg_10__cmdlist_cmps_other_en_MASK	BIT(0)
+#define DPU_CTL_TOP_REG__dpu_ctl_top_reg_10__cmdlist_cmps_top_en_WORD(i)	(10 + (i))
+#define DPU_CTL_TOP_REG__dpu_ctl_top_reg_10__cmdlist_cmps_top_en_MASK	BIT(1)
+
+/* DPU_INTP_REG: 50 x 32-bit registers */
+#define DPU_INTP_REG__NWORDS	50
+
+/* EE_REG: 51 x 32-bit registers */
+#define EE_REG__NWORDS	51
+#define EE_REG__m_benable_WORD	0
+#define EE_REG__m_benable_MASK	BIT(0)
+
+/* MMU_TBU_REG: 21 x 32-bit registers */
+#define MMU_TBU_REG__NWORDS	21
+#define MMU_TBU_REG__tbu_en_WORD	0
+#define MMU_TBU_REG__tbu_en_MASK	BIT(0)
+#define MMU_TBU_REG__tbu_burst_limit_en_WORD	0
+#define MMU_TBU_REG__tbu_burst_limit_en_MASK	BIT(4)
+#define MMU_TBU_REG__tlb_fetch_active_en_WORD	0
+#define MMU_TBU_REG__tlb_fetch_active_en_MASK	BIT(5)
+#define MMU_TBU_REG__tbu_qos_WORD	0
+#define MMU_TBU_REG__tbu_qos_MASK	GENMASK(11, 8)
+#define MMU_TBU_REG__tbu_base_addr0_low_WORD	1
+#define MMU_TBU_REG__tbu_base_addr0_low_MASK	GENMASK(31, 0)
+#define MMU_TBU_REG__tbu_base_addr0_high_WORD	2
+#define MMU_TBU_REG__tbu_base_addr0_high_MASK	GENMASK(11, 0)
+#define MMU_TBU_REG__tbu_base_addr1_low_WORD	3
+#define MMU_TBU_REG__tbu_base_addr1_low_MASK	GENMASK(31, 0)
+#define MMU_TBU_REG__tbu_base_addr1_high_WORD	4
+#define MMU_TBU_REG__tbu_base_addr1_high_MASK	GENMASK(11, 0)
+#define MMU_TBU_REG__tbu_base_addr2_low_WORD	5
+#define MMU_TBU_REG__tbu_base_addr2_low_MASK	GENMASK(31, 0)
+#define MMU_TBU_REG__tbu_base_addr2_high_WORD	6
+#define MMU_TBU_REG__tbu_base_addr2_high_MASK	GENMASK(11, 0)
+#define MMU_TBU_REG__tbu_va0_WORD	7
+#define MMU_TBU_REG__tbu_va0_MASK	GENMASK(31, 0)
+#define MMU_TBU_REG__tbu_va1_WORD	8
+#define MMU_TBU_REG__tbu_va1_MASK	GENMASK(31, 0)
+#define MMU_TBU_REG__tbu_va2_WORD	9
+#define MMU_TBU_REG__tbu_va2_MASK	GENMASK(31, 0)
+#define MMU_TBU_REG__tbu_size0_WORD	10
+#define MMU_TBU_REG__tbu_size0_MASK	GENMASK(15, 0)
+#define MMU_TBU_REG__tbu_size1_WORD	11
+#define MMU_TBU_REG__tbu_size1_MASK	GENMASK(15, 0)
+#define MMU_TBU_REG__tbu_size2_WORD	12
+#define MMU_TBU_REG__tbu_size2_MASK	GENMASK(15, 0)
+#define MMU_TBU_REG__vsync_update_en_WORD	13
+#define MMU_TBU_REG__vsync_update_en_MASK	BIT(1)
+
+/* MMU_TOP_REG: 23 x 32-bit registers */
+#define MMU_TOP_REG__NWORDS	23
+#define MMU_TOP_REG__rdma_timelimit_WORD	0
+#define MMU_TOP_REG__rdma_timelimit_MASK	GENMASK(31, 16)
+#define MMU_TOP_REG__sram0_tlb_axi_port_sel_WORD	1
+#define MMU_TOP_REG__sram0_tlb_axi_port_sel_MASK	GENMASK(1, 0)
+#define MMU_TOP_REG__sram1_tlb_axi_port_sel_WORD	1
+#define MMU_TOP_REG__sram1_tlb_axi_port_sel_MASK	GENMASK(3, 2)
+#define MMU_TOP_REG__dmac0_rd_outs_num_WORD	2
+#define MMU_TOP_REG__dmac0_rd_outs_num_MASK	GENMASK(7, 0)
+#define MMU_TOP_REG__dmac1_rd_outs_num_WORD	3
+#define MMU_TOP_REG__dmac1_rd_outs_num_MASK	GENMASK(7, 0)
+
+/* POSTPIPE_REG: 50 x 32-bit registers */
+#define POSTPIPE_REG__NWORDS	50
+#define POSTPIPE_REG__m_inwidth_WORD	13
+#define POSTPIPE_REG__m_inwidth_MASK	GENMASK(15, 0)
+#define POSTPIPE_REG__m_inheight_WORD	13
+#define POSTPIPE_REG__m_inheight_MASK	GENMASK(31, 16)
+
+/* RDMA_PATH_X_REG: 60 x 32-bit registers */
+#define RDMA_PATH_X_REG__NWORDS	60
+#define RDMA_PATH_X_REG__layer_mode_WORD	0
+#define RDMA_PATH_X_REG__layer_mode_MASK	GENMASK(1, 0)
+#define RDMA_PATH_X_REG__layer_cmpsr_id_WORD	0
+#define RDMA_PATH_X_REG__layer_cmpsr_id_MASK	GENMASK(15, 13)
+#define RDMA_PATH_X_REG__is_two_layers_WORD	1
+#define RDMA_PATH_X_REG__is_two_layers_MASK	BIT(0)
+#define RDMA_PATH_X_REG__is_offline_WORD	1
+#define RDMA_PATH_X_REG__is_offline_MASK	BIT(1)
+#define RDMA_PATH_X_REG__base_addr0_low_ly0_WORD	9
+#define RDMA_PATH_X_REG__base_addr0_low_ly0_MASK	GENMASK(31, 0)
+#define RDMA_PATH_X_REG__base_addr0_high_ly0_WORD	10
+#define RDMA_PATH_X_REG__base_addr0_high_ly0_MASK	GENMASK(1, 0)
+#define RDMA_PATH_X_REG__base_addr1_low_ly0_WORD	11
+#define RDMA_PATH_X_REG__base_addr1_low_ly0_MASK	GENMASK(31, 0)
+#define RDMA_PATH_X_REG__base_addr1_high_ly0_WORD	12
+#define RDMA_PATH_X_REG__base_addr1_high_ly0_MASK	GENMASK(1, 0)
+#define RDMA_PATH_X_REG__base_addr2_low_ly0_WORD	13
+#define RDMA_PATH_X_REG__base_addr2_low_ly0_MASK	GENMASK(31, 0)
+#define RDMA_PATH_X_REG__base_addr2_high_ly0_WORD	14
+#define RDMA_PATH_X_REG__base_addr2_high_ly0_MASK	GENMASK(1, 0)
+#define RDMA_PATH_X_REG__rdma_stride0_layer0_WORD	15
+#define RDMA_PATH_X_REG__rdma_stride0_layer0_MASK	GENMASK(15, 0)
+#define RDMA_PATH_X_REG__rdma_stride1_layer0_WORD	15
+#define RDMA_PATH_X_REG__rdma_stride1_layer0_MASK	GENMASK(31, 16)
+#define RDMA_PATH_X_REG__img_width_ly0_WORD	16
+#define RDMA_PATH_X_REG__img_width_ly0_MASK	GENMASK(15, 0)
+#define RDMA_PATH_X_REG__img_height_ly0_WORD	16
+#define RDMA_PATH_X_REG__img_height_ly0_MASK	GENMASK(31, 16)
+#define RDMA_PATH_X_REG__bbox_start_x_ly0_WORD	17
+#define RDMA_PATH_X_REG__bbox_start_x_ly0_MASK	GENMASK(15, 0)
+#define RDMA_PATH_X_REG__bbox_start_y_ly0_WORD	17
+#define RDMA_PATH_X_REG__bbox_start_y_ly0_MASK	GENMASK(31, 16)
+#define RDMA_PATH_X_REG__bbox_end_x_ly0_WORD	18
+#define RDMA_PATH_X_REG__bbox_end_x_ly0_MASK	GENMASK(15, 0)
+#define RDMA_PATH_X_REG__bbox_end_y_ly0_WORD	18
+#define RDMA_PATH_X_REG__bbox_end_y_ly0_MASK	GENMASK(31, 16)
+#define RDMA_PATH_X_REG__pixel_format_WORD	29
+#define RDMA_PATH_X_REG__pixel_format_MASK	GENMASK(5, 0)
+#define RDMA_PATH_X_REG__uv_swap_WORD	29
+#define RDMA_PATH_X_REG__uv_swap_MASK	BIT(6)
+#define RDMA_PATH_X_REG__rot_mode_ly0_WORD	29
+#define RDMA_PATH_X_REG__rot_mode_ly0_MASK	GENMASK(10, 8)
+#define RDMA_PATH_X_REG__fbc_mem_size_WORD	31
+#define RDMA_PATH_X_REG__fbc_mem_size_MASK	GENMASK(15, 0)
+#define RDMA_PATH_X_REG__fbc_mem_map_WORD	31
+#define RDMA_PATH_X_REG__fbc_mem_map_MASK	BIT(28)
+
+/* TMG_REG: 30 x 32-bit registers */
+#define TMG_REG__NWORDS	30
+#define TMG_REG__split_en_WORD	0
+#define TMG_REG__split_en_MASK	BIT(0)
+#define TMG_REG__cmd_screen_WORD	0
+#define TMG_REG__cmd_screen_MASK	BIT(1)
+#define TMG_REG__fm_timing_en_WORD	0
+#define TMG_REG__fm_timing_en_MASK	BIT(2)
+#define TMG_REG__cmd_wait_en_WORD	0
+#define TMG_REG__cmd_wait_en_MASK	BIT(3)
+#define TMG_REG__cmd_wait_te_WORD	0
+#define TMG_REG__cmd_wait_te_MASK	BIT(4)
+#define TMG_REG__disp_ready_man_en_WORD	0
+#define TMG_REG__disp_ready_man_en_MASK	BIT(5)
+#define TMG_REG__hsp_WORD	0
+#define TMG_REG__hsp_MASK	BIT(7)
+#define TMG_REG__vsp_WORD	0
+#define TMG_REG__vsp_MASK	BIT(8)
+#define TMG_REG__user_WORD	2
+#define TMG_REG__user_MASK	GENMASK(15, 12)
+#define TMG_REG__hfp_WORD	3
+#define TMG_REG__hfp_MASK	GENMASK(27, 16)
+#define TMG_REG__hsync_width_WORD	4
+#define TMG_REG__hsync_width_MASK	GENMASK(9, 0)
+#define TMG_REG__hbp_WORD	4
+#define TMG_REG__hbp_MASK	GENMASK(27, 16)
+#define TMG_REG__vfp_WORD	5
+#define TMG_REG__vfp_MASK	GENMASK(15, 0)
+#define TMG_REG__vsync_width_WORD	5
+#define TMG_REG__vsync_width_MASK	GENMASK(25, 16)
+#define TMG_REG__vbp_WORD	6
+#define TMG_REG__vbp_MASK	GENMASK(11, 0)
+#define TMG_REG__h_active_WORD	6
+#define TMG_REG__h_active_MASK	GENMASK(29, 16)
+#define TMG_REG__v_active_WORD	7
+#define TMG_REG__v_active_MASK	GENMASK(13, 0)
+#define TMG_REG__background_r_WORD	9
+#define TMG_REG__background_r_MASK	GENMASK(11, 0)
+#define TMG_REG__background_g_WORD	9
+#define TMG_REG__background_g_MASK	GENMASK(27, 16)
+#define TMG_REG__background_b_WORD	10
+#define TMG_REG__background_b_MASK	GENMASK(11, 0)
+#define TMG_REG__eof_1st_ln_dly_num_WORD	11
+#define TMG_REG__eof_1st_ln_dly_num_MASK	GENMASK(15, 0)
+#define TMG_REG__eof_2nd_ln_dly_num_WORD	11
+#define TMG_REG__eof_2nd_ln_dly_num_MASK	GENMASK(31, 16)
+#define TMG_REG__sof_pre_ln_num_WORD	14
+#define TMG_REG__sof_pre_ln_num_MASK	GENMASK(16, 0)
+#define TMG_REG__vsync_align_with_hsync_WORD	15
+#define TMG_REG__vsync_align_with_hsync_MASK	BIT(0)
+
+#endif /* SATURN_FIELDS_H */
diff --git a/drivers/gpu/drm/spacemit/spacemit_dpu_ids.h b/drivers/gpu/drm/spacemit/spacemit_dpu_ids.h
new file mode 100644
index 0000000000000..d5ec7d51ca3a4
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_dpu_ids.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ */
+
+#ifndef _SPACEMIT_DPU_IDS_H_
+#define _SPACEMIT_DPU_IDS_H_
+
+/*
+ * Saturn online compositor ids. Both K3 DPU instances are wired as COMPOSER1,
+ * which selects the composer registers, the scene control block and the
+ * composer's command-list enable and CFG_RDY bits.
+ */
+#define COMPOSER0	0
+#define COMPOSER1	1
+#define COMPOSER2	2
+#define COMPOSER3	3
+
+/* Output-format encoding of the timing generator's user field. */
+#define OUTFMT_RGB121212	0
+#define OUTFMT_RGB101010	1
+#define OUTFMT_RGB888		2
+#define OUTFMT_RGB666		12
+#define OUTFMT_RGB565		13
+
+#endif /* _SPACEMIT_DPU_IDS_H_ */

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 08/17] drm/spacemit: add Saturn DPU core types, cmdlist and display MMU
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (6 preceding siblings ...)
  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 ` Cody Kang via B4 Relay
  2026-11-21  7:40 ` [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend Cody Kang via B4 Relay
                   ` (8 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Register programming of the Saturn DPU is batched: the driver builds
per-module register lists in memory and the hardware command-list
engine replays them once the driver raises config-ready (CFG_RDY),
while scanout buffers are mapped through the DPU's private address
translation unit (DMMU) rather than scanned out by physical address.

Add the shared driver types, the MMIO field accessors, the
command-list builder and the DMMU table code. Some DPU
configuration registers are write-only, so a read-modify-write would
corrupt neighbouring fields; byte- and halfword-aligned fields are
therefore written at their native width instead.

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

---
v3:
- drop the tracepoints and dpu_trace.h (Thomas Zimmermann)
- drop the hardware callback table; the Saturn register code is called
  directly (Thomas Zimmermann)
- one command list per channel, allocated once; the grouping, sorting
  and chaining of lists is gone (Thomas Zimmermann)
- build the display MMU table once per GEM object (Thomas Zimmermann)
- use drm_WARN_ON_ONCE() in the DMMU table fill (Thomas Zimmermann)
- keep the clock handles and the power state in the device data
- commit message: the engine replays the lists on config-ready, not at
  frame boundaries
v2:
- hold the DPU reset lines as one reset_control_bulk_data
  pipe_resets[5] array in spacemit_drm_private and drop the pointers
  duplicated into struct spacemit_crtc (Philipp Zabel)
- drop the INT_VSYNC_UPDATE enum member; it never had an irq_list[]
  mapping and the register model has no such status bit (Sashiko)
- drop the unreachable multi-planar arms in spacemit_dmmu_map(); every
  advertised format is single-planar (Sashiko)
- drop the unused cmdlist parameter from the crtc_cmdlist op (Sashiko)
---
 drivers/gpu/drm/spacemit/dpu/dpu_saturn.h   |  36 +++++
 drivers/gpu/drm/spacemit/spacemit_cmdlist.c | 198 ++++++++++++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_cmdlist.h | 133 +++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_crtc.h    | 133 +++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_dmmu.c    | 119 +++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_dmmu.h    |  80 +++++++++++
 drivers/gpu/drm/spacemit/spacemit_dpu_reg.h |  99 ++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_drm.h     |  62 +++++++++
 8 files changed, 860 insertions(+)

diff --git a/drivers/gpu/drm/spacemit/dpu/dpu_saturn.h b/drivers/gpu/drm/spacemit/dpu/dpu_saturn.h
new file mode 100644
index 0000000000000..9f3c58166273c
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/dpu/dpu_saturn.h
@@ -0,0 +1,36 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _DPU_SATURN_H_
+#define _DPU_SATURN_H_
+
+#include "../spacemit_crtc.h"
+
+struct dpu_format_id {
+	u32 format;		/* DRM fourcc */
+	u8 id;
+	u8 bpp;			/* bits per pixel */
+};
+
+#define SPACEMIT_DPU_INVALID_FORMAT_ID	0xff
+
+int spacemit_dpu_parse_clocks(struct device *dev, struct dpu_clk_context *clk_ctx);
+int spacemit_dpu_enable_clocks(struct spacemit_drm_private *priv);
+void spacemit_dpu_disable_clocks(struct spacemit_drm_private *priv);
+void spacemit_dpu_init(struct spacemit_crtc *a_crtc,
+		       const struct drm_display_mode *mode);
+void spacemit_dpu_uninit(struct spacemit_crtc *a_crtc);
+void spacemit_dpu_run(struct drm_crtc *crtc, struct drm_atomic_commit *state);
+bool spacemit_dpu_online_isr(struct spacemit_crtc *a_crtc);
+u8 spacemit_plane_hw_get_format_id(u32 format);
+u32 saturn_conf_dpuctrl_rdma(struct drm_atomic_commit *state,
+			     const struct drm_crtc_state *crtc_state);
+extern const struct spacemit_hw_device spacemit_k3_saturn_dpu;
+void saturn_enable_irq_mask(struct spacemit_crtc *a_crtc, bool enable,
+			    u32 offset, u32 mask);
+void spacemit_cfg_rdy_timer_handler(struct timer_list *t);
+void spacemit_dpu_complete_event(struct spacemit_crtc *a_crtc);
+#endif
diff --git a/drivers/gpu/drm/spacemit/spacemit_cmdlist.c b/drivers/gpu/drm/spacemit/spacemit_cmdlist.c
new file mode 100644
index 0000000000000..fbd5c2d85eaa2
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_cmdlist.c
@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/string.h>
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_managed.h>
+#include <drm/drm_print.h>
+
+#include "dpu/dpu_saturn.h"
+#include "dpu/saturn_regs/ops_hee.h"
+#include "spacemit_cmdlist.h"
+#include "spacemit_crtc.h"
+#include "spacemit_dpu_reg.h"
+#include "spacemit_drm.h"
+
+struct cmdlist *spacemit_plane_to_cl(struct drm_plane *plane)
+{
+	struct spacemit_plane *p = to_spacemit_plane(plane);
+
+	return &p->cl[p->cl_cur];
+}
+
+struct cmdlist *spacemit_crtc_to_cl(struct drm_crtc *crtc)
+{
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+
+	return &a_crtc->cl[a_crtc->cl_cur];
+}
+
+static void spacemit_cmdlist_ring_release(struct drm_device *drm, void *res)
+{
+	struct cmdlist *cl = res;
+	int i;
+
+	for (i = 0; i < CMDLIST_RING; i++) {
+		if (cl[i].va)
+			dma_free_coherent(drm->dev, cl[i].size, cl[i].va,
+					  cl[i].pa);
+	}
+}
+
+/* Allocate a channel's lists once, for the life of the DRM device. */
+int spacemit_cmdlist_ring_init(struct drm_device *drm, struct cmdlist cl[CMDLIST_RING],
+			       enum cmdlist_type type, struct drm_plane *plane,
+		      struct drm_crtc *crtc)
+{
+	int i;
+
+	for (i = 0; i < CMDLIST_RING; i++) {
+		cl[i].type = type;
+		cl[i].plane = plane;
+		cl[i].crtc = crtc;
+		cl[i].size = PER_CMDLIST_SIZE;
+		cl[i].va = dma_alloc_coherent(drm->dev, cl[i].size, &cl[i].pa,
+					      GFP_KERNEL);
+		if (!cl[i].va) {
+			spacemit_cmdlist_ring_release(drm, cl);
+			return -ENOMEM;
+		}
+	}
+
+	return drmm_add_action_or_reset(drm, spacemit_cmdlist_ring_release, cl);
+}
+
+/* Switch to the other list and empty it for this commit. */
+struct cmdlist *spacemit_cmdlist_ring_next(struct cmdlist cl[CMDLIST_RING], u8 *cur)
+{
+	struct cmdlist *next;
+
+	*cur ^= 1;
+	next = &cl[*cur];
+	next->nod_len = 0;
+	next->mode_mask = 0;
+	memset(next->va, 0, CMDLIST_HEADER_SIZE);
+
+	return next;
+}
+
+/* Allocated once at init: the commit tail has no way to fail. */
+struct cmdlist_regs *spacemit_cmdlist_regs_alloc(struct drm_device *drm,
+						 u16 nwords)
+{
+	struct cmdlist_regs *regs;
+
+	regs = drmm_kzalloc(drm, sizeof(*regs), GFP_KERNEL);
+	if (!regs)
+		return NULL;
+
+	regs->size = nwords;
+	regs->module = drmm_kcalloc(drm, nwords, sizeof(*regs->module),
+				    GFP_KERNEL);
+	regs->flags = drmm_kcalloc(drm, nwords, sizeof(*regs->flags),
+				   GFP_KERNEL);
+	if (!regs->module || !regs->flags)
+		return NULL;
+
+	return regs;
+}
+
+/* Append the words written to @cl_regs to @cl and empty the image. */
+void spacemit_cmdlist_regs_packing(struct cmdlist *cl, enum cmdlist_mode_type mod,
+				   struct cmdlist_regs *cl_regs)
+{
+	struct drm_device *drm;
+	u32 *reg_base;
+	int i;
+	u32 index;
+
+	drm = cl->type == CMDLIST_PLANE ? cl->plane->dev : cl->crtc->dev;
+
+	reg_base = cl_regs->module;
+
+	cl->mode_mask |= mod;
+
+	/* Allocated in spacemit_cmdlist_ring_init(); without it the writes vanish. */
+	if (drm_WARN_ON(drm, !cl->va))
+		goto out;
+
+	for (i = 0; i < cl_regs->size;) {
+		u32 value[CMDLIST_ROW_REGS] = {0x0};
+		u32 offset, strobe = 0;
+
+		if (cl_regs->flags[i]) {
+			offset = cl_regs->base + i * sizeof(u32);
+			for (u8 j = 0; j < CMDLIST_ROW_REGS; j++) {
+				index = i + j;
+				if (likely(index < cl_regs->size)) {
+					if (cl_regs->flags[index]) {
+						value[j] = reg_base[index];
+						strobe |= CMDLIST_REG_STROBE(j);
+					}
+				} else {
+					break;
+				}
+			}
+			if (!saturn_hee_cmdlist_fill_data_row(cl, strobe, offset,
+							      value)) {
+				drm_WARN_ONCE(drm, 1,
+					      "cmdlist buffer full (rows %u)\n",
+					      cl->nod_len);
+				goto out;
+			}
+			/*
+			 * the row covers the whole window; a shorter stride
+			 * would revisit covered words as duplicate rows
+			 */
+			i += CMDLIST_ROW_REGS;
+			cl->nod_len++;
+		} else {
+			i++;
+		}
+	}
+
+	drm_dbg(drm, "row_num = %d\n", cl->nod_len);
+out:
+	memset(cl_regs->flags, 0, cl_regs->size);
+}
+
+/*
+ * Terminate the plane's list and point its read channel at it; the engine
+ * replays it at the next CFG_RDY.
+ */
+void spacemit_cmdlist_submit_plane(struct drm_plane *plane,
+				   struct drm_plane_state *state)
+{
+	struct spacemit_plane *p = to_spacemit_plane(plane);
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(state->crtc);
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	struct cmdlist *cl = spacemit_plane_to_cl(plane);
+	u32 addrl, addrh;
+
+	saturn_hee_cmdlist_fill_conf_row(cl, state->dst.y1);
+
+	addrl = (lower_32_bits(cl->pa) & CMDLIST_ADDRL_ALIGN_MASK) >>
+		CMDLIST_ADDRL_ALIGN_BITS;
+	addrh = upper_32_bits(cl->pa);
+
+	saturn_hee_enable_cmdlist(a_crtc, hwdev, p->rdma_id, false);
+	saturn_hee_cfg_cmdlist(hwdev, p->rdma_id, state->dst.y1, addrl, addrh);
+	saturn_hee_enable_cmdlist(a_crtc, hwdev, p->rdma_id, true);
+}
+
+/* Terminate the CRTC's compose list and point the composer channel at it. */
+void spacemit_cmdlist_submit_crtc(struct spacemit_crtc *a_crtc)
+{
+	struct drm_crtc *crtc = &a_crtc->crtc;
+	struct spacemit_drm_private *priv = crtc->dev->dev_private;
+	struct cmdlist *cl = spacemit_crtc_to_cl(crtc);
+
+	saturn_hee_cmdlist_fill_conf_row(cl, 0);
+	saturn_hee_crtc_cmdlist(priv->hwdev, cl->pa, drm_crtc_index(crtc));
+}
diff --git a/drivers/gpu/drm/spacemit/spacemit_cmdlist.h b/drivers/gpu/drm/spacemit/spacemit_cmdlist.h
new file mode 100644
index 0000000000000..ebf2e26f48188
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_cmdlist.h
@@ -0,0 +1,133 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _SPACEMIT_CMDLIST_H_
+#define _SPACEMIT_CMDLIST_H_
+
+#include <linux/bits.h>
+#include <linux/io.h>
+#include <linux/types.h>
+
+#include <drm/drm_crtc.h>
+#include <drm/drm_plane.h>
+
+struct spacemit_crtc;
+struct spacemit_plane_state;
+
+#define PER_CMDLIST_SIZE             4096
+/* The engine's node header; rows follow it. Layout in dpu_saturn_hee.c. */
+#define CMDLIST_HEADER_SIZE          16
+#define CMDLIST_ROW_REGS	(3)
+
+/**
+ * enum cmdlist_type - what surface owns a cmdlist instance
+ * @CMDLIST_PLANE: Per-plane RDMA register batches.
+ * @CMDLIST_CRTC: Compose-side batches submitted on every flush.
+ */
+enum cmdlist_type {
+	CMDLIST_PLANE = 1,
+	CMDLIST_CRTC,
+};
+
+/**
+ * struct cmdlist - A DMA-backed batch of register writes replayed at CFG_RDY
+ * @nod_len: Number of register-write rows currently filled.
+ * @size: Capacity of the DMA buffer in bytes.
+ * @mode_mask: &enum cmdlist_mode_type bits of the blocks packed into the
+ *	       list; selects the wait events and CFG_RDY bits when it is closed.
+ * @va: Kernel virtual address of the DMA buffer.
+ * @pa: DMA address programmed into the cmdlist base register.
+ * @type: Originating surface; see &enum cmdlist_type.
+ * @plane: Owning plane for a %CMDLIST_PLANE list.
+ * @crtc: Owning CRTC for a %CMDLIST_CRTC list.
+ */
+struct cmdlist {
+	u16 nod_len;
+	u32 size;
+	u32 mode_mask;
+	void *va;
+	dma_addr_t pa;
+	u8 type;
+	struct drm_plane *plane;
+	struct drm_crtc *crtc;
+};
+
+/*
+ * Two lists per channel, used alternately: the engine may still re-read the
+ * list of the previous commit until the next CFG_RDY has been consumed, and
+ * every commit waits for that before it completes.
+ */
+#define CMDLIST_RING	2
+
+enum cmdlist_mode_type {
+	CMDLIST_MOD_RDMA = BIT(0),
+	CMDLIST_MOD_COMP = BIT(3),
+	CMDLIST_MOD_DMMU = BIT(6),
+};
+
+#define CMDLIST_REG_STROBE(index)	(0xf << ((index) * 4))
+
+#define CMDLIST_ADDRL_ALIGN_BITS               (4) /* From cmdlist_reg_0[] in CMDLIST_REG */
+#define CMDLIST_ADDRL_ALIGN_MASK \
+	((u32)(~(BIT(CMDLIST_ADDRL_ALIGN_BITS) - 1)))
+/*
+ * First touch seeds the word from a live MMIO read: only register blocks that
+ * read back what was written may be routed through cmdlist.
+ */
+#define cmdlist_write_reg(hwdev, module_name, module_base, field, data, cl_regs) \
+do { \
+	struct cmdlist_regs *cl_p = (cl_regs); \
+	u32 *__words = cl_p->module; \
+	const unsigned int __w = dpu_field_word(module_name, field); \
+	if (cl_p->flags[__w] == 0) { \
+		__words[__w] = readl((hwdev)->base + (module_base) + 4 * __w); \
+		cl_p->base = (module_base); \
+		cl_p->flags[__w] = 1; \
+	} \
+	__words[__w] &= ~dpu_field_mask(module_name, field); \
+	__words[__w] |= FIELD_PREP(dpu_field_mask(module_name, field), \
+				   (u32)(data)); \
+} while (0)
+
+/* Raw whole-word variant; no seeding needed. */
+#define cmdlist_write_word(module_base, word, data, cl_regs) \
+do { \
+	struct cmdlist_regs *cl_p = (cl_regs); \
+	u32 *__words = cl_p->module; \
+	cl_p->base = (module_base); \
+	cl_p->flags[(word)] = 1; \
+	__words[(word)] = (u32)(data); \
+} while (0)
+
+/**
+ * struct cmdlist_regs - Scratch image of one register block
+ * @base: Offset of the block the image currently describes.
+ * @size: Number of words in the block.
+ * @module: The words.
+ * @flags: Nonzero for each word written since the image was last packed.
+ */
+struct cmdlist_regs {
+	u32 base;
+	u16 size;
+	u32 *module;
+	u8 *flags;
+};
+
+struct cmdlist_regs *spacemit_cmdlist_regs_alloc(struct drm_device *drm,
+						 u16 nwords);
+void spacemit_cmdlist_regs_packing(struct cmdlist *cl, enum cmdlist_mode_type mod,
+				   struct cmdlist_regs *cl_regs);
+int spacemit_cmdlist_ring_init(struct drm_device *drm, struct cmdlist cl[CMDLIST_RING],
+			       enum cmdlist_type type, struct drm_plane *plane,
+		      struct drm_crtc *crtc);
+struct cmdlist *spacemit_cmdlist_ring_next(struct cmdlist cl[CMDLIST_RING], u8 *cur);
+void spacemit_cmdlist_submit_plane(struct drm_plane *plane,
+				   struct drm_plane_state *state);
+void spacemit_cmdlist_submit_crtc(struct spacemit_crtc *a_crtc);
+struct cmdlist *spacemit_plane_to_cl(struct drm_plane *plane);
+struct cmdlist *spacemit_crtc_to_cl(struct drm_crtc *crtc);
+
+#endif /* _SPACEMIT_CMDLIST_H_ */
diff --git a/drivers/gpu/drm/spacemit/spacemit_crtc.h b/drivers/gpu/drm/spacemit/spacemit_crtc.h
new file mode 100644
index 0000000000000..d1f7ebe5d1a9d
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_crtc.h
@@ -0,0 +1,133 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _SPACEMIT_CRTC_H_
+#define _SPACEMIT_CRTC_H_
+
+#include <linux/container_of.h>
+#include <linux/timer.h>
+#include <linux/types.h>
+
+#include <drm/drm_crtc.h>
+#include <drm/drm_plane.h>
+
+#include "spacemit_cmdlist.h"
+#include "spacemit_drm.h"
+
+struct regmap;
+
+/* RDMA stride is a 16-bit byte count; img_width/height are 16-bit fields. */
+#define SPACEMIT_DPU_MAX_FB_WIDTH	(U16_MAX / 4)
+#define SPACEMIT_DPU_MAX_FB_HEIGHT	U16_MAX
+#define SPACEMIT_DPU_MAX_PITCH		U16_MAX
+/* K3 user manual ch.12: each DPU output is at most 3840x2160. */
+#define SPACEMIT_DPU_MAX_HDISPLAY	3840
+#define SPACEMIT_DPU_MAX_VDISPLAY	2160
+
+#define DPU_MCLK_DEFAULT	307200000
+#define DPU_AXICLK_DEFAULT	409000000
+
+enum spacemit_dpu_irq {
+	INT_UNDERRUN,
+	INT_CFG_RDY,
+	INT_VSYNC,
+	INT_EOF,
+	INT_REST,
+};
+
+/**
+ * struct spacemit_crtc - Per-instance state for a Saturn DPU CRTC
+ * @crtc: Embedded DRM CRTC; reachable via to_spacemit_crtc().
+ * @cfg_rdy_timer: Watchdog for a CFG_RDY that never arrives.
+ * @is_1st_f: True until the first frame of a new modeset is transferred.
+ * @event: The commit's event, held until the engine has taken its lists;
+ *	   under &drm_device.event_lock.
+ * @cl_cmp: Scratch image of the composer registers.
+ * @cl_pp: Scratch image of the post-pipe registers.
+ * @cl: The composer channel's command lists, written alternately.
+ * @cl_cur: Index of the list being built for the current commit.
+ * @ur_reported: True once an underrun has been logged since the last CFG_RDY.
+ * @ur_mask_armed: True while saturn_hee_clr_int_sts() may still mask the
+ *		   underrun IRQ.
+ */
+struct spacemit_crtc {
+	struct drm_crtc crtc;
+	struct timer_list cfg_rdy_timer;
+
+	bool is_1st_f;
+	struct drm_pending_vblank_event *event;
+
+	struct cmdlist_regs *cl_cmp;
+	struct cmdlist_regs *cl_pp;
+	struct cmdlist cl[CMDLIST_RING];
+	u8 cl_cur;
+
+	bool ur_reported;
+	bool ur_mask_armed;
+};
+
+static inline struct spacemit_crtc *to_spacemit_crtc(struct drm_crtc *crtc)
+{
+	return container_of(crtc, struct spacemit_crtc, crtc);
+}
+
+struct spacemit_hw_device;
+
+/**
+ * struct spacemit_plane - Subclassed drm_plane for the Saturn DPU
+ * @plane: Base DRM plane.
+ * @rdma_id: The RDMA read channel this plane scans out through, fixed at init.
+ * @cl: The channel's command lists, written alternately.
+ * @cl_cur: Index of the list being built for the current commit.
+ * @cl_rdma: Scratch image of the read channel's registers.
+ * @cl_tbu: Scratch image of the channel's TBU registers.
+ */
+struct spacemit_plane {
+	struct drm_plane plane;
+	u8 rdma_id;
+	struct cmdlist_regs *cl_rdma;
+	struct cmdlist_regs *cl_tbu;
+	struct cmdlist cl[CMDLIST_RING];
+	u8 cl_cur;
+};
+
+/**
+ * struct spacemit_plane_state - Subclassed drm_plane_state for the Saturn DPU
+ * @state: Embedded drm_plane_state; reachable via to_spacemit_plane_state().
+ * @format: DPU-internal pixel-format token translated from the fourcc.
+ * @fbcmem_size: Line-buffer units (FBCMEM_UNIT bytes) this plane needs.
+ */
+struct spacemit_plane_state {
+	struct drm_plane_state state;
+	u8 format;
+	u32 fbcmem_size;
+};
+
+struct spacemit_plane *to_spacemit_plane(struct drm_plane *plane);
+
+static inline struct
+spacemit_plane_state *
+to_spacemit_plane_state(const struct drm_plane_state *state)
+{
+	return container_of(state, struct spacemit_plane_state, state);
+}
+
+struct drm_plane *spacemit_plane_init(struct drm_device *drm);
+
+/*
+ * Per-revision Saturn DPU description. One static instance per DT compatible,
+ * copied at probe.
+ */
+struct spacemit_hw_device {
+	void __iomem *base;
+	struct regmap *regmap;
+	u8 rdma_nums;
+	u8 n_formats;
+	const struct dpu_format_id *formats;
+	u8 n_fbcmems;
+	const u32 *fbcmem_sizes;
+};
+#endif
diff --git a/drivers/gpu/drm/spacemit/spacemit_dmmu.c b/drivers/gpu/drm/spacemit/spacemit_dmmu.c
new file mode 100644
index 0000000000000..e886547cff6a3
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_dmmu.c
@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2023-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/cleanup.h>
+#include <linux/dma-mapping.h>
+#include <linux/gfp.h>
+#include <linux/stddef.h>
+
+#include <drm/drm_framebuffer.h>
+#include <drm/drm_gem_shmem_helper.h>
+
+#include "dpu/saturn_regs/ops_hee.h"
+#include "spacemit_cmdlist.h"
+#include "spacemit_crtc.h"
+#include "spacemit_dmmu.h"
+#include "spacemit_dpu_reg.h"
+#include "spacemit_drm.h"
+
+static inline void spacemit_dmmu_fill_pgtable(struct drm_device *drm,
+					      struct dpu_mmu_tbl *tbl,
+					      struct sg_table *sgt)
+{
+	struct sg_dma_page_iter dma_iter;
+	u32 max_entries = tbl->size / 4;
+	u32 *ttbr = tbl->va;
+	u32 i = 0, n = 0, temp = 0;
+
+	for_each_sgtable_dma_page(sgt, &dma_iter, 0) {
+		/*
+		 * The table was sized from this object, so running past it is
+		 * a driver bug.
+		 */
+		if (drm_WARN_ON_ONCE(drm, n + HW_ALIGN_TTB_NUM >= max_entries))
+			break;
+		ttbr[n++] = SPACEMIT_DMMU_PFN_MASK &
+			    (sg_page_iter_dma_address(&dma_iter) >> PAGE_SHIFT);
+	}
+
+	if (drm_WARN_ON_ONCE(drm, !n))
+		return;
+
+	/*
+	 * The silicon over-fetches past the last entry; pad it to avoid a DDR
+	 * fault.
+	 */
+	temp = ttbr[n - 1];
+	for (i = 0; i < HW_ALIGN_TTB_NUM; i++)
+		ttbr[n++] = temp;
+}
+
+/*
+ * Build the translation table for @obj once. The table describes the buffer,
+ * not a plane state, so it lives with the object and is reused by every
+ * commit that scans the buffer out.
+ */
+int spacemit_dmmu_prepare(struct drm_gem_object *obj)
+{
+	struct spacemit_gem_object *sgem = to_spacemit_gem(obj);
+	struct drm_gem_shmem_object *shmem = &sgem->base;
+	struct device *dev = obj->dev->dev;
+	struct dpu_mmu_tbl tbl;
+	struct sg_table *sgt;
+
+	guard(mutex)(&sgem->tbl_lock);
+
+	if (sgem->mmu_tbl.va)
+		return 0;
+
+	/* An imported dma-buf has its sg table mapped for this device. */
+	if (drm_gem_is_imported(obj)) {
+		sgt = shmem->sgt;
+		if (!sgt)
+			return -EINVAL;
+	} else {
+		sgt = drm_gem_shmem_get_pages_sgt(shmem);
+		if (IS_ERR(sgt))
+			return PTR_ERR(sgt);
+	}
+
+	tbl.size = ((PAGE_ALIGN(obj->size) >> PAGE_SHIFT) + HW_ALIGN_TTB_NUM) * 4;
+	tbl.va = dma_alloc_coherent(dev, tbl.size, &tbl.pa, GFP_KERNEL);
+	if (!tbl.va)
+		return -ENOMEM;
+
+	spacemit_dmmu_fill_pgtable(obj->dev, &tbl, sgt);
+	sgem->mmu_tbl = tbl;
+
+	return 0;
+}
+
+void spacemit_dmmu_release(struct drm_gem_object *obj)
+{
+	struct spacemit_gem_object *sgem = to_spacemit_gem(obj);
+
+	if (sgem->mmu_tbl.va)
+		dma_free_coherent(obj->dev->dev, sgem->mmu_tbl.size,
+				  sgem->mmu_tbl.va, sgem->mmu_tbl.pa);
+	mutex_destroy(&sgem->tbl_lock);
+}
+
+/* Point the plane's TBU at the framebuffer's table; built in prepare_fb. */
+void spacemit_dmmu_map(struct drm_framebuffer *fb, u8 tbu_id,
+		       struct cmdlist_regs *cl_rdma, struct drm_plane *plane)
+{
+	struct spacemit_drm_private *priv = fb->dev->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	struct spacemit_gem_object *sgem = to_spacemit_gem(fb->obj[0]);
+	struct tbu_instance tbu = { };
+
+	/* Every advertised format is single-planar */
+	tbu.ttb_pa[0] = sgem->mmu_tbl.pa;
+	tbu.tbu_va[0] = TBU_BASE_VA(tbu_id);
+	tbu.ttb_size[0] = roundup(fb->obj[0]->size, PAGE_SIZE) >> PAGE_SHIFT;
+
+	saturn_hee_rdma_dmmu(hwdev, tbu_id, &tbu, fb, cl_rdma, plane);
+}
diff --git a/drivers/gpu/drm/spacemit/spacemit_dmmu.h b/drivers/gpu/drm/spacemit/spacemit_dmmu.h
new file mode 100644
index 0000000000000..b5a3b48d19893
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_dmmu.h
@@ -0,0 +1,80 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _SPACEMIT_DMMU_H_
+#define _SPACEMIT_DMMU_H_
+
+#include <linux/bits.h>
+#include <linux/mutex.h>
+#include <linux/types.h>
+
+#include <drm/drm_file.h>
+#include <drm/drm_gem_shmem_helper.h>
+
+#include "spacemit_cmdlist.h"
+
+#define DPU_QOS_URGENT	4
+/* The TLB over-fetches past the table's end, further the larger src_x is. */
+#define SPACEMIT_DMMU_MAX_SRC_X	4096
+/* Entries of padding that cover the over-fetch at SPACEMIT_DMMU_MAX_SRC_X. */
+#define HW_ALIGN_TTB_NUM	60
+
+/* tbu_size is a 16-bit page count. */
+#define SPACEMIT_DMMU_MAX_PAGES	U16_MAX
+/* A table entry holds a 26-bit page frame number. */
+#define SPACEMIT_DMMU_PFN_MASK	GENMASK(25, 0)
+
+#define RD_OUTS_NUM             16
+#define RDMA_TIMELIMIT  0xFFFF
+
+#define BASE_VA         0x10000000ULL
+#define VA_STEP_PER_TBU 0x40000000ULL
+
+#define TBU_BASE_VA(tbu_id) ((u64)BASE_VA + (u64)VA_STEP_PER_TBU * (tbu_id))
+
+struct tbu_instance {
+	u64 ttb_pa[3];
+	u64 tbu_va[3];
+	u32 ttb_size[3];
+};
+
+/**
+ * struct dpu_mmu_tbl - DMMU translation table for one buffer object
+ * @size: Bytes of table, including the over-fetch padding.
+ * @va: CPU address of the table.
+ * @pa: DMA address programmed into the TBU.
+ */
+struct dpu_mmu_tbl {
+	u32 size;
+	void *va;
+	dma_addr_t pa;
+};
+
+/**
+ * struct spacemit_gem_object - shmem object plus its DMMU table
+ * @base: The shmem object.
+ * @mmu_tbl: Built on the first scanout of this buffer, freed with it.
+ * @tbl_lock: Serialises the lazy build between commits.
+ */
+struct spacemit_gem_object {
+	struct drm_gem_shmem_object base;
+	struct dpu_mmu_tbl mmu_tbl;
+	struct mutex tbl_lock;	/* serialises the build of @mmu_tbl */
+};
+
+static inline struct spacemit_gem_object *
+to_spacemit_gem(struct drm_gem_object *obj)
+{
+	return container_of(to_drm_gem_shmem_obj(obj), struct spacemit_gem_object,
+			    base);
+}
+
+int spacemit_dmmu_prepare(struct drm_gem_object *obj);
+void spacemit_dmmu_release(struct drm_gem_object *obj);
+void spacemit_dmmu_map(struct drm_framebuffer *fb, u8 tbu_id,
+		       struct cmdlist_regs *cl_rdma, struct drm_plane *plane);
+
+#endif /* _SPACEMIT_DMMU_H_ */
diff --git a/drivers/gpu/drm/spacemit/spacemit_dpu_reg.h b/drivers/gpu/drm/spacemit/spacemit_dpu_reg.h
new file mode 100644
index 0000000000000..4147f5f548f1c
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_dpu_reg.h
@@ -0,0 +1,99 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ * Saturn DPU register accessors.
+ */
+
+#ifndef _SPACEMIT_DPU_REG_H_
+#define _SPACEMIT_DPU_REG_H_
+
+#include <linux/bitfield.h>
+#include <linux/io.h>
+
+#include "dpu/saturn_regs/saturn_fields.h"
+
+#define dpu_field_word(module_name, field)	(module_name##__##field##_WORD)
+#define dpu_field_mask(module_name, field)	(module_name##__##field##_MASK)
+
+/* MMIO field read: returns the field value shifted down to bit 0. */
+#define dpu_read_reg(hwdev, module_name, module_base, field)		\
+	FIELD_GET(dpu_field_mask(module_name, field),			\
+		  readl((hwdev)->base + (module_base) +			\
+			4 * dpu_field_word(module_name, field)))
+
+/* MMIO raw 32-bit register read/write by word index within the block. */
+#define dpu_read_word(hwdev, module_base, word)				\
+	readl((hwdev)->base + (module_base) + 4 * (word))
+
+#define dpu_write_reg_word(hwdev, module_base, word, data)		\
+	writel((u32)(data), (hwdev)->base + (module_base) + 4 * (word))
+
+/*
+ * Not every DPU config word reads back what was written, so a byte- or
+ * halfword-aligned field is stored at its own width rather than read-modified.
+ */
+#define __dpu_mmio_field_write(__addr, __mask, data)			\
+do {									\
+	if ((__mask) == 0xffU)						\
+		writeb((u8)((data) & 0xffU), __addr);			\
+	else if ((__mask) == 0xff00U)					\
+		writeb((u8)((data) & 0xffU), (__addr) + 1);		\
+	else if ((__mask) == 0xff0000U)					\
+		writeb((u8)((data) & 0xffU), (__addr) + 2);		\
+	else if ((__mask) == 0xff000000U)				\
+		writeb((u8)((data) & 0xffU), (__addr) + 3);		\
+	else if ((__mask) == 0xffffU)					\
+		writew((u16)((data) & 0xffffU), __addr);		\
+	else if ((__mask) == 0xffff0000U)				\
+		writew((u16)((data) & 0xffffU), (__addr) + 2);		\
+	else if ((__mask) == 0xffffffffU)				\
+		writel((u32)(data), __addr);				\
+	else								\
+		writel((readl(__addr) & ~(__mask)) |			\
+		       FIELD_PREP(__mask, (u32)(data)), __addr);	\
+} while (0)
+
+#define dpu_write_reg(hwdev, module_name, module_base, field, data)	\
+do {									\
+	void __iomem *__waddr = (hwdev)->base + (module_base) +	\
+				4 * dpu_field_word(module_name, field);	\
+	__dpu_mmio_field_write(__waddr,					\
+			       dpu_field_mask(module_name, field), data); \
+} while (0)
+
+/* Field write into a register array element; the index is a runtime value. */
+#define dpu_write_reg_arr(hwdev, module_name, module_base, arr, i, field, data) \
+do {									\
+	void __iomem *__waddr = (hwdev)->base + (module_base) +	\
+		4 * module_name##__##arr##__##field##_WORD(i);		\
+	__dpu_mmio_field_write(__waddr,					\
+			       module_name##__##arr##__##field##_MASK,	\
+			       data);					\
+} while (0)
+
+/*
+ * Unified CPU/cmdlist field write; a NULL cl_regs selects the direct MMIO path.
+ */
+#define _dpu_write_reg(hwdev, module_name, module_base, field, data, cl_regs, ...) \
+do {									\
+	if ((cl_regs) != NULL)						\
+		cmdlist_write_reg(hwdev, module_name, module_base,	\
+				  field, data, cl_regs);		\
+	else								\
+		dpu_write_reg(hwdev, module_name, module_base, field,	\
+			      data);					\
+} while (0)
+
+#define dpu_write(...) _dpu_write_reg(__VA_ARGS__, NULL)
+
+/* Unified CPU/cmdlist raw-word write. */
+#define dpu_write_word(hwdev, module_base, word, data, cl_regs)	\
+do {									\
+	if ((cl_regs) != NULL)						\
+		cmdlist_write_word(module_base, word, data, cl_regs);	\
+	else								\
+		dpu_write_reg_word(hwdev, module_base, word, data);	\
+} while (0)
+
+#endif
diff --git a/drivers/gpu/drm/spacemit/spacemit_drm.h b/drivers/gpu/drm/spacemit/spacemit_drm.h
new file mode 100644
index 0000000000000..af969194057b8
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_drm.h
@@ -0,0 +1,62 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef _SPACEMIT_DRM_H_
+#define _SPACEMIT_DRM_H_
+
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/reset.h>
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_print.h>
+#include <drm/drm_probe_helper.h>
+#include <drm/drm_vblank.h>
+
+#include "spacemit_dmmu.h"
+
+/* The DPU's clock inputs, as named by the binding. */
+struct dpu_clk_context {
+	struct clk *pxclk;
+	struct clk *mclk;
+	struct clk *escclk;
+	struct clk *aclk;
+	struct clk *dscclk;
+};
+
+/**
+ * struct spacemit_drm_private - Top-level driver state for the SpacemiT DRM
+ * card
+ * @ddev: DRM device; lives from the component master bind to its unbind.
+ * @dev: The DPU platform device; the DPU is the drm subsystem root.
+ * @a_crtc: Per-DPU CRTC state; lives as long as @ddev.
+ * @hwdev: Per-revision Saturn DPU description.
+ * @clk_ctx: The DPU's clocks, acquired once at probe.
+ * @clocks_on: True while clocks run; MMIO on a gated DPU stalls the bus.
+ * @pipe_resets: The DPU reset lines, in assert order; bulk-deassert
+ *		 releases them in reverse.
+ * @irq_online: Online-compose IRQ; requested disabled, enabled at bind.
+ */
+struct spacemit_drm_private {
+	struct drm_device *ddev;
+	struct device *dev;
+	struct spacemit_crtc *a_crtc;
+	struct spacemit_hw_device *hwdev;
+
+	struct dpu_clk_context clk_ctx;
+	bool clocks_on;
+	struct reset_control_bulk_data pipe_resets[5];
+	int irq_online;
+};
+
+extern const struct drm_driver spacemit_drm_drv;
+extern const struct component_master_ops spacemit_drm_master_ops;
+
+int spacemit_drm_mode_config_init(struct drm_device *drm);
+int spacemit_drm_of_component_probe(struct device *dev);
+
+#endif /* _SPACEMIT_DRM_H_ */

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (7 preceding siblings ...)
  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
  2026-11-21  8:01   ` sashiko-bot
  2026-11-21  7:40 ` [PATCH v3 10/17] drm/spacemit: add Saturn DPU KMS pipeline Cody Kang via B4 Relay
                   ` (7 subsequent siblings)
  16 siblings, 1 reply; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

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



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 10/17] drm/spacemit: add Saturn DPU KMS pipeline
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (8 preceding siblings ...)
  2026-11-21  7:40 ` [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend Cody Kang via B4 Relay
@ 2026-11-21  7:40 ` 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
                   ` (6 subsequent siblings)
  16 siblings, 1 reply; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Add the atomic KMS implementation on top of the hardware backend: one
CRTC and one primary plane per DPU instance. The plane's atomic_check
sizes its share of the RDMA line buffer and prepare_fb builds the
framebuffer's DMMU table; atomic commit fills the per-channel command
lists and arms the CFG_RDY handshake, and the commit's event is
delivered at the vblank after the engine has taken the lists. The DPU
is powered through runtime PM.

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

---
v3:
- use atomic_create_state; .reset is gone from the CRTC and plane funcs
  in v7.4-rc1
- drop the ops table between the KMS code and the DPU backend (Thomas
  Zimmermann)
- drop the tracepoints; use drm_dbg() and drm_WARN_ON() (Thomas
  Zimmermann)
- wrap only the hardware access in drm_dev_enter() (Thomas Zimmermann)
- enable vblank after programming the mode, and initialise vblank after
  drm_mode_config_reset() (Thomas Zimmermann)
- program the plane from the clipped rectangles; drop the 1:1 and
  zero-size source checks (Thomas Zimmermann)
- submit the plane's command list from its atomic_update, and turn its
  channel off when the plane is disabled (Thomas Zimmermann)
- size the line buffer in the plane's atomic_check; no allocation in
  atomic_check (Thomas Zimmermann)
- add prepare_fb: build the display MMU table there and wait for the
  buffer's fences (Thomas Zimmermann)
- stop the boot loader's pipeline at probe instead of at the first
  modeset, and request the interrupt after it (Thomas Zimmermann)
- power the DPU through runtime PM instead of from atomic_disable
  (Thomas Zimmermann)
- release the drm_device when the aggregate unbinds, and stop output
  polling before its components unbind; take the mode and the plane
  state from the commit
- reject a framebuffer with an offset, a src_x beyond the DMMU table
  padding, or a buffer larger than one TBU can map
- reject modes above 3840x2160 in the CRTC's mode_valid (Icenowy Zheng)
- do not advertise a gamma table (Guodong Xu)
v2:
- put all five DPU reset lines behind one reset_control_bulk_* pair
  (Philipp Zabel, Guodong Xu)
- keep the online IRQ alive across drm_dev_unregister() and
  drm_atomic_helper_shutdown() in unbind (Sashiko)
- free the per-state DMA buffers in the plane .reset path instead of
  bypassing the custom state destructor (Sashiko)
- release the duplicated state's references on the rdmas allocation
  failure path in crtc duplicate_state (Sashiko)
- set clocks_on only after dpu_pm_resume() has enabled the clocks
  (Sashiko)
---
 drivers/gpu/drm/spacemit/spacemit_crtc.c   | 589 +++++++++++++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_planes.c | 332 ++++++++++++++++
 2 files changed, 921 insertions(+)

diff --git a/drivers/gpu/drm/spacemit/spacemit_crtc.c b/drivers/gpu/drm/spacemit/spacemit_crtc.c
new file mode 100644
index 0000000000000..c1257444dd150
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_crtc.c
@@ -0,0 +1,589 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/aperture.h>
+#include <linux/component.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_graph.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/property.h>
+#include <linux/regmap.h>
+#include <linux/reset.h>
+#include <linux/timer.h>
+
+#include <drm/clients/drm_client_setup.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_managed.h>
+#include <drm/drm_print.h>
+#include <drm/drm_probe_helper.h>
+#include <drm/drm_vblank.h>
+
+#include "dpu/dpu_saturn.h"
+#include "dpu/saturn_regs/ops_hee.h"
+#include "dpu/saturn_regs/saturn_fields.h"
+#include "spacemit_cmdlist.h"
+#include "spacemit_crtc.h"
+#include "spacemit_dmmu.h"
+#include "spacemit_drm.h"
+
+static void spacemit_crtc_atomic_enable(struct drm_crtc *crtc,
+					struct drm_atomic_commit *state)
+{
+	struct drm_crtc_state *crtc_state =
+			drm_atomic_get_new_crtc_state(state, crtc);
+	const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+	struct spacemit_drm_private *priv = crtc->dev->dev_private;
+	int idx;
+	int ret;
+
+	/*
+	 * Not pm_runtime_resume_and_get(): atomic_disable runs and drops this
+	 * reference even when the power-up failed.
+	 */
+	ret = pm_runtime_get_sync(priv->dev);
+	if (ret < 0) {
+		/* The resume callback has said what failed. */
+		drm_dbg(crtc->dev, "DPU power-up failed: %d\n", ret);
+		return;
+	}
+
+	if (drm_dev_enter(crtc->dev, &idx)) {
+		spacemit_dpu_init(a_crtc, mode);
+		a_crtc->is_1st_f = true;
+		drm_dev_exit(idx);
+	}
+
+	drm_crtc_vblank_on(&a_crtc->crtc);
+}
+
+static void spacemit_crtc_atomic_disable(struct drm_crtc *crtc,
+					 struct drm_atomic_commit *state)
+{
+	struct drm_crtc_state *crtc_state =
+			drm_atomic_get_new_crtc_state(state, crtc);
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+	struct drm_device *drm = a_crtc->crtc.dev;
+	struct spacemit_drm_private *priv = drm->dev_private;
+	int idx;
+
+	if (drm_dev_enter(drm, &idx)) {
+		spacemit_dpu_uninit(a_crtc);
+		drm_dev_exit(idx);
+	}
+
+	drm_crtc_vblank_off(&a_crtc->crtc);
+
+	/* A commit may still be waiting for CFG_RDY: stop its watchdog. */
+	timer_delete_sync(&a_crtc->cfg_rdy_timer);
+
+	pm_runtime_put_sync(priv->dev);
+
+	/* No further vblank will come; complete the disable event here. */
+	spacemit_dpu_complete_event(a_crtc);
+	spin_lock_irq(&drm->event_lock);
+	if (crtc_state->event) {
+		drm_crtc_send_vblank_event(crtc, crtc_state->event);
+		crtc_state->event = NULL;
+	}
+	spin_unlock_irq(&drm->event_lock);
+}
+
+/* Planes write composer rows into the CRTC list, so open it before them. */
+static void spacemit_crtc_atomic_begin(struct drm_crtc *crtc,
+				       struct drm_atomic_commit *state)
+{
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+
+	spacemit_cmdlist_ring_next(a_crtc->cl, &a_crtc->cl_cur);
+}
+
+static void spacemit_crtc_atomic_flush(struct drm_crtc *crtc,
+				       struct drm_atomic_commit *state)
+{
+	struct drm_crtc_state *crtc_state =
+			drm_atomic_get_new_crtc_state(state, crtc);
+	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
+	struct spacemit_drm_private *priv = crtc->dev->dev_private;
+	int idx;
+
+	/*
+	 * The event releases the next commit, which rewrites the other
+	 * command list and points the engine at it. Hold the event until
+	 * CFG_RDY says the engine has taken this commit's lists; the
+	 * interrupt then arms it for the following vblank.
+	 */
+	spin_lock_irq(&crtc->dev->event_lock);
+	if (crtc_state->event) {
+		if (drm_crtc_vblank_get(crtc) == 0)
+			a_crtc->event = crtc_state->event;
+		else
+			drm_crtc_send_vblank_event(crtc, crtc_state->event);
+		crtc_state->event = NULL;
+	}
+	spin_unlock_irq(&crtc->dev->event_lock);
+
+	/* clocks_on is false here only after a failed power-up. */
+	if (priv->clocks_on && drm_dev_enter(crtc->dev, &idx)) {
+		spacemit_dpu_run(crtc, state);
+		drm_dev_exit(idx);
+	} else {
+		spacemit_dpu_complete_event(a_crtc);
+	}
+}
+
+static int spacemit_crtc_enable_vblank(struct drm_crtc *crtc)
+{
+	saturn_hee_enable_irq(to_spacemit_crtc(crtc), INT_VSYNC, true);
+
+	return 0;
+}
+
+static void spacemit_crtc_disable_vblank(struct drm_crtc *crtc)
+{
+	saturn_hee_enable_irq(to_spacemit_crtc(crtc), INT_VSYNC, false);
+}
+
+static enum drm_mode_status
+spacemit_crtc_mode_valid(struct drm_crtc *crtc,
+			 const struct drm_display_mode *mode)
+{
+	if (mode->hdisplay > SPACEMIT_DPU_MAX_HDISPLAY)
+		return MODE_BAD_HVALUE;
+	if (mode->vdisplay > SPACEMIT_DPU_MAX_VDISPLAY)
+		return MODE_BAD_VVALUE;
+
+	return MODE_OK;
+}
+
+static const struct drm_crtc_helper_funcs spacemit_crtc_helper_funcs = {
+	.mode_valid = spacemit_crtc_mode_valid,
+	.atomic_begin = spacemit_crtc_atomic_begin,
+	.atomic_flush = spacemit_crtc_atomic_flush,
+	.atomic_enable = spacemit_crtc_atomic_enable,
+	.atomic_disable = spacemit_crtc_atomic_disable,
+};
+
+static const struct drm_crtc_funcs spacemit_crtc_funcs = {
+	.set_config = drm_atomic_helper_set_config,
+	.page_flip = drm_atomic_helper_page_flip,
+	.atomic_create_state = drm_atomic_helper_crtc_create_state,
+	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
+	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
+	.enable_vblank = spacemit_crtc_enable_vblank,
+	.disable_vblank = spacemit_crtc_disable_vblank,
+};
+
+static void spacemit_crtc_put_port(struct drm_device *drm, void *port)
+{
+	of_node_put(port);
+}
+
+static struct spacemit_crtc *spacemit_crtc_create(struct drm_device *drm,
+						  struct drm_plane *primary,
+						  struct device_node *port)
+{
+	struct spacemit_crtc *a_crtc;
+	int err;
+
+	a_crtc = drmm_crtc_alloc_with_planes(drm, struct spacemit_crtc, crtc,
+					     primary, NULL,
+					     &spacemit_crtc_funcs, NULL);
+	if (IS_ERR(a_crtc)) {
+		drm_err(drm, "failed to init crtc\n");
+		return a_crtc;
+	}
+
+	/*
+	 * drm_of_find_possible_crtcs() walks crtc->port for the life of the
+	 * drm_device.
+	 */
+	a_crtc->crtc.port = of_node_get(port);
+	err = drmm_add_action_or_reset(drm, spacemit_crtc_put_port, port);
+	if (err)
+		return ERR_PTR(err);
+
+	drm_crtc_helper_add(&a_crtc->crtc, &spacemit_crtc_helper_funcs);
+
+	err = spacemit_cmdlist_ring_init(drm, a_crtc->cl, CMDLIST_CRTC, NULL,
+					 &a_crtc->crtc);
+	if (err)
+		return ERR_PTR(err);
+
+	a_crtc->cl_cmp = spacemit_cmdlist_regs_alloc(drm, CMPS_X_REG__NWORDS);
+	a_crtc->cl_pp = spacemit_cmdlist_regs_alloc(drm, POSTPIPE_REG__NWORDS);
+	if (!a_crtc->cl_cmp || !a_crtc->cl_pp)
+		return ERR_PTR(-ENOMEM);
+
+	return a_crtc;
+}
+
+/* The one plane and the one CRTC of a DPU instance. */
+static struct spacemit_crtc *spacemit_drm_pipeline_init(struct drm_device *drm)
+{
+	struct spacemit_crtc *a_crtc;
+	struct device_node *port;
+	struct drm_plane *plane;
+
+	plane = spacemit_plane_init(drm);
+	if (IS_ERR(plane))
+		return ERR_CAST(plane);
+
+	port = of_graph_get_port_by_id(drm->dev->of_node, 0);
+	if (!port)
+		return ERR_PTR(dev_err_probe(drm->dev, -EINVAL,
+					     "no output port\n"));
+
+	a_crtc = spacemit_crtc_create(drm, plane, port);
+	of_node_put(port);
+	if (IS_ERR(a_crtc))
+		return a_crtc;
+
+	timer_setup(&a_crtc->cfg_rdy_timer, spacemit_cfg_rdy_timer_handler, 0);
+
+	return a_crtc;
+}
+
+static irqreturn_t spacemit_dpu_isr(int irq, void *data)
+{
+	struct spacemit_drm_private *priv = data;
+	struct spacemit_crtc *a_crtc = priv->a_crtc;
+
+	if (!a_crtc)
+		return IRQ_NONE;
+
+	/* Reading a clock-gated DPU's status registers stalls the bus. */
+	if (unlikely(!READ_ONCE(priv->clocks_on)))
+		return IRQ_NONE;
+
+	/*
+	 * Not under drm_dev_enter(): an unplugged device raises interrupts
+	 * until its CRTC is off, and they still have to be acked.
+	 */
+	return spacemit_dpu_online_isr(a_crtc) ? IRQ_HANDLED : IRQ_NONE;
+}
+
+/*
+ * Acquire at probe, not at bind: the aggregate can rebind without this device
+ * detaching, and the exclusive resets would not be handed out a second time.
+ */
+static int spacemit_dpu_hw_resources_init(struct spacemit_drm_private *priv,
+					  struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	int n_rstc;
+	int ret;
+
+	ret = spacemit_dpu_parse_clocks(dev, &priv->clk_ctx);
+	if (ret)
+		return ret;
+
+	priv->pipe_resets[0].id = "lcd";
+	priv->pipe_resets[1].id = "esc";
+	priv->pipe_resets[2].id = "mclk";
+	priv->pipe_resets[3].id = "aclk";
+	priv->pipe_resets[4].id = "dsc";
+	n_rstc = ARRAY_SIZE(priv->pipe_resets);
+	ret = devm_reset_control_bulk_get_exclusive(dev, n_rstc,
+						    priv->pipe_resets);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to get resets\n");
+
+	/*
+	 * The boot loader may leave its boot-logo pipeline running. Stop it
+	 * here with the resets alone (the clocks are not ours to gate yet)
+	 * and hold them until the first enable brings the block up.
+	 */
+	ret = reset_control_bulk_assert(n_rstc, priv->pipe_resets);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to assert resets\n");
+	usleep_range(10000, 20000);
+
+	priv->irq_online = platform_get_irq_byname(pdev, "online");
+	if (priv->irq_online < 0)
+		return priv->irq_online;
+
+	/* Keep the line disabled until bind: the handler needs bind state. */
+	return devm_request_irq(dev, priv->irq_online, spacemit_dpu_isr,
+				IRQF_NO_AUTOEN, "DPU_ONLINE", priv);
+}
+
+static const struct regmap_config spacemit_dpu_regmap_config = {
+	.name		= "dpu",
+	.reg_bits	= 32,
+	.val_bits	= 32,
+	.reg_stride	= 4,
+	.max_register	= 0x53ffc,	/* 0x54000-byte DPU register window */
+};
+
+static int spacemit_drm_master_bind(struct device *dev)
+{
+	struct spacemit_drm_private *priv = dev_get_drvdata(dev);
+	struct spacemit_crtc *a_crtc;
+	struct drm_device *drm;
+	int ret;
+
+	ret = aperture_remove_all_conflicting_devices(spacemit_drm_drv.name);
+	if (ret)
+		return dev_err_probe(dev, ret,
+				     "failed to remove existing framebuffers\n");
+
+	/*
+	 * Bind-scoped, not devm: the aggregate can rebind without this
+	 * device being re-probed, and each bind must release its own
+	 * drm_device.
+	 */
+	drm = drm_dev_alloc(&spacemit_drm_drv, dev);
+	if (IS_ERR(drm))
+		return PTR_ERR(drm);
+	priv->ddev = drm;
+	drm->dev_private = priv;
+
+	ret = spacemit_drm_mode_config_init(drm);
+	if (ret)
+		goto err_dc;
+
+	a_crtc = spacemit_drm_pipeline_init(drm);
+	if (IS_ERR(a_crtc)) {
+		ret = PTR_ERR(a_crtc);
+		goto err_dc;
+	}
+	priv->a_crtc = a_crtc;
+
+	/*
+	 * component_bind_all() unbinds what it bound before returning an error.
+	 */
+	ret = component_bind_all(dev, drm);
+	if (ret) {
+		dev_err_probe(dev, ret, "failed to bind all components\n");
+		goto err_dc;
+	}
+
+	drm_mode_config_reset(drm);
+
+	ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
+	if (ret) {
+		dev_err_probe(dev, ret, "failed to initialize vblank\n");
+		goto err_unbind_all;
+	}
+
+	drmm_kms_helper_poll_init(drm);
+	drm_helper_hpd_irq_event(drm);
+
+	enable_irq(priv->irq_online);
+
+	ret = drm_dev_register(drm, 0);
+	if (ret < 0)
+		goto err_disable_irq;
+	drm_client_setup(drm, NULL);
+
+	return 0;
+
+err_disable_irq:
+	disable_irq(priv->irq_online);
+
+err_unbind_all:
+	component_unbind_all(dev, drm);
+err_dc:
+	/*
+	 * .shutdown tests priv->ddev; never leave it on a half-initialised
+	 * device.
+	 */
+	priv->ddev = NULL;
+	priv->a_crtc = NULL;
+	drm_dev_put(drm);
+	return ret;
+}
+
+static void spacemit_drm_master_unbind(struct device *dev)
+{
+	struct spacemit_drm_private *priv = dev_get_drvdata(dev);
+	struct drm_device *drm = priv->ddev;
+
+	/*
+	 * A process may keep the card open past this point. Unplug, so that
+	 * its ioctls fail and the drm_dev_enter() sections keep off the
+	 * registers. The commits that follow still turn the outputs off: the
+	 * CRTC drops its runtime PM reference, and the suspend resets the DPU.
+	 * The interrupt stays alive until then, for a commit that was already
+	 * waiting on it.
+	 */
+	drm_dev_unplug(drm);
+	/* An open file keeps the drm_device, and its poll worker, alive. */
+	drm_kms_helper_poll_fini(drm);
+	drm_atomic_helper_shutdown(drm);
+
+	disable_irq(priv->irq_online);
+
+	component_unbind_all(dev, drm);
+
+	/* .shutdown and a later re-bind must not touch the stale instance. */
+	priv->ddev = NULL;
+	priv->a_crtc = NULL;
+
+	drm_dev_put(drm);
+}
+
+const struct component_master_ops spacemit_drm_master_ops = {
+	.bind = spacemit_drm_master_bind,
+	.unbind = spacemit_drm_master_unbind,
+};
+
+static int spacemit_dpu_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	const struct spacemit_hw_device *hwdev_template;
+	struct spacemit_drm_private *priv;
+	int ret;
+
+	/* A display MMU entry holds a 26-bit page frame number. */
+	ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(38));
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to set DMA mask\n");
+
+	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+	if (!priv)
+		return -ENOMEM;
+	priv->dev = dev;
+	dev_set_drvdata(dev, priv);
+
+	/* The match data is shared const; the MMIO mapping is per-instance. */
+	hwdev_template = device_get_match_data(dev);
+	if (!hwdev_template)
+		return -ENODEV;
+	priv->hwdev = devm_kmemdup(dev, hwdev_template,
+				   sizeof(*hwdev_template), GFP_KERNEL);
+	if (!priv->hwdev)
+		return -ENOMEM;
+
+	priv->hwdev->base = devm_platform_ioremap_resource(pdev, 0);
+	if (IS_ERR(priv->hwdev->base))
+		return PTR_ERR(priv->hwdev->base);
+
+	priv->hwdev->regmap = devm_regmap_init_mmio(dev, priv->hwdev->base,
+						    &spacemit_dpu_regmap_config);
+	if (IS_ERR(priv->hwdev->regmap))
+		return dev_err_probe(dev, PTR_ERR(priv->hwdev->regmap),
+				     "failed to init DPU regmap\n");
+
+	ret = spacemit_dpu_hw_resources_init(priv, pdev);
+	if (ret)
+		return ret;
+
+	/* Held in reset with the clocks off: the suspended state. */
+	ret = devm_pm_runtime_enable(dev);
+	if (ret)
+		return ret;
+
+	return spacemit_drm_of_component_probe(dev);
+}
+
+static void spacemit_dpu_remove(struct platform_device *pdev)
+{
+	component_master_del(&pdev->dev, &spacemit_drm_master_ops);
+}
+
+static void spacemit_dpu_shutdown(struct platform_device *pdev)
+{
+	struct spacemit_drm_private *priv = dev_get_drvdata(&pdev->dev);
+	struct drm_device *drm = priv->ddev;
+
+	/* Not bound: nothing was ever enabled. */
+	if (!drm)
+		return;
+
+	drm_atomic_helper_shutdown(drm);
+}
+
+static int spacemit_dpu_runtime_suspend(struct device *dev)
+{
+	struct spacemit_drm_private *priv = dev_get_drvdata(dev);
+	int ret;
+
+	/*
+	 * Close the ISR's MMIO gate, then let a handler that is already past
+	 * it finish before the clocks stop.
+	 */
+	WRITE_ONCE(priv->clocks_on, false);
+	synchronize_irq(priv->irq_online);
+
+	/*
+	 * Assert before gating: a reset asserted into an already-gated block
+	 * has no clock edges to propagate on and leaves the register file
+	 * untouched.
+	 */
+	ret = reset_control_bulk_assert(ARRAY_SIZE(priv->pipe_resets),
+					priv->pipe_resets);
+	if (ret)
+		dev_warn(dev, "failed to assert resets: %d\n", ret);
+	usleep_range(10000, 20000);
+
+	spacemit_dpu_disable_clocks(priv);
+
+	return 0;
+}
+
+static int spacemit_dpu_runtime_resume(struct device *dev)
+{
+	struct spacemit_drm_private *priv = dev_get_drvdata(dev);
+	int ret;
+
+	ret = reset_control_bulk_deassert(ARRAY_SIZE(priv->pipe_resets),
+					  priv->pipe_resets);
+	if (ret) {
+		dev_err(dev, "failed to deassert resets: %d\n", ret);
+		return ret;
+	}
+
+	ret = spacemit_dpu_enable_clocks(priv);
+	if (ret) {
+		reset_control_bulk_assert(ARRAY_SIZE(priv->pipe_resets),
+					  priv->pipe_resets);
+		return ret;
+	}
+
+	/* The DPU must settle after reset deassert or CFG_RDY races the flush. */
+	usleep_range(10000, 20000);
+	WRITE_ONCE(priv->clocks_on, true);
+
+	return 0;
+}
+
+static const struct dev_pm_ops spacemit_dpu_pm_ops = {
+	RUNTIME_PM_OPS(spacemit_dpu_runtime_suspend, spacemit_dpu_runtime_resume,
+		       NULL)
+};
+
+static const struct of_device_id spacemit_dpu_match_table[] = {
+	{
+		.compatible = "spacemit,k3-saturn-dpu",
+		.data = &spacemit_k3_saturn_dpu,
+	},
+	{},
+};
+MODULE_DEVICE_TABLE(of, spacemit_dpu_match_table);
+
+static struct platform_driver spacemit_dpu_driver = {
+	.probe = spacemit_dpu_probe,
+	.remove = spacemit_dpu_remove,
+	.shutdown = spacemit_dpu_shutdown,
+	.driver = {
+		.name = "spacemit-dpu-drv",
+		.of_match_table = spacemit_dpu_match_table,
+		.pm = pm_ptr(&spacemit_dpu_pm_ops),
+		.suppress_bind_attrs = true,
+	},
+};
+module_platform_driver(spacemit_dpu_driver);
+
+MODULE_DESCRIPTION("SpacemiT DRM KMS master driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpu/drm/spacemit/spacemit_planes.c b/drivers/gpu/drm/spacemit/spacemit_planes.c
new file mode 100644
index 0000000000000..c49a2e1572771
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_planes.c
@@ -0,0 +1,332 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/bits.h>
+#include <linux/slab.h>
+
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_blend.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_framebuffer.h>
+#include <drm/drm_gem.h>
+#include <drm/drm_gem_atomic_helper.h>
+#include <drm/drm_plane.h>
+#include <drm/drm_print.h>
+
+#include "dpu/dpu_saturn.h"
+#include "dpu/saturn_fbcmem.h"
+#include "dpu/saturn_regs/ops_hee.h"
+#include "dpu/saturn_regs/saturn_fields.h"
+#include "spacemit_cmdlist.h"
+#include "spacemit_dmmu.h"
+#include "spacemit_drm.h"
+
+/* The AFBC decoder exists but no modifier has been validated on hardware. */
+static const u64 supported_format_modifiers[] = {
+	DRM_FORMAT_MOD_LINEAR,
+	DRM_FORMAT_MOD_INVALID
+};
+
+struct spacemit_plane *to_spacemit_plane(struct drm_plane *plane)
+{
+	return container_of(plane, struct spacemit_plane, plane);
+}
+
+static int spacemit_plane_atomic_check(struct drm_plane *plane,
+				       struct drm_atomic_commit *atomic_state)
+{
+	struct drm_plane_state *state =
+			drm_atomic_get_new_plane_state(atomic_state, plane);
+	struct drm_framebuffer *fb = state->fb;
+	struct spacemit_plane_state *cur_state = to_spacemit_plane_state(state);
+	struct drm_crtc_state *crtc_state = NULL;
+	int ret;
+
+	if (state->crtc)
+		crtc_state = drm_atomic_get_new_crtc_state(atomic_state,
+							   state->crtc);
+
+	ret = drm_atomic_helper_check_plane_state(state, crtc_state,
+						  DRM_PLANE_NO_SCALING,
+						  DRM_PLANE_NO_SCALING,
+						  true, false);
+	if (ret)
+		return ret;
+
+	if (!state->visible)
+		return 0;
+
+	/* The width limit bounds the default pitch; userspace may pass a larger one. */
+	if (fb->pitches[0] > SPACEMIT_DPU_MAX_PITCH) {
+		drm_dbg(plane->dev, "pitch %u exceeds the stride field\n",
+			fb->pitches[0]);
+		return -EINVAL;
+	}
+
+	/* Scanout starts at the first byte of the buffer object. */
+	if (fb->offsets[0]) {
+		drm_dbg(plane->dev, "framebuffer offset %u is not supported\n",
+			fb->offsets[0]);
+		return -EINVAL;
+	}
+
+	if (state->src.x1 >> 16 > SPACEMIT_DMMU_MAX_SRC_X) {
+		drm_dbg(plane->dev, "src_x %d exceeds the DMMU table padding\n",
+			state->src.x1 >> 16);
+		return -EINVAL;
+	}
+
+	if (fb->obj[0]->size >> PAGE_SHIFT > SPACEMIT_DMMU_MAX_PAGES) {
+		drm_dbg(plane->dev, "buffer of %zu bytes exceeds one TBU\n",
+			fb->obj[0]->size);
+		return -EINVAL;
+	}
+
+	if (saturn_cal_layer_fbcmem_size(plane, state)) {
+		drm_dbg(plane->dev, "invalid fbcmem size\n");
+		return -EINVAL;
+	}
+
+	cur_state->format = spacemit_plane_hw_get_format_id(fb->format->format);
+	if (cur_state->format == SPACEMIT_DPU_INVALID_FORMAT_ID) {
+		drm_dbg(plane->dev, "unsupported format %p4cc\n",
+			&fb->format->format);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static void spacemit_plane_program(struct drm_plane *plane,
+				   struct drm_plane_state *state,
+				   const struct drm_display_mode *mode)
+{
+	struct spacemit_plane *p = to_spacemit_plane(plane);
+	u32 rdma_id = p->rdma_id;
+
+	spacemit_cmdlist_ring_next(p->cl, &p->cl_cur);
+
+	saturn_hee_plane_update_hw_channel(plane, state, mode);
+	spacemit_dmmu_map(state->fb, rdma_id * 2, p->cl_rdma, plane);
+	spacemit_cmdlist_regs_packing(spacemit_plane_to_cl(plane), CMDLIST_MOD_RDMA,
+				      p->cl_rdma);
+
+	spacemit_cmdlist_submit_plane(plane, state);
+}
+
+/* Take the layer out of the composition and stop its read channel. */
+static void spacemit_plane_off(struct drm_plane *plane, struct drm_crtc *crtc)
+{
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	struct spacemit_plane *p = to_spacemit_plane(plane);
+
+	saturn_hee_plane_disable_hw_channel(plane, crtc);
+	saturn_hee_enable_cmdlist(to_spacemit_crtc(crtc), priv->hwdev,
+				  p->rdma_id, false);
+}
+
+static void spacemit_plane_atomic_update(struct drm_plane *plane,
+					 struct drm_atomic_commit *state)
+{
+	struct drm_plane_state *new_state =
+			drm_atomic_get_new_plane_state(state, plane);
+	struct drm_crtc_state *crtc_state =
+			drm_atomic_get_new_crtc_state(state, new_state->crtc);
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	int idx;
+
+	if (priv->clocks_on && drm_dev_enter(plane->dev, &idx)) {
+		/* A plane moved off the screen has no rectangle to program. */
+		if (new_state->visible)
+			spacemit_plane_program(plane, new_state,
+					       &crtc_state->adjusted_mode);
+		else
+			spacemit_plane_off(plane, new_state->crtc);
+		drm_dev_exit(idx);
+	}
+}
+
+static void spacemit_plane_atomic_disable(struct drm_plane *plane,
+					  struct drm_atomic_commit *state)
+{
+	struct drm_plane_state *old_state =
+			drm_atomic_get_old_plane_state(state, plane);
+	struct spacemit_drm_private *priv = plane->dev->dev_private;
+	int idx;
+
+	if (priv->clocks_on && drm_dev_enter(plane->dev, &idx)) {
+		spacemit_plane_off(plane, old_state->crtc);
+		drm_dev_exit(idx);
+	}
+}
+
+static struct drm_plane_state *
+spacemit_plane_atomic_create_state(struct drm_plane *plane)
+{
+	struct spacemit_plane_state *s;
+
+	s = kzalloc_obj(*s);
+	if (!s)
+		return ERR_PTR(-ENOMEM);
+
+	__drm_atomic_helper_plane_state_init(&s->state, plane);
+
+	return &s->state;
+}
+
+static struct drm_plane_state *
+spacemit_plane_atomic_duplicate_state(struct drm_plane *plane)
+{
+	struct spacemit_plane_state *s;
+	struct spacemit_plane_state *old_state =
+			to_spacemit_plane_state(plane->state);
+
+	s = kzalloc_obj(*s);
+	if (!s)
+		return NULL;
+
+	__drm_atomic_helper_plane_duplicate_state(plane, &s->state);
+
+	s->format = old_state->format;
+	s->fbcmem_size = old_state->fbcmem_size;
+
+	return &s->state;
+}
+
+static void spacemit_plane_atomic_destroy_state(struct drm_plane *plane,
+						struct drm_plane_state *state)
+{
+	__drm_atomic_helper_plane_destroy_state(state);
+
+	kfree(to_spacemit_plane_state(state));
+}
+
+static int spacemit_plane_create_properties(struct spacemit_plane *p)
+{
+	unsigned int support_modes = BIT(DRM_MODE_BLEND_PIXEL_NONE) |
+		BIT(DRM_MODE_BLEND_PREMULTI) |
+		BIT(DRM_MODE_BLEND_COVERAGE);
+	int ret;
+
+	ret = drm_plane_create_alpha_property(&p->plane);
+	if (ret)
+		return ret;
+
+	return drm_plane_create_blend_mode_property(&p->plane, support_modes);
+}
+
+/* Collect the buffer's fences and build its DMMU table once. */
+static int spacemit_plane_prepare_fb(struct drm_plane *plane,
+				     struct drm_plane_state *state)
+{
+	int ret;
+
+	if (!state->fb)
+		return 0;
+
+	ret = drm_gem_plane_helper_prepare_fb(plane, state);
+	if (ret)
+		return ret;
+
+	return spacemit_dmmu_prepare(state->fb->obj[0]);
+}
+
+static const struct drm_plane_helper_funcs spacemit_plane_helper_funcs = {
+	.prepare_fb = spacemit_plane_prepare_fb,
+	.atomic_check = spacemit_plane_atomic_check,
+	.atomic_update = spacemit_plane_atomic_update,
+	.atomic_disable = spacemit_plane_atomic_disable,
+};
+
+static void spacemit_plane_atomic_print_state(struct drm_printer *p,
+					      const struct drm_plane_state *state)
+{
+	const struct spacemit_plane_state *s = to_spacemit_plane_state(state);
+
+	drm_printf(p, "\tformat-id=%u\n", s->format);
+	drm_printf(p, "\tfbcmem-size=%u\n", s->fbcmem_size);
+}
+
+static const struct drm_plane_funcs spacemit_plane_funcs = {
+	.update_plane = drm_atomic_helper_update_plane,
+	.disable_plane	= drm_atomic_helper_disable_plane,
+	.atomic_create_state = spacemit_plane_atomic_create_state,
+	.atomic_duplicate_state = spacemit_plane_atomic_duplicate_state,
+	.atomic_destroy_state = spacemit_plane_atomic_destroy_state,
+	.atomic_print_state = spacemit_plane_atomic_print_state,
+};
+
+struct drm_plane *spacemit_plane_init(struct drm_device *drm)
+{
+	struct spacemit_plane *p;
+	int err, j;
+	u32 *formats;
+	struct spacemit_drm_private *priv = drm->dev_private;
+	struct spacemit_hw_device *hwdev = priv->hwdev;
+	u8 n_formats = hwdev->n_formats;
+	u8 n_fbcmems = hwdev->n_fbcmems;
+	u8 n_rdmas = hwdev->rdma_nums;
+	u32 plane_crtc_mask;
+
+	if (n_fbcmems * 2 != n_rdmas) {
+		drm_err(drm, "mismatched rdma/fbcmem counts: %d vs %d\n",
+			n_rdmas, n_fbcmems);
+		return ERR_PTR(-EINVAL);
+	}
+
+	for (j = 0; j < n_fbcmems; j++) {
+		if (hwdev->fbcmem_sizes[j] < FBCMEM_UNIT) {
+			drm_err(drm, "invalid fbcmem_sizes[%d] = %u\n",
+				j, hwdev->fbcmem_sizes[j]);
+			return ERR_PTR(-EINVAL);
+		}
+	}
+
+	formats = kcalloc(n_formats, sizeof(*formats), GFP_KERNEL);
+	if (!formats)
+		return ERR_PTR(-ENOMEM);
+
+	/*
+	 * The CRTC is created right after this, so its index is the current
+	 * count.
+	 */
+	plane_crtc_mask = BIT(drm->mode_config.num_crtc);
+
+	for (j = 0; j < n_formats; j++)
+		formats[j] = hwdev->formats[j].format;
+
+	p = drmm_universal_plane_alloc(drm, struct spacemit_plane, plane,
+				       plane_crtc_mask, &spacemit_plane_funcs,
+				       formats, n_formats,
+				       supported_format_modifiers,
+				       DRM_PLANE_TYPE_PRIMARY, NULL);
+	kfree(formats);
+	if (IS_ERR(p)) {
+		drm_err(drm, "failed to init primary plane\n");
+		return ERR_CAST(p);
+	}
+
+	/* The single primary plane owns the first read channel. */
+	p->rdma_id = 0;
+
+	drm_plane_helper_add(&p->plane, &spacemit_plane_helper_funcs);
+
+	err = spacemit_cmdlist_ring_init(drm, p->cl, CMDLIST_PLANE, &p->plane, NULL);
+	if (err)
+		return ERR_PTR(err);
+
+	err = spacemit_plane_create_properties(p);
+	if (err)
+		return ERR_PTR(err);
+
+	p->cl_rdma = spacemit_cmdlist_regs_alloc(drm, RDMA_PATH_X_REG__NWORDS);
+	p->cl_tbu = spacemit_cmdlist_regs_alloc(drm, MMU_TBU_REG__NWORDS);
+	if (!p->cl_rdma || !p->cl_tbu)
+		return ERR_PTR(-ENOMEM);
+
+	return &p->plane;
+}

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 11/17] drm/spacemit: add Saturn DPU DRM device driver
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (9 preceding siblings ...)
  2026-11-21  7:40 ` [PATCH v3 10/17] drm/spacemit: add Saturn DPU KMS pipeline Cody Kang via B4 Relay
@ 2026-11-21  7:40 ` 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
                   ` (5 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Add the DRM device for the SpacemiT K3 Saturn display processing unit
and hook the driver up to the build. The SoC has two DPU instances;
each drives one CRTC that scans out a single primary plane in linear
RGB at up to 3840x2160@60 and feeds a downstream DP/eDP controller
over an OF-graph endpoint. Buffers use drm_gem_shmem_helper. The
AFBC/compressed decode path is not exposed and writeback is not
implemented.

The write-combining mapping of the scanout buffers is from Sarah Emery
<sarah.emery@canonical.com>.

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

---
v3:
- map scanout buffers write-combining (Sarah Emery); build the sg table
  when a dumb buffer is created, so the zeroes it was cleared with are
  written back before anything is drawn
- bound framebuffers by what the RDMA registers can address instead of
  by the largest mode (Icenowy Zheng)
- stop the component match loop on the first error; depend on PM
- add a GEM object wrapper carrying the display MMU table (Thomas
  Zimmermann)
v2:
- check for an ERR_PTR component match before
  component_master_add_with_match() (Sashiko)
- add a comment explaining why commit_tail waits for flip_done before
  commit_hw_done (Sashiko)
---
 drivers/gpu/drm/Kconfig                 |   1 +
 drivers/gpu/drm/Makefile                |   1 +
 drivers/gpu/drm/spacemit/Kconfig        |  18 +++
 drivers/gpu/drm/spacemit/Makefile       |  12 ++
 drivers/gpu/drm/spacemit/spacemit_drm.c | 204 ++++++++++++++++++++++++++++++++
 5 files changed, 236 insertions(+)

diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 61111d50b1c65..76abdfb25dc44 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -345,6 +345,7 @@ source "drivers/gpu/drm/renesas/Kconfig"
 source "drivers/gpu/drm/rockchip/Kconfig"
 source "drivers/gpu/drm/sitronix/Kconfig"
 source "drivers/gpu/drm/solomon/Kconfig"
+source "drivers/gpu/drm/spacemit/Kconfig"
 source "drivers/gpu/drm/sprd/Kconfig"
 source "drivers/gpu/drm/sti/Kconfig"
 source "drivers/gpu/drm/stm/Kconfig"
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 2c6bc093a923a..d0ef32d224382 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -204,6 +204,7 @@ obj-$(CONFIG_DRM_MSM) += msm/
 obj-$(CONFIG_DRM_TEGRA) += tegra/
 obj-$(CONFIG_DRM_STM) += stm/
 obj-$(CONFIG_DRM_STI) += sti/
+obj-$(CONFIG_DRM_SPACEMIT) += spacemit/
 obj-y 			+= imx/
 obj-$(CONFIG_DRM_INGENIC) += ingenic/
 obj-$(CONFIG_DRM_LOGICVC) += logicvc/
diff --git a/drivers/gpu/drm/spacemit/Kconfig b/drivers/gpu/drm/spacemit/Kconfig
new file mode 100644
index 0000000000000..8326a7b98151a
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/Kconfig
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: GPL-2.0
+
+config DRM_SPACEMIT
+	tristate "DRM support for SpacemiT display controllers"
+	depends on DRM && OF && MMU
+	depends on PM
+	depends on ARCH_SPACEMIT || COMPILE_TEST
+	select DRM_CLIENT_SELECTION
+	select DRM_KMS_HELPER
+	select DRM_GEM_SHMEM_HELPER
+	select REGMAP_MMIO
+	help
+	  Choose this option if you have a SpacemiT SoC with the Saturn
+	  display processing unit, such as the K3. The DPU scans out
+	  framebuffers through its private display MMU and feeds a
+	  DisplayPort or embedded DisplayPort controller.
+
+	  If M is selected the module will be called spacemit-drm.
diff --git a/drivers/gpu/drm/spacemit/Makefile b/drivers/gpu/drm/spacemit/Makefile
new file mode 100644
index 0000000000000..b3b148000cf7b
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/Makefile
@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: GPL-2.0
+
+spacemit-drm-y := spacemit_drm.o \
+		  spacemit_crtc.o \
+		  spacemit_cmdlist.o \
+		  spacemit_planes.o \
+		  spacemit_dmmu.o \
+		  dpu/dpu_saturn.o \
+		  dpu/dpu_saturn_hee.o \
+		  dpu/saturn_fbcmem.o
+
+obj-$(CONFIG_DRM_SPACEMIT) += spacemit-drm.o
diff --git a/drivers/gpu/drm/spacemit/spacemit_drm.c b/drivers/gpu/drm/spacemit/spacemit_drm.c
new file mode 100644
index 0000000000000..eb3cb5e302556
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_drm.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/component.h>
+#include <linux/of_graph.h>
+#include <linux/slab.h>
+
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_dumb_buffers.h>
+#include <drm/drm_fbdev_shmem.h>
+#include <drm/drm_framebuffer.h>
+#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_gem_shmem_helper.h>
+#include <drm/drm_of.h>
+
+#include "spacemit_crtc.h"
+#include "spacemit_dmmu.h"
+#include "spacemit_drm.h"
+
+#define DRIVER_NAME	"spacemit"
+#define DRIVER_DESC	"SpacemiT SoC DRM driver"
+#define DRIVER_MAJOR	1
+#define DRIVER_MINOR	0
+
+static void spacemit_drm_atomic_commit_tail(struct drm_atomic_commit *old_state)
+{
+	struct drm_device *dev = old_state->dev;
+
+	/*
+	 * Enables before planes, and planes on active CRTCs only: the DPU is
+	 * powered from atomic_enable to atomic_disable.
+	 */
+	drm_atomic_helper_commit_modeset_disables(dev, old_state);
+
+	drm_atomic_helper_commit_modeset_enables(dev, old_state);
+
+	drm_atomic_helper_commit_planes(dev, old_state,
+					DRM_PLANE_COMMIT_ACTIVE_ONLY);
+
+	/*
+	 * Flip first, hw_done second: each channel has two command lists
+	 * written alternately, and the engine may re-read the previous one
+	 * until the next CFG_RDY has been consumed. Holding the next commit
+	 * back until this one's vblank keeps it from rewriting a list still
+	 * in use.
+	 */
+	drm_atomic_helper_wait_for_flip_done(dev, old_state);
+
+	drm_atomic_helper_commit_hw_done(old_state);
+
+	drm_atomic_helper_cleanup_planes(dev, old_state);
+}
+
+static const struct drm_mode_config_helper_funcs spacemit_drm_mode_config_helper = {
+	.atomic_commit_tail = spacemit_drm_atomic_commit_tail,
+};
+
+static const struct drm_mode_config_funcs spacemit_drm_mode_config_funcs = {
+	.fb_create = drm_gem_fb_create,
+	.atomic_check = drm_atomic_helper_check,
+	.atomic_commit = drm_atomic_helper_commit,
+};
+
+int spacemit_drm_mode_config_init(struct drm_device *drm)
+{
+	int ret;
+
+	ret = drmm_mode_config_init(drm);
+	if (ret)
+		return ret;
+
+	drm->mode_config.min_width = 1;
+	drm->mode_config.min_height = 1;
+	/*
+	 * Framebuffer bounds come from the RDMA register widths: a 16-bit
+	 * byte stride (16383 pixels at 32 bpp) and 16-bit image dimensions.
+	 * The 3840x2160 output limit is enforced per CRTC in mode_valid.
+	 */
+	drm->mode_config.max_width = SPACEMIT_DPU_MAX_FB_WIDTH;
+	drm->mode_config.max_height = SPACEMIT_DPU_MAX_FB_HEIGHT;
+
+	drm->mode_config.funcs = &spacemit_drm_mode_config_funcs;
+	drm->mode_config.helper_private = &spacemit_drm_mode_config_helper;
+
+	return 0;
+}
+
+static void spacemit_gem_free(struct drm_gem_object *obj)
+{
+	spacemit_dmmu_release(obj);
+	drm_gem_shmem_free(to_drm_gem_shmem_obj(obj));
+}
+
+/* drm_gem_shmem_funcs with a free that also drops the DMMU table. */
+static const struct drm_gem_object_funcs spacemit_gem_funcs = {
+	.free = spacemit_gem_free,
+	.print_info = drm_gem_shmem_object_print_info,
+	.pin = drm_gem_shmem_object_pin,
+	.unpin = drm_gem_shmem_object_unpin,
+	.get_sg_table = drm_gem_shmem_object_get_sg_table,
+	.vmap = drm_gem_shmem_object_vmap,
+	.vunmap = drm_gem_shmem_object_vunmap,
+	.mmap = drm_gem_shmem_object_mmap,
+	.vm_ops = &drm_gem_shmem_vm_ops,
+};
+
+static struct drm_gem_object *spacemit_gem_create_object(struct drm_device *drm,
+							 size_t size)
+{
+	struct spacemit_gem_object *sgem;
+
+	sgem = kzalloc_obj(*sgem);
+	if (!sgem)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_init(&sgem->tbl_lock);
+	sgem->base.map_wc = true;
+	sgem->base.base.funcs = &spacemit_gem_funcs;
+
+	return &sgem->base.base;
+}
+
+/*
+ * A new buffer's pages are cleared through the cached linear map, while
+ * everything drawn afterwards goes through a write-combining mapping. Build
+ * the sg table now: mapping it writes the cached zeroes back before anything
+ * is drawn. Left to the first scanout, they would land on top of the picture.
+ */
+static int spacemit_gem_dumb_create(struct drm_file *file,
+				    struct drm_device *drm,
+				    struct drm_mode_create_dumb *args)
+{
+	struct drm_gem_shmem_object *shmem;
+	struct sg_table *sgt;
+	int ret;
+
+	ret = drm_mode_size_dumb(drm, args, 0, 0);
+	if (ret)
+		return ret;
+
+	shmem = drm_gem_shmem_create(drm, args->size);
+	if (IS_ERR(shmem))
+		return PTR_ERR(shmem);
+
+	sgt = drm_gem_shmem_get_pages_sgt(shmem);
+	if (IS_ERR(sgt))
+		ret = PTR_ERR(sgt);
+	else
+		ret = drm_gem_handle_create(file, &shmem->base, &args->handle);
+
+	/* On success the handle holds the reference. */
+	drm_gem_object_put(&shmem->base);
+
+	return ret;
+}
+
+DEFINE_DRM_GEM_FOPS(spacemit_drm_fops);
+
+const struct drm_driver spacemit_drm_drv = {
+	.driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
+	.fops = &spacemit_drm_fops,
+
+	.gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table,
+	.dumb_create = spacemit_gem_dumb_create,
+	.gem_create_object = spacemit_gem_create_object,
+	DRM_FBDEV_SHMEM_DRIVER_OPS,
+
+	.name		= DRIVER_NAME,
+	.desc		= DRIVER_DESC,
+	.major		= DRIVER_MAJOR,
+	.minor		= DRIVER_MINOR,
+};
+
+int spacemit_drm_of_component_probe(struct device *dev)
+{
+	struct component_match *match = NULL;
+	struct device_node *remote, *ep;
+
+	/* The DPU is the drm root: its OF graph names the DP/eDP components. */
+	for_each_endpoint_of_node(dev->of_node, ep) {
+		remote = of_graph_get_remote_port_parent(ep);
+		if (!remote)
+			continue;
+		if (of_device_is_available(remote))
+			drm_of_component_match_add(dev, &match,
+						   component_compare_of,
+						   remote);
+		of_node_put(remote);
+		if (IS_ERR(match)) {
+			of_node_put(ep);
+			return PTR_ERR(match);
+		}
+	}
+
+	if (!match)
+		return dev_err_probe(dev, -ENODEV,
+				     "no downstream component available\n");
+
+	return component_master_add_with_match(dev, &spacemit_drm_master_ops,
+					       match);
+}

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (10 preceding siblings ...)
  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 ` 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
                   ` (4 subsequent siblings)
  16 siblings, 1 reply; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Add the DP/eDP controller that sits downstream of the Saturn DPU. Two
identical instances share one compatible; the eDP-vs-DP role is board
wiring, so it is taken from the devicetree: an eDP panel always sits
under an aux-bus child node, an external DP connector never does.

The link rate is set through the generic PHY framework and the pixel
rate through the clock the PHY registers, so the controller programs
no PLL. It only sets the power-down bits of the two PLLs when it shuts
the link down or resets the block.

The controller's HPD interrupt is gated by the DP pixel clock, which
can be off exactly when a plug has to be caught, so the connector is
also polled and the interrupt path re-reads the live level when it
does fire.

The check that fails AUX transfers fast while HPD is low is from
Sarah Emery <sarah.emery@canonical.com>.

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

---
v3:
- fail AUX transfers fast when HPD is low (Sarah Emery)
- narrow the link after a failed training and read the EDID with
  drm_edid_read_ddc(); clear a stale AUX reply before a transfer and
  hold the AUX mutex across the AUX resets; drop the mode_config.mutex
  wrap, the external pixel clock path and the unused stream formats
- join the DRM device only once the eDP panel has probed
- let the panel supply the modes on eDP (Guodong Xu)
- use drm_dbg() (Thomas Zimmermann)
- commit message: the controller does set the PLL power-down bits
v2:
- use devm_reset_control_get_exclusive_deasserted(), dropping the manual
  deassert/assert paths and the reset field (Philipp Zabel)
- hand the pxclk disable to a devm action registered after the PHY
  child is populated (Yao Zi)
- drop the dead NULL-clk guards (Yao Zi)
- drop the error message duplicated by devm_request_threaded_irq()
  (Yao Zi)
- ack the W1C DP_GENERAL_INTERRUPT bits with plain writes (Sashiko)
- return IRQ_HANDLED when the ISR consumed an HPD latch instead of
  IRQ_NONE (Sashiko)
- read EDID blocks through the aux I2C adapter (Sashiko)
- drop DRM_BRIDGE_OP_MODES from the DP branch (Sashiko)
- respond to Rob Herring's suggestion, port@1 required, compute
  possible_crtcs from the input endpoint only
---
 drivers/gpu/drm/spacemit/Kconfig            |   19 +
 drivers/gpu/drm/spacemit/Makefile           |    3 +
 drivers/gpu/drm/spacemit/spacemit_inno_dp.c | 2186 +++++++++++++++++++++++++++
 drivers/gpu/drm/spacemit/spacemit_inno_dp.h |  328 ++++
 4 files changed, 2536 insertions(+)

diff --git a/drivers/gpu/drm/spacemit/Kconfig b/drivers/gpu/drm/spacemit/Kconfig
index 8326a7b98151a..4667cb624401a 100644
--- a/drivers/gpu/drm/spacemit/Kconfig
+++ b/drivers/gpu/drm/spacemit/Kconfig
@@ -16,3 +16,22 @@ config DRM_SPACEMIT
 	  DisplayPort or embedded DisplayPort controller.
 
 	  If M is selected the module will be called spacemit-drm.
+
+config SPACEMIT_INNO_DP
+	tristate "SpacemiT Innosilicon DP/eDP controller support"
+	depends on DRM_SPACEMIT
+	imply PHY_SPACEMIT_K3_INNO_DP
+	select GENERIC_PHY
+	select DRM_PANEL_BRIDGE
+	select DRM_BRIDGE_CONNECTOR
+	select DRM_DISPLAY_HELPER
+	select DRM_DISPLAY_DP_HELPER
+	select DRM_DISPLAY_DP_AUX_BUS
+	help
+	  Choose this option to enable the Innosilicon DisplayPort /
+	  embedded DisplayPort transmitter integrated in SpacemiT SoCs.
+	  The controller sits downstream of the Saturn DPU and drives an
+	  eDP panel (discovered over the DP AUX bus) or an external
+	  DisplayPort connector.
+
+	  If M is selected the module will be called spacemit-inno-dp.
diff --git a/drivers/gpu/drm/spacemit/Makefile b/drivers/gpu/drm/spacemit/Makefile
index b3b148000cf7b..260d316a271b5 100644
--- a/drivers/gpu/drm/spacemit/Makefile
+++ b/drivers/gpu/drm/spacemit/Makefile
@@ -9,4 +9,7 @@ spacemit-drm-y := spacemit_drm.o \
 		  dpu/dpu_saturn_hee.o \
 		  dpu/saturn_fbcmem.o
 
+spacemit-inno-dp-y := spacemit_inno_dp.o
+
 obj-$(CONFIG_DRM_SPACEMIT) += spacemit-drm.o
+obj-$(CONFIG_SPACEMIT_INNO_DP) += spacemit-inno-dp.o
diff --git a/drivers/gpu/drm/spacemit/spacemit_inno_dp.c b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c
new file mode 100644
index 0000000000000..436e5f15b4039
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c
@@ -0,0 +1,2186 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#include <linux/bitfield.h>
+#include <linux/bits.h>
+#include <linux/cleanup.h>
+#include <linux/clk.h>
+#include <linux/component.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/iopoll.h>
+#include <linux/math64.h>
+#include <linux/media-bus-format.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_graph.h>
+#include <linux/of_platform.h>
+#include <linux/phy/phy-dp.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/reset.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#include <drm/display/drm_dp.h>
+#include <drm/display/drm_dp_aux_bus.h>
+#include <drm/display/drm_dp_helper.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_state_helper.h>
+#include <drm/drm_bridge.h>
+#include <drm/drm_bridge_connector.h>
+#include <drm/drm_connector.h>
+#include <drm/drm_device.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_edid.h>
+#include <drm/drm_encoder.h>
+#include <drm/drm_of.h>
+#include <drm/drm_print.h>
+#include <drm/drm_probe_helper.h>
+
+#include "spacemit_inno_dp.h"
+
+#define SPACEMIT_DP_SWING_MAX  2
+#define SPACEMIT_DP_PREEMP_MAX 2
+#define SPACEMIT_DP_AUX_MAX_RETRIES 3
+#define SPACEMIT_DP_AUX_POLL_US     100
+#define SPACEMIT_DP_AUX_TIMEOUT_US  (200 * USEC_PER_MSEC)
+
+/* Adjust requests followed in one training phase before it is given up. */
+#define SPACEMIT_DP_TRAIN_MAX_TRIES 8
+
+#define SPACEMIT_DP_SINK_READY_DELAY_MS 120
+#define SPACEMIT_DP_SINK_READY_RETRIES 3
+
+/*
+ * With DP routed through a Type-C PD controller the HPD pin is virtual and
+ * can re-assert seconds after a transmitter power-cycle. Asserted HPD
+ * returns immediately; the full wait is paid only when no sink shows up.
+ */
+#define SPACEMIT_DP_HPD_POLL_US     1000
+#define SPACEMIT_DP_HPD_DEBOUNCE_US (1000 * USEC_PER_MSEC)
+
+enum spacemit_dp_link_rate {
+	SPACEMIT_DP_LINK_RATE_1_62 = 1620000, /* 1.62 Gbps */
+	SPACEMIT_DP_LINK_RATE_2_70 = 2700000, /* 2.70 Gbps */
+	SPACEMIT_DP_LINK_RATE_5_40 = 5400000, /* 5.40 Gbps */
+	SPACEMIT_DP_LINK_RATE_8_10 = 8100000, /* 8.10 Gbps */
+};
+
+/* The K3 source tops out at HBR2: the PHY's MPLL has no 8.1 Gbps config. */
+#define SPACEMIT_DP_SOURCE_MAX_RATE	SPACEMIT_DP_LINK_RATE_5_40
+
+enum spacemit_dp_lane_count {
+	SPACEMIT_DP_LANE_1 = 1,
+	SPACEMIT_DP_LANE_2 = 2,
+	SPACEMIT_DP_LANE_4 = 4,
+};
+
+/* DP_VIDEO_MAPPING encoding of the one stream format produced: RGB, 8 bpc. */
+#define SPACEMIT_DP_VIDEO_RGB_8BIT	1
+#define SPACEMIT_DP_BPP			24
+
+enum spacemit_dp_ref_clk {
+	SPACEMIT_DP_REF_CLK_24M = 24000,
+};
+
+static const struct spacemit_dp_link_config {
+	enum spacemit_dp_link_rate rate;
+	enum spacemit_dp_lane_count lanes;
+} spacemit_dp_link_priority_table[] = {
+	{SPACEMIT_DP_LINK_RATE_1_62, SPACEMIT_DP_LANE_1}, /* 1.62 Gbps */
+	{SPACEMIT_DP_LINK_RATE_2_70, SPACEMIT_DP_LANE_1}, /* 2.70 Gbps */
+	{SPACEMIT_DP_LINK_RATE_1_62, SPACEMIT_DP_LANE_2}, /* 3.24 Gbps */
+
+	{SPACEMIT_DP_LINK_RATE_2_70, SPACEMIT_DP_LANE_2}, /* 5.40 Gbps */
+	{SPACEMIT_DP_LINK_RATE_1_62, SPACEMIT_DP_LANE_4}, /* 6.48 Gbps */
+
+	{SPACEMIT_DP_LINK_RATE_2_70, SPACEMIT_DP_LANE_4}, /* 10.8 Gbps */
+	{SPACEMIT_DP_LINK_RATE_5_40, SPACEMIT_DP_LANE_2}, /* 10.8 Gbps */
+
+	{SPACEMIT_DP_LINK_RATE_5_40, SPACEMIT_DP_LANE_4}, /* 21.6 Gbps */
+};
+
+/**
+ * struct spacemit_dp_dev - Per-instance state for an Innosilicon DP/eDP
+ * controller
+ * @dev: Underlying platform device.
+ * @drm: Parent DRM device, set at component bind.
+ * @encoder: Passive encoder anchoring possible_crtcs; atomic goes through
+ * @bridge.
+ * @bridge: DRM bridge implementing this controller, attached NO_CONNECTOR.
+ * @connector: Connector built on top of @bridge by drm_bridge_connector_init().
+ * @connector_status: Last status .detect() reported; the HPD interrupt
+ *		      compares against it.
+ * @regs: Regmap over the DP controller register block.
+ * @aux: DPCD AUX channel, registered at bind.
+ * @dpcd: Raw DPCD capability bytes.
+ * @lane_count: Lane count chosen by link training (1, 2 or 4).
+ * @link_rate: Link rate chosen by link training, in kbit/s.
+ * @link: Link limits: the sink's capabilities, clamped to the PHY and
+ *	narrowed after a failed training until the sink is replugged.
+ * @link.revision: DPCD revision byte.
+ * @link.enhanced_framing: Whether the sink advertises enhanced framing.
+ * @link.max_rate: Maximum usable link rate, in kbit/s.
+ * @link.max_num_lanes: Maximum usable lane count.
+ * @pxclk: Pixel clock mux, parented onto @pll_clk at probe.
+ * @pll_clk: The PHY's pixel PLL; clk_set_rate() programs it.
+ * @phy: DP PHY handle.
+ * @phy_powered: Controller-side mirror of the PHY framework's power refcount.
+ * @edp_mode: True when this instance drives an embedded panel.
+ * @component_added: True once the component is registered; for eDP that is
+ *	when the panel has probed.
+ * @mode_lock: Serialises detect, EDID read, enable and disable.
+ * @modeset_retry_work: Deferred "link is bad" notification, see its handler.
+ * @irq: Controller interrupt line.
+ */
+struct spacemit_dp_dev {
+	struct device *dev;
+
+	struct drm_device *drm;
+	struct drm_encoder encoder;
+	struct drm_bridge bridge;
+	struct drm_connector *connector;
+
+	enum drm_connector_status connector_status;
+
+	struct regmap *regs;
+	struct drm_dp_aux aux;
+
+	u8 dpcd[DP_RECEIVER_CAP_SIZE];
+	int lane_count;
+	u32 link_rate;
+
+	struct {
+		u8 revision;
+		u8 enhanced_framing;
+		u32 max_rate;
+		u32 max_num_lanes;
+	} link;
+
+	struct clk *pxclk;
+	struct clk *pll_clk;
+	struct phy *phy;
+	bool phy_powered;
+
+	bool edp_mode;
+	bool component_added;
+	struct mutex mode_lock;	/* detect, EDID read, enable, disable */
+
+	struct work_struct modeset_retry_work;
+
+	int irq;
+};
+
+/*
+ * drm_connector_set_link_status_property() takes connection_mutex, which the
+ * commit already holds: calling it from .atomic_enable deadlocks against
+ * itself, hence the work item.
+ */
+static void spacemit_dp_modeset_retry_work(struct work_struct *work)
+{
+	struct spacemit_dp_dev *dp = container_of(work, struct spacemit_dp_dev,
+						  modeset_retry_work);
+	struct drm_connector *connector = dp->connector;
+
+	if (!connector)
+		return;
+
+	drm_connector_set_link_status_property(connector,
+					       DRM_MODE_LINK_STATUS_BAD);
+	drm_kms_helper_connector_hotplug_event(connector);
+}
+
+/**
+ * struct spacemit_dp_bridge_state - Per-state planned link configuration.
+ * @base: Parent &struct drm_bridge_state.
+ * @link_cfg_idx: Index into spacemit_dp_link_priority_table[] picked by
+ *	->atomic_check(); -1 means ->atomic_enable() walks the table from the start.
+ */
+struct spacemit_dp_bridge_state {
+	struct drm_bridge_state base;
+	int link_cfg_idx;
+};
+
+static inline struct spacemit_dp_bridge_state *
+to_spacemit_dp_bridge_state(struct drm_bridge_state *state)
+{
+	return container_of(state, struct spacemit_dp_bridge_state, base);
+}
+
+static const struct regmap_config spacemit_dp_regmap_config = {
+	.name		= "dp",
+	.reg_bits	= 32,
+	.val_bits	= 32,
+	.reg_stride	= 4,
+	.max_register	= 0x3ffc,	/* 0x4000-byte register window */
+};
+
+static u32 spacemit_dp_aux_get_cmd(struct drm_dp_aux_msg *msg)
+{
+	switch (msg->request & ~DP_AUX_I2C_MOT) {
+	case DP_AUX_NATIVE_WRITE:
+	case DP_AUX_I2C_WRITE:
+	case DP_AUX_I2C_WRITE_STATUS_UPDATE:
+	case DP_AUX_NATIVE_READ:
+	case DP_AUX_I2C_READ:
+		return msg->request;
+	default:
+		return 0;
+	}
+}
+
+static void spacemit_dp_aux_hw_reset(struct spacemit_dp_dev *dp)
+{
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
+			  FIELD_PREP(DP_AUX_RESET, 0x1));
+	usleep_range(2000, 2500);
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
+			  FIELD_PREP(DP_AUX_RESET, 0x0));
+	usleep_range(2000, 2500);
+	regmap_write(dp->regs, DP_GENERAL_INTERRUPT,
+		     DP_AUX_REPLY_EVENT_INT_STA);
+}
+
+static bool spacemit_dp_dpcd_caps_valid(const u8 *dpcd)
+{
+	u8 max_bw = dpcd[DP_MAX_LINK_RATE];
+	u8 max_lanes = dpcd[DP_MAX_LANE_COUNT] & DP_MAX_LANE_COUNT_MASK;
+
+	if (!dpcd[DP_DPCD_REV])
+		return false;
+
+	switch (max_bw) {
+	case DP_LINK_BW_1_62:
+	case DP_LINK_BW_2_7:
+	case DP_LINK_BW_5_4:
+	case DP_LINK_BW_8_1:
+		break;
+	default:
+		return false;
+	}
+
+	return max_lanes == 1 || max_lanes == 2 || max_lanes == 4;
+}
+
+static ssize_t spacemit_dp_aux_transfer(struct drm_dp_aux *aux,
+					struct drm_dp_aux_msg *msg)
+{
+	int ret, i, retries = 0;
+
+	struct spacemit_dp_dev *dp = container_of(aux, struct spacemit_dp_dev,
+						  aux);
+	u32 cmd, len, val, status;
+	u32 data[4] = {0};
+	u8 *buf = msg->buffer;
+	bool is_read = (msg->request & DP_AUX_I2C_READ) ||
+		((msg->request & DP_AUX_NATIVE_READ) == DP_AUX_NATIVE_READ);
+
+	/*
+	 * Nothing attached: skip the 200 ms timeout + retries, fail at once.
+	 * Read the live HPD-in level; the HPD interrupt is pixel-clock gated.
+	 */
+	if (!dp->edp_mode &&
+	    !regmap_test_bits(dp->regs, DP_HPD_INTERRUPT_STATUS, DP_HPD_IN_STATUS))
+		return -ENXIO;
+
+	if (msg->size > 16)
+		return -EINVAL;
+
+	cmd = spacemit_dp_aux_get_cmd(msg);
+
+retry_eio:
+	if (!is_read) {
+		/* Pack bytes into 32-bit words (Little Endian packing) */
+		for (i = 0; i < msg->size; i++)
+			data[i / 4] |= (u32)buf[i] << ((i % 4) * 8);
+
+		/* Write data to registers: DATA1(LSB)..DATA4(MSB) */
+		regmap_write_bits(dp->regs, DP_AUX_DATA1_REG, DP_AUX_DATA1,
+				  FIELD_PREP(DP_AUX_DATA1, data[0]));
+		regmap_write_bits(dp->regs, DP_AUX_DATA2_REG, DP_AUX_DATA2,
+				  FIELD_PREP(DP_AUX_DATA2, data[1]));
+		regmap_write_bits(dp->regs, DP_AUX_DATA3_REG, DP_AUX_DATA3,
+				  FIELD_PREP(DP_AUX_DATA3, data[2]));
+		regmap_write_bits(dp->regs, DP_AUX_DATA4_REG, DP_AUX_DATA4,
+				  FIELD_PREP(DP_AUX_DATA4, data[3]));
+	}
+
+	/* HW expects Length - 1 */
+	len = msg->size > 0 ? msg->size - 1 : 0;
+
+	regmap_write_bits(dp->regs, DP_AUX_CMD_REG, DP_AUX_LENGTH,
+			  FIELD_PREP(DP_AUX_LENGTH, len));
+	regmap_write_bits(dp->regs, DP_AUX_CMD_REG, DP_AUX_ADDR,
+			  FIELD_PREP(DP_AUX_ADDR, msg->address));
+	regmap_write_bits(dp->regs, DP_AUX_CMD_REG, DP_AUX_CMD_TYPE,
+			  FIELD_PREP(DP_AUX_CMD_TYPE, cmd));
+
+	/*
+	 * A transfer that timed out may complete late and latch the reply
+	 * event; start from a clean status so the poll below cannot see it.
+	 */
+	regmap_write(dp->regs, DP_GENERAL_INTERRUPT,
+		     DP_AUX_REPLY_EVENT_INT_STA);
+
+	regmap_write_bits(dp->regs, DP_AUX_START_REG, DP_AUX_START,
+			  FIELD_PREP(DP_AUX_START, 0));
+	regmap_write_bits(dp->regs, DP_AUX_START_REG, DP_AUX_START,
+			  FIELD_PREP(DP_AUX_START, 1));
+
+	ret = regmap_read_poll_timeout(dp->regs, DP_GENERAL_INTERRUPT, val,
+				       val & DP_AUX_REPLY_EVENT_INT_STA,
+				       SPACEMIT_DP_AUX_POLL_US,
+				       SPACEMIT_DP_AUX_TIMEOUT_US);
+	if (ret) {
+		if (retries < SPACEMIT_DP_AUX_MAX_RETRIES) {
+			retries++;
+			spacemit_dp_aux_hw_reset(dp);
+			dev_dbg(dp->dev,
+				"AUX timeout, cmd=0x%x addr=0x%x size=%zu retry %d/%d\n",
+				cmd, msg->address, msg->size, retries, SPACEMIT_DP_AUX_MAX_RETRIES);
+			goto retry_eio;
+		}
+
+		dev_err_ratelimited(dp->dev,
+				    "AUX transfer timeout, req: 0x%x, cmd: 0x%x, addr: 0x%x, size %zu\n",
+				    msg->request, cmd, msg->address, msg->size);
+		return ret;
+	}
+
+	regmap_read(dp->regs, DP_AUX_STS_REG, &status);
+	status = FIELD_GET(DP_AUX_STATUS, status);
+
+	/* Write 1 to clear. */
+	regmap_write(dp->regs, DP_GENERAL_INTERRUPT,
+		     DP_AUX_REPLY_EVENT_INT_STA);
+
+	/* Map HW status (the AUX reply command byte) to DRM reply codes */
+	switch (status) {
+	case 0: /* ACK */
+		msg->reply = DP_AUX_NATIVE_REPLY_ACK;
+		break;
+	case 1: /* NACK */
+		msg->reply = DP_AUX_NATIVE_REPLY_NACK;
+		return 0; /* the AUX helpers retry on a NACK */
+	case 2: /* DEFER */
+		msg->reply = DP_AUX_NATIVE_REPLY_DEFER;
+		return 0;
+	case DP_AUX_I2C_REPLY_NACK: /* native ACK, I2C NACK */
+		msg->reply = DP_AUX_I2C_REPLY_NACK;
+		return 0;
+	case DP_AUX_I2C_REPLY_DEFER: /* native ACK, I2C DEFER */
+		msg->reply = DP_AUX_I2C_REPLY_DEFER;
+		return 0;
+	default:
+		regmap_read(dp->regs, DP_AUX_STS_REG, &val);
+		val = FIELD_GET(DP_AUX_REPLY_ERR_CODE, val);
+		if (retries < SPACEMIT_DP_AUX_MAX_RETRIES) {
+			retries++;
+			dev_dbg(dp->dev,
+				"AUX status, cmd=0x%x addr=0x%x size=%zu retry %d/%d\n",
+				cmd, msg->address, msg->size, retries, SPACEMIT_DP_AUX_MAX_RETRIES);
+			usleep_range(1000, 1100);
+			goto retry_eio;
+		}
+		dev_err_ratelimited(dp->dev,
+				    "AUX error: cmd=0x%x addr=0x%x size=%zu status=0x%x code=0x%x\n",
+				    cmd, msg->address, msg->size, status, val);
+		return -EIO;
+	}
+
+	if (is_read && msg->size > 0) {
+		regmap_read(dp->regs, DP_AUX_DATA1_REG, &data[0]);
+		data[0] = FIELD_GET(DP_AUX_DATA1, data[0]);
+		regmap_read(dp->regs, DP_AUX_DATA2_REG, &data[1]);
+		data[1] = FIELD_GET(DP_AUX_DATA2, data[1]);
+		regmap_read(dp->regs, DP_AUX_DATA3_REG, &data[2]);
+		data[2] = FIELD_GET(DP_AUX_DATA3, data[2]);
+		regmap_read(dp->regs, DP_AUX_DATA4_REG, &data[3]);
+		data[3] = FIELD_GET(DP_AUX_DATA4, data[3]);
+
+		/* Unpack 32-bit words back to bytes */
+		for (i = 0; i < msg->size; i++)
+			buf[i] = (data[i / 4] >> ((i % 4) * 8)) & 0xFF;
+	}
+
+	return msg->size;
+}
+
+static int spacemit_dp_update_edp_config(struct spacemit_dp_dev *dp, bool enable)
+{
+	u8 value;
+	int ret;
+
+	ret = drm_dp_dpcd_read_byte(&dp->aux, DP_EDP_CONFIGURATION_SET, &value);
+	if (ret < 0) {
+		drm_dbg(dp->drm,
+			"failed to read DP_EDP_CONFIGURATION_SET: %d\n", ret);
+		return ret;
+	}
+
+	if (enable)
+		value |= DP_ALTERNATE_SCRAMBLER_RESET_ENABLE;
+	else
+		value &= ~DP_ALTERNATE_SCRAMBLER_RESET_ENABLE;
+
+	ret = drm_dp_dpcd_write_byte(&dp->aux, DP_EDP_CONFIGURATION_SET, value);
+	if (ret < 0) {
+		drm_dbg(dp->drm,
+			"failed to write DP_EDP_CONFIGURATION_SET: %d\n", ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+/*
+ * Read the sink's DPCD link-layer capabilities. EDID is handled separately.
+ * A sink that does not answer is reported here and given assumed limits, so
+ * there is nothing left for a caller to handle.
+ */
+static void spacemit_dp_hw_read_sink_caps(struct spacemit_dp_dev *dp)
+{
+	ssize_t ret;
+	int retry;
+
+	for (retry = 0; retry < SPACEMIT_DP_SINK_READY_RETRIES; retry++) {
+		if (retry) {
+			scoped_guard(mutex, &dp->aux.hw_mutex)
+				spacemit_dp_aux_hw_reset(dp);
+			msleep(SPACEMIT_DP_SINK_READY_DELAY_MS);
+		}
+
+		ret = drm_dp_read_dpcd_caps(&dp->aux, dp->dpcd);
+		if (ret < 0)
+			continue;
+
+		if (!spacemit_dp_dpcd_caps_valid(dp->dpcd)) {
+			drm_dbg(dp->drm,
+				"DPCD caps not ready: rev=0x%02x bw=0x%02x lanes=0x%02x\n",
+				dp->dpcd[DP_DPCD_REV], dp->dpcd[DP_MAX_LINK_RATE],
+				dp->dpcd[DP_MAX_LANE_COUNT]);
+			ret = -EAGAIN;
+			continue;
+		}
+
+		break;
+	}
+
+	if (ret < 0) {
+		drm_warn_ratelimited(dp->drm,
+				     "failed to read DPCD after %d retries: %zd\n",
+				     SPACEMIT_DP_SINK_READY_RETRIES, ret);
+		dp->link.revision = DP_DPCD_REV_14;
+		dp->link.max_rate = SPACEMIT_DP_LINK_RATE_5_40;
+		dp->link.max_num_lanes = SPACEMIT_DP_LANE_2;
+		dp->link.enhanced_framing = 1;
+		return;
+	}
+
+	dp->link.revision = dp->dpcd[DP_DPCD_REV];
+
+	/* drm_dp_max_link_rate() is in 10 kbit/s; the source stops at HBR2. */
+	dp->link.max_rate = min_t(u32, drm_dp_max_link_rate(dp->dpcd) * 10,
+				  SPACEMIT_DP_SOURCE_MAX_RATE);
+	dp->link.max_num_lanes = drm_dp_max_lane_count(dp->dpcd);
+	dp->link.enhanced_framing = drm_dp_enhanced_frame_cap(dp->dpcd);
+
+	drm_dbg(dp->drm,
+		"DPCD: Rev %x.%x, MaxRate %d kbit/s, MaxLanes %d, EnhFrame %d\n",
+		dp->link.revision >> 4, dp->link.revision & 0xF,
+		dp->link.max_rate, dp->link.max_num_lanes,
+		dp->link.enhanced_framing);
+}
+
+static int spacemit_dp_phy_set_lanes(struct spacemit_dp_dev *dp,
+				     enum spacemit_dp_lane_count lanes)
+{
+	union phy_configure_opts opts = {
+		.dp = {
+			.lanes = lanes,
+			.set_lanes = true,
+		},
+	};
+	int ret;
+
+	ret = phy_configure(dp->phy, &opts);
+	if (ret)
+		return ret;
+
+	dp->lane_count = lanes;
+	return 0;
+}
+
+static int spacemit_dp_phy_set_rate(struct spacemit_dp_dev *dp,
+				    enum spacemit_dp_link_rate rate)
+{
+	union phy_configure_opts opts = {
+		.dp = {
+			/*
+			 * enum value is in kbit/s; PHY framework wants Mbit/s.
+			 */
+			.link_rate = rate / 1000,
+			.set_rate = true,
+		},
+	};
+	int ret;
+
+	ret = phy_configure(dp->phy, &opts);
+	if (ret)
+		return ret;
+
+	dp->link_rate = rate;
+	return 0;
+}
+
+/*
+ * The link PLL rides phy_configure(); the pixel PLL is a clock the PHY
+ * registered. Link first: that is the order the analog blocks come up in.
+ */
+static int spacemit_dp_set_plls(struct spacemit_dp_dev *dp,
+				enum spacemit_dp_link_rate rate, u32 pclk_khz)
+{
+	int ret;
+
+	ret = spacemit_dp_phy_set_rate(dp, rate);
+	if (ret)
+		return ret;
+
+	return clk_set_rate(dp->pll_clk, (unsigned long)pclk_khz * 1000);
+}
+
+/*
+ * phy_power_on/off() are refcounted, but this driver's bring-up is idempotent
+ * rather than pair-balanced. Mirror the state so the refcount cannot go
+ * negative.
+ */
+static int spacemit_dp_phy_on(struct spacemit_dp_dev *dp)
+{
+	int ret;
+
+	if (dp->phy_powered)
+		return 0;
+
+	ret = phy_power_on(dp->phy);
+	if (ret)
+		return ret;
+
+	dp->phy_powered = true;
+	return 0;
+}
+
+static void spacemit_dp_phy_off(struct spacemit_dp_dev *dp)
+{
+	if (!dp->phy_powered)
+		return;
+
+	phy_power_off(dp->phy);
+	dp->phy_powered = false;
+}
+
+/* Pulse the AUX reset so the next bring-up starts from a clean state. */
+static void spacemit_dp_link_disable(struct spacemit_dp_dev *dp)
+{
+	regmap_write_bits(dp->regs, DP_VIDEO_VSAMPLE_REG,
+			  DP_VIDEO_STREAM_ENABLE,
+			  FIELD_PREP(DP_VIDEO_STREAM_ENABLE, 0));
+	spacemit_dp_phy_off(dp);
+
+	/* Not under a transfer: a userspace AUX client may be in one. */
+	guard(mutex)(&dp->aux.hw_mutex);
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
+			  FIELD_PREP(DP_AUX_RESET, 0x1));
+	usleep_range(5000, 8000);
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
+			  FIELD_PREP(DP_AUX_RESET, 0x0));
+	usleep_range(2000, 4000);
+}
+
+static enum drm_connector_status
+spacemit_dp_hw_detect_hpd(struct spacemit_dp_dev *dp)
+{
+	u32 hpd_status;
+	enum drm_connector_status connector_status =
+			connector_status_disconnected;
+
+	regmap_read(dp->regs, DP_HPD_INTERRUPT_STATUS, &hpd_status);
+	hpd_status = FIELD_GET(DP_HPD_IN_STATUS, hpd_status);
+	if (hpd_status)
+		connector_status = connector_status_connected;
+	else
+		connector_status = connector_status_disconnected;
+
+	return connector_status;
+}
+
+/* Returns true when a latched HPD event was pending and got acked. */
+static bool spacemit_dp_hw_clean_hpd(struct spacemit_dp_dev *dp)
+{
+	u32 plug_event, unplug_event;
+
+	regmap_read(dp->regs, DP_HPD_INTERRUPT_STATUS, &plug_event);
+	plug_event = FIELD_GET(DP_HOT_PLUG_EVENT, plug_event);
+	regmap_read(dp->regs, DP_HPD_INTERRUPT_STATUS, &unplug_event);
+	unplug_event = FIELD_GET(DP_HOT_UNPLUG_EVENT, unplug_event);
+
+	if (plug_event)
+		regmap_write(dp->regs, DP_HPD_INTERRUPT_STATUS,
+			     FIELD_PREP(DP_HOT_PLUG_EVENT, 0x1));
+
+	if (unplug_event)
+		regmap_write(dp->regs, DP_HPD_INTERRUPT_STATUS,
+			     FIELD_PREP(DP_HOT_UNPLUG_EVENT, 0x1));
+
+	return plug_event || unplug_event;
+}
+
+static int spacemit_dp_set_training_pattern(struct spacemit_dp_dev *dp,
+					    u8 pattern)
+{
+	u32 tps_sel;
+	u8 dpcd_pattern = pattern;
+	int ret;
+
+	if (pattern != DP_TRAINING_PATTERN_DISABLE)
+		dpcd_pattern |= DP_LINK_SCRAMBLING_DISABLE;
+
+	switch (pattern) {
+	case DP_TRAINING_PATTERN_DISABLE:
+		tps_sel = 0;
+		regmap_write_bits(dp->regs, DP_CORE_CONTROL,
+				  DP_SCRAMBLER_DISABLE,
+				  FIELD_PREP(DP_SCRAMBLER_DISABLE, 0));
+		break;
+	case DP_TRAINING_PATTERN_1:
+		tps_sel = 1;
+		regmap_write_bits(dp->regs, DP_CORE_CONTROL,
+				  DP_SCRAMBLER_DISABLE,
+				  FIELD_PREP(DP_SCRAMBLER_DISABLE, 1));
+		break;
+	case DP_TRAINING_PATTERN_2:
+		tps_sel = 2;
+		regmap_write_bits(dp->regs, DP_CORE_CONTROL,
+				  DP_SCRAMBLER_DISABLE,
+				  FIELD_PREP(DP_SCRAMBLER_DISABLE, 1));
+		break;
+	case DP_TRAINING_PATTERN_3:
+		tps_sel = 3;
+		regmap_write_bits(dp->regs, DP_CORE_CONTROL,
+				  DP_SCRAMBLER_DISABLE,
+				  FIELD_PREP(DP_SCRAMBLER_DISABLE, 1));
+		break;
+	default:
+		drm_err(dp->drm, "Unsupported training pattern: 0x%x\n",
+			pattern);
+		return -EINVAL;
+	}
+
+	regmap_write_bits(dp->regs, DP_PHYIF_CTRL_ADDR, DP_TPS_SEL,
+			  FIELD_PREP(DP_TPS_SEL, tps_sel));
+
+	ret = drm_dp_dpcd_write_byte(&dp->aux, DP_TRAINING_PATTERN_SET,
+				     dpcd_pattern);
+	if (ret < 0) {
+		drm_dbg(dp->drm, "failed to set DPCD training pattern: %d\n",
+			ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+/*
+ * The adjust request has to reach the source PHY, not just the sink's DPCD:
+ * a transmitter left at its reset default trains any level > 0 with a bad eye.
+ */
+static int spacemit_dp_link_apply_adjust(struct spacemit_dp_dev *dp,
+					 const u8 *link_status,
+				    enum spacemit_dp_lane_count lanes,
+				    u8 *training_set)
+{
+	union phy_configure_opts opts = {
+		.dp = {
+			.lanes = lanes,
+			.set_voltages = true,
+		},
+	};
+	int i, ret;
+
+	for (i = 0; i < lanes; i++) {
+		u8 v = drm_dp_get_adjust_request_voltage(link_status, i);
+		u8 p = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
+		u8 v_bits;
+
+		if (v >= SPACEMIT_DP_SWING_MAX)
+			v = SPACEMIT_DP_SWING_MAX;
+		if (p >= SPACEMIT_DP_PREEMP_MAX)
+			p = SPACEMIT_DP_PREEMP_MAX;
+
+		opts.dp.voltage[i] = v;
+		opts.dp.pre[i] = p;
+
+		v_bits = v;
+		if (v == SPACEMIT_DP_SWING_MAX)
+			v_bits |= DP_TRAIN_MAX_SWING_REACHED;
+		if (p == SPACEMIT_DP_PREEMP_MAX)
+			v_bits |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
+
+		training_set[i] = v_bits | (p << DP_TRAIN_PRE_EMPHASIS_SHIFT);
+	}
+
+	ret = phy_configure(dp->phy, &opts);
+	if (ret)
+		return ret;
+
+	return drm_dp_dpcd_write_data(&dp->aux, DP_TRAINING_LANE0_SET,
+				      training_set, lanes);
+}
+
+static int spacemit_dp_link_train_clock_recovery(struct spacemit_dp_dev *dp,
+						 enum spacemit_dp_link_rate rate,
+					    enum spacemit_dp_lane_count lanes)
+{
+	u8 link_status[DP_LINK_STATUS_SIZE] = {0};
+	u8 training_set[4] = {0};
+	int retries = 0;
+	int ret;
+
+	/* Level 0 on both ends: the PHY keeps what the last training left. */
+	ret = spacemit_dp_link_apply_adjust(dp, link_status, lanes,
+					    training_set);
+	if (ret < 0)
+		return ret;
+
+	ret = spacemit_dp_set_training_pattern(dp, DP_TRAINING_PATTERN_1);
+	if (ret < 0)
+		goto err_end_training;
+
+	while (retries < SPACEMIT_DP_TRAIN_MAX_TRIES) {
+		drm_dp_link_train_clock_recovery_delay(&dp->aux, dp->dpcd);
+
+		ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
+		if (ret < 0)
+			goto err_end_training;
+
+		if (drm_dp_clock_recovery_ok(link_status, lanes))
+			return 0;
+
+		ret = spacemit_dp_link_apply_adjust(dp, link_status, lanes,
+						    training_set);
+		if (ret)
+			goto err_end_training;
+
+		retries++;
+	}
+
+	drm_dbg(dp->drm, "link training: clock recovery failed\n");
+	ret = -ETIMEDOUT;
+
+err_end_training:
+	spacemit_dp_set_training_pattern(dp, DP_TRAINING_PATTERN_DISABLE);
+	return ret;
+}
+
+static int spacemit_dp_link_train_channel_eq(struct spacemit_dp_dev *dp,
+					     enum spacemit_dp_link_rate rate,
+					enum spacemit_dp_lane_count lanes)
+{
+	u8 link_status[DP_LINK_STATUS_SIZE];
+	u8 training_set[4] = {0};
+	u8 training_pattern = DP_TRAINING_PATTERN_2;
+	int retries = 0;
+	int ret;
+
+	if (drm_dp_tps3_supported(dp->dpcd)) {
+		training_pattern = DP_TRAINING_PATTERN_3;
+		drm_dbg(dp->drm, "link training: using TPS3\n");
+	} else {
+		drm_dbg(dp->drm, "link training: using TPS2\n");
+	}
+
+	ret = spacemit_dp_set_training_pattern(dp, training_pattern);
+	if (ret < 0)
+		goto err_end_training;
+
+	while (retries < SPACEMIT_DP_TRAIN_MAX_TRIES) {
+		drm_dp_link_train_channel_eq_delay(&dp->aux, dp->dpcd);
+
+		ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
+		if (ret < 0)
+			goto err_end_training;
+
+		if (drm_dp_channel_eq_ok(link_status, lanes))
+			return spacemit_dp_set_training_pattern(dp,
+					DP_TRAINING_PATTERN_DISABLE);
+
+		ret = spacemit_dp_link_apply_adjust(dp, link_status, lanes,
+						    training_set);
+		if (ret)
+			goto err_end_training;
+
+		retries++;
+	}
+
+	drm_dbg(dp->drm, "link training: channel EQ failed\n");
+	ret = -ETIMEDOUT;
+
+err_end_training:
+	spacemit_dp_set_training_pattern(dp, DP_TRAINING_PATTERN_DISABLE);
+	return ret;
+}
+
+static int spacemit_dp_link_train(struct spacemit_dp_dev *dp, enum spacemit_dp_link_rate rate,
+				  enum spacemit_dp_lane_count lanes)
+{
+	int ret;
+	u8 link_config[1];
+	u8 bw_code = drm_dp_link_rate_to_bw_code(rate / 10);
+
+	/*
+	 * A sink may act on the DP_LINK_BW_SET write, so set the lane count
+	 * first.
+	 */
+	link_config[0] = lanes;
+	if (dp->link.enhanced_framing)
+		link_config[0] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
+	regmap_write_bits(dp->regs, DP_CORE_CONTROL, DP_ENHANCE_FRAMING_EN,
+			  FIELD_PREP(DP_ENHANCE_FRAMING_EN,
+				     dp->link.enhanced_framing));
+
+	ret = drm_dp_dpcd_write_byte(&dp->aux, DP_LANE_COUNT_SET,
+				     link_config[0]);
+	if (ret < 0) {
+		drm_dbg(dp->drm, "failed to set DPCD lane count\n");
+		return ret;
+	}
+
+	ret = drm_dp_dpcd_write_byte(&dp->aux, DP_LINK_BW_SET, bw_code);
+	if (ret < 0) {
+		drm_dbg(dp->drm, "failed to set DPCD link rate\n");
+		return ret;
+	}
+
+	ret = spacemit_dp_link_train_clock_recovery(dp, rate, lanes);
+	if (ret)
+		return ret;
+
+	return spacemit_dp_link_train_channel_eq(dp, rate, lanes);
+}
+
+static void spacemit_dp_hw_set_msa_and_enable_video(struct spacemit_dp_dev *dp,
+						    const struct drm_display_mode *mode,
+						    enum spacemit_dp_link_rate rate,
+						    enum spacemit_dp_lane_count lanes)
+{
+	u64 hb_num;
+	u32 link_rate;
+	u32 fp; /* Pixel clock in MHz */
+	u32 tu, tu_frac, tu_int, rd_thres;
+	u32 hsync_len, hstart, vstart;
+
+	/* mode->clock unit is kHz, fp unit is MHz */
+	fp = mode->clock / 1000;
+
+	if (fp == 0)
+		fp = 1; /* Prevent division by zero */
+
+	/*
+	 * HBlank interval = (htotal - hactive) * (LinkSymbolClock / 4) /
+	 * PixelClock, where LinkSymbolClock = LinkRate * 100 (1.62G -> 162MHz).
+	 * rate is in kbit/s, so link_rate = rate / 10000 gives the 162, 270,
+	 * 540 form used below.
+	 */
+	link_rate = rate / 10000;
+
+	/* Multiply before dividing: hb_num = hblank * (link_rate / 4) / fp */
+	hb_num = (u64)(mode->htotal - mode->hdisplay) * link_rate;
+	do_div(hb_num, 4 * fp);
+
+	/* Transfer unit: tu = fp * bpp * 640 / (8 * lanes * link_rate) */
+	tu = div_u64((u64)fp * SPACEMIT_DP_BPP * 640, 8 * lanes * link_rate);
+	tu_frac = tu % 10;
+	tu_int  = tu / 10;
+
+	/* FIFO read threshold. */
+	if (tu_int < 6)
+		rd_thres = 32;
+	else if ((mode->htotal - mode->hdisplay) < 80)
+		rd_thres = 12;
+	else
+		rd_thres = 16;
+
+	drm_dbg(dp->drm,
+		"MSA: %dx%d, Rate:%d kbit/s, Lanes:%d, BPP:%d, TU:%d.%d\n",
+		mode->hdisplay, mode->vdisplay, rate, lanes, SPACEMIT_DP_BPP,
+		tu_int, tu_frac);
+
+	regmap_write_bits(dp->regs, DP_VIDEO_VSAMPLE_REG, DP_VIDEO_MAPPING,
+			  FIELD_PREP(DP_VIDEO_MAPPING, SPACEMIT_DP_VIDEO_RGB_8BIT));
+
+	/*
+	 * The Saturn TMG raster is always positive-sync (hsp/vsp fixed to 1).
+	 */
+	regmap_write_bits(dp->regs, DP_VINPUT_POLARITY, DP_HSYNC_IN_POLARITY,
+			  FIELD_PREP(DP_HSYNC_IN_POLARITY, 1));
+	regmap_write_bits(dp->regs, DP_VINPUT_POLARITY, DP_VSYNC_IN_POLARITY,
+			  FIELD_PREP(DP_VSYNC_IN_POLARITY, 1));
+
+	/* Basic timing */
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG1, DP_HACTIVE,
+			  FIELD_PREP(DP_HACTIVE, mode->hdisplay));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG2, DP_VACTIVE,
+			  FIELD_PREP(DP_VACTIVE, mode->vdisplay));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG1, DP_HBLANK,
+			  FIELD_PREP(DP_HBLANK, mode->htotal - mode->hdisplay));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG2, DP_VBLANK,
+			  FIELD_PREP(DP_VBLANK, mode->vtotal - mode->vdisplay));
+
+	/* MSA start values count from the leading edge of sync. */
+	hstart = mode->htotal - mode->hsync_start;
+	vstart = mode->vtotal - mode->vsync_start;
+
+	regmap_write_bits(dp->regs, DP_VIDEO_MSA1, DP_HSTART,
+			  FIELD_PREP(DP_HSTART, hstart));
+	regmap_write_bits(dp->regs, DP_VIDEO_MSA1, DP_VSTART,
+			  FIELD_PREP(DP_VSTART, vstart));
+
+	hsync_len = mode->hsync_end - mode->hsync_start;
+
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG3, DP_H_SYNC_WIDTH,
+			  FIELD_PREP(DP_H_SYNC_WIDTH, hsync_len));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG4, DP_V_SYNC_WIDTH,
+			  FIELD_PREP(DP_V_SYNC_WIDTH, mode->vsync_end - mode->vsync_start));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG3, DP_H_FRONT_PORCH,
+			  FIELD_PREP(DP_H_FRONT_PORCH, mode->hsync_start - mode->hdisplay));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG4, DP_V_FRONT_PORCH,
+			  FIELD_PREP(DP_V_FRONT_PORCH, mode->vsync_start - mode->vdisplay));
+
+	/* MSA and MISC */
+	regmap_write_bits(dp->regs, DP_VIDEO_MSA2, DP_MISC0,
+			  FIELD_PREP(DP_MISC0, DP_MSA_MISC_8_BPC));
+	regmap_write_bits(dp->regs, DP_VIDEO_MSA3, DP_MISC1,
+			  FIELD_PREP(DP_MISC1, 0));
+	regmap_write_bits(dp->regs, DP_VIDEO_MSA3, DP_NVID,
+			  FIELD_PREP(DP_NVID, 0));
+
+	/* Link layer parameters */
+	regmap_write_bits(dp->regs, DP_VIDEO_HBLANK_INTERVAL,
+			  DP_HBLANK_INTERVAL,
+			  FIELD_PREP(DP_HBLANK_INTERVAL, (u32)hb_num));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG5, DP_AVERAGE_BYTES_PER_TU,
+			  FIELD_PREP(DP_AVERAGE_BYTES_PER_TU, tu_int));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG5,
+			  DP_AVERAGE_BYTES_PER_TU_FRAC,
+			  FIELD_PREP(DP_AVERAGE_BYTES_PER_TU_FRAC, tu_frac));
+	regmap_write_bits(dp->regs, DP_VIDEO_CONFIG5, DP_INIT_THRESHOLD,
+			  FIELD_PREP(DP_INIT_THRESHOLD, rd_thres));
+
+	regmap_write_bits(dp->regs, DP_PHYIF_CTRL_ADDR, DP_PHY_SSC_DIS,
+			  FIELD_PREP(DP_PHY_SSC_DIS, 1));
+	regmap_write_bits(dp->regs, DP_CLK_INV_MUX, DP_REG_VID_CLK_SEL,
+			  FIELD_PREP(DP_REG_VID_CLK_SEL, 0));
+	regmap_write_bits(dp->regs, DP_VIDEO_COLORBAR_CFG, DP_VID_BIST_EN,
+			  FIELD_PREP(DP_VID_BIST_EN, 0));
+
+	drm_dbg(dp->drm, "enabling video stream\n");
+	regmap_write_bits(dp->regs, DP_VIDEO_VSAMPLE_REG,
+			  DP_VIDEO_STREAM_ENABLE,
+			  FIELD_PREP(DP_VIDEO_STREAM_ENABLE, 1));
+}
+
+static void spacemit_dp_hw_disable(struct spacemit_dp_dev *dp)
+{
+	dev_dbg(dp->dev, "disabling video and PHY\n");
+
+	regmap_write_bits(dp->regs, DP_VIDEO_VSAMPLE_REG,
+			  DP_VIDEO_STREAM_ENABLE,
+			  FIELD_PREP(DP_VIDEO_STREAM_ENABLE, 0));
+
+	regmap_write_bits(dp->regs, DP_PHYIF_CTRL_ADDR, DP_XMIT_ENABLE,
+			  FIELD_PREP(DP_XMIT_ENABLE, 0));
+
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_LDO_D0,
+			  FIELD_PREP(DP_ANA_TX_EN_LDO_D0, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_LDO_D1,
+			  FIELD_PREP(DP_ANA_TX_EN_LDO_D1, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_LDO_D2,
+			  FIELD_PREP(DP_ANA_TX_EN_LDO_D2, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_LDO_D3,
+			  FIELD_PREP(DP_ANA_TX_EN_LDO_D3, 0));
+
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_DRV_D0,
+			  FIELD_PREP(DP_ANA_TX_EN_DRV_D0, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_DRV_D1,
+			  FIELD_PREP(DP_ANA_TX_EN_DRV_D1, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_DRV_D2,
+			  FIELD_PREP(DP_ANA_TX_EN_DRV_D2, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_EN_DRV_D3,
+			  FIELD_PREP(DP_ANA_TX_EN_DRV_D3, 0));
+
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_EN_P2S_D0,
+			  FIELD_PREP(DP_ANA_TX_EN_P2S_D0, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_EN_P2S_D1,
+			  FIELD_PREP(DP_ANA_TX_EN_P2S_D1, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_EN_P2S_D2,
+			  FIELD_PREP(DP_ANA_TX_EN_P2S_D2, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_EN_P2S_D3,
+			  FIELD_PREP(DP_ANA_TX_EN_P2S_D3, 0));
+
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL6, DP_ANA_BG_EN,
+			  FIELD_PREP(DP_ANA_BG_EN, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_BG_EN_RCAL,
+			  FIELD_PREP(DP_ANA_BG_EN_RCAL, 0));
+
+	/* Both PLLs. */
+	regmap_write_bits(dp->regs, DP_MPLL_CTRL0, DP_ANA_MPLL_PD,
+			  FIELD_PREP(DP_ANA_MPLL_PD, 1));
+	regmap_write_bits(dp->regs, DP_PREPLL_CTRL0, DP_ANA_PREPLL_PD,
+			  FIELD_PREP(DP_ANA_PREPLL_PD, 1));
+}
+
+/* Calculate required bandwidth in kbit/s (Pixel Clock * Bits Per Pixel) */
+static u32 spacemit_dp_calc_required_bw(const struct drm_display_mode *mode,
+					int bpp)
+{
+	return mode->clock * bpp;
+}
+
+/*
+ * Calculate available link capacity in kbit/s (taking 8b/10b overhead into
+ * account)
+ */
+static u32 spacemit_dp_calc_link_capacity(enum spacemit_dp_link_rate rate,
+					  enum spacemit_dp_lane_count lanes)
+{
+	u32 rate_khz = rate;
+	u32 lane_count = lanes;
+
+	/* Capacity = Rate(kbit/s) * Lanes * 0.8 */
+	return (rate_khz * lane_count * 8) / 10;
+}
+
+/*
+ * Every configuration able to carry @req_bw failed to train. Limit the link
+ * to the best configuration below it, so that mode_valid() prunes the mode
+ * and userspace falls back to a smaller one.
+ */
+static bool spacemit_dp_link_narrow(struct spacemit_dp_dev *dp, u32 req_bw)
+{
+	const struct spacemit_dp_link_config *best = NULL;
+	u32 best_capacity = 0;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(spacemit_dp_link_priority_table); i++) {
+		const struct spacemit_dp_link_config *cfg =
+				&spacemit_dp_link_priority_table[i];
+		u32 capacity;
+
+		if (cfg->rate > dp->link.max_rate ||
+		    cfg->lanes > dp->link.max_num_lanes)
+			continue;
+
+		capacity = spacemit_dp_calc_link_capacity(cfg->rate, cfg->lanes);
+		if (capacity >= req_bw || capacity <= best_capacity)
+			continue;
+
+		best = cfg;
+		best_capacity = capacity;
+	}
+
+	if (!best)
+		return false;
+
+	dp->link.max_rate = best->rate;
+	dp->link.max_num_lanes = best->lanes;
+	return true;
+}
+
+static enum drm_connector_status
+spacemit_dp_bridge_detect(struct drm_bridge *bridge, struct drm_connector *connector)
+{
+	struct spacemit_dp_dev *dp = container_of(bridge,
+						  struct spacemit_dp_dev,
+						  bridge);
+	enum drm_connector_status status;
+
+	/*
+	 * The eDP panel is fixed, and DP_HPD_IN_STATUS does not read
+	 * meaningfully on that path.
+	 */
+	if (dp->edp_mode)
+		return connector_status_connected;
+
+	/*
+	 * The HPD interrupt is gated by the DP pixel clock, which is off
+	 * exactly when a plug must be caught. Read the level register live
+	 * instead.
+	 */
+	guard(mutex)(&dp->mode_lock);
+	status = spacemit_dp_hw_detect_hpd(dp);
+
+	/*
+	 * The bind-time cap read only covers a sink that was already there.
+	 * Without a re-read here, link.max_rate stays 0 and every link config
+	 * is filtered out.
+	 */
+	if (status == connector_status_connected &&
+	    dp->connector_status != connector_status_connected)
+		spacemit_dp_hw_read_sink_caps(dp);
+
+	WRITE_ONCE(dp->connector_status, status);
+
+	return status;
+}
+
+static const struct drm_edid *
+spacemit_dp_bridge_edid_read(struct drm_bridge *bridge, struct drm_connector *connector)
+{
+	struct spacemit_dp_dev *dp = container_of(bridge,
+						  struct spacemit_dp_dev,
+						  bridge);
+	const struct drm_edid *edid = NULL;
+	int retry;
+
+	scoped_guard(mutex, &dp->mode_lock) {
+		for (retry = 0; retry < SPACEMIT_DP_SINK_READY_RETRIES; retry++) {
+			if (retry) {
+				scoped_guard(mutex, &dp->aux.hw_mutex)
+					spacemit_dp_aux_hw_reset(dp);
+				msleep(SPACEMIT_DP_SINK_READY_DELAY_MS);
+			}
+
+			edid = drm_edid_read_ddc(connector, &dp->aux.ddc);
+			if (edid)
+				break;
+		}
+	}
+
+	if (!edid)
+		drm_err_ratelimited(dp->drm, "failed to read EDID\n");
+
+	return edid;
+}
+
+static enum drm_mode_status
+spacemit_dp_bridge_mode_valid(struct drm_bridge *bridge,
+			      const struct drm_display_info *info,
+			 const struct drm_display_mode *mode)
+{
+	struct spacemit_dp_dev *dp = container_of(bridge,
+						  struct spacemit_dp_dev,
+						  bridge);
+	unsigned int max_link_rate, max_lanes;
+	u64 max_bw, req_bw;
+
+	/*
+	 * Prefer the link limits the driver maintains: they start as the
+	 * sink's capabilities clamped to the PHY and are narrowed after a
+	 * failed training. drm_dp_max_link_rate() is in 10 kbit/s.
+	 */
+	if (dp->link.max_rate && dp->link.max_num_lanes) {
+		max_link_rate = dp->link.max_rate / 10;
+		max_lanes = dp->link.max_num_lanes;
+	} else {
+		max_link_rate = min_t(unsigned int,
+				      drm_dp_max_link_rate(dp->dpcd),
+				      SPACEMIT_DP_SOURCE_MAX_RATE / 10);
+		max_lanes = drm_dp_max_lane_count(dp->dpcd);
+	}
+	if (!max_link_rate || !max_lanes) {
+		/* Sink not enumerated yet: accept and re-check at modeset. */
+		return MODE_OK;
+	}
+
+	/*
+	 * max_link_rate is per lane in 10 kbit/s. The x10 to reach kbit/s and
+	 * the 8b/10b coding overhead cancel down to a plain "* 8".
+	 */
+	max_bw = (u64)max_link_rate * max_lanes * 8;
+
+	/* Required bandwidth: pixel clock (kHz) * bits per pixel. */
+	req_bw = (u64)mode->clock * SPACEMIT_DP_BPP;
+
+	if (req_bw > max_bw) {
+		drm_dbg(bridge->dev,
+			"rejecting %dx%d@%d: %llu > %llu kbit/s (%u kbit/s x%u lanes)\n",
+			mode->hdisplay, mode->vdisplay, drm_mode_vrefresh(mode),
+			req_bw, max_bw, max_link_rate * 10, max_lanes);
+		return MODE_CLOCK_HIGH;
+	}
+
+	/* The pixel clock is made by the PHY PLL, which cannot hit every rate. */
+	if (clk_round_rate(dp->pll_clk, mode->clock * 1000UL) <= 0)
+		return MODE_NOCLOCK;
+
+	return MODE_OK;
+}
+
+static const struct drm_encoder_funcs spacemit_dp_encoder_funcs = {
+	.destroy = drm_encoder_cleanup,
+};
+
+static void spacemit_dp_bridge_atomic_enable(struct drm_bridge *bridge,
+					     struct drm_atomic_commit *state)
+{
+	struct spacemit_dp_dev *dp = container_of(bridge,
+						  struct spacemit_dp_dev,
+						  bridge);
+	struct drm_bridge_state *new_bridge_state =
+		drm_atomic_get_new_bridge_state(state, bridge);
+	struct spacemit_dp_bridge_state *st =
+			to_spacemit_dp_bridge_state(new_bridge_state);
+	struct drm_connector *connector =
+		drm_atomic_get_new_connector_for_encoder(state, bridge->encoder);
+	struct drm_connector_state *conn_state =
+		drm_atomic_get_new_connector_state(state, connector);
+	struct drm_crtc_state *crtc_state =
+		drm_atomic_get_new_crtc_state(state, conn_state->crtc);
+	struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode;
+	const struct spacemit_dp_link_config *cfg;
+	bool hpd_lost = false;
+	bool trained;
+	u32 req_bw;
+	u32 hpd;
+	int start;
+	int i;
+
+	guard(mutex)(&dp->mode_lock);
+
+	/* Enable-time retry for the caps .detect() could not read. */
+	if (!dp->link.max_rate || !dp->link.max_num_lanes)
+		spacemit_dp_hw_read_sink_caps(dp);
+
+	req_bw = spacemit_dp_calc_required_bw(adjusted_mode, SPACEMIT_DP_BPP);
+
+	/*
+	 * Start where atomic_check() left off, but keep the upgrade walk as
+	 * fallback.
+	 */
+	start = st->link_cfg_idx >= 0 ? st->link_cfg_idx : 0;
+
+	for (trained = false, i = start;
+	     i < ARRAY_SIZE(spacemit_dp_link_priority_table); i++) {
+		u32 capacity;
+
+		cfg = &spacemit_dp_link_priority_table[i];
+
+		/* Source and sink limits */
+		if (cfg->rate > dp->link.max_rate || cfg->lanes > dp->link.max_num_lanes)
+			continue;
+
+		/* Bandwidth requirement */
+		capacity = spacemit_dp_calc_link_capacity(cfg->rate,
+							  cfg->lanes);
+		if (capacity < req_bw)
+			continue;
+
+		drm_dbg(dp->drm, "trying link config: rate %d lanes %d (capacity %d, required %d)\n",
+			cfg->rate, cfg->lanes, capacity, req_bw);
+
+		spacemit_dp_link_disable(dp);
+
+		/* Apply Hardware Settings */
+		if (spacemit_dp_set_plls(dp, cfg->rate, adjusted_mode->clock))
+			continue;
+
+		if (spacemit_dp_phy_set_lanes(dp, cfg->lanes))
+			continue;
+
+		if (spacemit_dp_phy_on(dp))
+			continue;
+
+		/*
+		 * Debounce: the transmitter was power-cycled just now and a
+		 * sink may legitimately drop HPD across a link-down. eDP is
+		 * hardwired and noisy.
+		 */
+		if (!dp->edp_mode &&
+		    regmap_read_poll_timeout(dp->regs, DP_HPD_INTERRUPT_STATUS, hpd,
+					     hpd & DP_HPD_IN_STATUS,
+					     SPACEMIT_DP_HPD_POLL_US,
+					     SPACEMIT_DP_HPD_DEBOUNCE_US)) {
+			drm_dbg(dp->drm,
+				"sink is not asserting HPD; not training\n");
+			hpd_lost = true;
+			break;
+		}
+
+		if (dp->edp_mode) {
+			regmap_write_bits(dp->regs, DP_CORE_CONTROL,
+					  DP_ENABLE_EDP,
+					  FIELD_PREP(DP_ENABLE_EDP, 0x1));
+			regmap_write_bits(dp->regs, DP_VIDEO_VSAMPLE_REG,
+					  DP_STREAM_ENC_EN,
+					  FIELD_PREP(DP_STREAM_ENC_EN, 0x1));
+
+			/* Do not train a link the panel was not set up for. */
+			if (spacemit_dp_update_edp_config(dp, true))
+				continue;
+		}
+
+		/* Execute Link Training */
+		if (spacemit_dp_link_train(dp, cfg->rate, cfg->lanes) == 0) {
+			drm_dbg(dp->drm,
+				"link training succeeded: rate %d lanes %d\n",
+				cfg->rate, cfg->lanes);
+			trained = true;
+			break;
+		}
+
+		drm_dbg(dp->drm,
+			"link training failed: rate %d lanes %d, trying next config\n",
+			cfg->rate, cfg->lanes);
+	}
+
+	/*
+	 * The DPU's pixel clock comes from the PHY PLL, so scanning out into an
+	 * untrained link never reaches CFG_RDY and wedges the CRTC on
+	 * flip_done.
+	 */
+	if (!trained) {
+		/* A sink that went away is not a link that failed. */
+		if (!hpd_lost)
+			drm_err_ratelimited(dp->drm,
+					    "no usable link config; leaving video disabled (%u kbit/s x%u lanes)\n",
+					    dp->link.max_rate,
+					    dp->link.max_num_lanes);
+
+		/*
+		 * A panel has no smaller mode to fall back to and a sink that
+		 * dropped HPD was not trained at all: retry those as they are,
+		 * with the capabilities read again. Otherwise retrying the
+		 * same mode would fail the same way, so narrow the link, and
+		 * give up once nothing is left to narrow.
+		 */
+		if (dp->edp_mode || hpd_lost) {
+			dp->link.max_rate = 0;
+			dp->link.max_num_lanes = 0;
+		} else if (!spacemit_dp_link_narrow(dp, req_bw)) {
+			dp->link.max_rate = 0;
+			dp->link.max_num_lanes = 0;
+			return;
+		}
+
+		/*
+		 * Deferred: we are inside the commit and hold the modeset
+		 * locks.
+		 */
+		schedule_work(&dp->modeset_retry_work);
+		return;
+	}
+
+	spacemit_dp_hw_set_msa_and_enable_video(dp, adjusted_mode,
+						dp->link_rate, dp->lane_count);
+}
+
+static void spacemit_dp_bridge_atomic_disable(struct drm_bridge *bridge,
+					      struct drm_atomic_commit *state)
+{
+	struct spacemit_dp_dev *dp = container_of(bridge,
+						  struct spacemit_dp_dev,
+						  bridge);
+
+	guard(mutex)(&dp->mode_lock);
+
+	spacemit_dp_link_disable(dp);
+}
+
+static int spacemit_dp_bridge_atomic_check(struct drm_bridge *bridge,
+					   struct drm_bridge_state *bridge_state,
+				      struct drm_crtc_state *crtc_state,
+				      struct drm_connector_state *conn_state)
+{
+	struct spacemit_dp_dev *dp = container_of(bridge,
+						  struct spacemit_dp_dev,
+						  bridge);
+	struct spacemit_dp_bridge_state *st =
+			to_spacemit_dp_bridge_state(bridge_state);
+	const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
+	u32 req_bw;
+	int i;
+
+	req_bw = spacemit_dp_calc_required_bw(mode, SPACEMIT_DP_BPP);
+
+	/* No caps yet: leave idx unset and let ->atomic_enable() retry. */
+	if (!dp->link.max_rate || !dp->link.max_num_lanes) {
+		st->link_cfg_idx = -1;
+		return 0;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(spacemit_dp_link_priority_table); i++) {
+		const struct spacemit_dp_link_config *cfg =
+				&spacemit_dp_link_priority_table[i];
+
+		if (cfg->rate > dp->link.max_rate ||
+		    cfg->lanes > dp->link.max_num_lanes)
+			continue;
+		if (spacemit_dp_calc_link_capacity(cfg->rate, cfg->lanes) < req_bw)
+			continue;
+
+		st->link_cfg_idx = i;
+		return 0;
+	}
+
+	drm_dbg(bridge->dev,
+		"no DP link cfg fits %dx%d@%d (need %u kbit/s; sink %u kbit/s x %u lanes)\n",
+		mode->hdisplay, mode->vdisplay, drm_mode_vrefresh(mode),
+		req_bw, dp->link.max_rate, dp->link.max_num_lanes);
+	return -EINVAL;
+}
+
+static struct drm_bridge_state *
+spacemit_dp_bridge_atomic_duplicate_state(struct drm_bridge *bridge)
+{
+	struct spacemit_dp_bridge_state *cur =
+		to_spacemit_dp_bridge_state(drm_priv_to_bridge_state(bridge->base.state));
+	struct spacemit_dp_bridge_state *new;
+
+	new = kzalloc_obj(*new);
+	if (!new)
+		return NULL;
+
+	__drm_atomic_helper_bridge_duplicate_state(bridge, &new->base);
+	new->link_cfg_idx = cur->link_cfg_idx;
+	return &new->base;
+}
+
+static void
+spacemit_dp_bridge_atomic_destroy_state(struct drm_bridge *bridge,
+					struct drm_bridge_state *state)
+{
+	kfree(to_spacemit_dp_bridge_state(state));
+}
+
+static u32 *spacemit_dp_bridge_atomic_get_output_bus_fmts(struct drm_bridge *bridge,
+							  struct drm_bridge_state *bridge_state,
+				struct drm_crtc_state *crtc_state,
+				struct drm_connector_state *conn_state,
+				unsigned int *num_output_fmts)
+{
+	u32 *output_fmts;
+
+	output_fmts = kmalloc_obj(*output_fmts, GFP_KERNEL);
+	if (!output_fmts) {
+		*num_output_fmts = 0;
+		return NULL;
+	}
+
+	output_fmts[0] = MEDIA_BUS_FMT_RGB888_1X24;
+	*num_output_fmts = 1;
+	return output_fmts;
+}
+
+static struct drm_bridge_state *
+spacemit_dp_bridge_atomic_create_state(struct drm_bridge *bridge)
+{
+	struct spacemit_dp_bridge_state *new;
+
+	new = kzalloc_obj(*new);
+	if (!new)
+		return ERR_PTR(-ENOMEM);
+
+	__drm_atomic_helper_bridge_state_init(&new->base, bridge);
+	new->link_cfg_idx = -1;
+	return &new->base;
+}
+
+static int spacemit_dp_bridge_attach(struct drm_bridge *bridge,
+				     struct drm_encoder *encoder,
+				enum drm_bridge_attach_flags flags)
+{
+	if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR))
+		return -EINVAL;
+
+	if (!bridge->next_bridge)
+		return 0;
+
+	return drm_bridge_attach(encoder, bridge->next_bridge, bridge, flags);
+}
+
+static const struct drm_bridge_funcs spacemit_dp_bridge_funcs = {
+	.attach				= spacemit_dp_bridge_attach,
+	.atomic_enable			= spacemit_dp_bridge_atomic_enable,
+	.atomic_disable			= spacemit_dp_bridge_atomic_disable,
+	.atomic_check			= spacemit_dp_bridge_atomic_check,
+	.atomic_duplicate_state		= spacemit_dp_bridge_atomic_duplicate_state,
+	.atomic_destroy_state		= spacemit_dp_bridge_atomic_destroy_state,
+	.atomic_create_state		= spacemit_dp_bridge_atomic_create_state,
+	.atomic_get_output_bus_fmts	= spacemit_dp_bridge_atomic_get_output_bus_fmts,
+	.mode_valid			= spacemit_dp_bridge_mode_valid,
+	.detect				= spacemit_dp_bridge_detect,
+	.edid_read			= spacemit_dp_bridge_edid_read,
+};
+
+static irqreturn_t spacemit_dp_irq_handler(int irq, void *data)
+{
+	struct spacemit_dp_dev *dp = data;
+	irqreturn_t ret = IRQ_NONE;
+	int idx;
+
+	if (!drm_dev_enter(dp->drm, &idx))
+		return IRQ_NONE;
+
+	/*
+	 * eDP .detect() ignores the HPD level (and never records it), so a
+	 * level flip would wake the thread forever; ack and ignore.
+	 */
+	if (dp->edp_mode) {
+		spacemit_dp_hw_clean_hpd(dp);
+		drm_dev_exit(idx);
+		return IRQ_HANDLED;
+	}
+
+	/*
+	 * Only compare here: the authoritative connector_status update
+	 * happens in the thread under mode_lock, via .detect().
+	 */
+	if (spacemit_dp_hw_detect_hpd(dp) != READ_ONCE(dp->connector_status))
+		ret = IRQ_WAKE_THREAD;
+	if (spacemit_dp_hw_clean_hpd(dp) && ret == IRQ_NONE)
+		ret = IRQ_HANDLED;
+
+	drm_dev_exit(idx);
+	return ret;
+}
+
+static irqreturn_t spacemit_dp_hotplug_event_handler(int irq, void *data)
+{
+	struct spacemit_dp_dev *dp = data;
+	enum drm_connector_status status;
+	int idx;
+
+	if (!drm_dev_enter(dp->drm, &idx))
+		return IRQ_HANDLED;
+
+	/*
+	 * .detect() owns mode_lock and re-reads the sink caps on a fresh plug
+	 */
+	status = spacemit_dp_bridge_detect(&dp->bridge, dp->connector);
+	drm_bridge_hpd_notify(&dp->bridge, status);
+
+	drm_dev_exit(idx);
+	return IRQ_HANDLED;
+}
+
+static int spacemit_dp_resource_init(struct spacemit_dp_dev *dp,
+				     struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	void __iomem *base;
+
+	base = devm_platform_ioremap_resource(pdev, 0);
+	if (IS_ERR(base))
+		return dev_err_probe(dev, PTR_ERR(base),
+				     "failed to map registers\n");
+	dp->regs = devm_regmap_init_mmio(dev, base, &spacemit_dp_regmap_config);
+	if (IS_ERR(dp->regs))
+		return dev_err_probe(dev, PTR_ERR(dp->regs),
+				     "failed to init DP regmap\n");
+
+	dp->irq = platform_get_irq(pdev, 0);
+	if (dp->irq < 0)
+		return dp->irq;
+
+	return 0;
+}
+
+static int spacemit_dp_dev_init(struct spacemit_dp_dev *dp)
+{
+	int ret;
+	u32 m_isel = 0x5, m_mainsel = 0x19;
+	u32 m_pre = 0x0, m_post = 0x2;
+	u32 tx_mode = 0x1, tx_pre = 0x0;
+	u32 clk_div = 24 * 1000 / 100;
+
+	regmap_write_bits(dp->regs, DP_PHYIF_CTRL_ADDR, DP_XMIT_ENABLE,
+			  FIELD_PREP(DP_XMIT_ENABLE, 0));
+	usleep_range(2000, 4000);
+
+	regmap_write_bits(dp->regs, DP_MPLL_CTRL0, DP_ANA_MPLL_PD,
+			  FIELD_PREP(DP_ANA_MPLL_PD, 1));
+	regmap_write_bits(dp->regs, DP_PREPLL_CTRL0, DP_ANA_PREPLL_PD,
+			  FIELD_PREP(DP_ANA_PREPLL_PD, 1));
+	usleep_range(2000, 4000);
+
+	/* Reset Controller and PHY */
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_CONTROLLER_RESET,
+			  FIELD_PREP(DP_CONTROLLER_RESET, 0x1));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_PHY_RESET,
+			  FIELD_PREP(DP_PHY_RESET, 0x1));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_HDCP_RESET,
+			  FIELD_PREP(DP_HDCP_RESET, 0x1));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
+			  FIELD_PREP(DP_AUX_RESET, 0x1));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_VIDEO_RESET,
+			  FIELD_PREP(DP_VIDEO_RESET, 0x1));
+	usleep_range(5000, 8000);
+
+	/* Release the resets */
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_CONTROLLER_RESET,
+			  FIELD_PREP(DP_CONTROLLER_RESET, 0x0));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_PHY_RESET,
+			  FIELD_PREP(DP_PHY_RESET, 0x0));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_HDCP_RESET,
+			  FIELD_PREP(DP_HDCP_RESET, 0x0));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
+			  FIELD_PREP(DP_AUX_RESET, 0x0));
+	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_VIDEO_RESET,
+			  FIELD_PREP(DP_VIDEO_RESET, 0x0));
+	usleep_range(2000, 4000);
+
+	regmap_write(dp->regs, DP_GENERAL_INTERRUPT,
+		     DP_AUX_REPLY_EVENT_INT_STA);
+
+	regmap_write_bits(dp->regs, DP_CORE_CONTROL,
+			  DP_DEFAULT_FAST_LINK_TRAIN_EN,
+			  FIELD_PREP(DP_DEFAULT_FAST_LINK_TRAIN_EN, 0x0));
+	regmap_write_bits(dp->regs, DP_CORE_CONTROL, DP_SCRAMBLER_DISABLE,
+			  FIELD_PREP(DP_SCRAMBLER_DISABLE, 0x0));
+	regmap_write_bits(dp->regs, DP_CORE_CONTROL, DP_SCALE_DOWN_MODE,
+			  FIELD_PREP(DP_SCALE_DOWN_MODE, 0x0));
+	regmap_write_bits(dp->regs, DP_PHYIF_CTRL_ADDR, DP_XMIT_ENABLE,
+			  FIELD_PREP(DP_XMIT_ENABLE, 0));
+
+	regmap_write_bits(dp->regs, DP_VIDEO_VSAMPLE_REG,
+			  DP_VIDEO_STREAM_ENABLE,
+			  FIELD_PREP(DP_VIDEO_STREAM_ENABLE, 0));
+
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_AUX_REPLY_EVENT_INT_STA_MSK,
+			  FIELD_PREP(DP_AUX_REPLY_EVENT_INT_STA_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_HDCP_INT_STA_MSK,
+			  FIELD_PREP(DP_HDCP_INT_STA_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_ILLEGAL_AUX_CMD_INT_STA_MSK,
+			  FIELD_PREP(DP_ILLEGAL_AUX_CMD_INT_STA_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_TYPE_C_EVENT_MSK,
+			  FIELD_PREP(DP_TYPE_C_EVENT_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK, DP_DSC_EVENT_MSK,
+			  FIELD_PREP(DP_DSC_EVENT_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_SDP_INT_STA_S3_MSK,
+			  FIELD_PREP(DP_SDP_INT_STA_S3_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_SDP_INT_STA_S2_MSK,
+			  FIELD_PREP(DP_SDP_INT_STA_S2_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_SDP_INT_STA_S1_MSK,
+			  FIELD_PREP(DP_SDP_INT_STA_S1_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_SDP_INT_STA_S0_MSK,
+			  FIELD_PREP(DP_SDP_INT_STA_S0_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S3_MSK,
+			  FIELD_PREP(DP_VIDEO_FIFO_OVERFLOW_INT_STA_S3_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S2_MSK,
+			  FIELD_PREP(DP_VIDEO_FIFO_OVERFLOW_INT_STA_S2_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S1_MSK,
+			  FIELD_PREP(DP_VIDEO_FIFO_OVERFLOW_INT_STA_S1_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S0_MSK,
+			  FIELD_PREP(DP_VIDEO_FIFO_OVERFLOW_INT_STA_S0_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_HPD_INTERRUPT_ENABLE,
+			  DP_SINK_IRQ_EVENT_MSK,
+			  FIELD_PREP(DP_SINK_IRQ_EVENT_MSK, 0x0));
+	regmap_write_bits(dp->regs, DP_GENERAL_INTERRUPT_MASK,
+			  DP_HPD_INT_STA_MSK,
+			  FIELD_PREP(DP_HPD_INT_STA_MSK, 0x1));
+	regmap_write_bits(dp->regs, DP_HPD_INTERRUPT_ENABLE,
+			  DP_HOT_PLUG_EVENT_MSK,
+			  FIELD_PREP(DP_HOT_PLUG_EVENT_MSK, 0x1));
+	regmap_write_bits(dp->regs, DP_HPD_INTERRUPT_ENABLE,
+			  DP_HOT_UNPLUG_EVENT_MSK,
+			  FIELD_PREP(DP_HOT_UNPLUG_EVENT_MSK, 0x1));
+	regmap_write_bits(dp->regs, DP_HPD_INTERRUPT_ENABLE,
+			  DP_SINK_UNPLUG_ERROR_EVENT_MSK,
+			  FIELD_PREP(DP_SINK_UNPLUG_ERROR_EVENT_MSK, 0x0));
+	usleep_range(2000, 4000);
+
+	regmap_write_bits(dp->regs, DP_PHYIF_CTRL_ADDR, DP_PHY_BUSY_BYP,
+			  FIELD_PREP(DP_PHY_BUSY_BYP, 0x1));
+
+	/* Enable enhanced framing */
+	regmap_write_bits(dp->regs, DP_CORE_CONTROL, DP_ENHANCE_FRAMING_EN,
+			  FIELD_PREP(DP_ENHANCE_FRAMING_EN, 0x1));
+
+	ret = spacemit_dp_set_plls(dp, SPACEMIT_DP_LINK_RATE_2_70, 148500);
+	if (ret)
+		return ret;
+
+	ret = spacemit_dp_phy_set_lanes(dp, SPACEMIT_DP_LANE_2);
+	if (ret)
+		return ret;
+
+	ret = spacemit_dp_phy_on(dp);
+	if (ret)
+		return ret;
+
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D0,
+			  FIELD_PREP(DP_ANA_TX_MODE_D0, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D1,
+			  FIELD_PREP(DP_ANA_TX_MODE_D1, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D2,
+			  FIELD_PREP(DP_ANA_TX_MODE_D2, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D3,
+			  FIELD_PREP(DP_ANA_TX_MODE_D3, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_RTCAL_FREQDIV_HBIT,
+			  FIELD_PREP(DP_ANA_RTCAL_FREQDIV_HBIT, (clk_div >> 8) & 0x7f));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_RTCAL_BYPASS,
+			  FIELD_PREP(DP_ANA_RTCAL_BYPASS, 1));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_RTCAL_FREQDIV_LBIT,
+			  FIELD_PREP(DP_ANA_RTCAL_FREQDIV_LBIT, clk_div & 0xff));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_BG_RCAL_SEL,
+			  FIELD_PREP(DP_ANA_BG_RCAL_SEL, 0));
+
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL8, DP_ANA_TX_RTM_D3,
+			  FIELD_PREP(DP_ANA_TX_RTM_D3, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL8, DP_ANA_TX_RTM_D2,
+			  FIELD_PREP(DP_ANA_TX_RTM_D2, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL8, DP_ANA_TX_RTM_D1,
+			  FIELD_PREP(DP_ANA_TX_RTM_D1, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL8, DP_ANA_TX_RTM_D0,
+			  FIELD_PREP(DP_ANA_TX_RTM_D0, 0));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_RTCAL_BYPASS,
+			  FIELD_PREP(DP_ANA_RTCAL_BYPASS, 1));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL7, DP_ANA_RTCAL_BYPASS,
+			  FIELD_PREP(DP_ANA_RTCAL_BYPASS, 0));
+	msleep(100);
+
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_PRE_D3,
+			  FIELD_PREP(DP_ANA_TX_MODE_PRE_D3, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_PRE_D2,
+			  FIELD_PREP(DP_ANA_TX_MODE_PRE_D2, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_PRE_D1,
+			  FIELD_PREP(DP_ANA_TX_MODE_PRE_D1, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_PRE_D0,
+			  FIELD_PREP(DP_ANA_TX_MODE_PRE_D0, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_DE_D3,
+			  FIELD_PREP(DP_ANA_TX_MODE_DE_D3, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_DE_D2,
+			  FIELD_PREP(DP_ANA_TX_MODE_DE_D2, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_DE_D1,
+			  FIELD_PREP(DP_ANA_TX_MODE_DE_D1, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_MODE_DE_D0,
+			  FIELD_PREP(DP_ANA_TX_MODE_DE_D0, 1));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_POSTSEL_PRE_D3,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_PRE_D3, tx_pre));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_POSTSEL_PRE_D2,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_PRE_D2, tx_pre));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_POSTSEL_PRE_D1,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_PRE_D1, tx_pre));
+	regmap_write_bits(dp->regs, DP_ANA_LANE_EMPH, DP_ANA_TX_POSTSEL_PRE_D0,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_PRE_D0, tx_pre));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_ISEL_DRV_D3,
+			  FIELD_PREP(DP_ANA_TX_ISEL_DRV_D3, m_isel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_ENABLE, DP_ANA_TX_ISEL_DRV_D2,
+			  FIELD_PREP(DP_ANA_TX_ISEL_DRV_D2, m_isel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL1, DP_ANA_TX_MAINSEL_D2,
+			  FIELD_PREP(DP_ANA_TX_MAINSEL_D2, m_mainsel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL1, DP_ANA_TX_MAINSEL_D3,
+			  FIELD_PREP(DP_ANA_TX_MAINSEL_D3, m_mainsel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL1, DP_ANA_TX_ISEL_DRV_D1,
+			  FIELD_PREP(DP_ANA_TX_ISEL_DRV_D1, m_isel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL1, DP_ANA_TX_ISEL_DRV_D0,
+			  FIELD_PREP(DP_ANA_TX_ISEL_DRV_D0, m_isel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL2, DP_ANA_TX_POSTSEL_D1,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_D1, m_post));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL2, DP_ANA_TX_POSTSEL_D0,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_D0, m_post));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL2, DP_ANA_TX_POSTSEL_D3,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_D3, m_post));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL2, DP_ANA_TX_POSTSEL_D2,
+			  FIELD_PREP(DP_ANA_TX_POSTSEL_D2, m_post));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL2, DP_DA_TX_MAINSEL_D0_4_0,
+			  FIELD_PREP(DP_DA_TX_MAINSEL_D0_4_0, m_mainsel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL2, DP_ANA_TX_MAINSEL_D1,
+			  FIELD_PREP(DP_ANA_TX_MAINSEL_D1, m_mainsel));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_PRESEL_D1,
+			  FIELD_PREP(DP_ANA_TX_PRESEL_D1, m_pre));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_PRESEL_D0,
+			  FIELD_PREP(DP_ANA_TX_PRESEL_D0, m_pre));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_PRESEL_D3,
+			  FIELD_PREP(DP_ANA_TX_PRESEL_D3, m_pre));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_PRESEL_D2,
+			  FIELD_PREP(DP_ANA_TX_PRESEL_D2, m_pre));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D3,
+			  FIELD_PREP(DP_ANA_TX_MODE_D3, tx_mode));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D2,
+			  FIELD_PREP(DP_ANA_TX_MODE_D2, tx_mode));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D1,
+			  FIELD_PREP(DP_ANA_TX_MODE_D1, tx_mode));
+	regmap_write_bits(dp->regs, DP_ANA_TX_CTRL3, DP_ANA_TX_MODE_D0,
+			  FIELD_PREP(DP_ANA_TX_MODE_D0, tx_mode));
+	regmap_write_bits(dp->regs, DP_ANA_TX_AUX_CTRL, DP_ANA_TX_AUX_RX_VSEL,
+			  FIELD_PREP(DP_ANA_TX_AUX_RX_VSEL, 0x0));
+
+	return 0;
+}
+
+static int spacemit_dp_bind(struct device *dev, struct device *master,
+			    void *data)
+{
+	struct spacemit_dp_dev *dp = dev_get_drvdata(dev);
+	struct drm_device *drm = data;
+	struct device_node *ep;
+	int ret;
+
+	dp->drm = drm;
+	dp->aux.drm_dev = drm;
+	ret = drm_dp_aux_register(&dp->aux);
+	if (ret) {
+		dev_err_probe(dev, ret, "failed to register DP AUX\n");
+		goto err_drm;
+	}
+
+	ret = drm_encoder_init(drm, &dp->encoder, &spacemit_dp_encoder_funcs,
+			       DRM_MODE_ENCODER_NONE, NULL);
+	if (ret) {
+		dev_err_probe(dev, ret, "failed to init encoder\n");
+		goto err_aux;
+	}
+
+	ep = of_graph_get_endpoint_by_regs(dev->of_node, 0, -1);
+	if (ep) {
+		struct device_node *remote = of_graph_get_remote_port(ep);
+
+		dp->encoder.possible_crtcs = drm_of_crtc_port_mask(drm, remote);
+		of_node_put(remote);
+		of_node_put(ep);
+	}
+
+	ret = drm_bridge_attach(&dp->encoder, &dp->bridge, NULL,
+				DRM_BRIDGE_ATTACH_NO_CONNECTOR);
+	if (ret) {
+		dev_err_probe(dev, ret, "failed to attach bridge\n");
+		goto err_encoder;
+	}
+
+	dp->connector = drm_bridge_connector_init(drm, &dp->encoder);
+	if (IS_ERR(dp->connector)) {
+		ret = PTR_ERR(dp->connector);
+		dev_err_probe(dev, ret, "failed to init bridge connector\n");
+		goto err_encoder;
+	}
+
+	ret = spacemit_dp_dev_init(dp);
+	if (ret)
+		goto err_encoder;
+
+	spacemit_dp_link_disable(dp);
+
+	WRITE_ONCE(dp->connector_status, spacemit_dp_hw_detect_hpd(dp));
+	spacemit_dp_hw_clean_hpd(dp);
+
+	if (dp->connector_status == connector_status_connected)
+		spacemit_dp_hw_read_sink_caps(dp);
+
+	drm_bridge_hpd_notify(&dp->bridge,
+			      spacemit_dp_bridge_detect(&dp->bridge,
+							dp->connector));
+
+	enable_irq(dp->irq);
+
+	return 0;
+
+err_encoder:
+	drm_encoder_cleanup(&dp->encoder);
+err_aux:
+	drm_dp_aux_unregister(&dp->aux);
+err_drm:
+	/* The master releases the drm_device; the AUX channel outlives it. */
+	dp->drm = NULL;
+	dp->connector = NULL;
+	dp->aux.drm_dev = NULL;
+	return ret;
+}
+
+static void spacemit_dp_unbind(struct device *dev, struct device *master,
+			       void *data)
+{
+	struct spacemit_dp_dev *dp = dev_get_drvdata(dev);
+
+	disable_irq(dp->irq);
+
+	/* The connector this work touches dies with the DRM device. */
+	cancel_work_sync(&dp->modeset_retry_work);
+
+	drm_dp_aux_unregister(&dp->aux);
+
+	spacemit_dp_hw_disable(dp);
+
+	drm_encoder_cleanup(&dp->encoder);
+
+	dp->drm = NULL;
+	dp->connector = NULL;
+	dp->aux.drm_dev = NULL;
+}
+
+static const struct component_ops spacemit_dp_ops = {
+	.bind = spacemit_dp_bind,
+	.unbind = spacemit_dp_unbind,
+};
+
+/*
+ * AUX-bus done-probing callback. The controller joins the DRM device only
+ * now, so the bind always finds the panel bridge at the end of the chain.
+ */
+static int spacemit_dp_edp_link_panel(struct drm_dp_aux *aux)
+{
+	struct spacemit_dp_dev *dp = container_of(aux, struct spacemit_dp_dev,
+						  aux);
+	struct drm_bridge *next;
+	int ret;
+
+	/* A panel that probes again cannot join a registered controller. */
+	if (dp->component_added)
+		return -EBUSY;
+
+	next = devm_drm_of_get_bridge(dp->dev, dp->dev->of_node, 1, 0);
+	if (IS_ERR(next))
+		return PTR_ERR(next);
+
+	/* Held until the bridge is freed; the core drops it then. */
+	dp->bridge.next_bridge = drm_bridge_get(next);
+
+	ret = component_add(dp->dev, &spacemit_dp_ops);
+	if (ret) {
+		dp->bridge.next_bridge = NULL;
+		drm_bridge_put(next);
+		return ret;
+	}
+	dp->component_added = true;
+
+	return 0;
+}
+
+/* Leave the DRM device, or power down a controller that never joined one. */
+static void spacemit_dp_unregister(struct spacemit_dp_dev *dp)
+{
+	if (dp->component_added)
+		component_del(dp->dev, &spacemit_dp_ops);
+	else
+		spacemit_dp_hw_disable(dp);
+}
+
+/*
+ * Registered after devm_of_platform_populate(), so devres runs it before
+ * the PHY child (and the PLL clock it provides) is torn down: unregistering
+ * a clock that still has an enabled child warns, a disabled child is
+ * orphaned silently.
+ */
+static void spacemit_dp_pxclk_disable(void *data)
+{
+	clk_disable_unprepare(data);
+}
+
+static int spacemit_dp_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct device_node *aux_bus_np;
+	struct spacemit_dp_dev *dp;
+	struct reset_control *rstc;
+	int ret;
+
+	dp = devm_drm_bridge_alloc(dev, struct spacemit_dp_dev, bridge,
+				   &spacemit_dp_bridge_funcs);
+	if (IS_ERR(dp))
+		return PTR_ERR(dp);
+
+	dp->dev = dev;
+	INIT_WORK(&dp->modeset_retry_work, spacemit_dp_modeset_retry_work);
+
+	/* eDP instances have an aux-bus child node; DP instances do not. */
+	aux_bus_np = of_get_child_by_name(dev->of_node, "aux-bus");
+	dp->edp_mode = !!aux_bus_np;
+	of_node_put(aux_bus_np);
+
+	dp->bridge.of_node = dev->of_node;
+	dp->connector_status = connector_status_disconnected;
+	ret = devm_mutex_init(dev, &dp->mode_lock);
+	if (ret)
+		return ret;
+
+	rstc = devm_reset_control_get_exclusive_deasserted(&pdev->dev, NULL);
+	if (IS_ERR(rstc))
+		return dev_err_probe(dev, PTR_ERR(rstc),
+				     "failed to get reset\n");
+
+	dp->pxclk = devm_clk_get(dev, "pxclk");
+	if (IS_ERR(dp->pxclk))
+		return dev_err_probe(dev, PTR_ERR(dp->pxclk),
+				     "failed to get pxclk\n");
+
+	if (dp->edp_mode) {
+		dp->bridge.type = DRM_MODE_CONNECTOR_eDP;
+		/* .detect() reports the fixed panel as connected. */
+		dp->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_HPD;
+	} else {
+		dp->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
+		/*
+		 * No OP_HPD: the HPD interrupt is gated by the DP pixel clock.
+		 * Leaving it out marks the connector POLL_CONNECT |
+		 * POLL_DISCONNECT instead.
+		 */
+		dp->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID;
+	}
+
+	ret = clk_prepare_enable(dp->pxclk);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to enable pxclk\n");
+
+	/*
+	 * The PHY child shares this device's regmap, so the regmap must exist
+	 * before devm_of_platform_populate() lets the PHY probe and
+	 * devm_phy_get() succeed.
+	 */
+	ret = spacemit_dp_resource_init(dp, pdev);
+	if (ret)
+		goto err_disable_pxclk;
+
+	ret = devm_of_platform_populate(dev);
+	if (ret) {
+		dev_err_probe(dev, ret, "failed to populate child devices\n");
+		goto err_disable_pxclk;
+	}
+
+	dp->phy = devm_phy_get(dev, "dp");
+	if (IS_ERR(dp->phy)) {
+		ret = dev_err_probe(dev, PTR_ERR(dp->phy),
+				    "failed to get DP PHY\n");
+		goto err_disable_pxclk;
+	}
+
+	/*
+	 * The PHY exposes its PLL as the APMU pixel-clock mux's external
+	 * parent.
+	 */
+	dp->pll_clk = devm_clk_get(dev, "pll");
+	if (IS_ERR(dp->pll_clk)) {
+		ret = dev_err_probe(dev, PTR_ERR(dp->pll_clk),
+				    "failed to get PHY pixel clock\n");
+		goto err_disable_pxclk;
+	}
+
+	ret = clk_set_parent(dp->pxclk, dp->pll_clk);
+	if (ret) {
+		dev_err_probe(dev, ret,
+			      "failed to route the pixel mux to the PHY PLL\n");
+		goto err_disable_pxclk;
+	}
+
+	ret = devm_add_action_or_reset(dev, spacemit_dp_pxclk_disable,
+				       dp->pxclk);
+	if (ret)
+		return ret;
+
+	/*
+	 * Panel discovery needs the AUX channel here; registration waits for
+	 * bind.
+	 */
+	dp->aux.name = "spacemit-dp-aux";
+	dp->aux.dev = dev;
+	dp->aux.transfer = spacemit_dp_aux_transfer;
+	dp->aux.no_zero_sized = true;
+	drm_dp_aux_init(&dp->aux);
+	dp->bridge.ddc = &dp->aux.ddc;
+
+	/*
+	 * drm_bridge_attach() expects the bridge to already be on the global
+	 * list.
+	 */
+	ret = devm_drm_bridge_add(dev, &dp->bridge);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to register DP bridge\n");
+
+	platform_set_drvdata(pdev, dp);
+
+	/*
+	 * The handler needs bind-created state, so keep the line disabled until
+	 * bind.
+	 */
+	ret = devm_request_threaded_irq(dev, dp->irq, spacemit_dp_irq_handler,
+					spacemit_dp_hotplug_event_handler,
+					IRQF_NO_AUTOEN, dev_name(dev), dp);
+	if (ret)
+		return ret;
+
+	if (!dp->edp_mode) {
+		ret = component_add(dev, &spacemit_dp_ops);
+		if (ret)
+			return dev_err_probe(dev, ret,
+					     "failed to add component\n");
+		dp->component_added = true;
+
+		return 0;
+	}
+
+	/*
+	 * eDP hands panel power, enable-GPIO and backlight to panel-edp over
+	 * the AUX bus, and panel-edp reads the EDID over AUX while it probes:
+	 * bring the controller up first. The component is added once the panel
+	 * is there, from spacemit_dp_edp_link_panel(); that may be before this
+	 * call returns.
+	 */
+	ret = spacemit_dp_dev_init(dp);
+	if (ret) {
+		spacemit_dp_hw_disable(dp);
+		return dev_err_probe(dev, ret,
+				     "eDP: failed to bring up the controller\n");
+	}
+	spacemit_dp_link_disable(dp);
+
+	ret = devm_of_dp_aux_populate_bus(&dp->aux, spacemit_dp_edp_link_panel);
+	if (ret) {
+		spacemit_dp_unregister(dp);
+		return dev_err_probe(dev, ret,
+				     "eDP: failed to populate aux-bus panel\n");
+	}
+
+	return 0;
+
+err_disable_pxclk:
+	clk_disable_unprepare(dp->pxclk);
+	return ret;
+}
+
+static void spacemit_dp_remove(struct platform_device *pdev)
+{
+	spacemit_dp_unregister(platform_get_drvdata(pdev));
+}
+
+static void spacemit_dp_shutdown(struct platform_device *pdev)
+{
+	spacemit_dp_hw_disable(platform_get_drvdata(pdev));
+}
+
+static const struct of_device_id spacemit_dp_match[] = {
+	{ .compatible = "spacemit,k3-inno-dp" },
+	{}
+};
+MODULE_DEVICE_TABLE(of, spacemit_dp_match);
+
+static struct platform_driver spacemit_dp_driver = {
+	.probe = spacemit_dp_probe,
+	.remove = spacemit_dp_remove,
+	.shutdown = spacemit_dp_shutdown,
+	.driver = {
+		.name = "spacemit-inno-dp-drv",
+		.of_match_table = spacemit_dp_match,
+	},
+};
+
+module_platform_driver(spacemit_dp_driver);
+
+MODULE_DESCRIPTION("SpacemiT K3 Innosilicon DP/eDP bridge driver");
+MODULE_LICENSE("GPL");
+MODULE_SOFTDEP("pre: phy-k3-inno-dp");
diff --git a/drivers/gpu/drm/spacemit/spacemit_inno_dp.h b/drivers/gpu/drm/spacemit/spacemit_inno_dp.h
new file mode 100644
index 0000000000000..fa61783102ce0
--- /dev/null
+++ b/drivers/gpu/drm/spacemit/spacemit_inno_dp.h
@@ -0,0 +1,328 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2025-2026 SpacemiT Co., Ltd.
+ *
+ */
+
+#ifndef __SPACEMIT_INNO_DP_H__
+#define __SPACEMIT_INNO_DP_H__
+
+#include <linux/bits.h>
+
+#define DP_CORE_CONTROL                      0x0018
+#define  DP_SCRAMBLER_DISABLE               BIT(31)
+#define  DP_ENHANCE_FRAMING_EN              BIT(30)
+#define  DP_DEFAULT_FAST_LINK_TRAIN_EN      BIT(29)
+#define  DP_SCALE_DOWN_MODE                 BIT(28)
+#define  DP_FORCE_HPD                       BIT(27)
+#define  DP_ENABLE_EDP                      BIT(4)
+
+#define DP_SOFT_RESET                        0x001c
+#define  DP_CONTROLLER_RESET                BIT(31)
+#define  DP_PHY_RESET                       BIT(30)
+#define  DP_HDCP_RESET                      BIT(29)
+#define  DP_AUDIO_RESET                     BIT(28)
+#define  DP_AUX_RESET                       BIT(27)
+#define  DP_VIDEO_RESET                     GENMASK(3, 0)
+
+#define DP_CLK_INV_MUX                       0x0028
+#define  DP_REG_VID_CLK_SEL                 BIT(0)
+
+/* Interrupt status latches; write 1 to clear. */
+#define DP_GENERAL_INTERRUPT                 0x0080
+#define  DP_AUX_REPLY_EVENT_INT_STA         BIT(16)
+
+#define DP_GENERAL_INTERRUPT_MASK            0x0084
+#define  DP_HPD_INT_STA_MSK                 BIT(17)
+#define  DP_AUX_REPLY_EVENT_INT_STA_MSK     BIT(16)
+#define  DP_HDCP_INT_STA_MSK                BIT(15)
+#define  DP_ILLEGAL_AUX_CMD_INT_STA_MSK     BIT(14)
+#define  DP_TYPE_C_EVENT_MSK                BIT(13)
+#define  DP_DSC_EVENT_MSK                   BIT(12)
+#define  DP_SDP_INT_STA_S3_MSK              BIT(11)
+#define  DP_SDP_INT_STA_S2_MSK              BIT(10)
+#define  DP_SDP_INT_STA_S1_MSK              BIT(9)
+#define  DP_SDP_INT_STA_S0_MSK              BIT(8)
+#define  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S3_MSK BIT(7)
+#define  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S2_MSK BIT(6)
+#define  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S1_MSK BIT(5)
+#define  DP_VIDEO_FIFO_OVERFLOW_INT_STA_S0_MSK BIT(4)
+
+#define DP_HPD_INTERRUPT_STATUS              0x0088
+#define  DP_HOT_PLUG_EVENT                  BIT(29)
+#define  DP_HOT_UNPLUG_EVENT                BIT(28)
+#define  DP_HPD_IN_STATUS                   BIT(26)
+
+#define DP_HPD_INTERRUPT_ENABLE              0x008c
+#define  DP_SINK_IRQ_EVENT_MSK              BIT(31)
+#define  DP_HOT_PLUG_EVENT_MSK              BIT(29)
+#define  DP_HOT_UNPLUG_EVENT_MSK            BIT(28)
+#define  DP_SINK_UNPLUG_ERROR_EVENT_MSK     BIT(27)
+
+#define DP_PHYIF_CTRL_ADDR                   0x0100
+#define  DP_PHY_BUSY_BYP                    BIT(31)
+#define  DP_TPS_SEL                         GENMASK(28, 25)
+#define  DP_XMIT_ENABLE                     GENMASK(20, 17)
+#define  DP_PHY_POWERDOWN                   GENMASK(16, 13)
+#define  DP_PHY_SSC_DIS                     BIT(8)
+#define  DP_PHY_NUM_LANES                   GENMASK(6, 5)
+#define  DP_PHY_RATE                        GENMASK(1, 0)
+
+#define DP_PHYIF_TX_EQ_ADDR                  0x0104
+#define  DP_PHY_LANE3_TX_VSWING             GENMASK(21, 20)
+#define  DP_PHY_LANE3_TX_PREEMP             GENMASK(19, 18)
+#define  DP_PHY_LANE2_TX_VSWING             GENMASK(15, 14)
+#define  DP_PHY_LANE2_TX_PREEMP             GENMASK(13, 12)
+#define  DP_PHY_LANE1_TX_VSWING             GENMASK(9, 8)
+#define  DP_PHY_LANE1_TX_PREEMP             GENMASK(7, 6)
+#define  DP_PHY_LANE0_TX_VSWING             GENMASK(3, 2)
+#define  DP_PHY_LANE0_TX_PREEMP             GENMASK(1, 0)
+
+#define DP_MPLL_CTRL0                        0x0180
+#define  DP_ANA_MPLL_FBDIV_LBIT             GENMASK(31, 24)
+#define  DP_ANA_MPLL_SEL_EXTWAVE            BIT(22)
+#define  DP_ANA_MPLL_DISABLE_SSCG           BIT(21)
+#define  DP_ANA_MPLL_DOWNSPREAD             BIT(20)
+#define  DP_ANA_MPLL_FBDIV_HBIT             GENMASK(19, 16)
+#define  DP_ANA_MPLL_OBSEN                  BIT(15)
+#define  DP_ANA_MPLL_OBSSEL                 BIT(14)
+#define  DP_ANA_MPLL_PREDIV                 GENMASK(13, 8)
+#define  DP_AD_LOCK_COREPLL                 BIT(7)
+#define  DP_ANA_MPLL_DACPD                  BIT(5)
+#define  DP_ANA_MPLL_DSMPD                  BIT(4)
+#define  DP_ANA_MPLL_PD                     BIT(0)
+
+#define DP_MPLL_CTRL1                        0x0184
+#define  DP_ANA_MPLL_FRAC_LBIT              GENMASK(23, 16)
+#define  DP_ANA_MPLL_FRAC_MBIT              GENMASK(15, 8)
+#define  DP_ANA_MPLL_FRAC_HBIT              GENMASK(7, 0)
+
+#define DP_MPLL_CTRL2                        0x0188
+#define  DP_ANA_MPLL_VCOCLK_DIV8_EN         BIT(16)
+#define  DP_ANA_MPLL_POSTDIVEN              BIT(11)
+#define  DP_ANA_MPLL_POSTDIV                GENMASK(10, 8)
+
+#define DP_PREPLL_CTRL0                      0x0190
+#define  DP_ANA_PREPLL_FBDIV2_LBIT          GENMASK(31, 24)
+#define  DP_ANA_PREPLL_FBDIV2_HBIT          GENMASK(19, 16)
+#define  DP_ANA_PREPLL_PREDIV               GENMASK(13, 8)
+#define  DP_AD_LOCK_PIXELPLL                BIT(7)
+#define  DP_ANA_PREPLL_DACPD                BIT(5)
+#define  DP_ANA_PREPLL_DSMPD                BIT(4)
+#define  DP_REG_PCLK_OUTPUT_NORMAL          BIT(1)
+#define  DP_ANA_PREPLL_PD                   BIT(0)
+
+#define DP_PREPLL_CTRL1                      0x0194
+#define  DP_ANA_PREPLL_PRECLK_DIVM          GENMASK(17, 16)
+#define  DP_ANA_PREPLL_PRECLK_DIVAUX        GENMASK(12, 8)
+
+#define DP_PREPLL_CTRL2                      0x0198
+#define  DP_ANA_PREPLL_PCLKDIV5_EN          BIT(31)
+#define  DP_ANA_PREPLL_PCLK_DIVAUX          GENMASK(28, 24)
+#define  DP_ANA_PREPLL_LOCK_BYPEN           BIT(17)
+#define  DP_ANA_PREPLL_LOWFRE_EN            BIT(16)
+#define  DP_ANA_PREPLL_TESTEN               BIT(15)
+#define  DP_ANA_PREPLL_TESTSEL              GENMASK(14, 12)
+#define  DP_ANA_PREPLL_HDMI_EN              BIT(9)
+#define  DP_ANA_PREPLL_DP_EN                BIT(8)
+
+#define DP_PREPLL_SSC_CTRL                   0x019c
+#define  DP_ANA_PREPLL_FRAC2_LBIT           GENMASK(23, 16)
+#define  DP_ANA_PREPLL_FRAC2_MBIT           GENMASK(15, 8)
+#define  DP_ANA_PREPLL_FRAC2_HBIT           GENMASK(7, 0)
+
+#define DP_ANA_TX_CTRL0                      0x01a0
+#define  DP_ANA_MPLL_CLKDIV_16M             GENMASK(13, 8)
+
+#define DP_ANA_TX_ENABLE                     0x01a4
+#define  DP_ANA_TX_ISEL_DRV_D3              GENMASK(31, 28)
+#define  DP_ANA_TX_ISEL_DRV_D2              GENMASK(27, 24)
+#define  DP_AD_TX_ESDSENSE_D3               GENMASK(23, 22)
+#define  DP_AD_TX_ESDSENSE_D2               GENMASK(21, 20)
+#define  DP_AD_TX_ESDSENSE_D1               GENMASK(19, 18)
+#define  DP_AD_TX_ESDSENSE_D0               GENMASK(17, 16)
+#define  DP_ANA_TX_EN_LDO_D3                BIT(11)
+#define  DP_ANA_TX_EN_LDO_D2                BIT(10)
+#define  DP_ANA_TX_EN_LDO_D1                BIT(9)
+#define  DP_ANA_TX_EN_LDO_D0                BIT(8)
+#define  DP_ANA_TX_EN_BYP_D3                BIT(7)
+#define  DP_ANA_TX_EN_BYP_D2                BIT(6)
+#define  DP_ANA_TX_EN_BYP_D1                BIT(5)
+#define  DP_ANA_TX_EN_BYP_D0                BIT(4)
+#define  DP_ANA_TX_EN_DRV_D3                BIT(3)
+#define  DP_ANA_TX_EN_DRV_D2                BIT(2)
+#define  DP_ANA_TX_EN_DRV_D1                BIT(1)
+#define  DP_ANA_TX_EN_DRV_D0                BIT(0)
+
+#define DP_ANA_TX_CTRL1                      0x01a8
+#define  DP_ANA_TX_PHASE_D2                 GENMASK(31, 30)
+#define  DP_ANA_TX_MAINSEL_D2               GENMASK(28, 24)
+#define  DP_ANA_TX_PHASE_D3                 GENMASK(23, 22)
+#define  DP_ANA_TX_MAINSEL_D3               GENMASK(20, 16)
+#define  DP_ANA_TX_ISEL_LDO_D3              BIT(11)
+#define  DP_ANA_TX_ISEL_LDO_D2              BIT(10)
+#define  DP_ANA_TX_ISEL_LDO_D1              BIT(9)
+#define  DP_ANA_TX_ISEL_LDO_D0              BIT(8)
+#define  DP_ANA_TX_ISEL_DRV_D1              GENMASK(7, 4)
+#define  DP_ANA_TX_ISEL_DRV_D0              GENMASK(3, 0)
+
+#define DP_ANA_TX_CTRL2                      0x01ac
+#define  DP_ANA_TX_POSTSEL_D1               GENMASK(31, 28)
+#define  DP_ANA_TX_POSTSEL_D0               GENMASK(27, 24)
+#define  DP_ANA_TX_POSTSEL_D3               GENMASK(23, 20)
+#define  DP_ANA_TX_POSTSEL_D2               GENMASK(19, 16)
+#define  DP_ANA_TX_PHASE_D0                 GENMASK(15, 14)
+#define  DP_DA_TX_MAINSEL_D0_4_0            GENMASK(12, 8)
+#define  DP_ANA_TX_PHASE_D1                 GENMASK(7, 6)
+#define  DP_ANA_TX_MAINSEL_D1               GENMASK(4, 0)
+
+#define DP_ANA_TX_CTRL3                      0x01b0
+#define  DP_ANA_TX_EN_P2S_D3                BIT(31)
+#define  DP_ANA_TX_EN_P2S_D2                BIT(30)
+#define  DP_ANA_TX_EN_P2S_D1                BIT(29)
+#define  DP_ANA_TX_EN_P2S_D0                BIT(28)
+#define  DP_ANA_TX_MODE_D3                  BIT(27)
+#define  DP_ANA_TX_MODE_D2                  BIT(26)
+#define  DP_ANA_TX_MODE_D1                  BIT(25)
+#define  DP_ANA_TX_MODE_D0                  BIT(24)
+#define  DP_ANA_TX_PRESEL_D1                GENMASK(14, 12)
+#define  DP_ANA_TX_PRESEL_D0                GENMASK(10, 8)
+#define  DP_ANA_TX_PRESEL_D3                GENMASK(6, 4)
+#define  DP_ANA_TX_PRESEL_D2                GENMASK(2, 0)
+
+#define DP_ANA_TX_CTRL6                      0x01bc
+#define  DP_ANA_BG_VREF5                    GENMASK(15, 14)
+#define  DP_ANA_BG_VREF4                    GENMASK(13, 12)
+#define  DP_ANA_BG_VREF3                    GENMASK(11, 10)
+#define  DP_ANA_BG_VREF2                    GENMASK(9, 8)
+#define  DP_ANA_BG_VREF                     GENMASK(7, 6)
+#define  DP_ANA_BG_VREF1                    GENMASK(5, 4)
+#define  DP_ANA_BG_EN_CHOP                  BIT(3)
+#define  DP_ANA_BG_EN                       BIT(2)
+#define  DP_ANA_BG_ISEL                     BIT(1)
+#define  DP_ANA_BG_VSEL                     BIT(0)
+
+#define DP_ANA_TX_CTRL7                      0x01c0
+#define  DP_ANA_BG_EN_RCAL                  BIT(27)
+#define  DP_ANA_BG_RCAL_SEL                 GENMASK(26, 25)
+#define  DP_AD_BG_RCAL_OUT                  BIT(24)
+#define  DP_ANA_RTCAL_FREQDIV_LBIT          GENMASK(23, 16)
+#define  DP_ANA_RTCAL_BYPASS                BIT(15)
+#define  DP_ANA_RTCAL_FREQDIV_HBIT          GENMASK(14, 8)
+#define  DP_ANA_BG_RCAL_VAL                 GENMASK(5, 0)
+
+#define DP_ANA_TX_CTRL8                      0x01c4
+#define  DP_ANA_TX_RTM_D3                   GENMASK(29, 24)
+#define  DP_ANA_TX_RTM_D2                   GENMASK(21, 16)
+#define  DP_ANA_TX_RTM_D1                   GENMASK(13, 8)
+#define  DP_ANA_TX_RTM_D0                   GENMASK(5, 0)
+
+#define DP_ANA_TX_AUX_CTRL                   0x01d0
+#define  DP_ANA_TX_AUX_RX_VSEL              GENMASK(13, 12)
+
+#define DP_ANA_LANE_EMPH                     0x01dc
+#define  DP_ANA_TX_POSTSEL_PRE_D3           GENMASK(23, 20)
+#define  DP_ANA_TX_POSTSEL_PRE_D2           GENMASK(19, 16)
+#define  DP_ANA_TX_POSTSEL_PRE_D1           GENMASK(15, 12)
+#define  DP_ANA_TX_POSTSEL_PRE_D0           GENMASK(11, 8)
+#define  DP_ANA_TX_MODE_DE_D3               BIT(7)
+#define  DP_ANA_TX_MODE_DE_D2               BIT(6)
+#define  DP_ANA_TX_MODE_DE_D1               BIT(5)
+#define  DP_ANA_TX_MODE_DE_D0               BIT(4)
+#define  DP_ANA_TX_MODE_PRE_D3              BIT(3)
+#define  DP_ANA_TX_MODE_PRE_D2              BIT(2)
+#define  DP_ANA_TX_MODE_PRE_D1              BIT(1)
+#define  DP_ANA_TX_MODE_PRE_D0              BIT(0)
+
+#define DP_VIDEO_VSAMPLE_REG                 0x0200
+#define  DP_VIDEO_STREAM_ENABLE             BIT(28)
+#define  DP_VIDEO_MAPPING                   GENMASK(26, 22)
+#define  DP_STREAM_ENC_EN                   BIT(18)
+
+#define DP_VINPUT_POLARITY                   0x020c
+#define  DP_HSYNC_IN_POLARITY               BIT(29)
+#define  DP_VSYNC_IN_POLARITY               BIT(28)
+
+#define DP_VIDEO_CONFIG2                     0x0210
+#define  DP_VACTIVE                         GENMASK(31, 16)
+#define  DP_VBLANK                          GENMASK(15, 0)
+
+#define DP_VIDEO_CONFIG1                     0x0214
+#define  DP_HBLANK                          GENMASK(29, 16)
+#define  DP_HACTIVE                         GENMASK(15, 0)
+
+#define DP_VIDEO_CONFIG5                     0x0218
+#define  DP_AVERAGE_BYTES_PER_TU            GENMASK(31, 25)
+#define  DP_AVERAGE_BYTES_PER_TU_FRAC       GENMASK(24, 21)
+#define  DP_INIT_THRESHOLD                  GENMASK(18, 10)
+
+#define DP_VIDEO_CONFIG3                     0x021c
+#define  DP_H_FRONT_PORCH                   GENMASK(31, 16)
+#define  DP_H_SYNC_WIDTH                    GENMASK(15, 0)
+
+#define DP_VIDEO_CONFIG4                     0x0220
+#define  DP_V_FRONT_PORCH                   GENMASK(31, 16)
+#define  DP_V_SYNC_WIDTH                    GENMASK(15, 0)
+
+#define DP_VIDEO_MSA1                        0x0224
+#define  DP_HSTART                          GENMASK(31, 16)
+#define  DP_VSTART                          GENMASK(15, 0)
+
+#define DP_VIDEO_MSA2                        0x0228
+#define  DP_MISC0                           GENMASK(7, 0)
+
+#define DP_VIDEO_MSA3                        0x022c
+#define  DP_NVID                            GENMASK(31, 8)
+#define  DP_MISC1                           GENMASK(7, 0)
+
+#define DP_VIDEO_HBLANK_INTERVAL             0x0230
+#define  DP_HBLANK_INTERVAL                 GENMASK(31, 16)
+
+#define DP_VIDEO_COLORBAR_CFG                0x0238
+#define  DP_VID_BIST_EN                     BIT(0)
+
+#define DP_AUDIO_CONFIG1                     0x0300
+#define  DP_AUDIO_INF_SELECT                BIT(31)
+#define  DP_AUDIO_MUTE                      BIT(30)
+#define  DP_HBR_MODE_ENABLE                 BIT(29)
+#define  DP_AUDIO_DATA_IN_EN                GENMASK(28, 25)
+#define  DP_I2S_AUDIO_MODE                  GENMASK(24, 23)
+#define  DP_AUD_ADJUST_SEL                  BIT(22)
+#define  DP_AUDIO_DATA_WIDTH                GENMASK(21, 17)
+#define  DP_AUDIO_NUM_CHANNELS              GENMASK(16, 14)
+#define  DP_AUDIO_PACKET_ID                 GENMASK(13, 6)
+#define  DP_AUDIO_TIMESTAMP_VERSION_NUM     GENMASK(5, 0)
+
+#define DP_AUX_STS_REG                       0x0400
+#define  DP_AUX_STATUS                      GENMASK(31, 24)
+#define  DP_AUX_REPLY_ERR_CODE              GENMASK(6, 4)
+
+#define DP_AUX_CMD_REG                       0x0404
+#define  DP_AUX_LENGTH                      GENMASK(27, 24)
+#define  DP_AUX_ADDR                        GENMASK(23, 4)
+#define  DP_AUX_CMD_TYPE                    GENMASK(3, 0)
+
+#define DP_AUX_START_REG                     0x0408
+#define  DP_AUX_START                       BIT(31)
+
+#define DP_AUX_DATA4_REG                     0x040c
+#define  DP_AUX_DATA4                       GENMASK(31, 0)
+
+#define DP_AUX_DATA3_REG                     0x0410
+#define  DP_AUX_DATA3                       GENMASK(31, 0)
+
+#define DP_AUX_DATA2_REG                     0x0414
+#define  DP_AUX_DATA2                       GENMASK(31, 0)
+
+#define DP_AUX_DATA1_REG                     0x0418
+#define  DP_AUX_DATA1                       GENMASK(31, 0)
+
+#define DP_SDP_HORIZONTAL_CTRL               0x0420
+#define  DP_AUD_STREAM_HORIZONTAL_EN        BIT(13)
+#define  DP_AUD_TIMESTAMP_HORIZONTAL_EN     BIT(12)
+
+#define DP_SDP_VERTICAL_CTRL                 0x0424
+#define  DP_AUD_STREAM_VERTICAL_EN          BIT(13)
+#define  DP_AUD_TIMESTAMP_VERTICAL_EN       BIT(12)
+
+#endif /* __SPACEMIT_INNO_DP_H__ */

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 13/17] MAINTAINERS: add SpacemiT K3 display driver entry
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (11 preceding siblings ...)
  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  7:40 ` 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
                   ` (3 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Cover the Saturn DPU, the Innosilicon DP/eDP controller, the DP PHY and
their bindings.

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

---
v3:
- add Guodong Xu as maintainer
- list Cody Kang with the vsit.ai address
v2:
- no change
---
 MAINTAINERS | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 93abbb315065d..7bba82e8cc810 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -26364,6 +26364,17 @@ S:	Maintained
 F:	Documentation/devicetree/bindings/sound/spacemit,k1-i2s.yaml
 F:	sound/soc/spacemit/k1_i2s.c
 
+SPACEMIT K3 DISPLAY DRIVER
+M:	Cody Kang <codykang@vsit.ai>
+M:	Guodong Xu <docular.xu@gmail.com>
+L:	dri-devel@lists.freedesktop.org
+L:	linux-riscv@lists.infradead.org
+S:	Maintained
+F:	Documentation/devicetree/bindings/display/spacemit/
+F:	Documentation/devicetree/bindings/phy/spacemit,k3-inno-dp-phy.yaml
+F:	drivers/gpu/drm/spacemit/
+F:	drivers/phy/spacemit/phy-k3-inno-dp.c
+
 SPACEMIT RESET CONTROLLER DRIVER
 M:	Guodong Xu <docular.xu@gmail.com>
 L:	linux-riscv@lists.infradead.org

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 14/17] riscv: dts: spacemit: k3: add display nodes
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (12 preceding siblings ...)
  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 ` 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
                   ` (2 subsequent siblings)
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Add the SoC-level display nodes: the two Saturn DPUs, the two DP/eDP
controllers with their PHY children.

The PHY PLLs feed back into the APMU as pixel-clock mux parents, so
list them as clock inputs of the APMU node.

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

---
v3:
- order the display nodes by unit address
- commit message: reword the sentence about the APMU node
v2:
- edp0/dp1: add port@1 with a board-completable endpoint, needed once
  the binding requires port@1 (Rob Herring, on patch 03)
---
 arch/riscv/boot/dts/spacemit/k3-display.dtsi | 166 +++++++++++++++++++++++++++
 1 file changed, 166 insertions(+)

diff --git a/arch/riscv/boot/dts/spacemit/k3-display.dtsi b/arch/riscv/boot/dts/spacemit/k3-display.dtsi
new file mode 100644
index 0000000000000..694c6d3c660f7
--- /dev/null
+++ b/arch/riscv/boot/dts/spacemit/k3-display.dtsi
@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: (GPL-2.0 OR MIT)
+/*
+ * SpacemiT K3 display subsystem (DPU0/eDP0 + DPU1/DP1) shared
+ * device-tree definitions for inclusion alongside k3.dtsi.
+ *
+ * Copyright (C) 2026 SpacemiT Co., Ltd.
+ */
+
+#include <dt-bindings/clock/spacemit,k3-clocks.h>
+#include <dt-bindings/reset/spacemit,k3-resets.h>
+#include <dt-bindings/interrupt-controller/irq.h>
+
+&soc {
+	dpu0_crtc0: dpu@c0340000 {
+		compatible = "spacemit,k3-saturn-dpu";
+		reg = <0x0 0xc0340000 0x0 0x54000>;
+		interrupts = <90 IRQ_TYPE_LEVEL_HIGH>,
+			     <89 IRQ_TYPE_LEVEL_HIGH>;
+		interrupt-names = "online", "offline";
+		clocks = <&syscon_apmu CLK_APMU_LCD_PXCLK>,
+			 <&syscon_apmu CLK_APMU_LCD_MCLK>,
+			 <&syscon_apmu CLK_APMU_DPU_ACLK>,
+			 <&syscon_apmu CLK_APMU_DSI_ESC>,
+			 <&syscon_apmu CLK_APMU_LCD_DSC>;
+		clock-names = "pxclk", "mclk", "aclk", "escclk", "dscclk";
+		resets = <&syscon_apmu RESET_APMU_LCD_MCLK>,
+			 <&syscon_apmu RESET_APMU_LCD>,
+			 <&syscon_apmu RESET_APMU_DSI_ESC>,
+			 <&syscon_apmu RESET_APMU_DPU_ACLK>,
+			 <&syscon_apmu RESET_APMU_LCD_DSCCLK>;
+		reset-names = "mclk", "lcd", "esc",
+			      "aclk", "dsc";
+		status = "disabled";
+
+		ports {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			port@0 {
+				reg = <0>;
+				dpu0_out: endpoint {
+					remote-endpoint = <&edp0_in>;
+				};
+			};
+		};
+	};
+
+	dpu1_crtc0: dpu@c0440000 {
+		compatible = "spacemit,k3-saturn-dpu";
+		reg = <0x0 0xc0440000 0x0 0x54000>;
+		interrupts = <139 IRQ_TYPE_LEVEL_HIGH>,
+			     <138 IRQ_TYPE_LEVEL_HIGH>;
+		interrupt-names = "online", "offline";
+		clocks = <&syscon_apmu CLK_APMU_DSI4LN2_LCD_PXCLK>,
+			 <&syscon_apmu CLK_APMU_DSI4LN2_LCD_MCLK>,
+			 <&syscon_apmu CLK_APMU_DSI4LN2_DPU_ACLK>,
+			 <&syscon_apmu CLK_APMU_DSI4LN2_DSI_ESC>,
+			 <&syscon_apmu CLK_APMU_DSI4LN2_LCD_DSC>;
+		clock-names = "pxclk", "mclk", "aclk", "escclk", "dscclk";
+		resets = <&syscon_apmu RESET_APMU_DSI4LN2_LCD_MCLK>,
+			 <&syscon_apmu RESET_APMU_DSI4LN2_LCD_SW>,
+			 <&syscon_apmu RESET_APMU_DSI4LN2_ESCCLK>,
+			 <&syscon_apmu RESET_APMU_DSI4LN2_DPU_ACLK>,
+			 <&syscon_apmu RESET_APMU_DSI4LN2_LCD_DSCCLK>;
+		reset-names = "mclk", "lcd", "esc",
+			      "aclk", "dsc";
+		status = "disabled";
+
+		ports {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			port@0 {
+				reg = <0>;
+				dpu1_out: endpoint {
+					remote-endpoint = <&dp1_in>;
+				};
+			};
+		};
+	};
+
+	edp0: edp@cac84000 {
+		compatible = "spacemit,k3-inno-dp";
+		reg = <0x0 0xcac84000 0x0 0x4000>;
+		interrupts = <132 IRQ_TYPE_LEVEL_HIGH>;
+		clocks = <&syscon_apmu CLK_APMU_EDP0_PXCLK>, <&edp0_phy>;
+		clock-names = "pxclk", "pll";
+		resets = <&syscon_apmu RESET_APMU_EDP0>;
+		phys = <&edp0_phy>;
+		phy-names = "dp";
+		status = "disabled";
+
+		edp0_phy: phy {
+			compatible = "spacemit,k3-inno-dp-phy";
+			#phy-cells = <0>;
+			#clock-cells = <0>;
+			clock-output-names = "edp0_pll_pxclk";
+		};
+
+		ports {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			port@0 {
+				reg = <0>;
+				edp0_in: endpoint {
+					remote-endpoint = <&dpu0_out>;
+				};
+			};
+
+			port@1 {
+				reg = <1>;
+				edp0_out: endpoint {
+				};
+			};
+		};
+	};
+
+	dp1: dp@cac88000 {
+		compatible = "spacemit,k3-inno-dp";
+		reg = <0x0 0xcac88000 0x0 0x4000>;
+		interrupts = <140 IRQ_TYPE_LEVEL_HIGH>;
+		clocks = <&syscon_apmu CLK_APMU_EDP1_PXCLK>, <&dp1_phy>;
+		clock-names = "pxclk", "pll";
+		resets = <&syscon_apmu RESET_APMU_EDP1>;
+		phys = <&dp1_phy>;
+		phy-names = "dp";
+		status = "disabled";
+
+		dp1_phy: phy {
+			compatible = "spacemit,k3-inno-dp-phy";
+			#phy-cells = <0>;
+			#clock-cells = <0>;
+			clock-output-names = "edp1_pll_pxclk";
+		};
+
+		ports {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			port@0 {
+				reg = <0>;
+				dp1_in: endpoint {
+					remote-endpoint = <&dpu1_out>;
+				};
+			};
+
+			port@1 {
+				reg = <1>;
+				dp1_out: endpoint {
+				};
+			};
+		};
+	};
+};
+
+/*
+ * Feed the PHY PLL pixel clocks back in as the APMU mux parents. This lives
+ * here, not in k3.dtsi: the PHYs only exist where this file is included.
+ */
+&syscon_apmu {
+	clocks = <&osc_32k>, <&vctcxo_1m>, <&vctcxo_3m>, <&vctcxo_24m>,
+		 <&edp0_phy>, <&dp1_phy>;
+	clock-names = "osc", "vctcxo_1m", "vctcxo_3m", "vctcxo_24m",
+		      "edp0_pll_pxclk", "edp1_pll_pxclk";
+};

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 15/17] riscv: dts: spacemit: k3-pico-itx: enable the DisplayPort output
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (13 preceding siblings ...)
  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 ` 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
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Pico-ITX brings the second DPU's output to a USB Type-C receptacle,
as DisplayPort alternate mode. The mux and the PD controller in
front of the receptacle are run by the on-board EC and the SoC only
gets the HPD line back, so there is no connector node to link the
output to. Enable that DPU and the DisplayPort controller it feeds.

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

---
v3:
- commit message: the output is the Type-C receptacle's DP alternate
  mode, not a DisplayPort connector (Icenowy Zheng)
v2:
- no change
---
 arch/riscv/boot/dts/spacemit/k3-pico-itx.dts | 11 +++++++++++
 arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi | 11 +++++++++++
 2 files changed, 22 insertions(+)

diff --git a/arch/riscv/boot/dts/spacemit/k3-pico-itx.dts b/arch/riscv/boot/dts/spacemit/k3-pico-itx.dts
index dda420900aa2c..da042d7c30328 100644
--- a/arch/riscv/boot/dts/spacemit/k3-pico-itx.dts
+++ b/arch/riscv/boot/dts/spacemit/k3-pico-itx.dts
@@ -6,6 +6,7 @@
 #include <dt-bindings/gpio/gpio.h>
 
 #include "k3.dtsi"
+#include "k3-display.dtsi"
 #include "k3-pinctrl.dtsi"
 
 / {
@@ -368,3 +369,13 @@ &usb3d {
 	phy-names = "usb2-phy", "usb3-phy";
 	status = "okay";
 };
+
+&dpu1_crtc0 {
+	status = "okay";
+};
+
+&dp1 {
+	pinctrl-names = "default";
+	pinctrl-0 = <&dp1_1_cfg>;
+	status = "okay";
+};
diff --git a/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi b/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi
index cb4f4f4e33aff..a3188ca0ceb36 100644
--- a/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi
+++ b/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi
@@ -11,6 +11,17 @@
 #define K3_GPIO(x)	(x / 32) (x % 32)
 
 &pinctrl {
+	/omit-if-no-ref/
+	dp1_1_cfg: dp1-1-cfg {
+		dp1-pins {
+			pinmux = <K3_PADCONF(24, 6)>;	/* dp1 hpd */
+
+			bias-disable;
+			drive-strength = <25>;
+			power-source = <3300>;
+		};
+	};
+
 	gmac0_rgmii_0_cfg: gmac0-rgmii-0-cfg {
 		gmac0-rgmii-0-pins {
 			pinmux = <K3_PADCONF(0, 1)>,	/* gmac0_rxdv */

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 16/17] riscv: dts: spacemit: k3-com260-ifx: enable the DisplayPort output
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (14 preceding siblings ...)
  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 ` 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
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

CoM260-IFX carries a single DisplayPort output. Enable the second DPU
and the DisplayPort controller it feeds.

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

---
v3:
- describe the HPD pad at the 1.8 V it runs at
- commit message: reworded
v2:
- describe the DP receptacle (dp-connector) and link it to dp1 port@1
  (Rob Herring, on patch 03)
---
 arch/riscv/boot/dts/spacemit/k3-com260-ifx.dts | 27 ++++++++++++++++++++++++++
 arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi   | 11 +++++++++++
 2 files changed, 38 insertions(+)

diff --git a/arch/riscv/boot/dts/spacemit/k3-com260-ifx.dts b/arch/riscv/boot/dts/spacemit/k3-com260-ifx.dts
index fadcf28389be9..321715d455865 100644
--- a/arch/riscv/boot/dts/spacemit/k3-com260-ifx.dts
+++ b/arch/riscv/boot/dts/spacemit/k3-com260-ifx.dts
@@ -6,6 +6,7 @@
 #include <dt-bindings/phy/phy.h>
 
 #include "k3-com260.dtsi"
+#include "k3-display.dtsi"
 
 / {
 	model = "SpacemiT K3 CoM260 IFX";
@@ -20,6 +21,18 @@ chosen {
 		stdout-path = "serial0:115200n8";
 	};
 
+	connector {
+		compatible = "dp-connector";
+		label = "DP1";
+		type = "full-size";
+
+		port {
+			dp1_connector_in: endpoint {
+				remote-endpoint = <&dp1_out>;
+			};
+		};
+	};
+
 	reg_hub_5v: regulator-usb3-hub-5v {
 		compatible = "regulator-fixed";
 		regulator-name = "USB30_HUB";
@@ -129,3 +142,17 @@ &sdhci0 {
 	sd-uhs-sdr104;
 	status = "okay";
 };
+
+&dpu1_crtc0 {
+	status = "okay";
+};
+
+&dp1 {
+	pinctrl-names = "default";
+	pinctrl-0 = <&dp1_3_cfg>;
+	status = "okay";
+};
+
+&dp1_out {
+	remote-endpoint = <&dp1_connector_in>;
+};
diff --git a/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi b/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi
index a3188ca0ceb36..ea88ec95b9136 100644
--- a/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi
+++ b/arch/riscv/boot/dts/spacemit/k3-pinctrl.dtsi
@@ -22,6 +22,17 @@ dp1-pins {
 		};
 	};
 
+	/omit-if-no-ref/
+	dp1_3_cfg: dp1-3-cfg {
+		dp1-pins {
+			pinmux = <K3_PADCONF(72, 4)>;	/* dp1 hpd */
+
+			bias-disable;
+			drive-strength = <25>;
+			power-source = <1800>;
+		};
+	};
+
 	gmac0_rgmii_0_cfg: gmac0-rgmii-0-cfg {
 		gmac0-rgmii-0-pins {
 			pinmux = <K3_PADCONF(0, 1)>,	/* gmac0_rxdv */

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* [PATCH v3 17/17] riscv: defconfig: spacemit: k3: enable display driver
  2026-11-21  7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
                   ` (15 preceding siblings ...)
  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 ` Cody Kang via B4 Relay
  16 siblings, 0 replies; 23+ messages in thread
From: Cody Kang via B4 Relay @ 2026-11-21  7:40 UTC (permalink / raw)
  To: David Airlie, Simona Vetter, Maarten Lankhorst, Maxime Ripard,
	Thomas Zimmermann, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
	Yixun Lan, Troy Mitchell, Vinod Koul, Neil Armstrong,
	Manivannan Sadhasivam, Haylen Chu, Michael Turquette,
	Stephen Boyd, Brian Masney, Philipp Zabel, Paul Walmsley,
	Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Yao Zi,
	Uwe Kleine-König, Guodong Xu, Icenowy Zheng, Jerome Brunet,
	Sarah Emery, Ze Huang, Dmitry Baryshkov
  Cc: Cody Kang, dri-devel, linux-riscv, devicetree, spacemit,
	linux-kernel, linux-phy, linux-clk

From: Cody Kang <codykang@vsit.ai>

Enable the Saturn DPU and the DP/eDP controller as modules, matching the
other DRM drivers in this defconfig; the DP PHY follows through the
controller's imply.

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

---
v3:
- no change
v2:
- no change
---
 arch/riscv/configs/defconfig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/arch/riscv/configs/defconfig b/arch/riscv/configs/defconfig
index 04ae305d5511b..7db411d385582 100644
--- a/arch/riscv/configs/defconfig
+++ b/arch/riscv/configs/defconfig
@@ -194,6 +194,8 @@ CONFIG_VIDEO_CADENCE_CSI2RX=m
 CONFIG_DRM=m
 CONFIG_DRM_RADEON=m
 CONFIG_DRM_NOUVEAU=m
+CONFIG_DRM_SPACEMIT=m
+CONFIG_SPACEMIT_INNO_DP=m
 CONFIG_DRM_SUN4I=m
 CONFIG_DRM_VIRTIO_GPU=m
 CONFIG_FB=y

-- 
2.43.0



^ permalink raw reply related	[flat|nested] 23+ messages in thread

* Re: [PATCH v3 01/17] dt-bindings: display: spacemit: add K3 Saturn DPU controller
  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
  0 siblings, 0 replies; 23+ messages in thread
From: sashiko-bot @ 2026-11-21  7:44 UTC (permalink / raw)
  To: Cody Kang
  Cc: dri-devel, devicetree, linux-phy, linux-clk, robh, conor+dt,
	vkoul, neil.armstrong, olteanv

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Low] dt-bindings: display: spacemit: interrupts ordered before clocks
  in K3 DPU
--

commit 5cacd6c3de4c42a0a1e84fc0f0f6938c6990b78e
Author: Cody Kang <codykang@vsit.ai>

dt-bindings: display: spacemit: add K3 Saturn DPU controller

This commit adds the Device Tree binding schema for the Saturn display
processing unit found on the SpacemiT K3 SoC.

> diff --git a/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-saturn-dpu.yaml b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-saturn-dpu.yaml
> new file mode 100644
> index 0000000000000..97ea9da4b68e4
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-saturn-dpu.yaml
> @@ -0,0 +1,132 @@

[ ... ]

> +properties:
> +  compatible:
> +    const: spacemit,k3-saturn-dpu
> +
> +  reg:
> +    maxItems: 1
> +
> +  interrupts:
> +    items:
> +      - description: Online (live display) compose path.
> +      - description: Offline (writeback) compose path.
> +
> +  interrupt-names:
> +    items:
> +      - const: online
> +      - const: offline
> +
> +  clocks:
> +    items:
> +      - description: Pixel clock.
> +      - description: Memory clock for the compose pipeline.
> +      - description: AXI bus clock.
> +      - description: DSI escape clock.
> +      - description: DSC clock.
> +
> +  clock-names:
> +    items:
> +      - const: pxclk
> +      - const: mclk
> +      - const: aclk
> +      - const: escclk
> +      - const: dscclk

[ ... ]

> +required:
> +  - compatible
> +  - reg
> +  - interrupts
> +  - interrupt-names
> +  - clocks
> +  - clock-names
> +  - resets
> +  - reset-names
> +  - ports

[ ... ]

> +        dpu@c0340000 {
> +            compatible = "spacemit,k3-saturn-dpu";
> +            reg = <0x0 0xc0340000 0x0 0x54000>;
> +            interrupts = <90 IRQ_TYPE_LEVEL_HIGH>,
> +                         <89 IRQ_TYPE_LEVEL_HIGH>;
> +            interrupt-names = "online", "offline";
> +            clocks = <&syscon_apmu CLK_APMU_LCD_PXCLK>,
> +                     <&syscon_apmu CLK_APMU_LCD_MCLK>,
> +                     <&syscon_apmu CLK_APMU_DPU_ACLK>,
> +                     <&syscon_apmu CLK_APMU_DSI_ESC>,
> +                     <&syscon_apmu CLK_APMU_LCD_DSC>;
> +            clock-names = "pxclk", "mclk", "aclk", "escclk", "dscclk";

[Severity: Low]
This isn't a bug, but in Device Tree binding schemas, clocks and clock-names
should be listed before interrupts and interrupt-names in the properties,
required, and examples sections to follow the canonical property order
(compatible, reg, clocks, clock-names, interrupts, interrupt-names).

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261121-k3-display-v3-0-ec419e8e96b8@gmail.com?part=1

^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: [PATCH v3 03/17] dt-bindings: display: spacemit: add K3 Innosilicon DP/eDP controller
  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
  0 siblings, 0 replies; 23+ messages in thread
From: sashiko-bot @ 2026-11-21  7:45 UTC (permalink / raw)
  To: Cody Kang
  Cc: dri-devel, devicetree, linux-phy, linux-clk, robh, conor+dt,
	vkoul, neil.armstrong, olteanv

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Low] dt-bindings: display: spacemit: interrupts listed before clocks
  in k3-inno-dp
--

commit ec123ddd0dcb86d2168d07ef0954ffae1dd9d9aa
Author: Cody Kang <codykang@vsit.ai>

dt-bindings: display: spacemit: add K3 Innosilicon DP/eDP controller

This commit adds the Device Tree binding schema for the SpacemiT K3
Innosilicon DisplayPort and embedded DisplayPort controller.

> diff --git a/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-inno-dp.yaml b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-inno-dp.yaml
> new file mode 100644
> index 0000000000000..491d25730da9f
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/display/spacemit/spacemit,k3-inno-dp.yaml
> @@ -0,0 +1,141 @@

[ ... ]

> +properties:
> +  compatible:
> +    const: spacemit,k3-inno-dp
> +
> +  reg:
> +    maxItems: 1
> +
> +  interrupts:
> +    maxItems: 1
> +    description: Link and hot-plug events.
> +
> +  clocks:
> +    items:
> +      - description: Pixel clock for the controller.
> +      - description:
> +          Pixel clock generated by the DP PHY PLL; the pixel clock above is
> +          parented onto it in use.
> +
> +  clock-names:
> +    items:
> +      - const: pxclk
> +      - const: pll

[ ... ]

> +required:
> +  - compatible
> +  - reg
> +  - interrupts
> +  - clocks
> +  - clock-names

[ ... ]

> +        edp@cac84000 {
> +            compatible = "spacemit,k3-inno-dp";
> +            reg = <0x0 0xcac84000 0x0 0x4000>;
> +            interrupts = <132 IRQ_TYPE_LEVEL_HIGH>;
> +            clocks = <&syscon_apmu CLK_APMU_EDP0_PXCLK>, <&edp0_phy>;
> +            clock-names = "pxclk", "pll";

[Severity: Low]
This isn't a bug, but DT binding schemas and example nodes follow the
canonical property ordering where clocks and clock-names appear before
interrupts.  Could interrupts be moved after clock-names in properties,
required, and the edp@cac84000 example node?

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261121-k3-display-v3-0-ec419e8e96b8@gmail.com?part=3

^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend
  2026-11-21  7:40 ` [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend Cody Kang via B4 Relay
@ 2026-11-21  8:01   ` sashiko-bot
  0 siblings, 0 replies; 23+ messages in thread
From: sashiko-bot @ 2026-11-21  8:01 UTC (permalink / raw)
  To: Cody Kang
  Cc: dri-devel, devicetree, linux-phy, linux-clk, robh, conor+dt,
	vkoul, neil.armstrong, olteanv

Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] drm/spacemit: vfp underflow in saturn_init_tmg() when front
  porch < 7
- [High] drm/spacemit: unmasked IRQ dispatch and premature vblank event
  in ISR
- [Medium] drm/spacemit: stale underrun IRQ and ur_mask_armed race on
  CFG_RDY
- [Medium] drm/spacemit: race on cfg_rdy_timer and INT_CFG_RDY in
  spacemit_dpu_run()
--

commit feb91f776850387e06b93738a2a9ed3971674069
Author: Cody Kang <codykang@vsit.ai>

drm/spacemit: add Saturn DPU hardware backend

This commit adds the Saturn DPU hardware backend, covering clock setup,
scene control and timing generator programming, RDMA channel and composer
configuration, line-buffer sizing, and interrupt handling.

> 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 @@

[ ... ]

> +/* 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);
> +}

[ ... ]

> +/* 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;
> +}

[Severity: High]
Can spacemit_dpu_online_isr() complete a commit's vblank event a frame
early when INT_CFG_RDY and INT_VSYNC are both set in irq_raw?

As noted in saturn_hee_irq_enable() and spacemit_dpu_run(),
DPU_ONLINE_IRQ_STS latches status bits even while their mask bits in
DPU_ONLINE_IRQ_MSK are cleared, yet saturn_hee_enable_irq() unmasks
interrupts without clearing DPU_ONLINE_IRQ_STS first and
spacemit_dpu_online_isr() does not mask irq_raw against
DPU_ONLINE_IRQ_MSK.  When INT_CFG_RDY fires while INT_VSYNC is also set
(either from a frame boundary or latched while vblank was masked), the
INT_CFG_RDY branch calls drm_crtc_arm_vblank_event() and the following
INT_VSYNC branch immediately calls drm_crtc_handle_vblank() in the same
ISR invocation.  That delivers the flip event before the next vblank and
unblocks drm_atomic_helper_wait_for_flip_done() early, allowing the next
commit to overwrite the active command list slot.

> +
> +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);
> +	}
> +}

[Severity: Medium]
Can spacemit_cfg_rdy_timer_handler() race with spacemit_dpu_online_isr()
and spacemit_dpu_run() to complete the next commit's vblank event early or
leave INT_CFG_RDY masked?

CPU0 (<softirq>)                  CPU1
spacemit_cfg_rdy_timer_handler()
  drm_err_ratelimited(...)
                                  <hardirq>
                                  spacemit_dpu_online_isr()
                                    timer_delete(&a_crtc->cfg_rdy_timer)
                                    drm_crtc_arm_vblank_event(...)
                                    drm_crtc_handle_vblank(...)
                                  spacemit_crtc_atomic_flush()
                                    a_crtc->event = new_event
                                    spacemit_dpu_run()
                                      saturn_hee_enable_irq(..., true)
  saturn_hee_enable_irq(..., false)
  spacemit_dpu_complete_event()
    drm_crtc_send_vblank_event()  <-- completes new commit early

timer_delete() in spacemit_dpu_online_isr() does not wait for an in-flight
spacemit_cfg_rdy_timer_handler(), so the timer callback can mask the next
commit's INT_CFG_RDY and complete its a_crtc->event before the hardware
consumes its command lists.

In addition, spacemit_dpu_run() unmasks INT_CFG_RDY before mod_timer() and
saturn_hee_cfg_ready().  If a late CFG_RDY from a previously timed-out
commit arrives right after saturn_hee_enable_irq(a_crtc, INT_CFG_RDY,
true), spacemit_dpu_online_isr() runs timer_delete() before the timer is
armed, masks INT_CFG_RDY, and arms a_crtc->event before both_cfg_rdy is
written for the new commit.

> 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 @@

[ ... ]

> +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);
> +}

[Severity: Medium]
Does enabling INT_UNDERRUN in saturn_hee_cfg_ready() before setting
a_crtc->ur_mask_armed and without clearing DPU_ONLINE_IRQ_STS race with
spacemit_dpu_online_isr()?

saturn_hee_cfg_ready()
  saturn_hee_enable_irq(a_crtc, INT_UNDERRUN, true)
  <hardirq>
    spacemit_dpu_online_isr()
      saturn_hee_clr_int_sts(a_crtc, ...)
        if (... && a_crtc->ur_mask_armed)  <-- still false; stays unmasked
  a_crtc->ur_mask_armed = true

After an underrun, INT_UNDERRUN is masked for the rest of the frame while
the hardware continues latching DPU_INT_FRM_TIMING_UNFLOW in
DPU_ONLINE_IRQ_STS.  When the next commit calls saturn_hee_cfg_ready(),
unmasking INT_UNDERRUN without clearing DPU_ONLINE_IRQ_STS immediately
triggers spacemit_dpu_online_isr().  If the interrupt arrives before
a_crtc->ur_mask_armed = true (which also happens in
saturn_hee_irq_enable()), saturn_hee_clr_int_sts() sees ur_mask_armed ==
false and leaves INT_UNDERRUN unmasked; if it arrives after
ur_mask_armed = true but before INT_CFG_RDY clears ur_reported, the bottom
saturn_hee_clr_int_sts() call in spacemit_dpu_online_isr() immediately
masks INT_UNDERRUN again before the new commit takes effect.

> +
> +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));

[Severity: High]
Does vfp - 7 and vfp - 6 underflow when the display mode's vertical front
porch is smaller than 7 lines?

Standard modes such as 1920x1080@60Hz (vdisplay = 1080, vsync_start =
1084, so vfp = 4) have vfp < 7, which wraps the 16-bit eof_1st_ln_dly_num
and eof_2nd_ln_dly_num fields to 0xfff9..0xffff, exceeding vtotal so the
EOF line-delay counters cannot fire within the frame.  Also, the raw
readl()/writel() sequence at the end of saturn_init_tmg() redundantly
rewrites the same vfp field that dpu_write(hwdev, TMG_REG, base, vfp, vfp)
just programmed above.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261121-k3-display-v3-0-ec419e8e96b8@gmail.com?part=9

^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: [PATCH v3 10/17] drm/spacemit: add Saturn DPU KMS pipeline
  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
  0 siblings, 0 replies; 23+ messages in thread
From: sashiko-bot @ 2026-11-21  8:06 UTC (permalink / raw)
  To: Cody Kang
  Cc: dri-devel, devicetree, linux-phy, linux-clk, robh, conor+dt,
	vkoul, neil.armstrong, olteanv

Thank you for your contribution! Sashiko AI review found 6 potential
issues to consider:
- [High] drm/spacemit: premature event send in
  spacemit_crtc_atomic_disable()
- [High] drm/spacemit: premature event arming in
  spacemit_crtc_atomic_flush() and ISR
- [High] drm/spacemit: stale INT_VSYNC not cleared in
  spacemit_crtc_enable_vblank()
- [Medium] drm/spacemit: unbind before poll_fini in
  spacemit_drm_master_bind()
- [Medium] drm/spacemit: composer dst_w and dst_h left at 0 when no
  plane is visible
- [Medium] drm/spacemit: vblank not reset due to drm_vblank_init()
  ordering
--

commit c4c8906d170c5bfb4e5c852ca468ddf4805b4d47
Author: Cody Kang <codykang@vsit.ai>

drm/spacemit: add Saturn DPU KMS pipeline

This commit adds the atomic KMS CRTC and primary plane implementation,
runtime PM hooks, and component master bind/unbind logic for the Saturn
DPU.

> diff --git a/drivers/gpu/drm/spacemit/spacemit_crtc.c b/drivers/gpu/drm/spacemit/spacemit_crtc.c
> new file mode 100644
> index 0000000000000..c1257444dd150
> --- /dev/null
> +++ b/drivers/gpu/drm/spacemit/spacemit_crtc.c
> @@ -0,0 +1,589 @@

[ ... ]

> +static void spacemit_crtc_atomic_disable(struct drm_crtc *crtc,
> +					 struct drm_atomic_commit *state)
> +{
> +	struct drm_crtc_state *crtc_state =
> +			drm_atomic_get_new_crtc_state(state, crtc);
> +	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
> +	struct drm_device *drm = a_crtc->crtc.dev;
> +	struct spacemit_drm_private *priv = drm->dev_private;
> +	int idx;
> +
> +	if (drm_dev_enter(drm, &idx)) {
> +		spacemit_dpu_uninit(a_crtc);
> +		drm_dev_exit(idx);
> +	}
> +
> +	drm_crtc_vblank_off(&a_crtc->crtc);
> +
> +	/* A commit may still be waiting for CFG_RDY: stop its watchdog. */
> +	timer_delete_sync(&a_crtc->cfg_rdy_timer);
> +
> +	pm_runtime_put_sync(priv->dev);
> +
> +	/* No further vblank will come; complete the disable event here. */
> +	spacemit_dpu_complete_event(a_crtc);
> +	spin_lock_irq(&drm->event_lock);
> +	if (crtc_state->event) {
> +		drm_crtc_send_vblank_event(crtc, crtc_state->event);
> +		crtc_state->event = NULL;
> +	}
> +	spin_unlock_irq(&drm->event_lock);
> +}

[Severity: High]
Does sending crtc_state->event without checking !crtc_state->active
complete the vblank event prematurely during an active-to-active modeset?

When changing modes on an active CRTC, drm_atomic_helper_commit_modeset_disables()
calls spacemit_crtc_atomic_disable() before spacemit_crtc_atomic_enable()
and spacemit_crtc_atomic_flush() run.  Consuming crtc_state->event here
delivers the event and signals commit->flip_done before the new mode is
programmed, allowing a subsequent non-blocking commit to overwrite the
2-slot command-list ring before the engine takes the modeset lists.

[ ... ]

> +static void spacemit_crtc_atomic_flush(struct drm_crtc *crtc,
> +				       struct drm_atomic_commit *state)
> +{
> +	struct drm_crtc_state *crtc_state =
> +			drm_atomic_get_new_crtc_state(state, crtc);
> +	struct spacemit_crtc *a_crtc = to_spacemit_crtc(crtc);
> +	struct spacemit_drm_private *priv = crtc->dev->dev_private;
> +	int idx;
> +
> +	/*
> +	 * The event releases the next commit, which rewrites the other
> +	 * command list and points the engine at it. Hold the event until
> +	 * CFG_RDY says the engine has taken this commit's lists; the
> +	 * interrupt then arms it for the following vblank.
> +	 */
> +	spin_lock_irq(&crtc->dev->event_lock);
> +	if (crtc_state->event) {
> +		if (drm_crtc_vblank_get(crtc) == 0)
> +			a_crtc->event = crtc_state->event;
> +		else
> +			drm_crtc_send_vblank_event(crtc, crtc_state->event);
> +		crtc_state->event = NULL;
> +	}
> +	spin_unlock_irq(&crtc->dev->event_lock);
> +
> +	/* clocks_on is false here only after a failed power-up. */
> +	if (priv->clocks_on && drm_dev_enter(crtc->dev, &idx)) {
> +		spacemit_dpu_run(crtc, state);
> +		drm_dev_exit(idx);
> +	} else {
> +		spacemit_dpu_complete_event(a_crtc);
> +	}
> +}

[Severity: High]
Can a_crtc->event be armed and delivered before the hardware takes the new
command lists?

spacemit_crtc_atomic_flush()
  spin_lock_irq(&crtc->dev->event_lock)
  drm_crtc_vblank_get(crtc)
  a_crtc->event = crtc_state->event
  spin_unlock_irq(&crtc->dev->event_lock)
  <hardirq>
    spacemit_dpu_online_isr()
      if (irq_raw & INT_CFG_RDY)
        drm_crtc_arm_vblank_event(..., a_crtc->event)  <-- armed early
      if (irq_raw & INT_VSYNC)
        drm_crtc_handle_vblank(...)                    <-- sent early
  spacemit_dpu_run()
    saturn_hee_conf_dpuctrl()
    saturn_hee_clr_int_sts(..., INT_CFG_RDY)
    saturn_hee_cfg_ready()

spacemit_dpu_online_isr() inspects the unmasked DPU_ONLINE_IRQ_STS
register.  If an enabled interrupt (such as INT_VSYNC) fires after
event_lock is dropped and before spacemit_dpu_run() clears a leftover
INT_CFG_RDY status bit and raises both_cfg_rdy, the ISR sees INT_CFG_RDY
and arms a_crtc->event before the CRTC command list is even submitted.

In addition, because spacemit_dpu_online_isr() handles INT_CFG_RDY before
INT_VSYNC and there is no get_vblank_counter hook, when both bits are set
in irq_raw, drm_crtc_arm_vblank_event() arms the event for vblank->count + 1
and the immediately following drm_crtc_handle_vblank() increments
vblank->count and delivers it in the same interrupt instead of at the next
vblank, releasing flip_done while the command list is still in use.

> +
> +static int spacemit_crtc_enable_vblank(struct drm_crtc *crtc)
> +{
> +	saturn_hee_enable_irq(to_spacemit_crtc(crtc), INT_VSYNC, true);
> +
> +	return 0;
> +}

[Severity: High]
Does unmasking INT_VSYNC without clearing DPU_ONLINE_IRQ_STS first fire a
spurious mid-frame vblank interrupt?

As noted in saturn_hee_irq_enable(), DPU_ONLINE_IRQ_STS latches status
bits while masked and fires as soon as the mask opens, but
saturn_hee_irq_enable() only clears INT_UNDERRUN | INT_CFG_RDY:

drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c:saturn_hee_irq_enable() {
	mask = saturn_hee_get_irq_bit(INT_UNDERRUN) |
	       saturn_hee_get_irq_bit(INT_CFG_RDY);
	if (enable) {
		...
		regmap_write(priv->hwdev->regmap,
			     DPU_INT_BASE_ADDR + DPU_ONLINE_IRQ_STS, mask);
	}
}

Whenever vblank has been disabled while the CRTC is running, the next
frame latches INT_VSYNC in DPU_ONLINE_IRQ_STS.  Re-enabling vblank then
immediately raises an interrupt mid-frame, incrementing the software
vblank counter with a mid-frame timestamp or completing an event armed by
INT_CFG_RDY in the same ISR call before the actual vblank.

[ ... ]

> +	drm_mode_config_reset(drm);
> +
> +	ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
> +	if (ret) {
> +		dev_err_probe(dev, ret, "failed to initialize vblank\n");
> +		goto err_unbind_all;
> +	}
> +
> +	drmm_kms_helper_poll_init(drm);
> +	drm_helper_hpd_irq_event(drm);
> +
> +	enable_irq(priv->irq_online);
> +
> +	ret = drm_dev_register(drm, 0);
> +	if (ret < 0)
> +		goto err_disable_irq;
> +	drm_client_setup(drm, NULL);
> +
> +	return 0;
> +
> +err_disable_irq:
> +	disable_irq(priv->irq_online);
> +
> +err_unbind_all:
> +	component_unbind_all(dev, drm);
> +err_dc:
> +	/*
> +	 * .shutdown tests priv->ddev; never leave it on a half-initialised
> +	 * device.
> +	 */
> +	priv->ddev = NULL;
> +	priv->a_crtc = NULL;
> +	drm_dev_put(drm);
> +	return ret;
> +}

[Severity: Medium]
Does calling drm_mode_config_reset() before drm_vblank_init() leave
vblank->inmodeset unset while the CRTC is initially disabled?

drm_mode_config_crtc_create_state() only calls drm_crtc_vblank_reset()
when drm_dev_has_vblank() is true, which requires dev->num_crtcs to have
been set by drm_vblank_init().  With the current order, drm_vblank_get()
on the disabled CRTC succeeds instead of returning -EINVAL and enables
vblank while the DPU is powered off.  Calling drm_vblank_init() before
drm_mode_config_reset() avoids this.

[Severity: Medium]
If drm_dev_register() fails, does err_disable_irq unbind the components
while output polling is still active?

drmm_kms_helper_poll_init() and drm_helper_hpd_irq_event() start output
polling before drm_dev_register(), but the error path runs
component_unbind_all() before drm_dev_put() invokes the drmm poll release
action, unlike spacemit_drm_master_unbind() which calls
drm_kms_helper_poll_fini() before component_unbind_all().

[ ... ]

> diff --git a/drivers/gpu/drm/spacemit/spacemit_planes.c b/drivers/gpu/drm/spacemit/spacemit_planes.c
> new file mode 100644
> index 0000000000000..c49a2e1572771
> --- /dev/null
> +++ b/drivers/gpu/drm/spacemit/spacemit_planes.c
> @@ -0,0 +1,332 @@

[ ... ]

> +static void spacemit_plane_atomic_update(struct drm_plane *plane,
> +					 struct drm_atomic_commit *state)
> +{
> +	struct drm_plane_state *new_state =
> +			drm_atomic_get_new_plane_state(state, plane);
> +	struct drm_crtc_state *crtc_state =
> +			drm_atomic_get_new_crtc_state(state, new_state->crtc);
> +	struct spacemit_drm_private *priv = plane->dev->dev_private;
> +	int idx;
> +
> +	if (priv->clocks_on && drm_dev_enter(plane->dev, &idx)) {
> +		/* A plane moved off the screen has no rectangle to program. */
> +		if (new_state->visible)
> +			spacemit_plane_program(plane, new_state,
> +					       &crtc_state->adjusted_mode);
> +		else
> +			spacemit_plane_off(plane, new_state->crtc);
> +		drm_dev_exit(idx);
> +	}
> +}

[Severity: Medium]
When a CRTC is enabled with no visible plane (disabled or clipped
off-screen), do the composer output dimensions CMPS_X_REG dst_w and dst_h
remain at 0?

saturn_init_regs() enables CMPS_X_REG (module_enable = 1) and
saturn_hee_conf_dpuctrl() sets POSTPIPE_REG m_inwidth and m_inheight to
mode->hdisplay and mode->vdisplay, but CMPS_X_REG dst_w and dst_h are only
written in saturn_hee_plane_update_hw_channel():

drivers/gpu/drm/spacemit/dpu/dpu_saturn_hee.c:saturn_hee_plane_update_hw_channel() {
	...
	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);
	...
}

Skipping spacemit_plane_program() when new_state->visible is false leaves
the composer configured for a 0x0 output feeding a full-mode postpipe and
timing generator, causing a pipeline dimension mismatch and display
underrun.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261121-k3-display-v3-0-ec419e8e96b8@gmail.com?part=10

^ permalink raw reply	[flat|nested] 23+ messages in thread

* Re: [PATCH v3 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver
  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
  0 siblings, 0 replies; 23+ messages in thread
From: sashiko-bot @ 2026-11-21  8:08 UTC (permalink / raw)
  To: Cody Kang
  Cc: dri-devel, devicetree, linux-phy, linux-clk, robh, conor+dt,
	vkoul, neil.armstrong, olteanv

Thank you for your contribution! Sashiko AI review found 13 potential
issues to consider:
- [High] drm/spacemit: missing pre-emphasis shift in
  spacemit_dp_link_apply_adjust()
- [High] drm/spacemit: reset in spacemit_dp_dev_init() desyncs cached
  PREPLL clk rate
- [Medium] drm/spacemit: broken HPD IRQ notify in
  spacemit_dp_hotplug_event_handler()
- [Medium] drm/spacemit: fallback caps in
  spacemit_dp_hw_read_sink_caps() block retry
- [Medium] drm/spacemit: missing hw disable in spacemit_dp_unregister()
  and bind()
- [Medium] drm/spacemit: missing spacemit_dp_hw_disable() on bind init
  failure
- [Medium] drm/spacemit: pixel clock truncation to MHz in TU and HBLANK
  calculation
- [Medium] drm/spacemit: unacknowledged level-high HPD IRQ in
  spacemit_dp_irq_handler()
- [Medium] drm/spacemit: unlocked dp->link and dp->dpcd reads in
  mode_valid and check
- [Medium] drm/spacemit: AUX registered before init and MPLL reset
  without hw_mutex
- [Medium] drm/spacemit: pixel PLL left powered down on untrained link
  in atomic_enable
- [Medium] drm/spacemit: nested AUX retries and fallback in
  spacemit_dp_aux_transfer()
- [Medium] drm/spacemit: spacemit_dp_remove() runs before devm AUX bus
  depopulation
--

commit a1a5915e82d2de32d9e2fe7095172a35686df3b2
Author: Cody Kang <codykang@vsit.ai>

drm/spacemit: add Innosilicon DP/eDP controller bridge driver

This commit adds the DRM bridge driver for the Innosilicon DisplayPort and
embedded DisplayPort controller downstream of the SpacemiT Saturn DPU.

> diff --git a/drivers/gpu/drm/spacemit/spacemit_inno_dp.c b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c
> new file mode 100644
> index 0000000000000..436e5f15b4039
> --- /dev/null
> +++ b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c
[ ... ]
> +	ret = regmap_read_poll_timeout(dp->regs, DP_GENERAL_INTERRUPT, val,
> +				       val & DP_AUX_REPLY_EVENT_INT_STA,
> +				       SPACEMIT_DP_AUX_POLL_US,
> +				       SPACEMIT_DP_AUX_TIMEOUT_US);
> +	if (ret) {
> +		if (retries < SPACEMIT_DP_AUX_MAX_RETRIES) {
> +			retries++;
> +			spacemit_dp_aux_hw_reset(dp);
> +			dev_dbg(dp->dev,
> +				"AUX timeout, cmd=0x%x addr=0x%x size=%zu retry %d/%d\n",
> +				cmd, msg->address, msg->size, retries, SPACEMIT_DP_AUX_MAX_RETRIES);
> +			goto retry_eio;
> +		}
> +
> +		dev_err_ratelimited(dp->dev,
> +				    "AUX transfer timeout, req: 0x%x, cmd: 0x%x, addr: 0x%x, size %zu\n",
> +				    msg->request, cmd, msg->address, msg->size);
> +		return ret;
> +	}

[Severity: Medium]
Does retrying timed-out transfers inside spacemit_dp_aux_transfer() compound
with the DRM DP helpers and spacemit_dp_hw_read_sink_caps() to stall for
over two minutes under dp->mode_lock?

Each timed-out spacemit_dp_aux_transfer() call waits 4 * 200 ms (~813 ms).
drm_dp_dpcd_access() retries negative errors 32 times,
drm_dp_dpcd_read_data() falls back to a second 32-retry probe via
drm_dp_dpcd_readb(), and spacemit_dp_hw_read_sink_caps() loops
SPACEMIT_DP_SINK_READY_RETRIES (3) times, multiplying a single unresponsive
sink into 768 consecutive 200 ms timeouts (~156 seconds) while holding
dp->mode_lock or component bind locks.

This is also reachable on eDP during spacemit_dp_bind(), which checks
spacemit_dp_hw_detect_hpd() and calls spacemit_dp_hw_read_sink_caps() even
though DP_HPD_IN_STATUS is not meaningful on eDP and the panel is powered
off until atomic_pre_enable; when that read fails, the non-zero fallback
limits set by spacemit_dp_hw_read_sink_caps() prevent
spacemit_dp_bridge_atomic_enable() from re-reading DPCD once the panel is
powered.

[ ... ]

> +static void spacemit_dp_hw_read_sink_caps(struct spacemit_dp_dev *dp)
> +{
[ ... ]
> +	if (ret < 0) {
> +		drm_warn_ratelimited(dp->drm,
> +				     "failed to read DPCD after %d retries: %zd\n",
> +				     SPACEMIT_DP_SINK_READY_RETRIES, ret);
> +		dp->link.revision = DP_DPCD_REV_14;
> +		dp->link.max_rate = SPACEMIT_DP_LINK_RATE_5_40;
> +		dp->link.max_num_lanes = SPACEMIT_DP_LANE_2;
> +		dp->link.enhanced_framing = 1;
> +		return;
> +	}

[Severity: Medium]
Does populating non-zero fallback values in dp->link.max_rate and
dp->link.max_num_lanes when spacemit_dp_hw_read_sink_caps() fails prevent
spacemit_dp_bridge_atomic_enable() from retrying the DPCD read?

spacemit_dp_bridge_atomic_enable() only retries spacemit_dp_hw_read_sink_caps()
when !dp->link.max_rate || !dp->link.max_num_lanes.  If an earlier DPCD read
at bind or detect time fails (for example, on eDP during spacemit_dp_bind()
when noisy DP_HPD_IN_STATUS reads high before the panel is powered, or on a
slow-waking monitor), max_rate and max_num_lanes are set to 5.4 Gbps and 2
lanes while dp->dpcd remains zeroed or stale.  The enable-time retry is then
skipped, clamping 4-lane panels or monitors to 2 lanes and running link
training without valid dp->dpcd capability bytes (such as TPS3 support).

[ ... ]

> +static int spacemit_dp_link_apply_adjust(struct spacemit_dp_dev *dp,
> +					 const u8 *link_status,
> +				    enum spacemit_dp_lane_count lanes,
> +				    u8 *training_set)
> +{
> +	union phy_configure_opts opts = {
> +		.dp = {
> +			.lanes = lanes,
> +			.set_voltages = true,
> +		},
> +	};
> +	int i, ret;
> +
> +	for (i = 0; i < lanes; i++) {
> +		u8 v = drm_dp_get_adjust_request_voltage(link_status, i);
> +		u8 p = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
> +		u8 v_bits;
> +
> +		if (v >= SPACEMIT_DP_SWING_MAX)
> +			v = SPACEMIT_DP_SWING_MAX;
> +		if (p >= SPACEMIT_DP_PREEMP_MAX)
> +			p = SPACEMIT_DP_PREEMP_MAX;
> +
> +		opts.dp.voltage[i] = v;
> +		opts.dp.pre[i] = p;
> +
> +		v_bits = v;
> +		if (v == SPACEMIT_DP_SWING_MAX)
> +			v_bits |= DP_TRAIN_MAX_SWING_REACHED;
> +		if (p == SPACEMIT_DP_PREEMP_MAX)
> +			v_bits |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
> +
> +		training_set[i] = v_bits | (p << DP_TRAIN_PRE_EMPHASIS_SHIFT);
> +	}

[Severity: High]
Isn't the return value of drm_dp_get_adjust_request_pre_emphasis() already
shifted left by DP_TRAIN_PRE_EMPHASIS_SHIFT (3)?

For pre-emphasis levels 1, 2 and 3, drm_dp_get_adjust_request_pre_emphasis()
returns 8, 16 and 24.  Comparing p >= SPACEMIT_DP_PREEMP_MAX (2) without
shifting right by DP_TRAIN_PRE_EMPHASIS_SHIFT first causes any request for
pre-emphasis level 1 to be clamped to level 2, marked with
DP_TRAIN_MAX_PRE_EMPHASIS_REACHED, and shifted a second time when building
training_set[i].

[ ... ]

> +static void spacemit_dp_hw_set_msa_and_enable_video(struct spacemit_dp_dev *dp,
> +						    const struct drm_display_mode *mode,
> +						    enum spacemit_dp_link_rate rate,
> +						    enum spacemit_dp_lane_count lanes)
> +{
> +	u64 hb_num;
> +	u32 link_rate;
> +	u32 fp; /* Pixel clock in MHz */
> +	u32 tu, tu_frac, tu_int, rd_thres;
> +	u32 hsync_len, hstart, vstart;
> +
> +	/* mode->clock unit is kHz, fp unit is MHz */
> +	fp = mode->clock / 1000;
> +
> +	if (fp == 0)
> +		fp = 1; /* Prevent division by zero */
> +
> +	/*
> +	 * HBlank interval = (htotal - hactive) * (LinkSymbolClock / 4) /
> +	 * PixelClock, where LinkSymbolClock = LinkRate * 100 (1.62G -> 162MHz).
> +	 * rate is in kbit/s, so link_rate = rate / 10000 gives the 162, 270,
> +	 * 540 form used below.
> +	 */
> +	link_rate = rate / 10000;
> +
> +	/* Multiply before dividing: hb_num = hblank * (link_rate / 4) / fp */
> +	hb_num = (u64)(mode->htotal - mode->hdisplay) * link_rate;
> +	do_div(hb_num, 4 * fp);
> +
> +	/* Transfer unit: tu = fp * bpp * 640 / (8 * lanes * link_rate) */
> +	tu = div_u64((u64)fp * SPACEMIT_DP_BPP * 640, 8 * lanes * link_rate);

[Severity: Medium]
Does truncating mode->clock to integer MHz in fp underestimate the transfer
unit size for fractional-MHz pixel clocks?

spacemit_dp_set_plls() programs dp->pll_clk to mode->clock * 1000 Hz, so a
1080p60 mode runs at 148.5 MHz (and 720p60 at 74.25 MHz), whereas
fp = mode->clock / 1000 truncates those clocks to 148 MHz and 74 MHz.  For
1080p60 on 2 lanes at 2.7 Gbps, this programs a TU of 52.6 instead of 52.8,
packing fewer bytes per TU than the pixel clock delivers into the video
FIFO.  Using mode->clock in kHz and rate / 10 directly avoids the
truncation.

[ ... ]

> +static enum drm_mode_status
> +spacemit_dp_bridge_mode_valid(struct drm_bridge *bridge,
> +			      const struct drm_display_info *info,
> +			 const struct drm_display_mode *mode)
> +{
> +	struct spacemit_dp_dev *dp = container_of(bridge,
> +						  struct spacemit_dp_dev,
> +						  bridge);
> +	unsigned int max_link_rate, max_lanes;
> +	u64 max_bw, req_bw;
> +
> +	/*
> +	 * Prefer the link limits the driver maintains: they start as the
> +	 * sink's capabilities clamped to the PHY and are narrowed after a
> +	 * failed training. drm_dp_max_link_rate() is in 10 kbit/s.
> +	 */
> +	if (dp->link.max_rate && dp->link.max_num_lanes) {
> +		max_link_rate = dp->link.max_rate / 10;
> +		max_lanes = dp->link.max_num_lanes;
> +	} else {
> +		max_link_rate = min_t(unsigned int,
> +				      drm_dp_max_link_rate(dp->dpcd),
> +				      SPACEMIT_DP_SOURCE_MAX_RATE / 10);
> +		max_lanes = drm_dp_max_lane_count(dp->dpcd);
> +	}

[Severity: Medium]
Can spacemit_dp_bridge_mode_valid() and spacemit_dp_bridge_atomic_check()
race with concurrent updates to dp->link and dp->dpcd?

spacemit_dp_hw_read_sink_caps() and spacemit_dp_link_narrow() update
dp->dpcd, dp->link.max_rate and dp->link.max_num_lanes under dp->mode_lock
from the hotplug IRQ thread (spacemit_dp_hotplug_event_handler()) and from
non-blocking atomic commits (spacemit_dp_bridge_atomic_enable()), neither of
which holds the DRM modeset locks.  Reading those fields in
spacemit_dp_bridge_mode_valid() and spacemit_dp_bridge_atomic_check()
without dp->mode_lock can observe a torn rate/lane pair or partially read
dp->dpcd bytes.

[ ... ]

> +	for (trained = false, i = start;
> +	     i < ARRAY_SIZE(spacemit_dp_link_priority_table); i++) {
> +		u32 capacity;
> +
> +		cfg = &spacemit_dp_link_priority_table[i];
> +
> +		/* Source and sink limits */
> +		if (cfg->rate > dp->link.max_rate || cfg->lanes > dp->link.max_num_lanes)
> +			continue;
> +
> +		/* Bandwidth requirement */
> +		capacity = spacemit_dp_calc_link_capacity(cfg->rate,
> +							  cfg->lanes);
> +		if (capacity < req_bw)
> +			continue;
> +
> +		drm_dbg(dp->drm, "trying link config: rate %d lanes %d (capacity %d, required %d)\n",
> +			cfg->rate, cfg->lanes, capacity, req_bw);
> +
> +		spacemit_dp_link_disable(dp);
> +
> +		/* Apply Hardware Settings */
> +		if (spacemit_dp_set_plls(dp, cfg->rate, adjusted_mode->clock))
> +			continue;
> +
> +		if (spacemit_dp_phy_set_lanes(dp, cfg->lanes))
> +			continue;
> +
> +		if (spacemit_dp_phy_on(dp))
> +			continue;
[ ... ]
> +	/*
> +	 * The DPU's pixel clock comes from the PHY PLL, so scanning out into an
> +	 * untrained link never reaches CFG_RDY and wedges the CRTC on
> +	 * flip_done.
> +	 */
> +	if (!trained) {

[Severity: Medium]
Can the !trained path in spacemit_dp_bridge_atomic_enable() return with the
PHY pixel PLL powered down and stall the DPU commit?

When dp->link.max_rate or dp->link.max_num_lanes was 0 during atomic_check()
and the enable-time DPCD read yields limits below req_bw, every entry in
spacemit_dp_link_priority_table is skipped before spacemit_dp_set_plls() or
spacemit_dp_phy_on() is called, leaving the PHY powered off from
spacemit_dp_bind() or spacemit_dp_bridge_atomic_disable().  The same happens
if spacemit_dp_set_plls(), spacemit_dp_phy_set_lanes() or
spacemit_dp_phy_on() fails after spacemit_dp_link_disable().  Because the
DPU gets its pixel clock from dp->pll_clk, returning with PREPLL powered
down prevents the DPU from latching CFG_RDY and stalls
drm_atomic_helper_wait_for_flip_done() until the 3000 ms
SATURN_CFG_RDY_TIMEOUT_MS timeout expires.

[ ... ]

> +static irqreturn_t spacemit_dp_irq_handler(int irq, void *data)
> +{
> +	struct spacemit_dp_dev *dp = data;
> +	irqreturn_t ret = IRQ_NONE;
> +	int idx;
> +
> +	if (!drm_dev_enter(dp->drm, &idx))
> +		return IRQ_NONE;

[Severity: Medium]
What happens if a level-high HPD interrupt fires after drm_dev_unplug()
during master unbind?

In spacemit_drm_master_unbind(), drm_dev_unplug() runs before
drm_kms_helper_poll_fini(), drm_atomic_helper_shutdown() and
component_unbind_all().  Once drm_dev_unplug() marks the device unplugged,
drm_dev_enter() in spacemit_dp_irq_handler() returns false and the handler
exits with IRQ_NONE without calling spacemit_dp_hw_clean_hpd() to clear the
level-triggered interrupt latch, causing a hardirq storm until
spacemit_dp_unbind() calls disable_irq().

[ ... ]

> +static irqreturn_t spacemit_dp_hotplug_event_handler(int irq, void *data)
> +{
> +	struct spacemit_dp_dev *dp = data;
> +	enum drm_connector_status status;
> +	int idx;
> +
> +	if (!drm_dev_enter(dp->drm, &idx))
> +		return IRQ_HANDLED;
> +
> +	/*
> +	 * .detect() owns mode_lock and re-reads the sink caps on a fresh plug
> +	 */
> +	status = spacemit_dp_bridge_detect(&dp->bridge, dp->connector);
> +	drm_bridge_hpd_notify(&dp->bridge, status);
> +
> +	drm_dev_exit(idx);
> +	return IRQ_HANDLED;
> +}

[Severity: Medium]
Does drm_bridge_hpd_notify() ever notify DRM on external DisplayPort
hotplug interrupts?

In spacemit_dp_probe(), external DP sets dp->bridge.ops to
DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID without DRM_BRIDGE_OP_HPD.
Because drm_bridge_connector_init() only registers an HPD callback on a
bridge with DRM_BRIDGE_OP_HPD set, dp->bridge.hpd_cb is NULL and
drm_bridge_hpd_notify() is a no-op.  Moreover, calling
spacemit_dp_bridge_detect() here updates dp->connector_status without
updating dp->connector->status, so an unplug-and-replug while the pixel
clock is running between 10-second poll intervals leaves both statuses as
connector_status_connected and drops the hotplug event and EDID re-read.

[ ... ]

> +static int spacemit_dp_dev_init(struct spacemit_dp_dev *dp)
> +{
[ ... ]
> +	/* Reset Controller and PHY */
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_CONTROLLER_RESET,
> +			  FIELD_PREP(DP_CONTROLLER_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_PHY_RESET,
> +			  FIELD_PREP(DP_PHY_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_HDCP_RESET,
> +			  FIELD_PREP(DP_HDCP_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
> +			  FIELD_PREP(DP_AUX_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_VIDEO_RESET,
> +			  FIELD_PREP(DP_VIDEO_RESET, 0x1));
> +	usleep_range(5000, 8000);
[ ... ]
> +	ret = spacemit_dp_set_plls(dp, SPACEMIT_DP_LINK_RATE_2_70, 148500);
> +	if (ret)
> +		return ret;
> +
> +	ret = spacemit_dp_phy_set_lanes(dp, SPACEMIT_DP_LANE_2);
> +	if (ret)
> +		return ret;
> +
> +	ret = spacemit_dp_phy_on(dp);
> +	if (ret)
> +		return ret;

[Severity: High]
When spacemit_dp_dev_init() runs a second time in spacemit_dp_bind() on eDP
(or on component rebind), does pulsing DP_PHY_RESET wipe the PREPLL
registers while clk_set_rate(dp->pll_clk, 148500000) short-circuits in the
clock framework?

On eDP, spacemit_dp_probe() calls spacemit_dp_dev_init(), which programs
dp->pll_clk to 148.5 MHz, and the PHY clock provider caches that rate.  When
spacemit_dp_bind() calls spacemit_dp_dev_init() again, asserting
DP_PHY_RESET resets the shared PHY PREPLL registers back to hardware
defaults, but clk_set_rate(dp->pll_clk, 148500000) sees that the requested
rate matches the cached rate and returns without calling the PHY clock's
.set_rate callback.  spacemit_dp_phy_on() (and later atomic_enable() for any
148.5 MHz mode) then tries to lock an unprogrammed PREPLL.

[ ... ]

> +static int spacemit_dp_bind(struct device *dev, struct device *master,
> +			    void *data)
> +{
> +	struct spacemit_dp_dev *dp = dev_get_drvdata(dev);
> +	struct drm_device *drm = data;
> +	struct device_node *ep;
> +	int ret;
> +
> +	dp->drm = drm;
> +	dp->aux.drm_dev = drm;
> +	ret = drm_dp_aux_register(&dp->aux);
> +	if (ret) {
> +		dev_err_probe(dev, ret, "failed to register DP AUX\n");
> +		goto err_drm;
> +	}
[ ... ]
> +	ret = spacemit_dp_dev_init(dp);
> +	if (ret)
> +		goto err_encoder;

[Severity: Medium]
Can userspace AUX or DDC transactions race with spacemit_dp_dev_init() and
spacemit_dp_set_plls()?

spacemit_dp_bind() calls drm_dp_aux_register(&dp->aux) before
spacemit_dp_dev_init(dp), exposing /dev/drm_dp_aux* and the I2C adapter
before the controller is initialized on external DP and while
spacemit_dp_dev_init() powers down MPLL and asserts DP_CONTROLLER_RESET,
DP_PHY_RESET and DP_AUX_RESET without holding dp->aux.hw_mutex.  Similarly,
in spacemit_dp_bridge_atomic_enable(), spacemit_dp_link_disable() releases
dp->aux.hw_mutex before spacemit_dp_set_plls() power-cycles the MPLL that
supplies the 16 MHz AUX reference clock.

[Severity: Medium]
If spacemit_dp_dev_init() fails here in spacemit_dp_bind(), should the error
path call spacemit_dp_hw_disable(dp) the way spacemit_dp_probe() does?

spacemit_dp_dev_init() enables interrupt masks and powers up the MPLL and
PREPLL in spacemit_dp_set_plls() before calling spacemit_dp_phy_set_lanes()
and spacemit_dp_phy_on().  Jumping to err_encoder on failure leaves the
PLLs powered on, and because dp->component_added is true while bind failed,
a later spacemit_dp_remove() will not run spacemit_dp_unbind() or
spacemit_dp_hw_disable() either.

[ ... ]

> +/* Leave the DRM device, or power down a controller that never joined one. */
> +static void spacemit_dp_unregister(struct spacemit_dp_dev *dp)
> +{
> +	if (dp->component_added)
> +		component_del(dp->dev, &spacemit_dp_ops);
> +	else
> +		spacemit_dp_hw_disable(dp);
> +}

[Severity: Medium]
Does spacemit_dp_unregister() leave the hardware powered on when
dp->component_added is true but the component master was never bound?

On eDP, spacemit_dp_probe() powers up the MPLL and analog TX blocks via
spacemit_dp_dev_init() and spacemit_dp_edp_link_panel() sets
dp->component_added = true.  If the driver is removed while the aggregate
DRM device is unbound (or if spacemit_dp_dev_init() failed during
spacemit_dp_bind()), component_del() does not invoke spacemit_dp_unbind(),
and the if (dp->component_added) branch skips spacemit_dp_hw_disable(dp).
Calling spacemit_dp_hw_disable(dp) unconditionally after component_del()
would ensure the PLLs and TX blocks are always powered down.

[ ... ]

> +	ret = devm_of_dp_aux_populate_bus(&dp->aux, spacemit_dp_edp_link_panel);
> +	if (ret) {
> +		spacemit_dp_unregister(dp);
> +		return dev_err_probe(dev, ret,
> +				     "eDP: failed to populate aux-bus panel\n");
> +	}
> +
> +	return 0;
> +
> +err_disable_pxclk:
> +	clk_disable_unprepare(dp->pxclk);
> +	return ret;
> +}
> +
> +static void spacemit_dp_remove(struct platform_device *pdev)
> +{
> +	spacemit_dp_unregister(platform_get_drvdata(pdev));
> +}

[Severity: Medium]
On eDP, does spacemit_dp_remove() tear down the component and power down the
controller before devres depopulates the AUX bus?

devm_of_dp_aux_populate_bus() registers of_dp_aux_depopulate_bus_void() as a
devres action, which runs during devres_release_all() after
spacemit_dp_remove() returns.  During driver unbind, spacemit_dp_remove()
powers down the controller while the AUX-bus child panel device is still
registered, and a deferred panel probe completing in that window can still
invoke spacemit_dp_edp_link_panel() -> component_add() after
spacemit_dp_unregister() has already run:

CPU0                                  CPU1 (deferred_probe_work_func)
__device_release_driver()
  spacemit_dp_remove()
    spacemit_dp_unregister()
      /* dp->component_added is false */
      spacemit_dp_hw_disable()
                                      panel_edp_probe()
                                        spacemit_dp_edp_link_panel()
                                          component_add(dp->dev, ...)
  devres_release_all()
    of_dp_aux_depopulate_bus_void()
    /* dp freed while component remains registered */

Depopulating the AUX bus in spacemit_dp_remove() before
spacemit_dp_unregister() (or registering spacemit_dp_unregister() as a devm
action prior to devm_of_dp_aux_populate_bus()) avoids this ordering
inversion.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261121-k3-display-v3-0-ec419e8e96b8@gmail.com?part=12

^ permalink raw reply	[flat|nested] 23+ messages in thread

end of thread, other threads:[~2026-11-21  8:08 UTC | newest]

Thread overview: 23+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
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 ` [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend Cody Kang via B4 Relay
2026-11-21  8:01   ` 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

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox