From: Igor Velkov irq_suspended and irq_rerun share a word with link, autoneg_complete and interrupts. phy_interrupt() sets irq_rerun from the IRQ thread without phydev->lock, while the state machine writes link and autoneg_complete under it and phy_request_interrupt()/ phy_free_interrupt() write interrupts, so one read-modify-write can undo another. A lost irq_rerun leaves the PHY interrupt disabled after resume, as phy_interrupt() has already disabled the line. The last patch of this series sets irq_suspended for PHYs whose MAC driver manages PHY PM; with stmmac that happens before the MAC stops the PHY, which widens the window. Taking phydev->lock in phy_interrupt() alone does not close it: phy_suspend() stores suspended in the same word and cannot hold the lock across phy_may_wakeup(), which may take it, and phy_init_hw() and mdio_bus_phy_suspend() write the word unlocked too. Locking every writer, MAC drivers included, is a wide audit, and one missed now or added later reopens the race. Make both flags bools. Fixes: 1758bde2e4aa ("net: phy: Don't trigger state machine while in suspend") Tested-by: Haoning Cheng Signed-off-by: Igor Velkov --- drivers/net/phy/phy.c | 2 +- drivers/net/phy/phy_device.c | 6 +++--- include/linux/phy.h | 7 +++++-- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c index fce9bc7be330..9af303d60bd6 100644 --- a/drivers/net/phy/phy.c +++ b/drivers/net/phy/phy.c @@ -1430,7 +1430,7 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) pm_wakeup_dev_event(parent, 0, true); } - phydev->irq_rerun = 1; + phydev->irq_rerun = true; disable_irq_nosync(irq); return IRQ_HANDLED; } diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c index b39e945cebd7..1791d578f4dd 100644 --- a/drivers/net/phy/phy_device.c +++ b/drivers/net/phy/phy_device.c @@ -344,7 +344,7 @@ static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) * has resumed. Wait for concurrent interrupt handler to complete. */ if (phy_interrupt_is_valid(phydev)) { - phydev->irq_suspended = 1; + phydev->irq_suspended = true; synchronize_irq(phydev->irq); } @@ -394,14 +394,14 @@ static __maybe_unused int mdio_bus_phy_resume(struct device *dev) return ret; no_resume: if (phy_interrupt_is_valid(phydev)) { - phydev->irq_suspended = 0; + phydev->irq_suspended = false; synchronize_irq(phydev->irq); /* Rerun interrupts which were postponed by phy_interrupt() * because they occurred during the system sleep transition. */ if (phydev->irq_rerun) { - phydev->irq_rerun = 0; + phydev->irq_rerun = false; enable_irq(phydev->irq); irq_wake_thread(phydev->irq, phydev); } diff --git a/include/linux/phy.h b/include/linux/phy.h index 21afc2082b17..59c75296d535 100644 --- a/include/linux/phy.h +++ b/include/linux/phy.h @@ -726,8 +726,11 @@ struct phy_device { /* Interrupts are enabled */ unsigned interrupts:1; - unsigned irq_suspended:1; - unsigned irq_rerun:1; + /* Not bitfields: phy_interrupt() and the PM callbacks write them + * without phydev->lock + */ + bool irq_suspended; + bool irq_rerun; unsigned default_timestamp:1; -- 2.43.0 From: Igor Velkov phy_interrupt() postpones interrupts during a system sleep transition: it sets irq_rerun and disables the line, and mdio_bus_phy_resume() re-enables the line once and reruns the handler. Three paths leave the line unbalanced: - On an edge-triggered line the IRQ core does not mask a ONESHOT interrupt, so an edge that arrives before disable_irq_nosync() runs the thread again. That second run disables the line again, and the line stays disabled after resume. - phy_free_interrupt() can run between the postponed interrupt and mdio_bus_phy_resume() and leaves irq_rerun set. Once the line has no users, free_irq() shuts it down and a new request starts it at depth 0, so the enable_irq() in mdio_bus_phy_resume() is unbalanced. On a shared line this can happen once the other users free it too, as with the two PHYs of dra72-evm-revc behind cpsw. - If phy_request_interrupt() then leaves the PHY polling, mdio_bus_phy_resume() returns before enable_irq(), and the other users of a shared line stay disabled. MAC drivers that close the interface in their suspend callback, such as cpsw, and ravb with Wake-on-LAN off, reach phy_free_interrupt() through phy_disconnect(), and so does dev_close() in a kernel-internal reset of the MAC such as stmmac_reset_subtask(), whose workqueue does not freeze. These drivers set mac_managed_pm, which a later patch brings under postponing. Let only the run that sets irq_rerun disable the line, and record the line it disabled. Clear irq_rerun where the line starts again at depth 0: in phy_free_interrupt() when free_irq() leaves the line without users, and in phy_request_interrupt() when the line has no users. Otherwise mdio_bus_phy_resume() enables the recorded line, also for a PHY that fell back to polling, and reruns the handler only if the PHY still uses that line. Enabling the line in phy_free_interrupt() instead would unmask a source that phy_disable_interrupts() failed to clear, and inside the noirq phase it would unbalance a wakeup line that suspend_device_irqs() enabled (IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND). Add irq_pm_lock, so that requesting and freeing the interrupt do not change irq_rerun between the check and the enable_irq() of the rerun after resume, and move the postponing and the rerun into helpers. phy_interrupt() never takes the lock, so synchronize_irq() and free_irq() can wait for the handler under it. irq_rerun and irq_rerun_line are plain fields: one thread runs the handler, and the other paths access them only under the lock, after free_irq() or synchronize_irq(), or before this PHY has requested the line. Mark the irq_suspended accesses with READ_ONCE() and WRITE_ONCE(): the handler reads it while the PM callbacks write it. Two cases on a shared line stay unbalanced: after all users have freed the line, another user requests it first, so it has users when this PHY requests it; or another user requests it between free_irq() and the irq_has_action() check in phy_free_interrupt(). irq_rerun then stays, and the enable after resume is unbalanced. This does not keep close and open off the MDIO bus: on close, phy_disconnect() calls phy_stop(), phy_free_interrupt() with its phy_disable_interrupts() and, in phy_detach(), phy_suspend(); on open, phy_attach_direct() calls phy_init_hw() and phy_request_interrupt() calls phy_enable_interrupts(). A MAC driver that powers its MDIO bus down during sleep must not close or open the interface until the bus is back. Fixes: 1758bde2e4aa ("net: phy: Don't trigger state machine while in suspend") Signed-off-by: Igor Velkov --- Haoning Cheng's Tested-by on v5 is not carried: phy_free_interrupt() no longer enables a shared line. --- drivers/net/phy/phy.c | 24 ++++++++++++++++--- drivers/net/phy/phy_device.c | 57 ++++++++++++++++++++++++++++---------------- include/linux/phy.h | 11 +++++++-- 3 files changed, 66 insertions(+), 26 deletions(-) diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c index 9af303d60bd6..92ee4651bdbc 100644 --- a/drivers/net/phy/phy.c +++ b/drivers/net/phy/phy.c @@ -1416,7 +1416,7 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) /* Wakeup interrupts may occur during a system sleep transition. * Postpone handling until the PHY has resumed. */ - if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) { + if (IS_ENABLED(CONFIG_PM_SLEEP) && READ_ONCE(phydev->irq_suspended)) { struct net_device *netdev = phydev->attached_dev; if (netdev) { @@ -1430,8 +1430,12 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) pm_wakeup_dev_event(parent, 0, true); } - phydev->irq_rerun = true; - disable_irq_nosync(irq); + /* Disable the line only once: an edge can rerun the thread. */ + if (!phydev->irq_rerun) { + phydev->irq_rerun_line = irq; + phydev->irq_rerun = true; + disable_irq_nosync(irq); + } return IRQ_HANDLED; } @@ -1480,6 +1484,12 @@ void phy_request_interrupt(struct phy_device *phydev) { int err; + /* A line without users restarts at depth 0, so our disable is gone */ + mutex_lock(&phydev->irq_pm_lock); + if (phydev->irq_rerun && !irq_has_action(phydev->irq_rerun_line)) + phydev->irq_rerun = false; + mutex_unlock(&phydev->irq_pm_lock); + err = request_threaded_irq(phydev->irq, NULL, phy_interrupt, IRQF_ONESHOT | IRQF_SHARED, phydev_name(phydev), phydev); @@ -1507,7 +1517,15 @@ EXPORT_SYMBOL(phy_request_interrupt); void phy_free_interrupt(struct phy_device *phydev) { phy_disable_interrupts(phydev); + + mutex_lock(&phydev->irq_pm_lock); free_irq(phydev->irq, phydev); + /* free_irq() shuts down a line left without users and the next request + * resets its depth; mdio_bus_phy_resume_irq() enables a shared line. + */ + if (!irq_has_action(phydev->irq)) + phydev->irq_rerun = false; + mutex_unlock(&phydev->irq_pm_lock); } EXPORT_SYMBOL(phy_free_interrupt); diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c index 1791d578f4dd..f2e2370b4be7 100644 --- a/drivers/net/phy/phy_device.c +++ b/drivers/net/phy/phy_device.c @@ -332,6 +332,39 @@ static bool mdio_bus_phy_may_suspend(struct phy_device *phydev) return !phydev->suspended; } +/* Wakeup interrupts may occur during the system sleep transition when + * the PHY is inaccessible. Set flag to postpone handling until the PHY + * has resumed. Wait for concurrent interrupt handler to complete. + */ +static __maybe_unused void mdio_bus_phy_suspend_irq(struct phy_device *phydev) +{ + if (!phy_interrupt_is_valid(phydev)) + return; + + WRITE_ONCE(phydev->irq_suspended, true); + synchronize_irq(phydev->irq); +} + +/* Rerun interrupts which were postponed by phy_interrupt() + * because they occurred during the system sleep transition. + */ +static __maybe_unused void mdio_bus_phy_resume_irq(struct phy_device *phydev) +{ + WRITE_ONCE(phydev->irq_suspended, false); + + mutex_lock(&phydev->irq_pm_lock); + if (phy_interrupt_is_valid(phydev)) + synchronize_irq(phydev->irq); + /* The PHY may have fallen back to polling since it disabled the line */ + if (phydev->irq_rerun) { + phydev->irq_rerun = false; + enable_irq(phydev->irq_rerun_line); + if (phydev->irq == phydev->irq_rerun_line) + irq_wake_thread(phydev->irq, phydev); + } + mutex_unlock(&phydev->irq_pm_lock); +} + static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) { struct phy_device *phydev = to_phy_device(dev); @@ -339,14 +372,7 @@ static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) if (phydev->mac_managed_pm) return 0; - /* Wakeup interrupts may occur during the system sleep transition when - * the PHY is inaccessible. Set flag to postpone handling until the PHY - * has resumed. Wait for concurrent interrupt handler to complete. - */ - if (phy_interrupt_is_valid(phydev)) { - phydev->irq_suspended = true; - synchronize_irq(phydev->irq); - } + mdio_bus_phy_suspend_irq(phydev); /* We must stop the state machine manually, otherwise it stops out of * control, possibly with the phydev->lock held. Upon resume, netdev @@ -393,19 +419,7 @@ static __maybe_unused int mdio_bus_phy_resume(struct device *dev) if (ret < 0) return ret; no_resume: - if (phy_interrupt_is_valid(phydev)) { - phydev->irq_suspended = false; - synchronize_irq(phydev->irq); - - /* Rerun interrupts which were postponed by phy_interrupt() - * because they occurred during the system sleep transition. - */ - if (phydev->irq_rerun) { - phydev->irq_rerun = false; - enable_irq(phydev->irq); - irq_wake_thread(phydev->irq, phydev); - } - } + mdio_bus_phy_resume_irq(phydev); if (phy_uses_state_machine(phydev)) phy_start_machine(phydev); @@ -711,6 +725,7 @@ struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id, dev->max_n_ports = 1; mutex_init(&dev->lock); + mutex_init(&dev->irq_pm_lock); INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine); /* Request the appropriate module unconditionally; don't diff --git a/include/linux/phy.h b/include/linux/phy.h index 59c75296d535..f370690d62a7 100644 --- a/include/linux/phy.h +++ b/include/linux/phy.h @@ -651,8 +651,8 @@ struct phy_oatc14_sqi_capability { * @interrupts: Flag interrupts have been enabled * @irq_suspended: Flag indicating PHY is suspended and therefore interrupt * handling shall be postponed until PHY has resumed - * @irq_rerun: Flag indicating interrupts occurred while PHY was suspended, - * requiring a rerun of the interrupt handler after resume + * @irq_rerun: Set by the postponed interrupt that disabled the line + * @irq_rerun_line: The line the postponed interrupt disabled * @default_timestamp: Flag indicating whether we are using the phy * timestamp as the default one * @interface: enum phy_interface_t value @@ -675,6 +675,8 @@ struct phy_oatc14_sqi_capability { * @n_ports: Number of ports currently attached to the PHY * @max_n_ports: Max number of ports this PHY can expose * @lock: Mutex for serialization access to PHY + * @irq_pm_lock: Serializes requesting and freeing the interrupt against the + * PM callbacks; phy_interrupt() never takes it * @state_queue: Work queue for state machine * @link_down_events: Number of times link was lost * @shared: Pointer to private data shared by phys in one package @@ -731,6 +733,7 @@ struct phy_device { */ bool irq_suspended; bool irq_rerun; + int irq_rerun_line; unsigned default_timestamp:1; @@ -808,6 +811,10 @@ struct phy_device { struct delayed_work state_queue; struct mutex lock; + /* Serializes requesting and freeing the interrupt against the PM + * callbacks + */ + struct mutex irq_pm_lock; /* This may be modified under the rtnl lock */ bool sfp_bus_attached; -- 2.43.0 From: Igor Velkov When phy_suspend() fails in mdio_bus_phy_suspend(), irq_suspended stays set and the state machine stays stopped: the PM core does not resume a device whose suspend callback failed, and the next PHY interrupt disables the line until the next resume. Undo the postponing and restart the state machine when phy_suspend() fails. Set suspended_by_mdio_bus only after phy_suspend() succeeds. Set before it, the flag outlived a failed suspend, and in a later cycle where mdio_bus_phy_may_suspend() returns false, mdio_bus_phy_resume() ran phy_init_hw() and phy_resume() on a PHY that the MDIO bus had not suspended. Fixes: 1758bde2e4aa ("net: phy: Don't trigger state machine while in suspend") Signed-off-by: Igor Velkov --- Haoning Cheng's Tested-by on v5 is not carried: this patch no longer changes the resume error path. --- drivers/net/phy/phy_device.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c index f2e2370b4be7..2d2058c29f30 100644 --- a/drivers/net/phy/phy_device.c +++ b/drivers/net/phy/phy_device.c @@ -368,6 +368,7 @@ static __maybe_unused void mdio_bus_phy_resume_irq(struct phy_device *phydev) static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) { struct phy_device *phydev = to_phy_device(dev); + int ret; if (phydev->mac_managed_pm) return 0; @@ -385,9 +386,20 @@ static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) if (!mdio_bus_phy_may_suspend(phydev)) return 0; + ret = phy_suspend(phydev); + if (ret) { + /* The PM core skips the resume callback of a device whose + * suspend callback failed. + */ + mdio_bus_phy_resume_irq(phydev); + if (phy_uses_state_machine(phydev)) + phy_start_machine(phydev); + return ret; + } + phydev->suspended_by_mdio_bus = 1; - return phy_suspend(phydev); + return 0; } static __maybe_unused int mdio_bus_phy_resume(struct device *dev) -- 2.43.0 From: Igor Velkov mdio_bus_phy_resume_irq() reruns a postponed interrupt with irq_wake_thread(). A PHY interrupt behind a nested threaded interrupt controller, such as an I2C or SPI GPIO expander, has no interrupt thread, so irq_wake_thread() does nothing and the postponed interrupt is lost: the PHY keeps its status latched and its INT line asserted. For a PHY without MAC-managed PM, mdio_bus_phy_resume() calls phy_init_hw() before the rerun, and config_intr() there acknowledges the latched status in drivers such as realtek. A later patch brings PHYs with MAC-managed PM under postponing, and stmmac, for one, does not call phy_init_hw() on resume. Call the PHY driver's handler from mdio_bus_phy_resume_irq(), as phy_interrupt() does, unless the PHY has freed its interrupt: on a shared line irq_rerun outlives the free, and the handler would run on a PHY with its interrupts disabled. Hold irq_pm_lock across the call and around phy_disable_interrupts() in phy_free_interrupt(), so that the free waits for the handler, as free_irq() waits for the thread. Fixes: 1758bde2e4aa ("net: phy: Don't trigger state machine while in suspend") Signed-off-by: Igor Velkov --- drivers/net/phy/phy.c | 3 +-- drivers/net/phy/phy_device.c | 13 ++++++++++--- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c index 92ee4651bdbc..6cc94b525e09 100644 --- a/drivers/net/phy/phy.c +++ b/drivers/net/phy/phy.c @@ -1516,9 +1516,8 @@ EXPORT_SYMBOL(phy_request_interrupt); */ void phy_free_interrupt(struct phy_device *phydev) { - phy_disable_interrupts(phydev); - mutex_lock(&phydev->irq_pm_lock); + phy_disable_interrupts(phydev); free_irq(phydev->irq, phydev); /* free_irq() shuts down a line left without users and the next request * resets its depth; mdio_bus_phy_resume_irq() enables a shared line. diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c index 2d2058c29f30..8bc394ff7d2d 100644 --- a/drivers/net/phy/phy_device.c +++ b/drivers/net/phy/phy_device.c @@ -355,12 +355,19 @@ static __maybe_unused void mdio_bus_phy_resume_irq(struct phy_device *phydev) mutex_lock(&phydev->irq_pm_lock); if (phy_interrupt_is_valid(phydev)) synchronize_irq(phydev->irq); - /* The PHY may have fallen back to polling since it disabled the line */ + /* The PHY may have fallen back to polling since it disabled the line, + * or freed its interrupt while another user keeps the line. + */ if (phydev->irq_rerun) { phydev->irq_rerun = false; enable_irq(phydev->irq_rerun_line); - if (phydev->irq == phydev->irq_rerun_line) - irq_wake_thread(phydev->irq, phydev); + /* A nested threaded line has no thread; we run the handler */ + if (phydev->irq == phydev->irq_rerun_line && + phydev->interrupts) { + mutex_lock(&phydev->lock); + phydev->drv->handle_interrupt(phydev); + mutex_unlock(&phydev->lock); + } } mutex_unlock(&phydev->irq_pm_lock); } -- 2.43.0 From: Igor Velkov mdio_bus_phy_suspend() and mdio_bus_phy_resume() return early when the MAC driver manages PHY PM, so the PHY never gets irq_suspended and phy_interrupt() runs the PHY driver's handler at any point of the sleep transition. If the MAC driver powers the MDIO bus down, the MDIO access in that handler can stall the CPU. This happens on both sides: - suspend: the MAC's suspend callback stops the PHY, the link goes down, and the handler runs while the MAC powers down; - resume: resume_device_irqs() re-enables a pending interrupt before the MAC resumes. On Helios64 (dwmac-rk, RTL8211F with its interrupt line described in DT) both hang the board: the handler reads INSR while the GMAC clocks are off, after rk_gmac_suspend() or before rk_gmac_resume(). The commit in the Fixes tag added the postponing after the early return for MAC-managed PHY PM, and stmmac has set mac_managed_pm since commit f151c147b3af ("net: stmmac: Enable mac_managed_pm phylink config"). Set irq_suspended for these PHYs too. The PHY device is a child of its MDIO bus, so mdio_bus_phy_resume() runs after the resume callbacks of the bus and its parents (with stmmac, the MAC) and replays the postponed interrupt then. The PM core resumes children of a device whose resume callback failed, and phylib cannot tell: if the MAC fails to power the bus up, the replay still reaches the bus. When the PHY sits on an MDIO bus the MAC does not own, phy_attach_direct() links the MAC as a consumer of the PHY, so the MAC suspends before and resumes after the PHY; there the replay still runs before the MAC resumes, as the handler did from resume_device_irqs() before this change, and until the PHY suspends, an interrupt still runs the handler after the MAC has suspended. ODROID-HC4 (stmmac, RTL8211F behind mdio-mux-meson-g12a) takes this path. phy_suspend(), phy_resume() and the state machine stay with the MAC driver, and no MAC driver needs a change. Doing this in phylink_suspend() instead would miss macb, which sets mac_managed_pm but suspends with phylink_stop(). A postponed interrupt cannot read the PHY, so it cannot tell Wake-on-LAN from a link change. A PHY without MAC-managed PM reports what phy_interrupt() reports today. A PHY with MAC-managed PM reports no wakeup from the postponed interrupt: the MAC can change the link in its suspend callback, as stmmac lowers the link speed through phylink_suspend() when the PHY may wake the system. A postponed interrupt leaves its line disabled. suspend_device_irqs() runs before the noirq callbacks: it arms a wakeup line and leaves a disabled one masked unless the irqchip has IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND, so a PHY whose interrupt line is also its wake IRQ would sleep through a wakeup. Enable the line a postponed interrupt disabled in the noirq suspend callback while it is still disabled and armed for wakeup, and disable it again in the noirq resume callback, before resume_device_irqs(). The irq core turns an interrupt on an armed line into a wakeup without running the handler, and clears the armed state before it disables the line, so a line that already woke the system is left alone, and so is a line that is no longer disabled. An edge the postponed interrupt consumed does not repeat, so on an edge-triggered line a magic packet that arrives during the transition does not abort it; the next one wakes the system. On a level-triggered line, a PHY that keeps a link interrupt asserted, such as the one from the speed change above, aborts every suspend with Wake-on-LAN enabled: its driver has to restrict the interrupt to Wake-on-LAN in its suspend callback, as rtl8211f_suspend() does. Tested on Helios64 with 7.3.5 and this series, s2idle with the link up: - no Wake-on-LAN, GMAC clocks off in suspend: 10 of 10 cycles suspended and resumed; on 7.3 without this series the same test hung or reset the board after the link went down 10 of 10 times; - MAC power/wakeup enabled, no Wake-on-LAN: 3 of 3 slept; - Wake-on-LAN in the PHY, so phylink_suspend() also drops the link speed: a magic packet woke the board 7 of 8 times, no suspend aborted; in the eighth the PHY raised no interrupt, cause not found; - the same under a flood of magic packets: a packet after rtl8211f_suspend() was postponed and disabled the line, the noirq callback enabled it, and the wakeup aborted the suspend 5 of 5 times (traced); a single magic packet then woke the board. Fixes: 1758bde2e4aa ("net: phy: Don't trigger state machine while in suspend") Signed-off-by: Igor Velkov --- Haoning Cheng's Tested-by on v5 is not carried: MAC-managed PHYs no longer report a wakeup. --- drivers/net/phy/phy.c | 13 ++++++++--- drivers/net/phy/phy_device.c | 54 ++++++++++++++++++++++++++++++++++++++++---- include/linux/phy.h | 7 ++++-- 3 files changed, 64 insertions(+), 10 deletions(-) diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c index 6cc94b525e09..45891570a56e 100644 --- a/drivers/net/phy/phy.c +++ b/drivers/net/phy/phy.c @@ -1419,7 +1419,10 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) if (IS_ENABLED(CONFIG_PM_SLEEP) && READ_ONCE(phydev->irq_suspended)) { struct net_device *netdev = phydev->attached_dev; - if (netdev) { + /* With MAC-managed PM, a postponed interrupt cannot tell + * Wake-on-LAN from a link change the MAC causes. + */ + if (netdev && !phydev->mac_managed_pm) { struct device *parent = netdev->dev.parent; if (netdev->ethtool->wol_enabled) @@ -1486,8 +1489,10 @@ void phy_request_interrupt(struct phy_device *phydev) /* A line without users restarts at depth 0, so our disable is gone */ mutex_lock(&phydev->irq_pm_lock); - if (phydev->irq_rerun && !irq_has_action(phydev->irq_rerun_line)) + if (phydev->irq_rerun && !irq_has_action(phydev->irq_rerun_line)) { phydev->irq_rerun = false; + phydev->irq_wake_enabled = false; + } mutex_unlock(&phydev->irq_pm_lock); err = request_threaded_irq(phydev->irq, NULL, phy_interrupt, @@ -1522,8 +1527,10 @@ void phy_free_interrupt(struct phy_device *phydev) /* free_irq() shuts down a line left without users and the next request * resets its depth; mdio_bus_phy_resume_irq() enables a shared line. */ - if (!irq_has_action(phydev->irq)) + if (!irq_has_action(phydev->irq)) { phydev->irq_rerun = false; + phydev->irq_wake_enabled = false; + } mutex_unlock(&phydev->irq_pm_lock); } EXPORT_SYMBOL(phy_free_interrupt); diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c index 8bc394ff7d2d..c700b34e40a2 100644 --- a/drivers/net/phy/phy_device.c +++ b/drivers/net/phy/phy_device.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -377,11 +378,14 @@ static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) struct phy_device *phydev = to_phy_device(dev); int ret; + /* An interrupt can fire while the MAC has the MDIO bus powered + * down, whether or not the MAC manages PHY PM. + */ + mdio_bus_phy_suspend_irq(phydev); + if (phydev->mac_managed_pm) return 0; - mdio_bus_phy_suspend_irq(phydev); - /* We must stop the state machine manually, otherwise it stops out of * control, possibly with the phydev->lock held. Upon resume, netdev * may call phy routines that try to grab the same lock, and that may @@ -414,8 +418,10 @@ static __maybe_unused int mdio_bus_phy_resume(struct device *dev) struct phy_device *phydev = to_phy_device(dev); int ret; - if (phydev->mac_managed_pm) + if (phydev->mac_managed_pm) { + mdio_bus_phy_resume_irq(phydev); return 0; + } if (!phydev->suspended_by_mdio_bus) goto no_resume; @@ -446,8 +452,46 @@ static __maybe_unused int mdio_bus_phy_resume(struct device *dev) return 0; } -static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend, - mdio_bus_phy_resume); +static __maybe_unused int mdio_bus_phy_suspend_noirq(struct device *dev) +{ + struct phy_device *phydev = to_phy_device(dev); + struct irq_data *d; + + mutex_lock(&phydev->irq_pm_lock); + /* We enable the line a postponed interrupt disabled if the irq core + * armed it for wakeup, so that it wakes the system. + */ + if (phydev->irq_rerun) { + d = irq_get_irq_data(phydev->irq_rerun_line); + if (d && irqd_irq_disabled(d) && irqd_is_wakeup_armed(d)) { + enable_irq(phydev->irq_rerun_line); + phydev->irq_wake_enabled = true; + } + } + mutex_unlock(&phydev->irq_pm_lock); + + return 0; +} + +static __maybe_unused int mdio_bus_phy_resume_noirq(struct device *dev) +{ + struct phy_device *phydev = to_phy_device(dev); + + mutex_lock(&phydev->irq_pm_lock); + if (phydev->irq_wake_enabled) { + phydev->irq_wake_enabled = false; + disable_irq_nosync(phydev->irq_rerun_line); + } + mutex_unlock(&phydev->irq_pm_lock); + + return 0; +} + +static const struct dev_pm_ops mdio_bus_phy_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(mdio_bus_phy_suspend, mdio_bus_phy_resume) + SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(mdio_bus_phy_suspend_noirq, + mdio_bus_phy_resume_noirq) +}; /** * genphy_match_phy_device - match a PHY device with a PHY driver diff --git a/include/linux/phy.h b/include/linux/phy.h index f370690d62a7..74acbb15ef7b 100644 --- a/include/linux/phy.h +++ b/include/linux/phy.h @@ -649,10 +649,12 @@ struct phy_oatc14_sqi_capability { * @mdix_ctrl: User setting of crossover * @pma_extable: Cached value of PMA/PMD Extended Abilities Register * @interrupts: Flag interrupts have been enabled - * @irq_suspended: Flag indicating PHY is suspended and therefore interrupt - * handling shall be postponed until PHY has resumed + * @irq_suspended: Flag indicating a system sleep transition, so interrupt + * handling shall be postponed until the PHY has resumed * @irq_rerun: Set by the postponed interrupt that disabled the line * @irq_rerun_line: The line the postponed interrupt disabled + * @irq_wake_enabled: Set while @irq_rerun_line is enabled for the noirq + * phase, as it wakes the system * @default_timestamp: Flag indicating whether we are using the phy * timestamp as the default one * @interface: enum phy_interface_t value @@ -734,6 +736,7 @@ struct phy_device { bool irq_suspended; bool irq_rerun; int irq_rerun_line; + bool irq_wake_enabled; unsigned default_timestamp:1; -- 2.43.0