Thank you for your contribution! Sashiko AI review found 5 potential
issues to consider:
- [High] drm/msm/dp: broken DPMS payload tracking in
  msm_dp_mst_stream_atomic_check()
- [High] drm/msm/dp: MST payload state corruption on
  msm_dp_mst_stream_enable() error
- [High] drm/msm/dp: link and runtime PM leak in
  msm_dp_mst_stream_post_disable()
- [Medium] drm/msm/dp: zero pbn_div in msm_dp_mst_stream_atomic_check()
  causes div-by-zero
- [Medium] drm/msm/dp: SST panel and connector queried in
  dpu_encoder_mst_atomic_enable()
--

commit 3b57ce88885b473a2748e491b3e969f409d8d170
Author: Yongxing Mou <[email protected]>

drm/msm/dp: add atomic stream handling for MST

This commit adds atomic check, enable, and disable helpers for DisplayPort
MST streams, reserving VC payload bandwidth and updating MST payloads.

> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c 
> b/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c
> index 802cb62fc0102..edf30d7d3d169 100644
> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c
> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c
> @@ -2745,16 +2745,27 @@ static const struct drm_encoder_helper_funcs 
> dpu_encoder_helper_funcs = {
>  static void dpu_encoder_mst_atomic_enable(struct drm_encoder *enc,
>                                     struct drm_atomic_commit *state)
>  {
> +     msm_dp_mst_stream_enable(enc, state);
>       dpu_encoder_virt_atomic_enable(enc, state);
>  }

[Severity: Medium]
Does dpu_encoder_virt_atomic_enable() query the SST panel and connector
instead of the MST stream's panel and connector when configuring widebus
and peripheral flush?

msm_dp_mst_stream_enable() binds the per-stream MST panel to the MST
connector and configures dp->ctrl->wide_bus_en from that panel.
dpu_encoder_virt_atomic_enable() then calls msm_dp_wide_bus_available() and
msm_dp_needs_periph_flush(), which inspect the SST dp->panel and
msm_dp_display->connector:

drivers/gpu/drm/msm/dp/dp_display.c:msm_dp_needs_periph_flush() {
        return drm_mode_is_420_only(&msm_dp_display->connector->display_info, 
mode);
}

drivers/gpu/drm/msm/dp/dp_display.c:msm_dp_wide_bus_available() {
        ...
        if (dp->panel->msm_dp_mode.out_fmt_is_yuv_420)
                return false;

        return dp->wide_bus_supported;
}

When a YUV420 mode is enabled on an MST connector (or if the SST panel
retained out_fmt_is_yuv_420 from an earlier SST session), the DPU INTF and
DP controller end up with mismatched widebus settings, and YUV420 MST
streams halve horizontal timings twice while skipping peripheral flush.

> diff --git a/drivers/gpu/drm/msm/dp/dp_mst_drm.c 
> b/drivers/gpu/drm/msm/dp/dp_mst_drm.c
> index ef5fb70863b81..eae82e857c849 100644
> --- a/drivers/gpu/drm/msm/dp/dp_mst_drm.c
> +++ b/drivers/gpu/drm/msm/dp/dp_mst_drm.c
[ ... ]
> @@ -147,6 +186,158 @@ static int msm_dp_mst_encoder_stream_id(struct 
> msm_dp_mst *mst,
>       return -1;
>  }
>  
> +void msm_dp_mst_stream_enable(struct drm_encoder *encoder,
> +                            struct drm_atomic_commit *state)
> +{
> +     struct drm_connector *connector =
> +             drm_atomic_get_new_connector_for_encoder(state, encoder);
> +     struct msm_dp_mst_connector *mst_conn = to_dp_mst_connector(connector);
> +     struct msm_dp_mst *mst = mst_conn->dp_mst;
> +     struct msm_dp *dp_display = mst->msm_dp;
> +     struct msm_dp_panel *panel = msm_dp_mst_panel_from_encoder(mst, 
> encoder);
> +     struct drm_dp_mst_port *port = mst_conn->mst_port;
> +     struct drm_dp_mst_topology_state *mst_state =
> +             drm_atomic_get_new_mst_topology_state(state, &mst->mst_mgr);
> +     struct drm_dp_mst_atomic_payload *payload =
> +             drm_atomic_get_mst_payload_state(mst_state, port);
> +     struct msm_dp_mst_slot_info slots[DP_STREAM_MAX] = {};
> +     int rc;
> +
> +     guard(mutex)(&mst->mst_lock);
> +
> +     drm_connector_get(connector);
> +     panel->connector = connector;
> +
> +     rc = msm_dp_display_set_mode_helper(dp_display, state, encoder, panel);
> +     if (rc) {
> +             drm_err(dp_display->drm_dev,
> +                     "[MST] stream:%u set_mode failed rc=%d\n", 
> panel->stream_id, rc);
> +             return;
> +     }
> +
> +     rc = msm_dp_display_prepare_link(dp_display);
> +     if (rc) {
> +             drm_err(dp_display->drm_dev,
> +                     "[MST] stream:%u prepare_link failed rc=%d\n", 
> panel->stream_id, rc);
> +             return;
> +     }
> +
> +     drm_dp_mst_update_slots(mst_state, DP_CAP_ANSI_8B10B);
> +
> +     rc = drm_dp_add_payload_part1(&mst->mst_mgr, mst_state, payload);
> +     if (rc)
> +             return;
> +
> +     msm_dp_mst_collect_slots(mst, mst_state, slots);
> +
> +     drm_dbg_kms(dp_display->drm_dev,
> +                 "[MST] stream:%u timeslots vc_start:%d slots:%d pbn:%d\n",
> +                 panel->stream_id, payload->vc_start_slot,
> +                 payload->time_slots, payload->pbn);
> +
> +     rc = msm_dp_display_enable_helper(dp_display, panel, slots);
> +     if (rc)
> +             return;
> +
> +     drm_dp_check_act_status(&mst->mst_mgr);
> +
> +     drm_dp_add_payload_part2(&mst->mst_mgr, payload);
> +}
> +
> +void msm_dp_mst_stream_disable(struct drm_encoder *encoder,
> +                            struct drm_atomic_commit *state)
> +{
> +     struct drm_connector *connector = 
> drm_atomic_get_old_connector_for_encoder(state, encoder);
> +     struct msm_dp_mst_connector *mst_conn = to_dp_mst_connector(connector);
> +     struct msm_dp_mst *mst = mst_conn->dp_mst;
> +     struct msm_dp_panel *panel = msm_dp_mst_panel_from_encoder(mst, 
> encoder);
> +     struct drm_dp_mst_topology_state *old_mst_state =
> +             drm_atomic_get_old_mst_topology_state(state, &mst->mst_mgr);
> +     struct drm_dp_mst_topology_state *new_mst_state =
> +             drm_atomic_get_new_mst_topology_state(state, &mst->mst_mgr);
> +     struct drm_dp_mst_atomic_payload *old_payload =
> +             drm_atomic_get_mst_payload_state(old_mst_state, 
> mst_conn->mst_port);
> +     struct drm_dp_mst_atomic_payload *new_payload =
> +             drm_atomic_get_mst_payload_state(new_mst_state, 
> mst_conn->mst_port);
> +     struct msm_dp_mst_slot_info slots[DP_STREAM_MAX] = {};
> +
> +     guard(mutex)(&mst->mst_lock);
> +
> +     drm_dp_remove_payload_part1(&mst->mst_mgr, new_mst_state, new_payload);
> +
> +     drm_dp_remove_payload_part2(&mst->mst_mgr, new_mst_state, old_payload, 
> new_payload);

[Severity: High]
Can an early return in msm_dp_mst_stream_enable() before
drm_dp_add_payload_part1() corrupt the MST payload state on the subsequent
disable?

If msm_dp_display_set_mode_helper() or msm_dp_display_prepare_link() fails
(for example, on a link training failure), drm_dp_add_payload_part1() is
skipped, so payload->vc_start_slot stays -1 and mst_mgr.payload_count is
not incremented.  When the stream is later disabled,
msm_dp_mst_stream_disable() still calls drm_dp_remove_payload_part2(),
which sees new_payload->vc_start_slot == -1, subtracts
old_payload->time_slots from the vc_start_slot of every active payload with
vc_start_slot >= 1, and underflows mst_mgr.payload_count and
mst_mgr.next_start_slot.

> +     msm_dp_mst_collect_slots(mst, new_mst_state, slots);
> +
> +     drm_dbg_kms(mst->msm_dp->drm_dev,
> +                 "[MST] stream:%u timeslots vc_start:%d slots:%d pbn:%d\n",
> +                 panel->stream_id, new_payload->vc_start_slot,
> +                 new_payload->time_slots, new_payload->pbn);
> +
> +     if (!msm_dp_display_is_plugged(mst->msm_dp))
> +             return;
> +
> +     msm_dp_display_disable_helper(mst->msm_dp, panel, slots);
> +
> +     drm_dp_check_act_status(&mst->mst_mgr);
> +}
> +
> +void msm_dp_mst_stream_post_disable(struct drm_encoder *encoder,
> +                                 struct drm_atomic_commit *state)
> +{
> +     struct drm_connector *connector = 
> drm_atomic_get_old_connector_for_encoder(state, encoder);
> +     struct msm_dp_mst_connector *mst_conn = to_dp_mst_connector(connector);
> +     struct msm_dp_mst *mst = mst_conn->dp_mst;
> +     struct msm_dp_panel *panel = msm_dp_mst_panel_from_encoder(mst, 
> encoder);
> +
> +     guard(mutex)(&mst->mst_lock);
> +
> +     msm_dp_display_atomic_post_disable_helper(mst->msm_dp, panel);
> +
> +     if (!mst->msm_dp->mst_active)
> +             msm_dp_display_unprepare(mst->msm_dp);

[Severity: High]
Does gating msm_dp_display_unprepare() on !mst->msm_dp->mst_active leak the
link state and runtime PM reference when the last MST stream is disabled?

mst_active stays true while an MST branch device is connected, and
msm_dp_display_unprepare() already returns early when
active_stream_mask != 0.  Skipping msm_dp_display_unprepare() when
mst_active is true leaves mainlink clocks and the PHY enabled, leaks the
runtime PM reference from msm_dp_display_prepare_link(), and leaves
link_ready set to true so later connections skip link training.

> +     panel->connector = NULL;
> +
> +     drm_connector_put(connector);
> +}
> +
> +int msm_dp_mst_stream_atomic_check(struct drm_encoder *enc,
> +                                struct drm_crtc_state *crtc_state,
> +                                struct drm_connector_state *conn_state)
> +{
> +     struct msm_dp_mst_connector *mst_conn = 
> to_dp_mst_connector(conn_state->connector);
> +     struct msm_dp_mst *mst = mst_conn->dp_mst;
> +     struct drm_dp_mst_topology_state *mst_state;
> +     int bpp, pbn, slots;
> +
> +     if (!conn_state->crtc)
> +             return 0;
> +
> +     if (!drm_atomic_crtc_needs_modeset(crtc_state) || !crtc_state->active)
> +             return 0;

[Severity: High]
Does skipping time slot allocation when !crtc_state->active break MST
payload tracking across inactive modesets and DPMS transitions?

drm_dp_atomic_release_time_slots() in msm_dp_mst_connector_atomic_check()
tracks payloads by conn_state->crtc (crtc_state->enable), not
crtc_state->active.  If a CRTC is enabled with active = false, no payload
is allocated here, so a later disable or mode change hits WARN_ON(!payload)
in drm_dp_atomic_release_time_slots() and fails with -EINVAL.  Conversely,
if an active MST stream goes to DPMS OFF (enable = true, active = false)
and is later disabled (enable = false), drm_dp_remove_payload_part2() runs
during the DPMS OFF commit while new_payload->delete is still false and
does not run on the final disable when old_crtc_state->active is already
false, leaking the port's malloc_kref reference.

> +     bpp = (conn_state->connector->display_info.bpc * 3) ?: 24; /* fallback: 
> assume 8bpc */
> +     pbn = drm_dp_calc_pbn_mode(crtc_state->mode.clock, bpp << 4);
> +
> +     mst_state = drm_atomic_get_mst_topology_state(crtc_state->state, 
> &mst->mst_mgr);
> +     if (IS_ERR(mst_state))
> +             return PTR_ERR(mst_state);
> +
> +     if (!dfixed_trunc(mst_state->pbn_div)) {
> +             mst_state->pbn_div =
> +                     drm_dp_get_vc_payload_bw(mst->link->link_caps.rate,
> +                                              
> mst->link->link_caps.num_lanes);
> +     }
> +
> +     slots = drm_dp_atomic_find_time_slots(crtc_state->state, &mst->mst_mgr,
> +                                           mst_conn->mst_port, pbn);

[Severity: Medium]
Can mst_state->pbn_div.full be zero here and cause a division by zero in
drm_dp_atomic_find_time_slots()?

msm_dp_panel_read_dpcd() zeroes mst->link->link_caps with memset() before
reading DPCD over AUX, and mst->link->link_caps is read here without locks
or a check that pbn_div.full > 0.  If an atomic check runs concurrently
with an HPD replug or after a failed DPCD read while the MST connector is
still registered, drm_dp_get_vc_payload_bw() returns 0 and
drm_dp_atomic_find_time_slots() divides by topology_state->pbn_div.full.

-- 
Sashiko AI review ยท 
https://sashiko.dev/#/patchset/[email protected]?part=18

Reply via email to