Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] drm/msm/dp: best_encoder mutation in
  msm_dp_mst_atomic_best_encoder()
- [Medium] drm/msm/dp: bad return and unlocked PBN in
  msm_dp_mst_connector_mode_valid()
- [Medium] drm/msm/dp: ignored display_info parameter in
  msm_dp_display_mode_valid()
- [Low] drm/msm/dp: unchecked allocs and duplicate prop in
  msm_dp_mst_add_connector()
--

commit 855fdaf041ee0928ad6a8b842de18b32e1e85391
Author: Yongxing Mou <[email protected]>

drm/msm/dp: add MST connector creation and topology callbacks

This commit adds DRM connector callbacks and the add_connector topology
callback to dynamically create and manage DisplayPort MST connectors.

> diff --git a/drivers/gpu/drm/msm/dp/dp_mst_drm.c 
> b/drivers/gpu/drm/msm/dp/dp_mst_drm.c
> index 5d22aa34c521c..a2900ff3b0ab3 100644
> --- a/drivers/gpu/drm/msm/dp/dp_mst_drm.c
> +++ b/drivers/gpu/drm/msm/dp/dp_mst_drm.c
[ ... ]
> @@ -25,6 +35,237 @@ struct msm_dp_mst {
[ ... ]
> +static enum drm_mode_status msm_dp_mst_connector_mode_valid(struct 
> drm_connector *connector,
> +                                                         const struct 
> drm_display_mode *mode)
> +{
> +     struct msm_dp_mst_connector *mst_conn;
> +     struct drm_dp_mst_port *mst_port;
> +     struct msm_dp *dp_display;
> +     int required_pbn;
> +
> +     if (drm_connector_is_unregistered(connector))
> +             return 0;
> +
> +     mst_conn = to_dp_mst_connector(connector);
> +     mst_port = mst_conn->mst_port;
> +     dp_display = mst_conn->dp_mst->msm_dp;
> +
> +     /* Use minimum possible bpp (6bpc RGB, 8b10b) to avoid rejecting modes
> +      * that would be feasible at the actual link bpp. mode_valid must not
> +      * depend on negotiated parameters.
> +      */
> +     required_pbn = drm_dp_calc_pbn_mode(mode->clock, (6 * 3) << 4);
> +
> +     if (required_pbn > mst_port->full_pbn) {
> +             drm_dbg_dp(dp_display->drm_dev, "mode:%s not supported.\n", 
> mode->name);
> +             return MODE_CLOCK_HIGH;
> +     }

[Severity: Medium]
Should msm_dp_mst_connector_mode_valid() be a .mode_valid_ctx callback
that returns MODE_ERROR when the connector is unregistered and takes
mst->mst_mgr.base.lock around reading mst_port->full_pbn?

Because this is wired up to .mode_valid, returning 0 returns MODE_OK and
accepts every mode on an unregistered connector without running the PBN or
display checks.  In addition, mst_port->full_pbn is documented as
protected by drm_dp_mst_topology_mgr.base.lock, which is not held here
when connector->force skips detect_ctx in
drm_helper_probe_single_connector_modes().

> +
> +     return msm_dp_display_mode_valid(dp_display, &connector->display_info, 
> mode);
> +}

[Severity: Medium]
Does passing &connector->display_info to msm_dp_display_mode_valid()
validate the mode against the MST sink's EDID as intended?

msm_dp_display_mode_valid() ignores its info parameter and reads the root
SST connector (dp->connector) instead:

drivers/gpu/drm/msm/dp/dp_display.c:msm_dp_display_mode_valid() {
        ...
        is_yuv_420 = drm_mode_is_420_only(&dp->connector->display_info, mode);
        ...
        mode_bpp = dp->connector->display_info.bpc * num_components;
        ...
}

Since msm_dp_mst_connector_get_modes() populates display_info on the
dynamic MST connector rather than dp->connector, YCbCr 4:2:0-only modes on
an MST sink are not recognized as 4:2:0 and are rejected with
MODE_CLOCK_HIGH or MODE_BAD, and mode_bpp is computed from the wrong
connector's bpc.

[ ... ]

> +static struct drm_encoder *
> +msm_dp_mst_atomic_best_encoder(struct drm_connector *connector, struct 
> drm_atomic_commit *state)
> +{
> +     struct msm_dp_mst_connector *mst_conn = to_dp_mst_connector(connector);
> +     struct msm_dp_mst *mst = mst_conn->dp_mst;
> +     struct drm_connector_state *conn_state;
> +     struct drm_connector *iter;
> +     struct drm_connector_list_iter conn_iter;
> +     u32 stream_mask = 0;
> +     u32 i;
> +
> +     conn_state = drm_atomic_get_new_connector_state(state, connector);
> +     if (!conn_state)
> +             return NULL;
> +
> +     if (conn_state->best_encoder)
> +             return conn_state->best_encoder;
> +
> +     drm_connector_list_iter_begin(connector->dev, &conn_iter);
> +     drm_for_each_connector_iter(iter, &conn_iter) {
> +             struct drm_connector_state *peer_state;
> +             int stream_id;
> +
> +             if (iter == connector ||
> +                 iter->funcs != &msm_dp_drm_mst_connector_funcs ||
> +                 to_dp_mst_connector(iter)->dp_mst != mst)
> +                     continue;
> +
> +             peer_state = drm_atomic_get_new_connector_state(state, iter) ?: 
> iter->state;
> +             if (!peer_state || !peer_state->crtc || 
> !peer_state->best_encoder)
> +                     continue;
> +
> +             stream_id = msm_dp_mst_encoder_stream_id(mst, 
> peer_state->best_encoder);
> +             if (stream_id >= 0 && stream_id < mst->max_streams)
> +                     stream_mask |= BIT(stream_id);
> +     }
> +     drm_connector_list_iter_end(&conn_iter);
> +
> +     for (i = 0; i < mst->max_streams; i++) {
> +             if (!(stream_mask & BIT(i))) {
> +                     conn_state->best_encoder = mst->mst_encoders[i].enc;
> +                     return mst->mst_encoders[i].enc;
> +             }
> +     }
> +
> +     return NULL;
> +}

[Severity: High]
Does assigning conn_state->best_encoder directly inside
msm_dp_mst_atomic_best_encoder() break encoder routing in
update_connector_routing()?

drm_atomic_helper_check_modeset() calls .atomic_best_encoder() first from
handle_conflicting_encoders() and then again from
update_connector_routing(), which checks whether the returned encoder
differs from new_connector_state->best_encoder:

drivers/gpu/drm/drm_atomic_helper.c:update_connector_routing() {
        ...
        if (new_encoder == new_connector_state->best_encoder) {
                set_best_encoder(state, new_connector_state, new_encoder);

                drm_dbg_atomic(connector->dev,
                               "[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on 
[CRTC:%d:%s]\n",
                               ...);

                return 0;
        }

        steal_encoder(state, new_encoder);
        ...
}

Because handle_conflicting_encoders() already overwrote
conn_state->best_encoder, update_connector_routing() always takes the
early return and skips steal_encoder().  When one atomic commit disables
an MST connector and enables an earlier-indexed MST connector on the same
CRTC, the new connector picks the old connector's encoder without stealing
it, and when update_connector_routing() then processes the disabled
connector, set_best_encoder(state, new_connector_state, NULL) clears that
encoder's bit from crtc_state->encoder_mask, leaving the active CRTC with
no encoder in encoder_mask.

[ ... ]

> +static struct drm_connector *
> +msm_dp_mst_add_connector(struct drm_dp_mst_topology_mgr *mgr,
> +                      struct drm_dp_mst_port *port, const char *pathprop)
> +{
> +     struct msm_dp_mst *mst = container_of(mgr, struct msm_dp_mst, mst_mgr);
> +     struct drm_device *dev = mst->msm_dp->drm_dev;
> +     struct msm_dp_mst_connector *mst_conn;
> +     struct drm_connector *connector;
> +     int rc, i;
> +
> +     mst_conn = kzalloc_obj(*mst_conn);
> +     if (!mst_conn)
> +             return NULL;
> +
> +     connector = &mst_conn->connector;
> +     rc = drm_connector_dynamic_init(dev, connector,
> +                                     &msm_dp_drm_mst_connector_funcs,
> +                                     DRM_MODE_CONNECTOR_DisplayPort, NULL);
> +     if (rc)
> +             goto err_free;
> +
> +     mst_conn->dp_mst = mst;
> +
> +     drm_connector_helper_add(connector, 
> &msm_dp_drm_mst_connector_helper_funcs);
> +     connector->funcs->reset(connector);
> +
> +     /* add all encoders as possible encoders */
> +     for (i = 0; i < mst->max_streams; i++) {
> +             rc = drm_connector_attach_encoder(connector, 
> mst->mst_encoders[i].enc);
> +             if (rc) {
> +                     drm_err(dev, "[MST] failed to attach encoder:%u to 
> conn:%d rc:%d\n",
> +                             mst->mst_encoders[i].enc->base.id,
> +                             connector->base.id, rc);
> +                     goto err_connector;
> +             }
> +     }
> +
> +     mst_conn->mst_port = port;
> +     drm_dp_mst_get_port_malloc(port);
> +
> +     drm_object_attach_property(&connector->base,
> +                                dev->mode_config.path_property, 0);
> +     drm_object_attach_property(&connector->base,
> +                                dev->mode_config.tile_property, 0);
> +     drm_connector_set_path_property(connector, pathprop);

[Severity: Low]
Does msm_dp_mst_add_connector() attach dev->mode_config.tile_property a
second time?

drm_connector_dynamic_init() -> drm_connector_init_only() already attaches
config->tile_property, so attaching it again adds a duplicate TILE
property entry to connector->base.properties.  Also,
connector->funcs->reset(connector) can leave connector->state NULL on
allocation failure (causing a NULL pointer dereference in atomic helpers
once registered), and the error return from
drm_connector_set_path_property() is not checked.

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

Reply via email to