From 4057473866c24de06cad3e39e0dff5a0afccf3a3 Mon Sep 17 00:00:00 2001 From: DjDeveloperr Date: Sun, 15 Nov 2026 18:58:21 -0500 Subject: [PATCH] phy: apple: atc-t6050-dp: run a DP tunnel clock only for its link On the J714s dock, a 4K display on the dock's second DP IN never holds its link beside a display on the first: the sink raises IRQ_HPD after each training, and the DCP firmware drops it and relinks. The driver ran the port's tunnel clocks unlike macOS: - the port's first clock started the other three with it, at its rate and with no user, so the second DP IN's clock already ran at the first display's rate when its own link came up, and took its own rate in place; the two clocks no display uses kept running; - a clock whose display went kept running while another clock ran; - a stop cleared the enable before it parked the switch. macOS, measured on this setup, starts a clock once, from off, when its DP IN's link is set up, at that link's rate. The clocks no display uses never run, and no clock takes another rate while it runs. After any change it walks all four clocks in order: a clock with a rate gets its gate on, then its power manager source, then its switch field and enable; a clock without one gets its switch parked and its enable cleared, then its gate off. A running clock's source and switch are written again as they are. Do the same. Each clock has the rate of its link, or none. A start and a stop both apply all four clocks in that order, a stop takes the clock to off, and a new rate for a running clock stops it and starts it again from off. The park in USB4 mode is the same walk with no clock running. On a J714s with a 1920x1280 display on the dock's DP IN 0 and a 3840x2160 display on DP IN 1, each clock now starts from off at its own link's rate, no clock changes rate while it runs, and the port's other two clocks stay off. This alone does not keep the DP IN 1 display's link: its sink still raises IRQ_HPD after training. Signed-off-by: Diljit Singh --- drivers/phy/apple/atc-t6050-dp.c | 262 ++++++++++++++++--------------- 1 file changed, 135 insertions(+), 127 deletions(-) diff --git a/drivers/phy/apple/atc-t6050-dp.c b/drivers/phy/apple/atc-t6050-dp.c index 55c9e3cff2b2a..6e76b8573d36a 100644 --- a/drivers/phy/apple/atc-t6050-dp.c +++ b/drivers/phy/apple/atc-t6050-dp.c @@ -123,12 +123,11 @@ struct t6050_dp { bool fw_running; bool fw_cold; /* idled for a system sleep and halted: its next start is a cold one */ void *fw_data_saved; /* the firmware data SRAM as the first start found it */ - /* USB4 DP tunnel pixel clocks: source words, gates, running link rates */ + /* USB4 DP tunnel pixel clocks: source words, gates, each one's link rate (0: off) */ void __iomem *dp_clk_src; struct atc_domain dp_gate[ATC_DP_TUNNELS]; bool dp_gates; u8 tunnel_rate[ATC_DP_TUNNELS]; - u8 tunnel_idle; /* bit k - 1: clock k runs with no user, see below */ /* A combo PHY's system sleep. */ u32 port; struct notifier_block pm_nb; @@ -497,73 +496,125 @@ static int atc_dp_source(u8 rate) } } -/* Switch tunnel clock @k off and park it; its gate stays as it is. */ -static void atc_dp_tunnel_switch_off(struct t6050_dp *dp, unsigned int k) +/* + * Set switch @k as tunnel clock @k's rate has it: field k (and the UHBR bit + * for a 128b/132b rate) with its enable bit for a clock with a rate, field 7 + * (parked) with its enable bit clear for one without. The switch is written + * before the enable, then the status read back for the enable bit. + */ +static int atc_dp_tunnel_switch(struct t6050_dp *dp, unsigned int k, u32 *status) { void __iomem *cfg = dp->banks[39]; - u32 en = atc_dp_enable_bit(k), v; - - writel(readl(cfg + ATC_CFG_DP_ENABLE) & ~en, cfg + ATC_CFG_DP_ENABLE); - writel((readl(cfg + ATC_CFG_DP_SWITCH) & ~atc_dp_switch_mask(k)) | - (ATC_DP_SWITCH_PARKED << (3 * k - 3)), cfg + ATC_CFG_DP_SWITCH); - if (readl_poll_timeout(cfg + ATC_CFG_DP_STATUS, v, !(v & en), 10, 10000)) - dev_warn(dp->dev, "DP tunnel clock %u: switch status %08x still on\n", k, v); - dp->tunnel_rate[k - 1] = 0; - dp->tunnel_idle &= ~BIT(k - 1); + u8 rate = dp->tunnel_rate[k - 1]; + u32 en = atc_dp_enable_bit(k); + u32 sw = readl(cfg + ATC_CFG_DP_SWITCH) & ~atc_dp_switch_mask(k); + u32 on = readl(cfg + ATC_CFG_DP_ENABLE) & ~en; + u32 v; + int ret; + + if (rate) { + sw |= k << (3 * k - 3); + if (rate == 0x81 || rate == 0x82) + sw |= BIT(11 + k); + on |= en; + } else { + sw |= ATC_DP_SWITCH_PARKED << (3 * k - 3); + } + writel(sw, cfg + ATC_CFG_DP_SWITCH); + writel(on, cfg + ATC_CFG_DP_ENABLE); + ret = readl_poll_timeout(cfg + ATC_CFG_DP_STATUS, v, !(v & en) == !rate, 10, 10000); + if (status) + *status = v; + return ret; } /* - * Park every tunnel clock switch that runs no clock (field 7, enable off), - * once the PHY is in USB4 mode: an unparked switch selects the native DP - * clock for its crossbar pixel clock. + * Bring tunnel clock @k to its rate: for a clock with one, its gate on, then + * the power manager's source for the rate (its busy bit waited out), then its + * switch; for a clock without one, its switch parked, then its gate off. */ -static void atc_dp_tunnels_park(struct t6050_dp *dp) +static int atc_dp_tunnel_apply(struct t6050_dp *dp, unsigned int k, u32 *status) { - void __iomem *cfg = dp->banks[39]; - u32 sw = readl(cfg + ATC_CFG_DP_SWITCH), en = readl(cfg + ATC_CFG_DP_ENABLE); + unsigned int i = k - 1; + u8 rate = dp->tunnel_rate[i]; + void __iomem *word; + int ret, src; + u32 v; - for (unsigned int k = 1; k <= ATC_DP_TUNNELS; k++) { - if (dp->tunnel_rate[k - 1]) - continue; - sw = (sw & ~atc_dp_switch_mask(k)) | (ATC_DP_SWITCH_PARKED << (3 * k - 3)); - en &= ~atc_dp_enable_bit(k); + if (!rate) { + if (atc_dp_tunnel_switch(dp, k, &v)) + dev_warn(dp->dev, "DP tunnel clock %u: switch status %08x still on\n", + k, v); + /* A failed start or gate suspend can leave a held domain at rate zero. */ + return dp->dp_gates ? atc_domain_set(&dp->dp_gate[i], false) : 0; } - writel(en, cfg + ATC_CFG_DP_ENABLE); - writel(sw, cfg + ATC_CFG_DP_SWITCH); + if (dp->dp_gates) { + ret = atc_domain_set(&dp->dp_gate[i], true); + if (ret) + return ret; + } + src = atc_dp_source(rate); + word = dp->dp_clk_src + 4 * i; + writel((readl(word) & ~ATC_DP_SRC_SELECT) | FIELD_PREP(ATC_DP_SRC_SELECT, src), word); + ret = readl_poll_timeout(word, v, !(v & ATC_DP_SRC_BUSY), 10, 200000); + if (ret) { + dev_err(dp->dev, "DP tunnel clock %u: source %d not taken (%08x)\n", k, src, v); + return ret; + } + ret = atc_dp_tunnel_switch(dp, k, &v); + if (ret) + dev_err(dp->dev, "DP tunnel clock %u: switch status %08x not on\n", k, v); + if (status) + *status = v; + return ret; } -/* Stop tunnel clock @k and gate it. */ -static int atc_dp_tunnel_stop(struct t6050_dp *dp, unsigned int k) +/* + * Apply every tunnel clock in clock order after one has changed: each clock + * with a rate keeps it, its source and switch written again as they are, + * and each clock without one stays parked and gated. A clock is therefore + * only ever started from off at its own user's rate, and only stopped to off; + * a clock no display uses never runs. Returns @clock's result. + */ +static int atc_dp_tunnels_apply(struct t6050_dp *dp, unsigned int clock, u32 *status) { - if (dp->tunnel_rate[k - 1]) - atc_dp_tunnel_switch_off(dp, k); - return dp->dp_gates ? atc_domain_set(&dp->dp_gate[k - 1], false) : 0; + int ret = 0; + + for (unsigned int k = 1; k <= ATC_DP_TUNNELS; k++) { + int err = atc_dp_tunnel_apply(dp, k, k == clock ? status : NULL); + + if (k == clock) + ret = err; + } + return ret; } /* - * Taking a running tunnel clock away disturbs the port's other tunnel - * clocks: the display on one of them loses its stream for a moment, and can - * lose its link. A clock whose user stopped it therefore keeps running while - * another clock of the port is in use, and stops with the last of them. + * Park every tunnel clock (field 7, enable off), once the PHY is in USB4 + * mode: an unparked switch selects the native DP clock for its crossbar pixel + * clock. No clock has a rate yet. */ -static bool atc_dp_tunnel_others_in_use(struct t6050_dp *dp, unsigned int k) +static void atc_dp_tunnels_park(struct t6050_dp *dp) { - for (unsigned int i = 0; i < ATC_DP_TUNNELS; i++) - if (i != k - 1 && dp->tunnel_rate[i] && !(dp->tunnel_idle & BIT(i))) - return true; - return false; + atc_dp_tunnels_apply(dp, 0, NULL); } -/* Stop every tunnel clock, before the PHY leaves USB4 mode. */ +/* + * Stop every tunnel clock, before the PHY leaves USB4 mode. The switches are + * written only while a clock runs, which it does only in USB4 mode. + */ static void atc_dp_tunnels_stop(struct t6050_dp *dp) { - for (unsigned int k = 1; k <= ATC_DP_TUNNELS; k++) { - if (dp->tunnel_rate[k - 1]) - atc_dp_tunnel_switch_off(dp, k); - /* A failed start or gate suspend can leave a held domain at rate zero. */ - if (dp->dp_gates) - atc_domain_set(&dp->dp_gate[k - 1], false); + bool running = memchr_inv(dp->tunnel_rate, 0, sizeof(dp->tunnel_rate)); + + memset(dp->tunnel_rate, 0, sizeof(dp->tunnel_rate)); + if (running) { + atc_dp_tunnels_apply(dp, 0, NULL); + return; } + /* A failed start or gate suspend can leave a held domain at rate zero. */ + for (unsigned int k = 1; dp->dp_gates && k <= ATC_DP_TUNNELS; k++) + atc_domain_set(&dp->dp_gate[k - 1], false); } #include "atc-t6050-combo.h" @@ -673,56 +724,19 @@ int apple_dp_phy_link_config(struct phy *phy, unsigned int *pclk, bool *uhbr) } EXPORT_SYMBOL_GPL(apple_dp_phy_link_config); -/* Start tunnel clock @clock at link rate @rate from PMGR source @src. */ -static int atc_dp_tunnel_start(struct t6050_dp *dp, unsigned int clock, u8 rate, - int src, u32 *status) -{ - void __iomem *cfg = dp->banks[39], *word; - unsigned int i = clock - 1; - u32 en = atc_dp_enable_bit(clock), v; - int ret; - - if (dp->dp_gates) { - ret = atc_domain_set(&dp->dp_gate[i], true); - if (ret) - return ret; - } - word = dp->dp_clk_src + 4 * i; - writel((readl(word) & ~ATC_DP_SRC_SELECT) | FIELD_PREP(ATC_DP_SRC_SELECT, src), word); - ret = readl_poll_timeout(word, v, !(v & ATC_DP_SRC_BUSY), 10, 200000); - if (ret) { - dev_err(dp->dev, "DP tunnel clock %u: source %d not taken (%08x)\n", - clock, src, v); - if (dp->dp_gates) - atc_domain_set(&dp->dp_gate[i], false); - return ret; - } - writel((readl(cfg + ATC_CFG_DP_SWITCH) & ~atc_dp_switch_mask(clock)) | - (clock << (3 * clock - 3)) | - (rate == 0x81 || rate == 0x82 ? BIT(11 + clock) : 0), - cfg + ATC_CFG_DP_SWITCH); - writel(readl(cfg + ATC_CFG_DP_ENABLE) | en, cfg + ATC_CFG_DP_ENABLE); - ret = readl_poll_timeout(cfg + ATC_CFG_DP_STATUS, v, v & en, 10, 10000); - if (ret) { - dev_err(dp->dev, "DP tunnel clock %u: switch status %08x not on\n", clock, v); - /* Undo the partial start before leaving the rate uncached for retry. */ - atc_dp_tunnel_switch_off(dp, clock); - if (dp->dp_gates) - atc_domain_set(&dp->dp_gate[i], false); - return ret; - } - dp->tunnel_rate[i] = rate; - *status = v; - return 0; -} - +/* + * A tunnel clock has one rate while its display uses it, the one its link + * was set up at, and none otherwise. It starts from off at that rate when the + * link is set up and stops to off when the link goes; a clock that runs is + * never given another rate in place. Every change applies all four clocks in + * order (atc_dp_tunnels_apply()). + */ int apple_t6050_dp_tunnel_clock(struct phy *phy, unsigned int clock, u8 rate) { struct t6050_dp *dp; unsigned int i = clock - 1; int src = 0, ret; - bool others; - u32 v; + u32 v = 0; if (!phy || phy->ops != &t6050_dp_ops) return -EOPNOTSUPP; @@ -737,50 +751,44 @@ int apple_t6050_dp_tunnel_clock(struct phy *phy, unsigned int clock, u8 rate) guard(mutex)(&dp->lock); if (!dp->combo || !dp->dp_clk_src) return -EOPNOTSUPP; - if (rate && dp->tunnel_rate[i] == rate) { - dp->tunnel_idle &= ~BIT(i); + if (dp->tunnel_rate[i] == rate) { + /* A failed start or gate suspend can leave a held domain at rate zero. */ + if (!rate && dp->dp_gates) + return atc_domain_set(&dp->dp_gate[i], false); return 0; } - others = atc_dp_tunnel_others_in_use(dp, clock); - if (!rate) { - if (dp->tunnel_rate[i] && others) { - dp->tunnel_idle |= BIT(i); - dev_dbg(dp->dev, "DP tunnel clock %u left running for the others\n", - clock); - return 0; + /* + * Stop a running clock to off: its switch parked and its gate off. One + * whose user now asks for another rate is stopped the same way and then + * started again from off below. + */ + if (dp->tunnel_rate[i]) { + u8 old = dp->tunnel_rate[i]; + + dp->tunnel_rate[i] = 0; + ret = atc_dp_tunnels_apply(dp, clock, NULL); + if (!rate) { + if (!ret) + dev_info(dp->dev, "DP tunnel clock %u stopped\n", clock); + return ret; } - ret = atc_dp_tunnel_stop(dp, clock); - /* The last user went: the clocks kept for it go as well. */ - for (unsigned int k = 1; !others && k <= ATC_DP_TUNNELS; k++) - if (dp->tunnel_idle & BIT(k - 1)) - atc_dp_tunnel_stop(dp, k); - if (!ret) - dev_info(dp->dev, "DP tunnel clock %u stopped\n", clock); - return ret; + if (ret) + dev_warn(dp->dev, "DP tunnel clock %u: gate not released: %d\n", + clock, ret); + dev_info(dp->dev, "DP tunnel clock %u: link rate 0x%02x to 0x%02x, restarting from off\n", + clock, old, rate); } - /* A new rate takes the clock off its old source first. */ - if (dp->tunnel_rate[i]) - atc_dp_tunnel_switch_off(dp, clock); if (dp->faulted) return -EIO; if (dp->combo_mode != COMBO_CIO) return -ENOLINK; - ret = atc_dp_tunnel_start(dp, clock, rate, src, &v); - if (ret) + dp->tunnel_rate[i] = rate; + ret = atc_dp_tunnels_apply(dp, clock, &v); + if (ret) { + /* Undo the partial start: the clock is left without a rate, for a retry. */ + dp->tunnel_rate[i] = 0; + atc_dp_tunnel_apply(dp, clock, NULL); return ret; - /* - * Starting a clock disturbs the running ones as stopping one does. The - * port's first clock therefore starts the others with it, at its rate - * and with no user: a display that comes later at that rate finds its - * clock running. - */ - for (unsigned int k = 1; !others && k <= ATC_DP_TUNNELS; k++) { - u32 unused; - - if (k == clock || dp->tunnel_rate[k - 1]) - continue; - if (!atc_dp_tunnel_start(dp, k, rate, src, &unused)) - dp->tunnel_idle |= BIT(k - 1); } dev_info(dp->dev, "DP tunnel clock %u: link rate 0x%02x, source %d, switch status %08x\n", clock, rate, src, v);