From 08758b6408ada8db5157aa935548c8e5ac81d8e1 Mon Sep 17 00:00:00 2001 From: DjDeveloperr Date: Sun, 15 Nov 2026 19:22:19 -0500 Subject: [PATCH 1/2] drm/apple: T6050: offer a merged mode only while a pair fits the platform A J714s external display that one engine cannot drive at its fastest timing, a 4K 240 Hz one, has the unrouted fourth external engine reserved as its peer and is offered its merged modes. With two other external displays present, that pair takes the last of the T6050's four external engines: the paired mode set leaves the display dark while the other two light. macOS limits this. It gives a display a full pair only while the external displays and the pair leave an external engine unused: with one other external display present it pairs the 4K 240 Hz display, with two others it runs it on one engine at 4K 120 Hz and leaves the peer off, and with only two external displays it pairs it again. Apply that limit on the J714s, with the decision in the fabric core (dcp_fabric_merged_fits()) and a KUnit case for it: - dcp_mode_valid() does not offer a mode only a pair drives while the external displays present, the asking one included, and the pair would take every external engine of the DRM device; the display's fastest single-engine modes remain; - the atomic check refuses such a timing then, for a CRTC being enabled too; - after each hotplug, a display whose limit changed has its connector probed again, so its merged modes are withdrawn when a third external display arrives and offered again when one leaves; one that runs a pair when the limit takes it away is also reported with a bad link, for the compositor to set one of the modes it is left with; - the peer stays reserved, as no display is routed to it: the firmware keeps the merged timings for when the pair fits again, and a single-engine mode set stops a pair that ran, as before. Nothing changes while a pair fits: alone or with one other external display, the 4K 240 Hz display pairs as before. On a J714s with a DP alt mode display and a dock with two displays, the 4K 240 Hz display is offered every mode but the one that needs a pair. With the DP IN 1 link fixes of the same series it then runs at 3840x2160@120, beside the other two at 3840x2160@120 and 1920x1280@60. Signed-off-by: Diljit Singh --- drivers/gpu/drm/apple/dcp-fabric-core.c | 8 ++ drivers/gpu/drm/apple/dcp-fabric-core.h | 14 +++ drivers/gpu/drm/apple/dcp-fabric-test.c | 65 ++++++++++ drivers/gpu/drm/apple/dcp-internal.h | 6 + .../gpu/drm/apple/dcp-peer-runtime-v27.inc | 23 +++- drivers/gpu/drm/apple/dcp-peer-v27.inc | 115 ++++++++++++++++++ drivers/gpu/drm/apple/dcp.h | 2 + drivers/gpu/drm/apple/iomfb.c | 11 ++ 8 files changed, 243 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/apple/dcp-fabric-core.c b/drivers/gpu/drm/apple/dcp-fabric-core.c index 6a7fab89c1908..84e1151343577 100644 --- a/drivers/gpu/drm/apple/dcp-fabric-core.c +++ b/drivers/gpu/drm/apple/dcp-fabric-core.c @@ -531,5 +531,13 @@ bool dcp_fabric_t6030_link(bool tunnel, bool has_xbar, bool t6030_dpin) } EXPORT_SYMBOL_GPL(dcp_fabric_t6030_link); +bool dcp_fabric_merged_fits(unsigned int displays, unsigned int extra, + unsigned int engines) +{ + return displays && extra && displays < engines && + extra < engines - displays; +} +EXPORT_SYMBOL_GPL(dcp_fabric_merged_fits); + MODULE_DESCRIPTION("Apple display fabric decisions"); MODULE_LICENSE("Dual MIT/GPL"); diff --git a/drivers/gpu/drm/apple/dcp-fabric-core.h b/drivers/gpu/drm/apple/dcp-fabric-core.h index 602e7b2efb7f6..af2be00cb6a2d 100644 --- a/drivers/gpu/drm/apple/dcp-fabric-core.h +++ b/drivers/gpu/drm/apple/dcp-fabric-core.h @@ -212,4 +212,18 @@ u32 dcp_fabric_port_crtc_mask(bool secondary, bool ordered_dual, bool typec_only enum dcp_fabric_attach_action dcp_fabric_attach_action(bool external); bool dcp_fabric_t6030_link(bool tunnel, bool has_xbar, bool t6030_dpin); +/* + * T6050's platform limit on merged (dual-pipe) modes: whether a display may + * take a mode its own engine cannot drive, @extra engines more than its own, + * while @displays external displays, it included, are present on the + * platform's @engines external display engines. A full pair is given only + * while the displays and the pair leave an external engine unused; on the + * four engines of a T6050, a display pairs alone or with one other external + * display present, not with two. Otherwise the platform offers only a limited + * pipe, which the driver does not implement, and the display runs on its own + * engine at a timing that one engine drives. + */ +bool dcp_fabric_merged_fits(unsigned int displays, unsigned int extra, + unsigned int engines); + #endif /* __APPLE_DCP_FABRIC_CORE_H__ */ diff --git a/drivers/gpu/drm/apple/dcp-fabric-test.c b/drivers/gpu/drm/apple/dcp-fabric-test.c index ef6381b159073..ae193fca48353 100644 --- a/drivers/gpu/drm/apple/dcp-fabric-test.c +++ b/drivers/gpu/drm/apple/dcp-fabric-test.c @@ -2345,6 +2345,70 @@ static void relink_stamp_test(struct kunit *test) KUNIT_EXPECT_TRUE(test, dcp_relink_unplug(&s, 1, 3)); } +/* + * T6050's limit on merged modes, on its four external engines (one of them an + * unrouted peer): a display that needs a pair gets it alone and with one other + * external display present, not with two, whichever order the three come in, + * and gets it back once one of the others leaves. + */ +static void fabric_t6050_merged_limit_test(struct kunit *test) +{ + /* One display on direct DP, one in the same dock as the paired one. */ + enum { DIRECT, DOCK, PAIRED, NR }; + static const u8 orders[][NR] = { + { DIRECT, DOCK, PAIRED }, /* direct first, the dock's other before it */ + { DIRECT, PAIRED, DOCK }, /* the dock's other after it */ + { DOCK, PAIRED, DIRECT }, /* the dock first */ + { DOCK, DIRECT, PAIRED }, + { PAIRED, DOCK, DIRECT }, /* the paired one first */ + { PAIRED, DIRECT, DOCK }, + }; + const unsigned int engines = 4; + unsigned int o, i, j; + + KUNIT_EXPECT_TRUE(test, dcp_fabric_merged_fits(1, 1, engines)); + KUNIT_EXPECT_TRUE(test, dcp_fabric_merged_fits(2, 1, engines)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(3, 1, engines)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(4, 1, engines)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(5, 1, engines)); + /* No display, no pair asked for, no engine to spare, no wrap. */ + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(0, 1, engines)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(1, 0, engines)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(1, 1, 2)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(1, UINT_MAX, engines)); + KUNIT_EXPECT_FALSE(test, dcp_fabric_merged_fits(UINT_MAX, 1, engines)); + + for (o = 0; o < ARRAY_SIZE(orders); o++) { + bool present[NR] = {}; + + for (i = 0; i < NR; i++) { + unsigned int others; + bool fits; + + present[orders[o][i]] = true; + if (!present[PAIRED]) + continue; + /* + * The paired display counts itself from its display hints + * on, which come before it is reported connected. + */ + others = present[DIRECT] + present[DOCK]; + fits = dcp_fabric_merged_fits(others + 1, 1, engines); + KUNIT_EXPECT_EQ_MSG(test, fits, others <= 1, "order %u, step %u", o, i); + } + /* From all three, either other one leaving gives the pair back. */ + for (j = DIRECT; j <= DOCK; j++) { + unsigned int displays; + + present[j] = false; + displays = present[DIRECT] + present[DOCK] + present[PAIRED]; + KUNIT_EXPECT_TRUE_MSG(test, dcp_fabric_merged_fits(displays, 1, engines), + "order %u, display %u unplugged", o, j); + present[j] = true; + } + } +} + /* * A refused T8132 tunnel clock stays refused through stops, failed or not, * and only a nonzero rate taken clears it: refused, 0, refused is one @@ -2377,6 +2441,7 @@ static void fabric_t8132_clock_refused_test(struct kunit *test) static struct kunit_case fabric_tests[] = { KUNIT_CASE(fabric_t8132_clock_refused_test), + KUNIT_CASE(fabric_t6050_merged_limit_test), KUNIT_CASE(relink_unplug_test), KUNIT_CASE(relink_running_test), KUNIT_CASE(relink_budget_test), diff --git a/drivers/gpu/drm/apple/dcp-internal.h b/drivers/gpu/drm/apple/dcp-internal.h index fd4f4c5746c33..2eb5eb53fb8c6 100644 --- a/drivers/gpu/drm/apple/dcp-internal.h +++ b/drivers/gpu/drm/apple/dcp-internal.h @@ -439,6 +439,12 @@ struct apple_dcp { struct delayed_work hybrid_wq; struct dcp_peer_tiling peer_tiling; bool peer_unbinding; + /* + * T6050: the platform limit left this display no pair when last + * evaluated (dcp_peer_hints_v27(), dcp_peer_limit_update_v27()). Under + * dcp_peer_lock. + */ + bool peer_limited; /* Firmware display endpoint (its Disp_Index), apple,dcp-endpoint; * separate from index, which also selects the doorbell and PHY mode. */ u32 peer_endpoint; diff --git a/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc b/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc index 7b4b500824c36..c8b4862d36c8d 100644 --- a/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc +++ b/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc @@ -127,13 +127,23 @@ bool dcp_peer_needs_pair_v27(struct apple_dcp *dcp, u32 clock_khz) return dcp->fw_compat == DCP_FIRMWARE_V_27_0 && rate && (u64)clock_khz * 1000 > rate; } +/* A timing only a pair drives, while the platform limit leaves no pair. */ +bool dcp_peer_mode_limited_v27(struct apple_dcp *dcp, u32 clock_khz) +{ + if (!dcp_peer_needs_pair_v27(dcp, clock_khz)) + return false; + guard(mutex)(&dcp_peer_lock); + return dcp_peer_limited_locked(dcp, NULL, NULL); +} + /* * At atomic check: refuse a paired timing the pair cannot take, so that the * commit fails instead of a mode set that leaves the CRTC without a timing. * The peer's CRTC is not taken into the commit; its current state is read. * A CRTC being enabled reserves its peer when the link comes up, in * dcp_poweron() after this check; iomfb_modeset() refuses the timing then - * if no peer was reserved. + * if no peer was reserved. While the platform limit leaves the display no + * pair, a paired timing is refused whatever the peer's state. */ int dcp_peer_check_v27(struct apple_dcp *dcp, struct drm_atomic_commit *commit, struct drm_crtc_state *crtc_state) @@ -157,7 +167,18 @@ int dcp_peer_check_v27(struct apple_dcp *dcp, struct drm_atomic_commit *commit, return -EINVAL; scoped_guard(mutex, &dcp_peer_lock) { struct apple_dcp *peer = dcp->peer_reserved; + unsigned int displays, engines; + /* Not even for a CRTC being enabled: the limit has no pair to give. */ + if (dcp_peer_limited_locked(dcp, &displays, &engines)) { + dev_info_ratelimited(dcp->dev, + "mode %ux%u@%u refused: %u external displays on %u engines leave no pair\n", + crtc_state->mode.hdisplay, + crtc_state->mode.vdisplay, + drm_mode_vrefresh(&crtc_state->mode), + displays, engines); + return -EINVAL; + } if (!peer && crtc_state->active_changed) return 0; if (!peer || peer->peer_owner != dcp || peer->fixed_phy || diff --git a/drivers/gpu/drm/apple/dcp-peer-v27.inc b/drivers/gpu/drm/apple/dcp-peer-v27.inc index a9424bcf79c1e..7d598c29e87c5 100644 --- a/drivers/gpu/drm/apple/dcp-peer-v27.inc +++ b/drivers/gpu/drm/apple/dcp-peer-v27.inc @@ -7,6 +7,105 @@ static bool peer_allocation_probe = true; module_param(peer_allocation_probe, bool, 0444); MODULE_PARM_DESC(peer_allocation_probe, "Firmware27 logical peer allocation for merged modes (default: on)"); +/* + * The platform limit on merged modes (dcp_fabric_merged_fits()) holds on the + * board it has run on, for the J714s's T6050 external display processors. + */ +static bool dcp_peer_limit_applies(struct apple_dcp *dcp) +{ + return dcp->fw_compat == DCP_FIRMWARE_V_27_0 && dcp_j714s_ext(dcp->dev); +} + +/* + * Whether the platform limit leaves @dcp's display no pair. The external + * engines of its DRM device are counted, and the external displays present on + * them: its own always, since its display hints come before its connector is + * reported connected. + */ +static bool dcp_peer_limited_locked(struct apple_dcp *dcp, unsigned int *displays, + unsigned int *engines) +{ + unsigned int present = 0, count = 0; + struct drm_crtc *crtc; + + lockdep_assert_held(&dcp_peer_lock); + if (!dcp_peer_limit_applies(dcp) || !dcp->crtc) + return false; + drm_for_each_crtc(crtc, dcp->crtc->base.dev) { + struct apple_dcp *p = platform_get_drvdata(to_apple_crtc(crtc)->dcp); + struct apple_connector *con; + + if (!p || !dcp_peer_limit_applies(p)) + continue; + count++; + con = READ_ONCE(p->connector); + if (p == dcp || (con && READ_ONCE(con->connected))) + present++; + } + if (displays) + *displays = present; + if (engines) + *engines = count; + /* The pair this driver sets up takes one engine more. */ + return !dcp_fabric_merged_fits(present, 1, count); +} + +/* More than the display processors of any board with the limit. */ +#define DCP_PEER_LIMIT_DISPLAYS 8 + +/* + * An external display of @drm came or went: the platform limit may now give + * another display its pair, or take it away. Have the connector of each + * display whose limit changed probed again, so that its merged modes are + * offered only while a pair fits (dcp_mode_valid()). A display that runs a + * pair when the limit takes it away is also reported with a bad link, for the + * compositor to set one of the modes it is left with. + */ +void dcp_peer_limit_update_v27(struct drm_device *drm) +{ + struct apple_connector *probe[DCP_PEER_LIMIT_DISPLAYS]; + bool bad[DCP_PEER_LIMIT_DISPLAYS]; + unsigned int n = 0, i; + struct drm_crtc *crtc; + + /* Neither a board without the limit nor a device without CRTCs. */ + if (!of_machine_is_compatible("apple,j714s") || !drm->mode_config.num_crtc) + return; + scoped_guard(mutex, &dcp_peer_lock) { + drm_for_each_crtc(crtc, drm) { + struct apple_dcp *p = platform_get_drvdata(to_apple_crtc(crtc)->dcp); + unsigned int displays = 0, engines = 0; + struct apple_connector *con; + bool limited; + + if (!p || !dcp_peer_limit_applies(p)) + continue; + limited = dcp_peer_limited_locked(p, &displays, &engines); + if (limited == p->peer_limited) + continue; + p->peer_limited = limited; + /* Only a display with merged modes has a peer reserved. */ + con = READ_ONCE(p->connector); + if (!con || !READ_ONCE(con->connected) || !p->peer_reserved || + n == ARRAY_SIZE(probe)) + continue; + dev_info(p->dev, "platform limit: %u external displays on %u engines: %s\n", + displays, engines, limited ? + "no pair, modes beyond one engine withdrawn" : + "a pair fits, modes beyond one engine offered again"); + probe[n] = con; + bad[n++] = limited && (p->peer_frames.active || p->peer_tiling.vftg); + } + } + /* Outside dcp_peer_lock: atomic check takes it under the modeset locks. */ + for (i = 0; i < n; i++) { + if (bad[i]) + drm_connector_set_link_status_property(&probe[i]->base, + DRM_MODE_LINK_STATUS_BAD); + dcp_queue_hotplug(probe[i]); + } +} + bool dcp_peer_tiling_state_v27(struct apple_dcp *dcp, bool write, u32 event, u32 param, u32 *value) { @@ -142,6 +241,22 @@ int dcp_peer_hints_v27(struct apple_dcp *dcp, struct dptx_port *port, get_unaligned_le32(r->hints + 0x40), get_unaligned_le32(r->hints + 0x44)); } + /* + * The platform limit keeps the reservation: the peer is an engine no + * display is routed to, and the firmware keeps the merged timings for + * when a pair fits again (dcp_peer_limit_update_v27()). Until then DRM + * offers only the modes one engine drives; a mode set of one of them + * stops a pair that ran and sets the mode on this engine alone + * (dcp_peer_install_video_v27()). + */ + { + unsigned int displays, engines; + + dcp->peer_limited = dcp_peer_limited_locked(dcp, &displays, &engines); + if (dcp->peer_limited) + dev_info(dcp->dev, "platform limit: %u external displays on %u engines: no pair, modes beyond one engine withheld\n", + displays, engines); + } /* The display allocation update writes primary/peer endpoint IDs. * The extra pipe count supplies byte8. This is full dual-pipe, so the * T6050 limited-dual-pipe flag (byte9 bit1) remains clear. diff --git a/drivers/gpu/drm/apple/dcp.h b/drivers/gpu/drm/apple/dcp.h index 61ca1ca35f709..565666522dc52 100644 --- a/drivers/gpu/drm/apple/dcp.h +++ b/drivers/gpu/drm/apple/dcp.h @@ -73,6 +73,8 @@ bool dcp_peer_tiling_state_v27(struct apple_dcp *dcp, bool write, void dcp_peer_display_ids_v27(struct apple_dcp *dcp, u32 own, u32 related); int dcp_peer_modeset_v27(struct apple_dcp *dcp, u32 timing, u32 color, u32 min_vrr); bool dcp_peer_needs_pair_v27(struct apple_dcp *dcp, u32 clock_khz); +bool dcp_peer_mode_limited_v27(struct apple_dcp *dcp, u32 clock_khz); +void dcp_peer_limit_update_v27(struct drm_device *drm); int dcp_peer_check_v27(struct apple_dcp *dcp, struct drm_atomic_commit *commit, struct drm_crtc_state *crtc_state); int dcp_peer_color_v27(struct apple_dcp *dcp, struct iomfb_set_matrix_req *matrix); diff --git a/drivers/gpu/drm/apple/iomfb.c b/drivers/gpu/drm/apple/iomfb.c index 336f6f46fdea8..561ecd46dafb6 100644 --- a/drivers/gpu/drm/apple/iomfb.c +++ b/drivers/gpu/drm/apple/iomfb.c @@ -1872,6 +1872,8 @@ void dcp_hotplug(struct work_struct *work) } dcp_notify_hotplug(connector); apple_connector_backlight_sync(connector); + /* The display left: another may get its pair back. */ + dcp_peer_limit_update_v27(connector->base.dev); return; } dcp = platform_get_drvdata(pdev); @@ -1961,6 +1963,8 @@ void dcp_hotplug(struct work_struct *work) dcp_notify_hotplug(connector); /* after the event, so registering a backlight cannot delay it */ apple_connector_backlight_sync(connector); + /* A display came or went: the platform limit may now differ for another. */ + dcp_peer_limit_update_v27(connector->base.dev); } /* @@ -3380,6 +3384,13 @@ enum drm_mode_status dcp_mode_valid(struct drm_connector *connector, scoped_guard(mutex, &dcp->modes_lock) if (!dcp_modes_for_connector(dcp, apple_connector)) return MODE_BAD; + /* + * A mode only a pair drives is not offered while the platform limit + * leaves this display no pair; dcp_peer_limit_update_v27() has the + * connector probed again when that changes. + */ + if (dcp_peer_mode_limited_v27(dcp, mode->clock)) + return MODE_CLOCK_HIGH; return dcp_mode_settable(dcp, mode) ? MODE_OK : MODE_BAD; } From acbfd05442d4c592ed09655fd886e303edf70f22 Mon Sep 17 00:00:00 2001 From: DjDeveloperr Date: Sun, 15 Nov 2026 19:22:20 -0500 Subject: [PATCH 2/2] drm/apple: T6050: run no paired call for a display the limit leaves unpaired dcp_peer_modeset_v27() also ran for a single-engine mode set of a display with a reserved peer while the platform limit leaves it no pair. It sent the paired preparation calls to both engines and asked the firmware for the merged video data first; once the firmware had dropped the link that query failed, and the failure was returned as a failed paired mode set: apple-dcp 302e00000.dcp: paired mode set failed: -2 While the limit holds no paired call runs now. A pair that ran is stopped, both engines powered off and only this one powered on again, so the peer stays off as in macOS, and the mode is set on this engine alone. On a J714s with three external displays, the 4K 240 Hz display's failed paired mode set is gone from the boot log. Signed-off-by: Diljit Singh --- .../gpu/drm/apple/dcp-peer-runtime-v27.inc | 50 +++++++++++++++++++ drivers/gpu/drm/apple/dcp-peer-v27.inc | 4 +- 2 files changed, 52 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc b/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc index c8b4862d36c8d..6be680b1c50f3 100644 --- a/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc +++ b/drivers/gpu/drm/apple/dcp-peer-runtime-v27.inc @@ -74,9 +74,45 @@ static void dcp_peer_finish_v27(struct apple_dcp *dcp, struct apple_dcp *peer) le32_to_cpu(tile[0]), le32_to_cpu(tile[1])); } +/* + * While the platform limit leaves the display no pair, it is set one of the + * modes one engine drives (dcp_peer_check_v27()), and no paired call runs for + * it. A pair it ran is stopped first: both engines powered off, the peer left + * off and this engine powered on again. -EOPNOTSUPP then has the caller set + * the mode on this engine alone. + */ +static bool dcp_peer_limited_pair_locked(struct apple_dcp *dcp, bool *prepared) +{ + struct apple_dcp *peer = dcp->peer_reserved; + + lockdep_assert_held(&dcp_peer_lock); + *prepared = false; + if (!peer || !dcp_peer_limited_locked(dcp, NULL, NULL)) + return false; + *prepared = dcp->peer_tiling.vftg || peer->peer_tiling.vftg; + return true; +} + +static int dcp_peer_limited_stop_v27(struct apple_dcp *dcp, struct apple_dcp *peer) +{ + u8 power[16] = {1}, response[8]; + int ret; + + ret = dcp_peer_probe_quiesce(dcp, peer); + if (ret) + return ret; + ret = dcp_peer_video_call(dcp, "A484", power, sizeof(power), + response, sizeof(response)); + if (ret || get_unaligned_le32(response + 4)) + return ret ?: -EIO; + dev_info(dcp->dev, "platform limit: pair stopped, its peer left off\n"); + return -EOPNOTSUPP; +} + int dcp_peer_modeset_v27(struct apple_dcp *dcp, u32 timing, u32 color, u32 min_vrr) { struct apple_dcp *peer; + bool limited, prepared; int ret = -EOPNOTSUPP; if (!peer_scanout || !peer_allocation_probe || @@ -84,6 +120,12 @@ int dcp_peer_modeset_v27(struct apple_dcp *dcp, u32 timing, u32 color, u32 min_v return ret; if (timing > U32_MAX - 10000 || color > U32_MAX - 10000) return -EINVAL; + /* No paired call, nor wait for one, for a display the limit leaves no pair. */ + scoped_guard(mutex, &dcp_peer_lock) { + limited = dcp_peer_limited_pair_locked(dcp, &prepared); + if (limited && !prepared) + return ret; + } if (!device_trylock(dcp->dev)) return -EBUSY; { @@ -91,6 +133,10 @@ int dcp_peer_modeset_v27(struct apple_dcp *dcp, u32 timing, u32 color, u32 min_v peer = dcp->peer_reserved; if (!peer) goto unlock; + /* The limit may have come or gone since the check above. */ + limited = dcp_peer_limited_pair_locked(dcp, &prepared); + if (limited && !prepared) + goto unlock; if (peer->peer_owner != dcp || !dcp_peer_transport_idle(dcp) || !dcp_peer_transport_idle(peer) || peer->fixed_phy || peer->nr_typec_routes || !peer->crtc || @@ -100,6 +146,10 @@ int dcp_peer_modeset_v27(struct apple_dcp *dcp, u32 timing, u32 color, u32 min_v goto unlock; } } + if (limited) { + ret = dcp_peer_limited_stop_v27(dcp, peer); + goto peer_unlock; + } ret = dcp_peer_prepare_v27(dcp, peer, min_vrr); if (ret) goto peer_unlock; diff --git a/drivers/gpu/drm/apple/dcp-peer-v27.inc b/drivers/gpu/drm/apple/dcp-peer-v27.inc index 7d598c29e87c5..a824ab7e99265 100644 --- a/drivers/gpu/drm/apple/dcp-peer-v27.inc +++ b/drivers/gpu/drm/apple/dcp-peer-v27.inc @@ -246,8 +246,8 @@ int dcp_peer_hints_v27(struct apple_dcp *dcp, struct dptx_port *port, * display is routed to, and the firmware keeps the merged timings for * when a pair fits again (dcp_peer_limit_update_v27()). Until then DRM * offers only the modes one engine drives; a mode set of one of them - * stops a pair that ran and sets the mode on this engine alone - * (dcp_peer_install_video_v27()). + * runs no paired call: it stops a pair that ran, leaving the peer off, + * and sets the mode on this engine alone (dcp_peer_modeset_v27()). */ { unsigned int displays, engines;