All of lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Luo Liu" <Luo.Liu@cixtech.com>
Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org,
	robh@kernel.org, conor+dt@kernel.org
Subject: Re: [PATCH v2 2/2] drm/cix: add Sky1 DisplayPort transmitter driver
Date: Tue, 17 Nov 2026 07:36:34 +0000	[thread overview]
Message-ID: <sashiko-outbox-218361@kernel.org> (raw)
In-Reply-To: <20261117064552.85256-3-Luo.Liu@cixtech.com>

Thank you for your contribution! Sashiko AI review found 22 potential
issues to consider:
- [High] drm/cix/dptx: wrong callback signature for
  cix_dptx_dev_release()
- [High] drm/cix/dptx: unlocked crtc->state access in cix_dp_get_mode()
  on HPD IRQ
- [High] drm/cix/dptx: __cix_dp_detect() ignores connect error and skips
  disconnect
- [High] drm/cix/dptx: suspend race in cix_dp_pm_prepare() and lost OOB
  HPD
- [High] drm/cix: uninitialized connector->fwnode breaks USB-C OOB
  hotplug events
- [High] drm/cix: premature drm_connector_cleanup() in
  cix_dp_bridge_detach()
- [High] drm/cix: use-after-free and destroyed mutex lock after device
  unbind
- [Medium] drm/cix/dptx: broken VSC SDP colorimetry in
  cix_dp_needs_vsc_sdp()
- [Medium] drm/cix/dptx: bridge PM callbacks toggle drm_device polling
- [Medium] drm/cix/dptx: DPTX_STATE_SUSPENDED blocks
  cix_dpcd_power_down() on suspend
- [Medium] drm/cix/dptx: CIX_DPTX_ENHANCED_FRAMING_ENABLE not cleared in
  cix_dp_link_configure()
- [Medium] drm/cix/dptx: hpd_event_work queued on multiple workqueues
- [Medium] drm/cix: unhandled DRM_BRIDGE_ATTACH_NO_CONNECTOR in
  cix_dp_bridge_attach()
- [Medium] drm/cix: force_hpd overwritten during suspend in
  cix_dp_oob_hotplug_event()
- [Medium] drm/cix: overly strict minbpp in
  cix_dp_connector_mode_valid() for fallback formats
- [Medium] drm/cix: late crtc_state->mode_changed assignment in
  cix_dp_bridge_atomic_check()
- [Medium] drm/cix: unlocked sink cap reads in atomic_check/mode_valid
  and HPD status race
- [Medium] drm/cix: unchecked connector->state allocation in
  cix_dp_connector_create()
- [Medium] drm/cix: broken sync polarity flags and pixel clock check in
  cix_dp_adjust_mode()
- [Medium] drm/cix: unlocked drm_helper_probe_detect() in
  cix_dp_hpd_event_work_func()
- [Low] drm/cix: missing error on RBR downshift in
  cix_dp_mode_configure()
- [Low] drm/cix: missing content_type check in
  cix_dp_bridge_atomic_check()
--

commit 91969ec67c0ae274ce458c0bfa9354271adf193d
Author: Luo Liu <Luo.Liu@cixtech.com>

drm/cix: add Sky1 DisplayPort transmitter driver

This commit adds a DRM bridge driver for the CIX Sky1 DisplayPort
transmitter, handling DP link training, EDID probing, mode validation,
YCbCr 4:2:0 output, and hotplug events.

> diff --git a/drivers/gpu/drm/cix/dptx/cix_dptx.c b/drivers/gpu/drm/cix/dptx/cix_dptx.c
> new file mode 100644
> index 0000000000000..882c4a92f5118
> --- /dev/null
> +++ b/drivers/gpu/drm/cix/dptx/cix_dptx.c
[ ... ]
> +static int cix_dp_mode_configure(struct cix_dp *dp, int pclk, u8 bw, u8 bpp,
> +				 bool downshift)
> +{
> +	int max_rate = dp->link_config.max_rate;
> +	int lane_cnt;
> +	int bw_code;
> +	int link_rate;
> +
> +	if (!downshift)
> +		bw_code = bw;
> +	else
> +		switch (bw) {
> +		case DP_LINK_BW_8_1:
> +			bw_code = DP_LINK_BW_5_4;
> +			break;
> +		case DP_LINK_BW_5_4:
> +			bw_code = DP_LINK_BW_2_7;
> +			break;
> +		case DP_LINK_BW_2_7:
> +			bw_code = DP_LINK_BW_1_62;
> +			break;
> +		case DP_LINK_BW_1_62:
> +			bw_code = DP_LINK_BW_1_62;
> +			break;

[Severity: Low]
Should downshifting from DP_LINK_BW_1_62 return -EINVAL instead of keeping
DP_LINK_BW_1_62 and returning 0?

cix_dp_train_loop() only breaks out of its inner downshift loop when
cix_dp_mode_configure() returns a negative error, so returning 0 causes it
to repeat training at 1.62 Gbps up to four times per outer loop iteration.

[ ... ]
> +static int cix_dp_link_configure(struct cix_dp *dp)
> +{
> +	u8 bw_code = dp->mode.bw_code;
> +	u8 lane_cnt = dp->mode.lane_cnt;
> +	int ret;
> +
> +	cix_dp_write(dp, CIX_DPTX_LANE_COUNT_SET, lane_cnt);
> +
> +	if (dp->caps.enhanced_framing) {
> +		cix_dp_write(dp, CIX_DPTX_ENHANCED_FRAMING_ENABLE, 1);
> +		lane_cnt |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
> +	}

[Severity: Medium]
Does cix_dp_link_configure() leave CIX_DPTX_ENHANCED_FRAMING_ENABLE set to
1 when switching to a sink that does not support enhanced framing?

cix_dp_core_off() does not reset the transmitter when a stream is disabled,
so if a sink without enhanced framing is connected after one that enabled
it, the transmitter keeps sending enhanced framing while
DP_LANE_COUNT_ENHANCED_FRAME_EN is cleared in the sink's DPCD.

[ ... ]
> +	value = (mode->htotal - mode->hdisplay) *
> +		(dp->mode.link_rate / 40) * 9 / mode->clock;
> +
> +	cix_dp_write(dp, CIX_DPTX_SECONDARY_DATA_WINDOW(stream_id), value);
> +	cix_dp_write(dp, CIX_DPTX_DATA_CONTROL(stream_id), data_control);
> +	cix_dp_write(dp, CIX_DPTX_USER_PIXEL_COUNT(stream_id),
> +		     dp->pixel_per_cycle);
> +}
> +
> +static struct drm_display_mode *cix_dp_get_mode(struct cix_dp *dp,
> +						int stream_id)
> +{
> +	struct drm_crtc *crtc;
> +
> +	if (stream_id < 0 || stream_id >= dp->max_streams)
> +		return NULL;
> +
> +	if (!dp->active_panels[stream_id] || !dp->bridge.encoder)
> +		return NULL;
> +
> +	crtc = dp->bridge.encoder->crtc;
> +	if (!crtc || !crtc->state)
> +		return NULL;
> +
> +	return &crtc->state->adjusted_mode;
> +}
> +
> +/*
> + * Link retraining can lower the bandwidth or the lane count while a stream
> + * is already enabled. TU and timing were programmed for the previous link,
> + * so write them again from the trained mode.
> + */
> +static void cix_dp_update_active_streams(struct cix_dp *dp)
> +{
> +	struct cix_dp_panel *panel;
> +	struct drm_display_mode *mode;
> +	int bpp;
> +	int i;
> +
> +	for (i = 0; i < dp->max_streams; i++) {
> +		panel = dp->active_panels[i];
> +		if (!panel || !panel->connector)
> +			continue;
> +
> +		mode = cix_dp_get_mode(dp, i);
> +		if (!mode)
> +			continue;
> +
> +		bpp = panel->connector->config.bpp;
> +		cix_dp_mode_set_transfer_unit(dp, panel->source_id, mode,
> +					      bpp);
> +		cix_dp_mode_set_timing(dp, panel->source_id, mode, bpp);
> +	}
> +}

[Severity: High]
Can cix_dp_get_mode() cause a use-after-free on crtc->state or a
divide-by-zero in cix_dp_mode_set_timing() when called from
cix_dp_hpd_irq_work_func()?

cix_dp_hpd_irq_work_func() runs under dp->session_lock without holding
crtc->mutex, while a concurrent atomic commit (such as a page flip or CRTC
disable) swaps and frees crtc->state without taking dp->session_lock:

CPU0 (atomic commit)              CPU1 (hpd_irq_work)
drm_atomic_helper_commit()        cix_dp_hpd_irq_work_func()
                                    cix_dp_train_loop()
                                      cix_dp_update_active_streams()
                                        mode = cix_dp_get_mode()
                                          return &crtc->state->adjusted_mode
  drm_atomic_helper_swap_state()
  drm_atomic_commit_put()
    kfree(old_crtc_state)
                                        cix_dp_mode_set_timing(..., mode, ...)
                                          ... / mode->clock  <-- UAF

If a CRTC disable commit has just swapped in a disabled crtc->state before
cix_dp_bridge_atomic_disable() acquires dp->session_lock, mode->clock is 0
and cix_dp_mode_set_timing() also divides by zero. Caching adjusted_mode in
struct cix_dp under dp->session_lock during cix_dp_bridge_mode_set() would
avoid touching crtc->state from the HPD worker.

[ ... ]
> +static ssize_t cix_dp_aux_transfer(struct drm_dp_aux *aux,
> +				   struct drm_dp_aux_msg *msg)
> +{
> +	struct cix_dp *dp = container_of(aux, struct cix_dp, aux);
> +	size_t to_access = 0;
> +	size_t accessed_bytes = 0;
> +	u32 reply_mask;
> +	u32 reply_ack;
> +	u32 state;
> +	ssize_t ret;
> +
> +	/*
> +	 * AUX has its own lock instead of session_lock: the driver calls
> +	 * drm_dp_*() helpers while holding session_lock, and those helpers
> +	 * re-enter aux->transfer. host_init() and host_deinit() take this
> +	 * lock while they enable or gate the APB clock.
> +	 */
> +	mutex_lock(&dp->aux_lock);
> +
> +	state = READ_ONCE(dp->state);
> +	if (!(state & DPTX_STATE_INITIALIZED) ||
> +	    (state & DPTX_STATE_SUSPENDED) ||
> +	    (!cix_dp_get_hpd_state(dp) && !READ_ONCE(dp->aux_ignore_hpd))) {
> +		ret = -ENODEV;
> +		goto out;
> +	}

[Severity: Medium]
Does rejecting AUX transfers when DPTX_STATE_SUSPENDED is set prevent
cix_dpcd_power_down() from putting the sink into D3 during suspend and
shutdown?

cix_dp_pm_prepare() sets DPTX_STATE_SUSPENDED before cix_dp_host_deinit()
or the KMS atomic disable path calls cix_dp_core_off() ->
cix_dpcd_power_down(). Because DPTX_STATE_INITIALIZED remains set while
apb_clk is enabled, checking only !(state & DPTX_STATE_INITIALIZED) here
would allow the D3 write to complete before cix_dp_host_deinit() gates the
clock.

[ ... ]
> +static bool cix_dp_needs_vsc_sdp(enum cix_dp_format output_format,
> +				 int colorspace)
> +{
> +	if (output_format == CIX_DP_FORMAT_YCBCR420)
> +		return true;
> +
> +	switch (colorspace) {
> +	case DRM_MODE_COLORIMETRY_SYCC_601:
> +	case DRM_MODE_COLORIMETRY_OPYCC_601:
> +	case DRM_MODE_COLORIMETRY_BT2020_YCC:
> +	case DRM_MODE_COLORIMETRY_BT2020_RGB:
> +	case DRM_MODE_COLORIMETRY_BT2020_CYCC:
> +		return true;
> +	default:
> +		break;
> +	}
> +
> +	return false;
> +}

[Severity: Medium]
Why does cix_dp_needs_vsc_sdp() omit the DCI-P3 and xvYCC colorimetries
that cix_dp_vsc_colorimetry() handles?

Because the non-VSC path in cix_dp_set_misc() never writes colorimetry bits
to MISC0, selecting DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65,
DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER, DRM_MODE_COLORIMETRY_XVYCC_601, or
DRM_MODE_COLORIMETRY_XVYCC_709 on an RGB, YCbCr 4:4:4, or YCbCr 4:2:2
stream leaves VSC SDP disabled and makes the DCI-P3 cases in
cix_dp_vsc_colorimetry() unreachable for RGB.

In addition, cix_dp_vsc_colorimetry() maps colorspace without checking
whether it matches the active pixel format, so YCbCr 4:2:0 with DCI-P3
emits 0x4 (which encodes sYCC601 in a YCbCr VSC SDP), RGB with BT2020_YCC
emits 0x7 (Reserved for RGB), and a YCbCr fallback with BT2020_RGB emits
0x6 (BT2020_CYCC instead of BT2020_YCC).

[ ... ]
> +static int __cix_dp_detect(struct cix_dp *dp)
> +{
> +	int ret;
> +
> +	lockdep_assert_held(&dp->session_lock);
> +
> +	/*
> +	 * This task is the HPD worker and suspend is already published.
> +	 * Leave the IRQ and the host down. A modeset on another task still
> +	 * goes through cix_dp_resume_locked().
> +	 */
> +	if ((dp->state & DPTX_STATE_SUSPENDED) &&
> +	    READ_ONCE(dp->hpd_worker) == current)
> +		return -EBUSY;
> +
> +	ret = cix_dp_resume_locked(dp);
> +	if (ret)
> +		return ret;
> +
> +	if (!(dp->state & DPTX_STATE_INITIALIZED)) {
> +		dev_warn_once(dp->dev, "detect with uninitialized host\n");
> +		return -ENODEV;
> +	}
> +
> +	if (!cix_dp_get_hpd_state(dp))
> +		return -ENODEV;
> +
> +	cix_dp_handle_connect_locked(dp);
> +
> +	return 0;
> +}

[Severity: High]
Does __cix_dp_detect() report a connected sink even when
cix_dp_handle_connect_locked() fails to read the DPCD, and leave
DPTX_STATE_CONNECTED set when HPD is deasserted?

If cix_dp_panel_read_sink_caps() fails over AUX, __cix_dp_detect() still
returns 0, so cix_dp_connector_detect() reports connector_status_connected
with zeroed dp->caps and stale dp->dpcd, and the next modeset fails with
-ENODEV in cix_dp_prepare(). Conversely, when !cix_dp_get_hpd_state(dp),
returning -ENODEV without calling cix_dp_handle_disconnect_locked(dp)
leaves DPTX_STATE_CONNECTED set across an unplug/replug if a poll runs
before hpd_event_work, causing cix_dp_handle_connect_locked() to skip
reading the new sink's DPCD.

[ ... ]
> +	drm_helper_probe_detect(&dp->connector.base, NULL, false);
> +
> +	cix_dp_session_lock(dp);
> +	status = dp->status;
> +	if (READ_ONCE(dp->hpd_stopped) || !dp->dp_panel.connector ||
> +	    !cix_dp_regs_accessible(dp)) {
> +		cix_dp_session_unlock(dp);
> +		goto out;
> +	}
> +	if (status == connector_status_connected)
> +		cix_dp_handle_connect_locked(dp);
> +	else
> +		cix_dp_handle_disconnect_locked(dp);
> +	cix_dp_session_unlock(dp);
> +
> +	if (old_status != status && dp->drm)
> +		drm_helper_hpd_irq_event(dp->drm);

[Severity: Medium]
Why does cix_dp_hpd_event_work_func() call drm_helper_probe_detect()
without holding dp->drm->mode_config.mutex before calling
drm_helper_hpd_irq_event()?

When ctx is NULL, drm_helper_probe_detect() only takes
mode_config.connection_mutex while reading connector->status and
incrementing connector->epoch_counter, which are protected by
mode_config.mutex, and then drm_helper_hpd_irq_event() immediately runs
detection a second time under mode_config.mutex. Moreover, if
cix_dp_replay_deferred_hotplug() schedules hpd_event_work during
cix_dp_bridge_attach() before the KMS driver calls
drm_kms_helper_poll_init(), the first drm_helper_probe_detect() updates
dp->status while drm_helper_hpd_irq_event() bails out because
!poll_enabled, leaving connector->status unknown and suppressing subsequent
hotplug events because old_status == status.

[ ... ]
> +	if (value & CIX_DPTX_INTERRUPT_HPD_EVENT)
> +		queue_delayed_work(system_freezable_wq, &dp->hpd_event_work, 0);
> +
> +	if (value & CIX_DPTX_INTERRUPT_HPD_IRQ)
> +		queue_delayed_work(system_freezable_wq, &dp->hpd_irq_work, 0);

[Severity: Medium]
Can queuing dp->hpd_event_work onto system_freezable_wq here while
cix_dp_replay_deferred_hotplug(), cix_dp_pm_complete(), and
cix_dp_oob_hotplug_event() use schedule_delayed_work() allow
cix_dp_hpd_event_work_func() to run concurrently on two CPUs?

schedule_delayed_work() queues onto system_wq, and workqueue non-reentrancy
only prevents concurrent execution when a work item is queued onto the same
workqueue it is currently running on. Two instances of
cix_dp_hpd_event_work_func() can therefore run simultaneously and race on
dp->hpd_worker (and cix_dp_oob_hotplug_event() also queues
dp->sw_hpd_irq_work onto system_wq instead of system_freezable_wq).

[ ... ]
> +static int cix_dp_pm_prepare(struct cix_dp *dp)
> +{
> +	if (dp->drm && dp->drm->mode_config.poll_enabled)
> +		drm_kms_helper_poll_disable(dp->drm);

[Severity: Medium]
Should a bridge driver's PM callbacks call drm_kms_helper_poll_disable()
and drm_kms_helper_poll_enable() on the shared struct drm_device?

Connector polling is device-wide state managed by the KMS master driver;
calling drm_kms_helper_poll_enable(dp->drm) in cix_dp_pm_complete()
re-enables polling across the whole drm_device as soon as the first
cix-dptx bridge instance resumes, while the display controller and sibling
bridges may still be suspended.

> +
> +	cix_dp_irq_off(dp);
> +
> +	/*
> +	 * Publish SUSPENDED before the cancel. oob and a running HPD
> +	 * worker then leave the IRQ and the host down.
> +	 */
> +	cix_dp_session_lock(dp);
> +	dp->state |= DPTX_STATE_SUSPENDED;
> +	cix_dp_session_unlock(dp);
> +
> +	cix_dp_cancel_hpd_works(dp);
> +
> +	cix_dp_session_lock(dp);
> +	if (!dp->active_stream_cnt)
> +		cix_dp_host_deinit(dp);
> +	dp->status = connector_status_unknown;
> +	dp->state &= ~DPTX_STATE_CONNECTED;
> +	cix_dp_session_unlock(dp);
> +
> +	return 0;
> +}

[Severity: High]
Can a concurrent detect or modeset between cix_dp_session_unlock() and the
second cix_dp_session_lock() undo suspend and leave dp->irq enabled with
apb_clk gated?

CPU0 (suspend)                    CPU1 (other task or hpd_worker)
cix_dp_pm_prepare()
  cix_dp_irq_off(dp)
  dp->state |= DPTX_STATE_SUSPENDED
  cix_dp_session_unlock(dp)
  cix_dp_cancel_hpd_works(dp)
                                  cix_dp_detect() / cix_dp_prepare()
                                    cix_dp_resume_locked(dp)
                                      cix_dp_host_init(dp)
                                      enable_irq(dp->irq)
                                      dp->state &= ~DPTX_STATE_SUSPENDED
  cix_dp_session_lock(dp)
  cix_dp_host_deinit(dp)
    clk_disable_unprepare(dp->apb_clk)  <-- IRQ left enabled with clock off

Any task other than dp->hpd_worker calling __cix_dp_detect() (such as
userspace probing or a sibling port's hpd_event_work running
drm_helper_hpd_irq_event()), or dp->hpd_worker itself calling
cix_dp_prepare() via drm_helper_hpd_irq_event() ->
drm_client_dev_hotplug(), will call cix_dp_resume_locked(dp) while
cix_dp_pm_prepare() has dropped session_lock. In addition,
cix_dp_oob_hotplug_event() overwrites dp->force_hpd with
connector_status_disconnected when DPTX_STATE_SUSPENDED is set, losing any
USB-C connect event that arrives during suspend.

[ ... ]
> +static void cix_dp_deinit(struct cix_dp *dp)
> +{
> +	if (!(dp->state & DPTX_STATE_CONFIGURED))
> +		return;
> +
> +	cix_dp_session_lock(dp);
> +	WRITE_ONCE(dp->hpd_stopped, true);
> +	cix_dp_session_unlock(dp);
> +
> +	cix_dp_irq_off(dp);
> +	cix_dp_cancel_hpd_works(dp);
> +
> +	cix_dp_session_lock(dp);
> +	cix_dp_stop_streams_locked(dp);
> +	cix_dp_host_deinit(dp);
> +	dp->state &= ~(DPTX_STATE_CONFIGURED);
> +	cix_dp_session_unlock(dp);
> +
> +	mutex_destroy(&dp->session_lock);
> +	mutex_destroy(&dp->aux_lock);
> +}

[Severity: High]
Can unbinding the platform device while dp->bridge is still attached to an
encoder cause use of destroyed mutexes and freed devm resources?

Because dp is allocated with devm_drm_bridge_alloc(), struct cix_dp
outlives platform device unbind until the encoder detaches the bridge.
However, devres runs cix_dp_deinit() on unbind, destroying
dp->session_lock and dp->aux_lock while dp->aux is still registered and
before cix_dp_bridge_detach() -> cix_dp_quiesce_hpd() locks
dp->session_lock; and if cix_dp_prepare() runs in the meantime, it sees
!(dp->state & DPTX_STATE_INITIALIZED) without checking
DPTX_STATE_CONFIGURED and calls cix_dp_host_init(), accessing freed devm
clocks, reset, PHY, and unmapped dp_iomem.

> +
> +static void cix_dptx_dev_release(struct device *dev, void *res)
> +{
> +	struct cix_dp *dp = res;
> +
> +	cix_dp_deinit(dp);
> +}
[ ... ]
> +	ret = cix_dp_init(dp);
> +	if (ret)
> +		return ret;
> +
> +	ret = devm_add_action_or_reset(dev, cix_dptx_dev_release, dp);
> +	if (ret)
> +		return ret;

[Severity: High]
Does cix_dptx_dev_release() have the wrong function signature for
devm_add_action_or_reset()?

devm_add_action_or_reset() expects void (*action)(void *), so this fails to
build with -Werror=incompatible-pointer-types, and when invoked by devres
with a single argument (dp), cix_dptx_dev_release() reads the second
parameter (res) and passes an uninitialized register value to
cix_dp_deinit().

> diff --git a/drivers/gpu/drm/cix/dptx/cix_dptx_drm.c b/drivers/gpu/drm/cix/dptx/cix_dptx_drm.c
> new file mode 100644
> index 0000000000000..5fc350daebfdd
> --- /dev/null
> +++ b/drivers/gpu/drm/cix/dptx/cix_dptx_drm.c
[ ... ]
> +static enum drm_connector_status
> +cix_dp_connector_detect(struct drm_connector *connector, bool force)
> +{
> +	struct cix_dp *dp = connector_to_dp(connector);
> +	enum drm_connector_status status;
> +
> +	if (dp->ops->detect(dp))
> +		status = connector_status_disconnected;
> +	else
> +		status = connector_status_connected;
> +
> +	dp->ops->session_lock(dp);
> +	dp->status = status;
> +	dp->ops->session_unlock(dp);
> +	drm_dp_set_subconnector_property(connector, status, dp->dpcd,
> +					 dp->downstream_ports);
> +
> +	return status;
> +}

[Severity: Medium]
Can updating dp->status in cix_dp_connector_detect() suppress hotplug
uevents in cix_dp_hpd_event_work_func(), and what protects dp->caps and
dp->link_config in cix_dp_bridge_atomic_check() and
cix_dp_connector_mode_valid()?

If userspace probes the connector after hpd_event_work is queued but before
cix_dp_hpd_event_work_func() samples old_status = dp->status, old_status
will already equal status and drm_helper_hpd_irq_event() will be skipped
(and because __cix_dp_detect() does not clear DPTX_STATE_CONNECTED on
disconnect, a subsequent reconnect will also skip reading the new sink's
DPCD). Additionally, cix_dp_bridge_atomic_check() and
cix_dp_connector_mode_valid() read dp->caps and dp->link_config without
holding dp->session_lock, racing with cix_dp_panel_read_sink_caps() zeroing
dp->caps before AUX reads complete.

> +
> +static void cix_dp_oob_hotplug_event(struct drm_connector *connector,
> +				     enum drm_connector_status hpd_state)
> +{
> +	struct cix_dp *dp = connector_to_dp(connector);
> +
> +	dp->ops->session_lock(dp);
> +	if (READ_ONCE(dp->hpd_stopped)) {
> +		dp->ops->session_unlock(dp);
> +		return;
> +	}
> +
> +	if (dp->state & DPTX_STATE_SUSPENDED) {
> +		dp->force_hpd = connector_status_disconnected;
> +		dp->ops->session_unlock(dp);
> +		return;
> +	}

[Severity: Medium]
If an out-of-band Type-C connect event arrives while DPTX_STATE_SUSPENDED
is set, doesn't setting dp->force_hpd = connector_status_disconnected lose
the hotplug event across resume?

On cix,sky1-usbdp where the hardware HPD pin is unwired,
cix_dp_get_hpd_state() relies on dp->force_hpd; clobbering it with
connector_status_disconnected instead of recording hpd_state causes the
hpd_event_work scheduled by cix_dp_pm_complete() to see the connected USB-C
monitor as disconnected after resume.

[ ... ]
> +static enum drm_mode_status
> +cix_dp_connector_mode_valid(struct drm_connector *connector,
> +			    const struct drm_display_mode *mode)
> +{
> +	const struct drm_display_info *info = &connector->display_info;
> +	struct cix_dp *dp = connector_to_dp(connector);
> +	int max_lanes = dp->link_config.max_lanes;
> +	int max_rate = dp->link_config.max_rate;
> +	int clock = mode->clock;
> +	u32 pixel_per_cycle = cix_dp_pick_ppc(mode, CIX_DP_FORMAT_RGB);
> +	int minbpp = CIX_DP_MIN_BPP;
> +
> +	if (drm_mode_is_420_only(info, mode)) {
> +		if (!connector->ycbcr_420_allowed || !dp->caps.vsc_supported)
> +			return MODE_NO_420;
> +
> +		minbpp = 8 * 3 / 2;
> +		pixel_per_cycle = 1;
> +	}
> +
> +	if (pixel_per_cycle == 1 && clock > CIX_DP_MAX_FREQ) {
> +		drm_mode_debug_printmodeline(mode);
> +		return MODE_CLOCK_HIGH;
> +	}
> +
> +	if (clock > CIX_DP_MAX_RATE(max_rate, max_lanes, minbpp)) {
> +		drm_mode_debug_printmodeline(mode);
> +		return MODE_CLOCK_HIGH;
> +	}
> +
> +	return MODE_OK;
> +}

[Severity: Medium]
Does cix_dp_connector_mode_valid() reject modes that would fit on the link
via the 8-bpc YCbCr 4:2:0 (420-also) or 8-bpc YCbCr 4:2:2 fallbacks in
fmt_prio[]?

minbpp defaults to CIX_DP_MIN_BPP (18) and is only lowered to 12 for
drm_mode_is_420_only(), so any 420-also mode (12 bpp) or YCbCr 4:2:2 mode
(16 bpp) whose clock exceeds the 18-bpp link rate limit is rejected with
MODE_CLOCK_HIGH before cix_dp_pick_format_bpc() can select those fallback
formats.

[ ... ]
> +static void cix_dp_adjust_mode(struct drm_display_mode *mode,
> +			       struct drm_display_mode *adjusted_mode)
> +{
> +	int diff = mode->htotal - mode->hsync_end;
> +
> +	/*
> +	 * Cix DP requires horizontal backporch to be greater than 12.
> +	 * This limitation may not be compatible with the sink device.
> +	 *
> +	 * Everything below is derived from @mode instead of accumulating on
> +	 * @adjusted_mode, so that repeated atomic checks of the same state
> +	 * produce the same result.
> +	 */
> +	if (diff < CIX_DPTX_MIN_H_BACKPORCH) {
> +		adjusted_mode->htotal = mode->htotal +
> +					CIX_DPTX_MIN_H_BACKPORCH - diff;
> +		adjusted_mode->clock =
> +			div_u64(mul_u32_u32(mode->clock, adjusted_mode->htotal),
> +				mode->htotal);
> +	}
> +
> +	/* The sync polarities are inverted with respect to the source mode. */
> +	if (mode->flags & DRM_MODE_FLAG_PVSYNC)
> +		adjusted_mode->flags &= ~DRM_MODE_FLAG_PVSYNC;
> +	else
> +		adjusted_mode->flags |= DRM_MODE_FLAG_PVSYNC;
> +
> +	if (mode->flags & DRM_MODE_FLAG_PHSYNC)
> +		adjusted_mode->flags &= ~DRM_MODE_FLAG_PHSYNC;
> +	else
> +		adjusted_mode->flags |= DRM_MODE_FLAG_PHSYNC;
> +}

[Severity: Medium]
Doesn't toggling only DRM_MODE_FLAG_PVSYNC and DRM_MODE_FLAG_PHSYNC leave
adjusted_mode->flags with either both positive and negative sync flags set
or neither set?

DRM_MODE_FLAG_NVSYNC and DRM_MODE_FLAG_NHSYNC need to be updated alongside
PVSYNC and PHSYNC. Also, when cix_dp_adjust_mode() increases
adjusted_mode->clock (or when a mode has clock >= CIX_DP_MAX_FREQ * 2 so
cix_dp_pick_ppc() returns 1), cix_dp_format_ok() only checks
adjusted_mode->clock against CIX_DP_MAX_FREQ for YCbCr 4:2:0 and never
validates the increased pixel clock for RGB or YCbCr 4:4:4/4:2:2.

[ ... ]
> +static int cix_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)
> +{
[ ... ]
> +	/*
> +	 * The colour space is programmed through a VSC SDP, so a change of
> +	 * the requested colour space requires a full modeset.
> +	 */
> +	if (dp->caps.vsc_supported) {
> +		const struct drm_connector_state *old_conn_state;
> +
> +		old_conn_state =
> +			drm_atomic_get_old_connector_state(bridge_state->base.state,
> +							   conn_state->connector);
> +		if (old_conn_state &&
> +		    old_conn_state->colorspace != conn_state->colorspace)
> +			crtc_state->mode_changed = true;
> +	}
> +
> +	return 0;
> +}

[Severity: Low]
Should this also check old_conn_state->content_type !=
conn_state->content_type (and enable VSC SDP in cix_dp_needs_vsc_sdp() when
content_type is non-zero)?

content_type is packed into the VSC SDP in dptx_setup_vsc_sdp() during
cix_dp_bridge_atomic_enable(), so changing the connector content type
property alone on an active stream will not update the hardware VSC SDP
unless a modeset is triggered.

[ ... ]
> +static int cix_dp_connector_atomic_check(struct drm_connector *conn,
> +					 struct drm_atomic_commit *state)
> +{
> +	struct drm_connector_state *new_con_state =
> +		drm_atomic_get_new_connector_state(state, conn);
> +
> +	if (!new_con_state)
> +		return 0;
> +
> +	/* PSR is not implemented, so never advertise self refresh support. */
> +	new_con_state->self_refresh_aware = false;
> +
> +	return 0;
> +}

[Severity: Medium]
Should the colorspace modeset check in cix_dp_bridge_atomic_check() live in
cix_dp_connector_atomic_check() instead?

cix_dp_bridge_atomic_check() runs from mode_fixup() at the end of
drm_atomic_helper_check_modeset(), after drm_atomic_crtc_needs_modeset()
has already decided whether to add affected connectors and planes, run
mode_valid(), and reset adjusted_mode from mode. Setting
crtc_state->mode_changed or connectors_changed here in
cix_dp_connector_atomic_check() ensures those modeset preparation steps are
not skipped when colorspace changes.

[ ... ]
> +static int cix_dp_connector_create(struct cix_dp *dp,
> +				   struct drm_encoder *encoder)
> +{
> +	struct cix_connector *conn = &dp->connector;
> +	struct drm_connector *connector = &conn->base;
> +	int ret;
> +
> +	conn->dp = dp;
> +
> +	connector->polled = DRM_CONNECTOR_POLL_HPD;
> +	connector->ycbcr_420_allowed = true;
> +
> +	ret = drm_connector_init_with_ddc(encoder->dev, connector,
> +					  &cix_dp_connector_funcs,
> +					  DRM_MODE_CONNECTOR_DisplayPort,
> +					  &dp->aux.ddc);
> +	if (ret)
> +		return ret;

[Severity: High]
Does cix_dp_connector_create() need to set connector->fwnode so
drm_connector_oob_hotplug_event() can find this connector?

drm_connector_oob_hotplug_event() looks up the target connector with
drm_connector_find_by_fwnode(connector_fwnode). Because connector->fwnode
is left NULL here, out-of-band hotplug notifications on cix,sky1-usbdp
ports always fail with -ENODEV and never reach cix_dp_oob_hotplug_event().

> +
> +	drm_connector_helper_add(connector, &cix_dp_connector_helper_funcs);
> +
> +	drm_atomic_helper_connector_reset(connector);
> +
> +	ret = drm_connector_attach_encoder(connector, encoder);
> +	if (ret)
> +		goto err_cleanup;
> +
> +	cix_dp_add_properties(connector);

[Severity: Medium]
Can cix_dp_add_properties() dereference a NULL connector->state if the
allocation inside drm_atomic_helper_connector_reset() fails?

drm_connector_attach_max_bpc_property() unconditionally writes to
connector->state->max_requested_bpc and connector->state->max_bpc.

[ ... ]
> +static int cix_dp_bridge_attach(struct drm_bridge *bridge,
> +				struct drm_encoder *encoder,
> +				enum drm_bridge_attach_flags flags)
> +{
> +	struct cix_dp *dp = bridge_to_dp(bridge);
> +	int ret;
> +
> +	dp->drm = bridge->dev;
> +	WRITE_ONCE(dp->hpd_stopped, false);
> +
> +	ret = dp->ops->aux_register(dp);
> +	if (ret)
> +		goto err_clear_drm;
> +
> +	/*
> +	 * Komeda (ARM Mali DPU on Sky1, not in this series) calls
> +	 * drm_bridge_attach() with attach flags 0 and does not register a
> +	 * connector; create one here so userspace gets a DP output.
> +	 */
> +	if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
> +		return 0;

[Severity: Medium]
Should cix_dp_bridge_attach() reject DRM_BRIDGE_ATTACH_NO_CONNECTOR with
-EINVAL before registering AUX?

The bridge does not implement drm_bridge_connector callbacks (.detect,
.edid_read, .get_modes, .hpd_enable/.hpd_disable), and returning 0 here
leaves dp->dp_panel.connector NULL, which causes cix_dp_set_misc() to fail
every stream enable with -EINVAL and cix_dp_hpd_event_work_func() to ignore
hotplug events.

[ ... ]
> +static void cix_dp_bridge_detach(struct drm_bridge *bridge)
> +{
> +	struct cix_dp *dp = bridge_to_dp(bridge);
> +
> +	/* Stop workers before the connector goes away. */
> +	dp->ops->quiesce_hpd(dp);
> +
> +	dp->dp_panel.connector = NULL;
> +
> +	if (dp->connector.base.dev)
> +		drm_connector_cleanup(&dp->connector.base);

[Severity: High]
Doesn't calling drm_connector_cleanup(&dp->connector.base) here while
cix_dp_connector_funcs.destroy is also set to drm_connector_cleanup()
corrupt connector refcounting during teardown?

In drm_mode_config_cleanup(), encoders (and their attached bridges) are
cleaned up before the connector list and CRTC states. Calling
drm_connector_cleanup() directly in cix_dp_bridge_detach() zeroes the
embedded struct drm_connector while references are still held, so the
subsequent drm_connector_put() underflows the zeroed refcount and
dereferences a NULL connector->funcs->destroy in drm_connector_free().

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117064552.85256-1-Luo.Liu@cixtech.com?part=2

  reply	other threads:[~2026-11-17  7:36 UTC|newest]

Thread overview: 6+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17  6:45 [PATCH v2 0/2] drm/cix: add Sky1 DisplayPort transmitter Luo Liu
2026-11-17  6:45 ` [PATCH v2 1/2] dt-bindings: display: add CIX " Luo Liu
2026-11-17  6:58   ` sashiko-bot
2026-11-17  6:45 ` [PATCH v2 2/2] drm/cix: add Sky1 DisplayPort transmitter driver Luo Liu
2026-11-17  7:36   ` sashiko-bot [this message]
2026-11-18  3:52   ` Chaoyi Chen

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-218361@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=Luo.Liu@cixtech.com \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=robh@kernel.org \
    --cc=sashiko-reviews@lists.linux.dev \
    /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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.