Devicetree
 help / color / mirror / Atom feed
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 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver
Date: Sat, 21 Nov 2026 08:08:32 +0000	[thread overview]
Message-ID: <sashiko-outbox-226820@kernel.org> (raw)
In-Reply-To: <20261121-k3-display-v3-12-ec419e8e96b8@gmail.com>

Thank you for your contribution! Sashiko AI review found 13 potential
issues to consider:
- [High] drm/spacemit: missing pre-emphasis shift in
  spacemit_dp_link_apply_adjust()
- [High] drm/spacemit: reset in spacemit_dp_dev_init() desyncs cached
  PREPLL clk rate
- [Medium] drm/spacemit: broken HPD IRQ notify in
  spacemit_dp_hotplug_event_handler()
- [Medium] drm/spacemit: fallback caps in
  spacemit_dp_hw_read_sink_caps() block retry
- [Medium] drm/spacemit: missing hw disable in spacemit_dp_unregister()
  and bind()
- [Medium] drm/spacemit: missing spacemit_dp_hw_disable() on bind init
  failure
- [Medium] drm/spacemit: pixel clock truncation to MHz in TU and HBLANK
  calculation
- [Medium] drm/spacemit: unacknowledged level-high HPD IRQ in
  spacemit_dp_irq_handler()
- [Medium] drm/spacemit: unlocked dp->link and dp->dpcd reads in
  mode_valid and check
- [Medium] drm/spacemit: AUX registered before init and MPLL reset
  without hw_mutex
- [Medium] drm/spacemit: pixel PLL left powered down on untrained link
  in atomic_enable
- [Medium] drm/spacemit: nested AUX retries and fallback in
  spacemit_dp_aux_transfer()
- [Medium] drm/spacemit: spacemit_dp_remove() runs before devm AUX bus
  depopulation
--

commit a1a5915e82d2de32d9e2fe7095172a35686df3b2
Author: Cody Kang <codykang@vsit.ai>

drm/spacemit: add Innosilicon DP/eDP controller bridge driver

This commit adds the DRM bridge driver for the Innosilicon DisplayPort and
embedded DisplayPort controller downstream of the SpacemiT Saturn DPU.

> diff --git a/drivers/gpu/drm/spacemit/spacemit_inno_dp.c b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c
> new file mode 100644
> index 0000000000000..436e5f15b4039
> --- /dev/null
> +++ b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c
[ ... ]
> +	ret = regmap_read_poll_timeout(dp->regs, DP_GENERAL_INTERRUPT, val,
> +				       val & DP_AUX_REPLY_EVENT_INT_STA,
> +				       SPACEMIT_DP_AUX_POLL_US,
> +				       SPACEMIT_DP_AUX_TIMEOUT_US);
> +	if (ret) {
> +		if (retries < SPACEMIT_DP_AUX_MAX_RETRIES) {
> +			retries++;
> +			spacemit_dp_aux_hw_reset(dp);
> +			dev_dbg(dp->dev,
> +				"AUX timeout, cmd=0x%x addr=0x%x size=%zu retry %d/%d\n",
> +				cmd, msg->address, msg->size, retries, SPACEMIT_DP_AUX_MAX_RETRIES);
> +			goto retry_eio;
> +		}
> +
> +		dev_err_ratelimited(dp->dev,
> +				    "AUX transfer timeout, req: 0x%x, cmd: 0x%x, addr: 0x%x, size %zu\n",
> +				    msg->request, cmd, msg->address, msg->size);
> +		return ret;
> +	}

[Severity: Medium]
Does retrying timed-out transfers inside spacemit_dp_aux_transfer() compound
with the DRM DP helpers and spacemit_dp_hw_read_sink_caps() to stall for
over two minutes under dp->mode_lock?

Each timed-out spacemit_dp_aux_transfer() call waits 4 * 200 ms (~813 ms).
drm_dp_dpcd_access() retries negative errors 32 times,
drm_dp_dpcd_read_data() falls back to a second 32-retry probe via
drm_dp_dpcd_readb(), and spacemit_dp_hw_read_sink_caps() loops
SPACEMIT_DP_SINK_READY_RETRIES (3) times, multiplying a single unresponsive
sink into 768 consecutive 200 ms timeouts (~156 seconds) while holding
dp->mode_lock or component bind locks.

This is also reachable on eDP during spacemit_dp_bind(), which checks
spacemit_dp_hw_detect_hpd() and calls spacemit_dp_hw_read_sink_caps() even
though DP_HPD_IN_STATUS is not meaningful on eDP and the panel is powered
off until atomic_pre_enable; when that read fails, the non-zero fallback
limits set by spacemit_dp_hw_read_sink_caps() prevent
spacemit_dp_bridge_atomic_enable() from re-reading DPCD once the panel is
powered.

[ ... ]

> +static void spacemit_dp_hw_read_sink_caps(struct spacemit_dp_dev *dp)
> +{
[ ... ]
> +	if (ret < 0) {
> +		drm_warn_ratelimited(dp->drm,
> +				     "failed to read DPCD after %d retries: %zd\n",
> +				     SPACEMIT_DP_SINK_READY_RETRIES, ret);
> +		dp->link.revision = DP_DPCD_REV_14;
> +		dp->link.max_rate = SPACEMIT_DP_LINK_RATE_5_40;
> +		dp->link.max_num_lanes = SPACEMIT_DP_LANE_2;
> +		dp->link.enhanced_framing = 1;
> +		return;
> +	}

[Severity: Medium]
Does populating non-zero fallback values in dp->link.max_rate and
dp->link.max_num_lanes when spacemit_dp_hw_read_sink_caps() fails prevent
spacemit_dp_bridge_atomic_enable() from retrying the DPCD read?

spacemit_dp_bridge_atomic_enable() only retries spacemit_dp_hw_read_sink_caps()
when !dp->link.max_rate || !dp->link.max_num_lanes.  If an earlier DPCD read
at bind or detect time fails (for example, on eDP during spacemit_dp_bind()
when noisy DP_HPD_IN_STATUS reads high before the panel is powered, or on a
slow-waking monitor), max_rate and max_num_lanes are set to 5.4 Gbps and 2
lanes while dp->dpcd remains zeroed or stale.  The enable-time retry is then
skipped, clamping 4-lane panels or monitors to 2 lanes and running link
training without valid dp->dpcd capability bytes (such as TPS3 support).

[ ... ]

> +static int spacemit_dp_link_apply_adjust(struct spacemit_dp_dev *dp,
> +					 const u8 *link_status,
> +				    enum spacemit_dp_lane_count lanes,
> +				    u8 *training_set)
> +{
> +	union phy_configure_opts opts = {
> +		.dp = {
> +			.lanes = lanes,
> +			.set_voltages = true,
> +		},
> +	};
> +	int i, ret;
> +
> +	for (i = 0; i < lanes; i++) {
> +		u8 v = drm_dp_get_adjust_request_voltage(link_status, i);
> +		u8 p = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
> +		u8 v_bits;
> +
> +		if (v >= SPACEMIT_DP_SWING_MAX)
> +			v = SPACEMIT_DP_SWING_MAX;
> +		if (p >= SPACEMIT_DP_PREEMP_MAX)
> +			p = SPACEMIT_DP_PREEMP_MAX;
> +
> +		opts.dp.voltage[i] = v;
> +		opts.dp.pre[i] = p;
> +
> +		v_bits = v;
> +		if (v == SPACEMIT_DP_SWING_MAX)
> +			v_bits |= DP_TRAIN_MAX_SWING_REACHED;
> +		if (p == SPACEMIT_DP_PREEMP_MAX)
> +			v_bits |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
> +
> +		training_set[i] = v_bits | (p << DP_TRAIN_PRE_EMPHASIS_SHIFT);
> +	}

[Severity: High]
Isn't the return value of drm_dp_get_adjust_request_pre_emphasis() already
shifted left by DP_TRAIN_PRE_EMPHASIS_SHIFT (3)?

For pre-emphasis levels 1, 2 and 3, drm_dp_get_adjust_request_pre_emphasis()
returns 8, 16 and 24.  Comparing p >= SPACEMIT_DP_PREEMP_MAX (2) without
shifting right by DP_TRAIN_PRE_EMPHASIS_SHIFT first causes any request for
pre-emphasis level 1 to be clamped to level 2, marked with
DP_TRAIN_MAX_PRE_EMPHASIS_REACHED, and shifted a second time when building
training_set[i].

[ ... ]

> +static void spacemit_dp_hw_set_msa_and_enable_video(struct spacemit_dp_dev *dp,
> +						    const struct drm_display_mode *mode,
> +						    enum spacemit_dp_link_rate rate,
> +						    enum spacemit_dp_lane_count lanes)
> +{
> +	u64 hb_num;
> +	u32 link_rate;
> +	u32 fp; /* Pixel clock in MHz */
> +	u32 tu, tu_frac, tu_int, rd_thres;
> +	u32 hsync_len, hstart, vstart;
> +
> +	/* mode->clock unit is kHz, fp unit is MHz */
> +	fp = mode->clock / 1000;
> +
> +	if (fp == 0)
> +		fp = 1; /* Prevent division by zero */
> +
> +	/*
> +	 * HBlank interval = (htotal - hactive) * (LinkSymbolClock / 4) /
> +	 * PixelClock, where LinkSymbolClock = LinkRate * 100 (1.62G -> 162MHz).
> +	 * rate is in kbit/s, so link_rate = rate / 10000 gives the 162, 270,
> +	 * 540 form used below.
> +	 */
> +	link_rate = rate / 10000;
> +
> +	/* Multiply before dividing: hb_num = hblank * (link_rate / 4) / fp */
> +	hb_num = (u64)(mode->htotal - mode->hdisplay) * link_rate;
> +	do_div(hb_num, 4 * fp);
> +
> +	/* Transfer unit: tu = fp * bpp * 640 / (8 * lanes * link_rate) */
> +	tu = div_u64((u64)fp * SPACEMIT_DP_BPP * 640, 8 * lanes * link_rate);

[Severity: Medium]
Does truncating mode->clock to integer MHz in fp underestimate the transfer
unit size for fractional-MHz pixel clocks?

spacemit_dp_set_plls() programs dp->pll_clk to mode->clock * 1000 Hz, so a
1080p60 mode runs at 148.5 MHz (and 720p60 at 74.25 MHz), whereas
fp = mode->clock / 1000 truncates those clocks to 148 MHz and 74 MHz.  For
1080p60 on 2 lanes at 2.7 Gbps, this programs a TU of 52.6 instead of 52.8,
packing fewer bytes per TU than the pixel clock delivers into the video
FIFO.  Using mode->clock in kHz and rate / 10 directly avoids the
truncation.

[ ... ]

> +static enum drm_mode_status
> +spacemit_dp_bridge_mode_valid(struct drm_bridge *bridge,
> +			      const struct drm_display_info *info,
> +			 const struct drm_display_mode *mode)
> +{
> +	struct spacemit_dp_dev *dp = container_of(bridge,
> +						  struct spacemit_dp_dev,
> +						  bridge);
> +	unsigned int max_link_rate, max_lanes;
> +	u64 max_bw, req_bw;
> +
> +	/*
> +	 * Prefer the link limits the driver maintains: they start as the
> +	 * sink's capabilities clamped to the PHY and are narrowed after a
> +	 * failed training. drm_dp_max_link_rate() is in 10 kbit/s.
> +	 */
> +	if (dp->link.max_rate && dp->link.max_num_lanes) {
> +		max_link_rate = dp->link.max_rate / 10;
> +		max_lanes = dp->link.max_num_lanes;
> +	} else {
> +		max_link_rate = min_t(unsigned int,
> +				      drm_dp_max_link_rate(dp->dpcd),
> +				      SPACEMIT_DP_SOURCE_MAX_RATE / 10);
> +		max_lanes = drm_dp_max_lane_count(dp->dpcd);
> +	}

[Severity: Medium]
Can spacemit_dp_bridge_mode_valid() and spacemit_dp_bridge_atomic_check()
race with concurrent updates to dp->link and dp->dpcd?

spacemit_dp_hw_read_sink_caps() and spacemit_dp_link_narrow() update
dp->dpcd, dp->link.max_rate and dp->link.max_num_lanes under dp->mode_lock
from the hotplug IRQ thread (spacemit_dp_hotplug_event_handler()) and from
non-blocking atomic commits (spacemit_dp_bridge_atomic_enable()), neither of
which holds the DRM modeset locks.  Reading those fields in
spacemit_dp_bridge_mode_valid() and spacemit_dp_bridge_atomic_check()
without dp->mode_lock can observe a torn rate/lane pair or partially read
dp->dpcd bytes.

[ ... ]

> +	for (trained = false, i = start;
> +	     i < ARRAY_SIZE(spacemit_dp_link_priority_table); i++) {
> +		u32 capacity;
> +
> +		cfg = &spacemit_dp_link_priority_table[i];
> +
> +		/* Source and sink limits */
> +		if (cfg->rate > dp->link.max_rate || cfg->lanes > dp->link.max_num_lanes)
> +			continue;
> +
> +		/* Bandwidth requirement */
> +		capacity = spacemit_dp_calc_link_capacity(cfg->rate,
> +							  cfg->lanes);
> +		if (capacity < req_bw)
> +			continue;
> +
> +		drm_dbg(dp->drm, "trying link config: rate %d lanes %d (capacity %d, required %d)\n",
> +			cfg->rate, cfg->lanes, capacity, req_bw);
> +
> +		spacemit_dp_link_disable(dp);
> +
> +		/* Apply Hardware Settings */
> +		if (spacemit_dp_set_plls(dp, cfg->rate, adjusted_mode->clock))
> +			continue;
> +
> +		if (spacemit_dp_phy_set_lanes(dp, cfg->lanes))
> +			continue;
> +
> +		if (spacemit_dp_phy_on(dp))
> +			continue;
[ ... ]
> +	/*
> +	 * The DPU's pixel clock comes from the PHY PLL, so scanning out into an
> +	 * untrained link never reaches CFG_RDY and wedges the CRTC on
> +	 * flip_done.
> +	 */
> +	if (!trained) {

[Severity: Medium]
Can the !trained path in spacemit_dp_bridge_atomic_enable() return with the
PHY pixel PLL powered down and stall the DPU commit?

When dp->link.max_rate or dp->link.max_num_lanes was 0 during atomic_check()
and the enable-time DPCD read yields limits below req_bw, every entry in
spacemit_dp_link_priority_table is skipped before spacemit_dp_set_plls() or
spacemit_dp_phy_on() is called, leaving the PHY powered off from
spacemit_dp_bind() or spacemit_dp_bridge_atomic_disable().  The same happens
if spacemit_dp_set_plls(), spacemit_dp_phy_set_lanes() or
spacemit_dp_phy_on() fails after spacemit_dp_link_disable().  Because the
DPU gets its pixel clock from dp->pll_clk, returning with PREPLL powered
down prevents the DPU from latching CFG_RDY and stalls
drm_atomic_helper_wait_for_flip_done() until the 3000 ms
SATURN_CFG_RDY_TIMEOUT_MS timeout expires.

[ ... ]

> +static irqreturn_t spacemit_dp_irq_handler(int irq, void *data)
> +{
> +	struct spacemit_dp_dev *dp = data;
> +	irqreturn_t ret = IRQ_NONE;
> +	int idx;
> +
> +	if (!drm_dev_enter(dp->drm, &idx))
> +		return IRQ_NONE;

[Severity: Medium]
What happens if a level-high HPD interrupt fires after drm_dev_unplug()
during master unbind?

In spacemit_drm_master_unbind(), drm_dev_unplug() runs before
drm_kms_helper_poll_fini(), drm_atomic_helper_shutdown() and
component_unbind_all().  Once drm_dev_unplug() marks the device unplugged,
drm_dev_enter() in spacemit_dp_irq_handler() returns false and the handler
exits with IRQ_NONE without calling spacemit_dp_hw_clean_hpd() to clear the
level-triggered interrupt latch, causing a hardirq storm until
spacemit_dp_unbind() calls disable_irq().

[ ... ]

> +static irqreturn_t spacemit_dp_hotplug_event_handler(int irq, void *data)
> +{
> +	struct spacemit_dp_dev *dp = data;
> +	enum drm_connector_status status;
> +	int idx;
> +
> +	if (!drm_dev_enter(dp->drm, &idx))
> +		return IRQ_HANDLED;
> +
> +	/*
> +	 * .detect() owns mode_lock and re-reads the sink caps on a fresh plug
> +	 */
> +	status = spacemit_dp_bridge_detect(&dp->bridge, dp->connector);
> +	drm_bridge_hpd_notify(&dp->bridge, status);
> +
> +	drm_dev_exit(idx);
> +	return IRQ_HANDLED;
> +}

[Severity: Medium]
Does drm_bridge_hpd_notify() ever notify DRM on external DisplayPort
hotplug interrupts?

In spacemit_dp_probe(), external DP sets dp->bridge.ops to
DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID without DRM_BRIDGE_OP_HPD.
Because drm_bridge_connector_init() only registers an HPD callback on a
bridge with DRM_BRIDGE_OP_HPD set, dp->bridge.hpd_cb is NULL and
drm_bridge_hpd_notify() is a no-op.  Moreover, calling
spacemit_dp_bridge_detect() here updates dp->connector_status without
updating dp->connector->status, so an unplug-and-replug while the pixel
clock is running between 10-second poll intervals leaves both statuses as
connector_status_connected and drops the hotplug event and EDID re-read.

[ ... ]

> +static int spacemit_dp_dev_init(struct spacemit_dp_dev *dp)
> +{
[ ... ]
> +	/* Reset Controller and PHY */
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_CONTROLLER_RESET,
> +			  FIELD_PREP(DP_CONTROLLER_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_PHY_RESET,
> +			  FIELD_PREP(DP_PHY_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_HDCP_RESET,
> +			  FIELD_PREP(DP_HDCP_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET,
> +			  FIELD_PREP(DP_AUX_RESET, 0x1));
> +	regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_VIDEO_RESET,
> +			  FIELD_PREP(DP_VIDEO_RESET, 0x1));
> +	usleep_range(5000, 8000);
[ ... ]
> +	ret = spacemit_dp_set_plls(dp, SPACEMIT_DP_LINK_RATE_2_70, 148500);
> +	if (ret)
> +		return ret;
> +
> +	ret = spacemit_dp_phy_set_lanes(dp, SPACEMIT_DP_LANE_2);
> +	if (ret)
> +		return ret;
> +
> +	ret = spacemit_dp_phy_on(dp);
> +	if (ret)
> +		return ret;

[Severity: High]
When spacemit_dp_dev_init() runs a second time in spacemit_dp_bind() on eDP
(or on component rebind), does pulsing DP_PHY_RESET wipe the PREPLL
registers while clk_set_rate(dp->pll_clk, 148500000) short-circuits in the
clock framework?

On eDP, spacemit_dp_probe() calls spacemit_dp_dev_init(), which programs
dp->pll_clk to 148.5 MHz, and the PHY clock provider caches that rate.  When
spacemit_dp_bind() calls spacemit_dp_dev_init() again, asserting
DP_PHY_RESET resets the shared PHY PREPLL registers back to hardware
defaults, but clk_set_rate(dp->pll_clk, 148500000) sees that the requested
rate matches the cached rate and returns without calling the PHY clock's
.set_rate callback.  spacemit_dp_phy_on() (and later atomic_enable() for any
148.5 MHz mode) then tries to lock an unprogrammed PREPLL.

[ ... ]

> +static int spacemit_dp_bind(struct device *dev, struct device *master,
> +			    void *data)
> +{
> +	struct spacemit_dp_dev *dp = dev_get_drvdata(dev);
> +	struct drm_device *drm = data;
> +	struct device_node *ep;
> +	int ret;
> +
> +	dp->drm = drm;
> +	dp->aux.drm_dev = drm;
> +	ret = drm_dp_aux_register(&dp->aux);
> +	if (ret) {
> +		dev_err_probe(dev, ret, "failed to register DP AUX\n");
> +		goto err_drm;
> +	}
[ ... ]
> +	ret = spacemit_dp_dev_init(dp);
> +	if (ret)
> +		goto err_encoder;

[Severity: Medium]
Can userspace AUX or DDC transactions race with spacemit_dp_dev_init() and
spacemit_dp_set_plls()?

spacemit_dp_bind() calls drm_dp_aux_register(&dp->aux) before
spacemit_dp_dev_init(dp), exposing /dev/drm_dp_aux* and the I2C adapter
before the controller is initialized on external DP and while
spacemit_dp_dev_init() powers down MPLL and asserts DP_CONTROLLER_RESET,
DP_PHY_RESET and DP_AUX_RESET without holding dp->aux.hw_mutex.  Similarly,
in spacemit_dp_bridge_atomic_enable(), spacemit_dp_link_disable() releases
dp->aux.hw_mutex before spacemit_dp_set_plls() power-cycles the MPLL that
supplies the 16 MHz AUX reference clock.

[Severity: Medium]
If spacemit_dp_dev_init() fails here in spacemit_dp_bind(), should the error
path call spacemit_dp_hw_disable(dp) the way spacemit_dp_probe() does?

spacemit_dp_dev_init() enables interrupt masks and powers up the MPLL and
PREPLL in spacemit_dp_set_plls() before calling spacemit_dp_phy_set_lanes()
and spacemit_dp_phy_on().  Jumping to err_encoder on failure leaves the
PLLs powered on, and because dp->component_added is true while bind failed,
a later spacemit_dp_remove() will not run spacemit_dp_unbind() or
spacemit_dp_hw_disable() either.

[ ... ]

> +/* Leave the DRM device, or power down a controller that never joined one. */
> +static void spacemit_dp_unregister(struct spacemit_dp_dev *dp)
> +{
> +	if (dp->component_added)
> +		component_del(dp->dev, &spacemit_dp_ops);
> +	else
> +		spacemit_dp_hw_disable(dp);
> +}

[Severity: Medium]
Does spacemit_dp_unregister() leave the hardware powered on when
dp->component_added is true but the component master was never bound?

On eDP, spacemit_dp_probe() powers up the MPLL and analog TX blocks via
spacemit_dp_dev_init() and spacemit_dp_edp_link_panel() sets
dp->component_added = true.  If the driver is removed while the aggregate
DRM device is unbound (or if spacemit_dp_dev_init() failed during
spacemit_dp_bind()), component_del() does not invoke spacemit_dp_unbind(),
and the if (dp->component_added) branch skips spacemit_dp_hw_disable(dp).
Calling spacemit_dp_hw_disable(dp) unconditionally after component_del()
would ensure the PLLs and TX blocks are always powered down.

[ ... ]

> +	ret = devm_of_dp_aux_populate_bus(&dp->aux, spacemit_dp_edp_link_panel);
> +	if (ret) {
> +		spacemit_dp_unregister(dp);
> +		return dev_err_probe(dev, ret,
> +				     "eDP: failed to populate aux-bus panel\n");
> +	}
> +
> +	return 0;
> +
> +err_disable_pxclk:
> +	clk_disable_unprepare(dp->pxclk);
> +	return ret;
> +}
> +
> +static void spacemit_dp_remove(struct platform_device *pdev)
> +{
> +	spacemit_dp_unregister(platform_get_drvdata(pdev));
> +}

[Severity: Medium]
On eDP, does spacemit_dp_remove() tear down the component and power down the
controller before devres depopulates the AUX bus?

devm_of_dp_aux_populate_bus() registers of_dp_aux_depopulate_bus_void() as a
devres action, which runs during devres_release_all() after
spacemit_dp_remove() returns.  During driver unbind, spacemit_dp_remove()
powers down the controller while the AUX-bus child panel device is still
registered, and a deferred panel probe completing in that window can still
invoke spacemit_dp_edp_link_panel() -> component_add() after
spacemit_dp_unregister() has already run:

CPU0                                  CPU1 (deferred_probe_work_func)
__device_release_driver()
  spacemit_dp_remove()
    spacemit_dp_unregister()
      /* dp->component_added is false */
      spacemit_dp_hw_disable()
                                      panel_edp_probe()
                                        spacemit_dp_edp_link_panel()
                                          component_add(dp->dev, ...)
  devres_release_all()
    of_dp_aux_depopulate_bus_void()
    /* dp freed while component remains registered */

Depopulating the AUX bus in spacemit_dp_remove() before
spacemit_dp_unregister() (or registering spacemit_dp_unregister() as a devm
action prior to devm_of_dp_aux_populate_bus()) avoids this ordering
inversion.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261121-k3-display-v3-0-ec419e8e96b8@gmail.com?part=12

  reply	other threads:[~2026-11-21  8:08 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
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 [this message]
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-226820@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