From: sashiko-bot@kernel.org
To: "Cody Kang" <codykang.hk@gmail.com>
Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org,
linux-phy@lists.infradead.org, linux-clk@vger.kernel.org,
robh@kernel.org, conor+dt@kernel.org, vkoul@kernel.org,
neil.armstrong@linaro.org, olteanv@gmail.com
Subject: Re: [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend
Date: Sat, 21 Nov 2026 08:01:22 +0000 [thread overview]
Message-ID: <sashiko-outbox-226811@kernel.org> (raw)
In-Reply-To: <20261121-k3-display-v3-9-ec419e8e96b8@gmail.com>
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
--
linux-phy mailing list
linux-phy@lists.infradead.org
https://lists.infradead.org/mailman/listinfo/linux-phy
next prev parent reply other threads:[~2026-11-21 8:01 UTC|newest]
Thread overview: 23+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-21 7:40 [PATCH v3 00/17] drm/spacemit: add SpacemiT K3 display support Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 01/17] dt-bindings: display: spacemit: add K3 Saturn DPU controller Cody Kang via B4 Relay
2026-11-21 7:44 ` sashiko-bot
2026-11-21 7:40 ` [PATCH v3 02/17] dt-bindings: phy: add SpacemiT K3 Innosilicon DP PHY Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 03/17] dt-bindings: display: spacemit: add K3 Innosilicon DP/eDP controller Cody Kang via B4 Relay
2026-11-21 7:45 ` sashiko-bot
2026-11-21 7:40 ` [PATCH v3 04/17] dt-bindings: soc: spacemit: allow eDP/DP PHY PLL pixel clocks on K3 APMU Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 05/17] phy: spacemit: add Innosilicon DP TX PHY driver Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 06/17] clk: spacemit: k3: parent eDP/DP pixel clock to the PHY PLL Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 07/17] drm/spacemit: add Saturn DPU register model Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 08/17] drm/spacemit: add Saturn DPU core types, cmdlist and display MMU Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 09/17] drm/spacemit: add Saturn DPU hardware backend Cody Kang via B4 Relay
2026-11-21 8:01 ` sashiko-bot [this message]
2026-11-21 7:40 ` [PATCH v3 10/17] drm/spacemit: add Saturn DPU KMS pipeline Cody Kang via B4 Relay
2026-11-21 8:06 ` sashiko-bot
2026-11-21 7:40 ` [PATCH v3 11/17] drm/spacemit: add Saturn DPU DRM device driver Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver Cody Kang via B4 Relay
2026-11-21 8:08 ` sashiko-bot
2026-11-21 7:40 ` [PATCH v3 13/17] MAINTAINERS: add SpacemiT K3 display driver entry Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 14/17] riscv: dts: spacemit: k3: add display nodes Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 15/17] riscv: dts: spacemit: k3-pico-itx: enable the DisplayPort output Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 16/17] riscv: dts: spacemit: k3-com260-ifx: " Cody Kang via B4 Relay
2026-11-21 7:40 ` [PATCH v3 17/17] riscv: defconfig: spacemit: k3: enable display driver Cody Kang via B4 Relay
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-226811@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=codykang.hk@gmail.com \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=dri-devel@lists.freedesktop.org \
--cc=linux-clk@vger.kernel.org \
--cc=linux-phy@lists.infradead.org \
--cc=neil.armstrong@linaro.org \
--cc=olteanv@gmail.com \
--cc=robh@kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
--cc=vkoul@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox