Hi Henry

On Wed, 28 Oct 2026 at 16:46, Henry Zhang <[email protected]> wrote:
>
> When a transfer times out, vc4_dsi_host_transfer() disables the
> command, resets the FIFOs and returns -ETIMEDOUT. That is not always
> enough: after an LP receive timeout during a read (the peripheral did
> not complete the bus turnaround), every following transfer times out
> as well, with no interrupt and STAT reading back 0. Only a modeset,
> which goes through post_disable/pre_enable, brings the block back.
>
> Reset the DSI block and its analog front end after a timeout and restore
> the configuration programmed in pre_enable, in the same order as
> pre_enable: the block is ungated and the AFE released only after the
> timings are programmed. Keep the interrupt handler out with
> disable_irq() until the block is restored and INT_STAT is cleared, so
> that neither a late completion interrupt of the timed-out transfer nor
> an error interrupt raised during the reset can complete the next
> transfer or run in the middle of the reset. Also mask the interrupts
> until the AFE is out of reset: the error interrupts otherwise fire
> continuously while it is held in reset. The timed-out message is not
> resent, as it may already have been executed by the peripheral; the
> error is returned and the caller decides whether to retry.
>
> Only do this while the block is enabled. Between post_disable and
> pre_enable the clocks are off and there is nothing to restore; a
> transfer then times out as before. The transfer lock keeps the
> recovery from running in the middle of pre_enable or post_disable.
>
> This does not prevent the timeouts themselves. With video running,
> vc4 does not keep commands within vertical blanking, and transfers can
> still time out, sometimes several in a row after a reset. That is a
> separate issue.

Whilst it's a belt and braces approach to work around the issue, I'll
have a dig next week to see if I can reproduce it and see what is
going on.
There are very few use cases that have a need for sending DCS commands
whilst transmitting video, so it's a bit niche. The reset stopping
video isn't nice although I guess it should be fairly brief.

  Dave

> Signed-off-by: Henry Zhang <[email protected]>
> ---
>  drivers/gpu/drm/vc4/vc4_dsi.c | 136 ++++++++++++++++++++++++++++++++--
>  1 file changed, 129 insertions(+), 7 deletions(-)
>
> diff --git a/drivers/gpu/drm/vc4/vc4_dsi.c b/drivers/gpu/drm/vc4/vc4_dsi.c
> index 3ee6e8e86..6edda74e1 100644
> --- a/drivers/gpu/drm/vc4/vc4_dsi.c
> +++ b/drivers/gpu/drm/vc4/vc4_dsi.c
> @@ -601,8 +601,11 @@ struct vc4_dsi {
>          * bridge enable/disable paths, which reprogram the block.
>          */
>         struct mutex transfer_lock;
> +       /* The block is powered and configured. Protected by transfer_lock. */
> +       bool enabled;
>         struct completion xfer_completion;
>         int xfer_result;
> +       int irq;
>
>         struct debugfs_regset32 regset;
>  };
> @@ -826,6 +829,8 @@ static void vc4_dsi_bridge_post_disable(struct drm_bridge 
> *bridge,
>
>         guard(mutex)(&dsi->transfer_lock);
>
> +       dsi->enabled = false;
> +
>         clk_disable_unprepare(dsi->pll_phy_clock);
>         clk_disable_unprepare(dsi->escape_clock);
>         clk_disable_unprepare(dsi->pixel_clock);
> @@ -1151,6 +1156,8 @@ static void vc4_dsi_bridge_pre_enable(struct drm_bridge 
> *bridge,
>                 DSI_PORT_WRITE(DISP0_CTRL,
>                                DSI_DISP0_COMMAND_MODE);
>         }
> +
> +       dsi->enabled = true;
>  }
>
>  static void vc4_dsi_bridge_enable(struct drm_bridge *bridge,
> @@ -1184,10 +1191,9 @@ static int vc4_dsi_bridge_attach(struct drm_bridge 
> *bridge,
>                                  &dsi->bridge, flags);
>  }
>
> -static ssize_t vc4_dsi_host_transfer(struct mipi_dsi_host *host,
> -                                    const struct mipi_dsi_msg *msg)
> +static ssize_t vc4_dsi_transfer(struct vc4_dsi *dsi,
> +                               const struct mipi_dsi_msg *msg)
>  {
> -       struct vc4_dsi *dsi = host_to_dsi(host);
>         struct drm_device *drm = dsi->bridge.dev;
>         struct mipi_dsi_packet packet;
>         u32 pkth = 0, pktc = 0;
> @@ -1195,8 +1201,6 @@ static ssize_t vc4_dsi_host_transfer(struct 
> mipi_dsi_host *host,
>         bool is_long = mipi_dsi_packet_format_is_long(msg->type);
>         u32 cmd_fifo_len = 0, pix_fifo_len = 0;
>
> -       guard(mutex)(&dsi->transfer_lock);
> -
>         mipi_dsi_create_packet(&packet, msg);
>
>         pkth |= VC4_SET_FIELD(packet.header[0], DSI_TXPKT1H_BC_DT);
> @@ -1374,6 +1378,120 @@ static ssize_t vc4_dsi_host_transfer(struct 
> mipi_dsi_host *host,
>         return ret;
>  }
>
> +/*
> + * Reset the DSI block and its analog front end, then restore the
> + * configuration done in pre_enable. Resetting the FIFOs alone does not
> + * clear the state the block can be left in after a transfer timed out
> + * (e.g. on an LP receive timeout): every following transfer then times
> + * out as well, until the next modeset.
> + */
> +static void vc4_dsi_reset_and_restore(struct vc4_dsi *dsi)
> +{
> +       u32 en = dsi->variant->port ? DSI1_CTRL_EN : DSI0_CTRL_CTRL0;
> +       u32 ctrl = DSI_PORT_READ(CTRL);
> +       u32 afec0 = DSI_PORT_READ(PHY_AFEC0);
> +       u32 afec1 = DSI_PORT_READ(PHY_AFEC1);
> +       u32 disp0 = DSI_PORT_READ(DISP0_CTRL) & ~DSI_DISP0_ENABLE;
> +       u32 disp1 = DSI_PORT_READ(DISP1_CTRL);
> +       u32 hstx_to = DSI_PORT_READ(HSTX_TO_CNT);
> +       u32 lprx_to = DSI_PORT_READ(LPRX_TO_CNT);
> +       u32 ta_to = DSI_PORT_READ(TA_TO_CNT);
> +       u32 pr_to = DSI_PORT_READ(PR_TO_CNT);
> +       u32 phyc = DSI_PORT_READ(PHYC);
> +       u32 clt0 = DSI_PORT_READ(HS_CLT0);
> +       u32 clt1 = DSI_PORT_READ(HS_CLT1);
> +       u32 clt2 = DSI_PORT_READ(HS_CLT2);
> +       u32 dlt3 = DSI_PORT_READ(HS_DLT3);
> +       u32 dlt4 = DSI_PORT_READ(HS_DLT4);
> +       u32 dlt5 = DSI_PORT_READ(HS_DLT5);
> +       u32 dlt6 = DSI_PORT_READ(HS_DLT6);
> +       u32 dlt7 = DSI_PORT_READ(HS_DLT7);
> +
> +       /*
> +        * Mask the interrupts while the block and its AFE are in reset: the
> +        * error interrupts would otherwise fire continuously.
> +        */
> +       DSI_PORT_WRITE(INT_EN, 0);
> +       DSI_PORT_WRITE(DISP0_CTRL, disp0);
> +       DSI_PORT_WRITE(TXPKT1C, 0);
> +       DSI_PORT_WRITE(CTRL, DSI_CTRL_SOFT_RESET_CFG |
> +                      DSI_PORT_BIT(CTRL_RESET_FIFOS));
> +       DSI_PORT_WRITE(PHY_AFEC0, afec0 | DSI_PORT_BIT(PHY_AFEC0_RESET));
> +       /* AFEC reset hold time */
> +       mdelay(1);
> +
> +       /*
> +        * Same order as pre_enable: the block stays gated and the AFE in
> +        * reset until the timings are programmed.
> +        */
> +       DSI_PORT_WRITE(CTRL, ctrl & ~(DSI_CTRL_CAL_BYTE | en));
> +       DSI_PORT_WRITE(STAT, DSI_PORT_READ(STAT));
> +       DSI_PORT_WRITE(PHY_AFEC1, afec1);
> +       DSI_PORT_WRITE(HS_CLT0, clt0);
> +       DSI_PORT_WRITE(HS_CLT1, clt1);
> +       DSI_PORT_WRITE(HS_CLT2, clt2);
> +       DSI_PORT_WRITE(HS_DLT3, dlt3);
> +       DSI_PORT_WRITE(HS_DLT4, dlt4);
> +       DSI_PORT_WRITE(HS_DLT5, dlt5);
> +       DSI_PORT_WRITE(HS_DLT6, dlt6);
> +       DSI_PORT_WRITE(HS_DLT7, dlt7);
> +       DSI_PORT_WRITE(PHYC, phyc);
> +       DSI_PORT_WRITE(CTRL, ctrl & ~en);
> +       DSI_PORT_WRITE(HSTX_TO_CNT, hstx_to);
> +       DSI_PORT_WRITE(LPRX_TO_CNT, lprx_to);
> +       DSI_PORT_WRITE(TA_TO_CNT, ta_to);
> +       DSI_PORT_WRITE(PR_TO_CNT, pr_to);
> +       DSI_PORT_WRITE(DISP1_CTRL, disp1);
> +       /* Ungate the block. */
> +       DSI_PORT_WRITE(CTRL, ctrl);
> +       /* Bring AFE out of reset. */
> +       DSI_PORT_WRITE(PHY_AFEC0, afec0 & ~DSI_PORT_BIT(PHY_AFEC0_RESET));
> +       DSI_PORT_WRITE(DISP0_CTRL, disp0);
> +
> +       DSI_PORT_WRITE(INT_STAT, DSI_PORT_READ(INT_STAT));
> +       DSI_PORT_WRITE(INT_EN, DSI_PORT_BIT(INTERRUPTS_ALWAYS_ENABLED));
> +}
> +
> +static ssize_t vc4_dsi_host_transfer(struct mipi_dsi_host *host,
> +                                    const struct mipi_dsi_msg *msg)
> +{
> +       struct vc4_dsi *dsi = host_to_dsi(host);
> +       u32 disp0_ctrl;
> +       ssize_t ret;
> +
> +       guard(mutex)(&dsi->transfer_lock);
> +
> +       ret = vc4_dsi_transfer(dsi, msg);
> +       /* Only a running block can be reset and restored. */
> +       if (ret != -ETIMEDOUT || !dsi->enabled)
> +               return ret;
> +
> +       /*
> +        * Leave the block usable for the next transfer. The message is not
> +        * resent: it may already have reached the peripheral, and only the
> +        * caller knows whether it is safe to repeat.
> +        */
> +       disp0_ctrl = DSI_PORT_READ(DISP0_CTRL);
> +       dev_warn(&dsi->pdev->dev,
> +                "transfer timed out (stat 0x%08x), resetting DSI\n",
> +                DSI_PORT_READ(STAT));
> +       /*
> +        * Keep the interrupt handler out until the block is restored and
> +        * INT_STAT is cleared. The error interrupts are still enabled, and
> +        * a handler running during the reset could complete the next
> +        * transfer, or race with the register writes on DSI1 of the
> +        * BCM2835, where both go through the DMA workaround. disable_irq()
> +        * also waits for a late completion interrupt of the timed-out
> +        * transfer.
> +        */
> +       disable_irq(dsi->irq);
> +       vc4_dsi_reset_and_restore(dsi);
> +       DSI_PORT_WRITE(DISP0_CTRL, disp0_ctrl);
> +       enable_irq(dsi->irq);
> +
> +       return ret;
> +}
> +
>  static const struct component_ops vc4_dsi_ops;
>  static int vc4_dsi_host_attach(struct mipi_dsi_host *host,
>                                struct mipi_dsi_device *device)
> @@ -1743,14 +1861,18 @@ static int vc4_dsi_bind(struct device *dev, struct 
> device *master, void *data)
>         /* Clear any existing interrupt state. */
>         DSI_PORT_WRITE(INT_STAT, DSI_PORT_READ(INT_STAT));
>
> +       dsi->irq = platform_get_irq(pdev, 0);
> +       if (dsi->irq < 0)
> +               return dsi->irq;
> +
>         if (dsi->reg_dma_mem)
> -               ret = devm_request_threaded_irq(dev, platform_get_irq(pdev, 
> 0),
> +               ret = devm_request_threaded_irq(dev, dsi->irq,
>                                                 
> vc4_dsi_irq_defer_to_thread_handler,
>                                                 vc4_dsi_irq_handler,
>                                                 IRQF_ONESHOT,
>                                                 "vc4 dsi", dsi);
>         else
> -               ret = devm_request_irq(dev, platform_get_irq(pdev, 0),
> +               ret = devm_request_irq(dev, dsi->irq,
>                                        vc4_dsi_irq_handler, 0, "vc4 dsi", 
> dsi);
>         if (ret) {
>                 if (ret != -EPROBE_DEFER)
> --
> 2.47.3
>

Reply via email to