From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1794917308; b=jCFEYWCSy6vvgTxuA9aHm88guyt5CEMFwvfyFqg3KmEcIDPG0jTnqER0lmJyOS2tVPba XxtH45FQRdPmNDZl2JZo309+m8vEIreQQ/xmapD4967LKB/Wg8GvJFCk/awA6D9KUgc1L 61JYQJ87SUnt6PSrJGT8mHQ8609YuZzYB+5nyFPnaig9p+2wZ51U07V50ssraRqZGG3Ow Ouw6rSMVrmvX1g59laqMS+jzfbcVC2nBjb7uVyja4IEJgdxVICd3xeX+BaD87QkulgwBI 9vRWqzca8PVYY3MkFZIa2CdzxZjmI2T/ZNpC7QPSpBwrd59+mljIUOLq4Lpb/eAaZkw== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1794917308; h=Received:DKIM-Signature:Subject:From:To:Cc:Date:Message-ID: In-Reply-To:References:X-sashiko-severity:Content-Type: Content-Transfer-Encoding:MIME-Version; bh=bAWHAy9krkgBXlIJkxkcBl1dWt2HRR+GxtmxZjDrD8c=; b=Hwsi5Bli/GsajwkcsUYjLEJ+8Buz1eNa46tGGBDWLmBXr9KGAOJ3EoTLzAhjBTyg9Lky 4KxbhEkb08yTvp7KE33xnKfyn/ZXy1KEKCFEFRnfxqyGM0uYeWhzmee0P3Jzgox25K1ih 72QrcY3vvn/Gdb2A/lDyCNQDsglWDz5ix7uJiQbDeNH4o4w97SQcUKAP7mlIHYQVYhuay 5hilsAIPnYSniSHmL3IYL7CQccAJCObhVWK+gfce9go+IjfwPS4mm7KjtaPkDTlXQA53E Vx5i8M/dWYQXX+gEF2Ju8N/80t9fit5wEsE7u03cYQ7Y5KxVl+vPnEeCiGKwMbXqELA== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=NXh54g7J; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D9351606A336; Tue, 17 Nov 2026 12:08:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=NXh54g7J Received: by smtp.kernel.org (Postfix) with ESMTPSA id 666BB1F000C4; Tue, 17 Nov 2026 12:08:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1794917308; bh=bAWHAy9krkgBXlIJkxkcBl1dWt2HRR+GxtmxZjDrD8c=; h=Subject:From:To:Cc:Date:In-Reply-To:References; b=NXh54g7JfcvQcSqYFFTql6s+2Hq2EuhQ26zuRlAY/uyeaw20sxNkgmsR5KYsKxBkP nkw2kAwTu7HMFmQj7eX63tFZpNeYEoP39M3QSCz2pt0xi5VA9bwvqCFt/Wh+pkDUho Zz3sDzTL9LLxg3Z7cEmmcdrHoBpLuEnm7lggjG28TuCOwA1a4TYZjC0Qq5T4S3Y7PX CPxJkUk/ALySgsLGxW94c/lNHgyhspvLt/3OBEu0nLkcKJVOcdjvPXJb0H51AcwTXr VlXTfxJbqnwT815TvqX0i+d6xCMjiRmwsOWQ3zISc7w7nMGbolxN+7Vus2u+Q/wds+ IEOHP1ul31y0A== Subject: Re: [PATCH net v6 4/4] net: phy: postpone PHY interrupts during sleep with MAC-managed PM From: netdev-bot+sashiko@kernel.org To: iav@iav.lv Cc: andrew@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@kernel.org, kuba@kernel.org, pabeni@redhat.com, maxime.chevallier@bootlin.com, lukas@wunner.de, rafael.j.wysocki@intel.com, wei.fang@nxp.com, niklas.soderlund@ragnatech.se, paul@pbarker.dev, florian.fainelli@broadcom.com, opendmb@gmail.com, Thangaraj.S@microchip.com, shenwei.wang@nxp.com, Haoning.CHENG@cn.bosch.com, netdev@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Date: Tue, 17 Nov 2026 12:08:26 +0000 Message-ID: <179491730695.3136.5496741718229288871@kernel.org> In-Reply-To: <20261113-b4-phylib-mac-pm-irq-v3-v6-4-05af2503cb23@iav.lv> References: <20261113-b4-phylib-mac-pm-irq-v3-v6-4-05af2503cb23@iav.lv> X-sashiko-severity: High Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit X-Mailing-List: netdev@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Thank you for your contribution! Sashiko AI review found 5 potential issue(s) to consider. Critical: 0 · High: 1 · Medium: 4 · Low: 0 If you believe none of the issues are legitimate, please reply to each issue of Medium severity or higher and explain why the AI is wrong. If any of them are legitimate and you plan to respin, please let patchwork know by including "pw-bot: cr" as a separate line at the end of your reply (one such reply per series is enough). - [High] net: phy: inverted PM IRQ ordering when consumer MAC links to PHY - [Medium] PHY Wake-on-LAN can be lost for MAC-managed PHYs whose interrupt line is also their wake IRQ. - [Medium] The postponed interrupt is lost for MAC-managed PHYs whose interrupt is a nested threaded IRQ (for example PHY INT routed through… - [Medium] A shared IRQ line's disable depth can leak when a MAC-managed PHY's interrupt is re-requested from the MAC's resume callback. - [Medium] net: phy: unbalanced enable_irq() in mdio_bus_phy_resume_irq() on shared IRQ -- net: phy: postpone PHY interrupts during sleep with MAC-managed PM This commit makes mdio_bus_phy_suspend() and mdio_bus_phy_resume() set and clear irq_suspended for PHYs whose PM is managed by the MAC driver. phy_interrupt() then postpones handling during the sleep transition instead of touching a possibly powered-down MDIO bus. For MAC-managed PHYs, the postponed interrupt no longer reports a wakeup event. > diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c > index 8e03c99fce8f5..ccf0658c4d101 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) [Severity: Medium] With this patch, a MAC-managed PHY gets irq_suspended set in mdio_bus_phy_suspend() before the MAC's own suspend callback runs. Any PHY interrupt from then until mdio_bus_phy_resume() takes this postponed path. For mac_managed_pm no wakeup is reported, but the line is still disabled: if (!phydev->irq_rerun) { phydev->irq_rerun = true; disable_irq_nosync(irq); } Could this lose PHY Wake-on-LAN for the whole sleep on PHYs whose interrupt line is also their wake IRQ? Both rtl8211f_probe() and an8801r_probe() register phydev->irq as the wake IRQ: devm_pm_set_wake_irq(dev, phydev->irq); In the noirq phase, suspend_device_irq() re-enables a disabled wake-armed line only when the irqchip has IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND: kernel/irq/pm.c:suspend_device_irq() { ... if ((chipflags & IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND) && irqd_irq_disabled(irqd)) { ... __enable_irq(desc); ... } On other irqchips the line would stay masked until resume. A later PME or magic packet interrupt then could not wake the system. One concrete case is stmmac with an RTL8211F and PHY WoL enabled. The link partner changes the link after irq_suspended is set, but before rtl8211f_suspend() switches INER to PME only: if (device_may_wakeup(&phydev->mdio.dev)) { ret = phy_write_paged(phydev, 0xa42, RTL821x_INER, RTL8211F_INER_PME); rtl8211f_suspend() then clears INTB. The software disable of the line stays in place until mdio_bus_phy_resume_irq(). Before this patch, phy_interrupt() ran handle_interrupt() here and the oneshot line was unmasked again. On boards whose MDIO bus stays powered, WoL kept working in this case. The phylink_speed_down() renegotiation in phylink_suspend() does not appear to trigger this for RTL8211F or AN8801. phylink_stop()->phy_stop()->phy_suspend() already restricts the interrupt mask before that point. It would only matter for a wake IRQ PHY that leaves link interrupts unmasked in suspend. The commit message says the line "may then stay masked until resume, so such a PHY may not wake the system from that sleep". It does not say that any link event in this window disables WoL for the whole sleep cycle. The Helios64 WoL test also runs on gpio-rockchip, and rockchip_irq_suspend() does this: irq_reg_writel(gc, ~gc->wake_active, bank->gpio_regs->int_mask); That unmasks wake pins in hardware whatever the software disable state is. Would that test be able to show this regression? > diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c > index 39e232a3144a2..c043071784f5b 100644 > --- a/drivers/net/phy/phy_device.c > +++ b/drivers/net/phy/phy_device.c > @@ -369,11 +369,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; [Severity: Medium] For a MAC-managed PHY, irq_suspended is now set here, before the MAC's suspend callback runs. cpsw and cpsw_new set mac_managed_pm, and they also disconnect the PHY from that callback. cpsw_suspend() calls cpsw_ndo_stop(), which ends in phy_disconnect(), and cpsw_resume() connects the PHY again. Can this leave a stale irq_rerun and an unbalanced enable_irq() on a board where the two slave PHYs share one interrupt line? phy_request_interrupt() uses IRQF_ONESHOT | IRQF_SHARED, so phy0 and phy1 each have an action on the same irq_desc. If the line fires after both mdio_bus_phy_suspend() calls, both threads run. Each phy_interrupt() takes the postponed path, sets its own irq_rerun and calls disable_irq_nosync(). The depth is then 2. cpsw_suspend() then disconnects phy0. phy_free_interrupt() keeps phy0->irq_rerun set, because phy1 still has an action on the line: if (!irq_has_action(phydev->irq)) phydev->irq_rerun = false; Disconnecting phy1 removes the last action. free_irq() shuts the line down and phy1->irq_rerun is cleared, but phy0->irq_rerun stays true. On resume, cpsw_resume() runs before mdio_bus_phy_resume() and calls phy_request_interrupt() again. With no actions left on the line, __setup_irq() calls irq_startup() and the depth goes back to 0. mdio_bus_phy_resume_irq() for phy0 still sees irq_rerun: if (phydev->irq_rerun) { phydev->irq_rerun = false; enable_irq(phydev->irq); irq_wake_thread(phydev->irq, phydev); } Wouldn't that enable_irq() hit the unbalanced enable WARN in __enable_irq()? The stale flag also matters before that point. Suppose the line fires after cpsw_resume() has requested phy0's IRQ but before mdio_bus_phy_resume(). phy_interrupt() for phy0 sees irq_rerun already set and skips disable_irq_nosync(). It returns IRQ_HANDLED without touching the PHY. If phy1 has not been reconnected yet, nothing masks a level-triggered line, so the oneshot thread keeps being woken. MAC-managed PHYs could not get here before, because irq_suspended was never set for them. Should phy_free_interrupt() undo this PHY's own disable_irq_nosync() whenever irq_rerun is set, instead of basing the cleanup on irq_has_action()? [Severity: Medium] For MAC-managed PHYs, irq_suspended is now set here and cleared only in mdio_bus_phy_resume(). That runs after the MAC's resume callback, so the flag is still true while the MAC resumes. ravb and sh_eth set mac_managed_pm. They call phy_disconnect() in suspend and of_phy_connect() in resume. So the PHY IRQ is requested again while irq_suspended is true: ravb_resume()->ravb_open()->...->phy_request_interrupt() Can this leave a shared IRQ line disabled? On an IRQF_SHARED line, the other device can interrupt after request_threaded_irq(). phy_interrupt() then takes the postponed path, sets irq_rerun and calls disable_irq_nosync(). Suppose phy_enable_interrupts() then fails: drivers/net/phy/phy.c:phy_request_interrupt() { ... if (phy_enable_interrupts(phydev)) { phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n"); phy_free_interrupt(phydev); phydev->irq = PHY_POLL; } ... } phy_free_interrupt() clears irq_rerun only when the line has no other actions left. On a shared line it still has one: if (!irq_has_action(phydev->irq)) phydev->irq_rerun = false; mdio_bus_phy_resume_irq() then returns early because the IRQ is now PHY_POLL: WRITE_ONCE(phydev->irq_suspended, false); if (!phy_interrupt_is_valid(phydev)) return; The matching enable_irq() never runs. Wouldn't the other device on that line stop getting interrupts, with irq_rerun left stale? MAC-managed PHYs could not reach this path before, because irq_suspended was never set for them. > > - 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 [ ... ] > @@ -406,8 +409,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; > + } [Severity: High] The ordering argument in the commit message needs the MAC to be the MDIO bus parent or one of its ancestors. That does not hold when the PHY sits on an MDIO bus owned by another device. In that case phy_attach_direct() calls device_link_add() with dev->dev.parent as consumer and &phydev->mdio.dev as supplier. device_link_add() moves the consumer to the tail of dpm_list. The MAC then suspends before mdio_bus_phy_suspend() and resumes after mdio_bus_phy_resume(). Examples are two FEC instances with FEC_QUIRK_SINGLE_MDIO, dual stmmac or macb sharing one MDIO bus, and MACs behind an mdio-mux. On resume, mdio_bus_phy_resume() for such a PHY clears irq_suspended and replays the postponed interrupt before the consumer's resume callback has run. handle_interrupt() then reads the PHY before fec_resume() has re-enabled fep->reg_phy and fep->clk_enet_out. It also runs before phy_resume() has turned the PHY driver's own clock back on, as rtl821x_resume() does with priv->clk. Interrupts after this point are not postponed either. If that MDIO access fails, the handler calls phy_error() and the state becomes PHY_ERROR. phy_start() from the MAC's resume only accepts PHY_READY or PHY_HALTED, so it hits its WARN and returns without starting the PHY. The link then stays down after resume. If the access succeeds, phydev->state is still PHY_HALTED. phy_trigger_machine() then queues a state machine run that takes the PHY_STATE_WORK_SUSPEND path and calls phy_suspend() outside phydev->lock. Can that race with the MAC's later phy_start()->__phy_resume()? The suspend side is not covered for this topology either. The consumer's suspend callback runs before mdio_bus_phy_suspend() sets irq_suspended. That callback may call phy_stop(), call phylink_speed_down() as stmmac_suspend() does, or gate clocks and regulators as fec_suspend() does. A link-down interrupt caused there still runs the handler directly. So for these PHYs the patch only moves the handler from resume_device_irqs() to mdio_bus_phy_resume(), still ahead of the MAC. Should the replay for a PHY with phydev->devlink wait until the consumer has resumed? Or should the commit message say that this topology is not covered? [Severity: Medium] For a MAC-managed PHY, this replay now runs without a phy_init_hw() call before it: if (phydev->irq_rerun) { phydev->irq_rerun = false; enable_irq(phydev->irq); irq_wake_thread(phydev->irq, phydev); } Is the postponed interrupt lost when the PHY interrupt is a nested threaded IRQ? One example is a PHY INT routed through an I2C or SPI GPIO expander such as pca953x. For a nested IRQ, __setup_irq() creates no thread. irq_wake_thread() only wakes a thread that exists: kernel/irq/manage.c:irq_wake_thread() { ... if (action->dev_id == dev_id) { if (action->thread) __irq_wake_thread(desc, action); break; } ... } The postponed path in phy_interrupt() disabled the line without reading the PHY's interrupt status. Getting there only takes the MAC's suspend stopping the PHY and the link going down, as the commit message describes. After resume, nothing reads the latched status (for example RTL8211F INSR), so INT stays asserted. An edge-triggered expander input would then never see a new edge. For non-MAC-managed PHYs this is hidden: mdio_bus_phy_resume() calls phy_init_hw()->config_intr() before the replay. stmmac_resume() does not call phy_init_hw(), while fec_resume() does. The state machine is in interrupt mode and does not poll. On such stmmac boards, could link up go unreported after resume, leaving the network down until the interface is reinitialised? > > if (!phydev->suspended_by_mdio_bus) > goto no_resume; -- Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261113-b4-phylib-mac-pm-irq-v3-v6-0-05af2503cb23%40iav.lv From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D460D606A323 for ; Tue, 17 Nov 2026 12:09:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=46DH2AJz; dkim=fail reason="signature verification failed" (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=NXh54g7J DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Cc:To:From:Subject:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Unsubscribe-Post:List-Owner; bh=E5jZhdqC5aHwUez25fpkj5nv4ba1+Yk0EVaFm/+IhIw=; b=46DH2AJzvElP+CfDOjDgV7AXCt ODAUFhUH1xNpa99RIhNLfEApxYl6krw0uSobSGtqqba5bPYlS79k0KlrF+LQ22oMefzOt5GNA8DAS O6lKS4ByxreH6R3OvL7Zyfq4/50eTd2+0XTdcAgrZKH2nPWRhp5xnj+VOk12TGJ/2MDai5h9pq1pH R1AtYV5QVWvxb33r6F39D/3/YiqefqLxcekEwZbk3hPWmCGdnisGa3eP6PurcfVGeS9W3QtExQPAz Z5INK+isqkMpCAGKt0/21w09GAQn5jagn5DOn+mZhQW19Vpc5AejpwLsEF/G7M4iO6RT+eVfJAeRm XjJMWsag==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.100.1 #2 (Red Hat Linux)) id 1xTHzk-00000005YdM-2Nkn; Tue, 17 Nov 2026 12:09:04 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.100.1 #2 (Red Hat Linux)) id 1xTHzB-00000005YOV-0HDc; Tue, 17 Nov 2026 12:08:29 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id CAD8243EC1; Tue, 17 Nov 2026 12:08:28 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 666BB1F000C4; Tue, 17 Nov 2026 12:08:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1794917308; bh=bAWHAy9krkgBXlIJkxkcBl1dWt2HRR+GxtmxZjDrD8c=; h=Subject:From:To:Cc:Date:In-Reply-To:References; b=NXh54g7JfcvQcSqYFFTql6s+2Hq2EuhQ26zuRlAY/uyeaw20sxNkgmsR5KYsKxBkP nkw2kAwTu7HMFmQj7eX63tFZpNeYEoP39M3QSCz2pt0xi5VA9bwvqCFt/Wh+pkDUho Zz3sDzTL9LLxg3Z7cEmmcdrHoBpLuEnm7lggjG28TuCOwA1a4TYZjC0Qq5T4S3Y7PX CPxJkUk/ALySgsLGxW94c/lNHgyhspvLt/3OBEu0nLkcKJVOcdjvPXJb0H51AcwTXr VlXTfxJbqnwT815TvqX0i+d6xCMjiRmwsOWQ3zISc7w7nMGbolxN+7Vus2u+Q/wds+ IEOHP1ul31y0A== Subject: Re: [PATCH net v6 4/4] net: phy: postpone PHY interrupts during sleep with MAC-managed PM From: netdev-bot+sashiko@kernel.org To: iav@iav.lv Cc: andrew@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@kernel.org, kuba@kernel.org, pabeni@redhat.com, maxime.chevallier@bootlin.com, lukas@wunner.de, rafael.j.wysocki@intel.com, wei.fang@nxp.com, niklas.soderlund@ragnatech.se, paul@pbarker.dev, florian.fainelli@broadcom.com, opendmb@gmail.com, Thangaraj.S@microchip.com, shenwei.wang@nxp.com, Haoning.CHENG@cn.bosch.com, netdev@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Date: Tue, 17 Nov 2026 12:08:26 +0000 Message-ID: <179491730695.3136.5496741718229288871@kernel.org> In-Reply-To: <20261113-b4-phylib-mac-pm-irq-v3-v6-4-05af2503cb23@iav.lv> References: <20261113-b4-phylib-mac-pm-irq-v3-v6-4-05af2503cb23@iav.lv> X-sashiko-severity: High X-Archived-By: MIME-Version: 1.0 X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" X-Spam-Status: No, score=-8.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_EF,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=4.0.1 X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-26) on aws-us-west-2-korg-listserv-alma10-1 VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NSBwb3RlbnRpYWwKaXNzdWUocykgdG8gY29uc2lkZXIuCgpDcml0aWNhbDogMCDCtyBIaWdoOiAx IMK3IE1lZGl1bTogNCDCtyBMb3c6IDAKCklmIHlvdSBiZWxpZXZlIG5vbmUgb2YgdGhlIGlzc3Vl cyBhcmUgbGVnaXRpbWF0ZSwgcGxlYXNlIHJlcGx5IHRvIGVhY2gKaXNzdWUgb2YgTWVkaXVtIHNl dmVyaXR5IG9yIGhpZ2hlciBhbmQgZXhwbGFpbiB3aHkgdGhlIEFJIGlzIHdyb25nLgpJZiBhbnkg b2YgdGhlbSBhcmUgbGVnaXRpbWF0ZSBhbmQgeW91IHBsYW4gdG8gcmVzcGluLCBwbGVhc2UgbGV0 IHBhdGNod29yawprbm93IGJ5IGluY2x1ZGluZyAicHctYm90OiBjciIgYXMgYSBzZXBhcmF0ZSBs aW5lIGF0IHRoZSBlbmQgb2YgeW91ciByZXBseQoob25lIHN1Y2ggcmVwbHkgcGVyIHNlcmllcyBp cyBlbm91Z2gpLgoKLSBbSGlnaF0gbmV0OiBwaHk6IGludmVydGVkIFBNIElSUSBvcmRlcmluZyB3 aGVuIGNvbnN1bWVyIE1BQyBsaW5rcyB0bwogIFBIWQotIFtNZWRpdW1dIFBIWSBXYWtlLW9uLUxB TiBjYW4gYmUgbG9zdCBmb3IgTUFDLW1hbmFnZWQgUEhZcyB3aG9zZQogIGludGVycnVwdCBsaW5l IGlzIGFsc28gdGhlaXIgd2FrZSBJUlEuCi0gW01lZGl1bV0gVGhlIHBvc3Rwb25lZCBpbnRlcnJ1 cHQgaXMgbG9zdCBmb3IgTUFDLW1hbmFnZWQgUEhZcyB3aG9zZQogIGludGVycnVwdCBpcyBhIG5l c3RlZCB0aHJlYWRlZCBJUlEgKGZvciBleGFtcGxlIFBIWSBJTlQgcm91dGVkIHRocm91Z2jigKYK LSBbTWVkaXVtXSBBIHNoYXJlZCBJUlEgbGluZSdzIGRpc2FibGUgZGVwdGggY2FuIGxlYWsgd2hl biBhIE1BQy1tYW5hZ2VkCiAgUEhZJ3MgaW50ZXJydXB0IGlzIHJlLXJlcXVlc3RlZCBmcm9tIHRo ZSBNQUMncyByZXN1bWUgY2FsbGJhY2suCi0gW01lZGl1bV0gbmV0OiBwaHk6IHVuYmFsYW5jZWQg ZW5hYmxlX2lycSgpIGluIG1kaW9fYnVzX3BoeV9yZXN1bWVfaXJxKCkKICBvbiBzaGFyZWQgSVJR CgotLQoKbmV0OiBwaHk6IHBvc3Rwb25lIFBIWSBpbnRlcnJ1cHRzIGR1cmluZyBzbGVlcCB3aXRo IE1BQy1tYW5hZ2VkIFBNCgpUaGlzIGNvbW1pdCBtYWtlcyBtZGlvX2J1c19waHlfc3VzcGVuZCgp IGFuZCBtZGlvX2J1c19waHlfcmVzdW1lKCkgc2V0CmFuZCBjbGVhciBpcnFfc3VzcGVuZGVkIGZv ciBQSFlzIHdob3NlIFBNIGlzIG1hbmFnZWQgYnkgdGhlIE1BQyBkcml2ZXIuCnBoeV9pbnRlcnJ1 cHQoKSB0aGVuIHBvc3Rwb25lcyBoYW5kbGluZyBkdXJpbmcgdGhlIHNsZWVwIHRyYW5zaXRpb24K aW5zdGVhZCBvZiB0b3VjaGluZyBhIHBvc3NpYmx5IHBvd2VyZWQtZG93biBNRElPIGJ1cy4gRm9y IE1BQy1tYW5hZ2VkClBIWXMsIHRoZSBwb3N0cG9uZWQgaW50ZXJydXB0IG5vIGxvbmdlciByZXBv cnRzIGEgd2FrZXVwIGV2ZW50LgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGh5L3BoeS5j IGIvZHJpdmVycy9uZXQvcGh5L3BoeS5jCj4gaW5kZXggOGUwM2M5OWZjZThmNS4uY2NmMDY1OGM0 ZDEwMSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL25ldC9waHkvcGh5LmMKPiArKysgYi9kcml2ZXJz L25ldC9waHkvcGh5LmMKPiBAQCAtMTQxOSw3ICsxNDE5LDEwIEBAIHN0YXRpYyBpcnFyZXR1cm5f dCBwaHlfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKnBoeV9kYXQpCj4gIAlpZiAoSVNfRU5BQkxF RChDT05GSUdfUE1fU0xFRVApICYmIFJFQURfT05DRShwaHlkZXYtPmlycV9zdXNwZW5kZWQpKSB7 Cj4gIAkJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiA9IHBoeWRldi0+YXR0YWNoZWRfZGV2Owo+ ICAKPiAtCQlpZiAobmV0ZGV2KSB7Cj4gKwkJLyogV2l0aCBNQUMtbWFuYWdlZCBQTSwgYSBwb3N0 cG9uZWQgaW50ZXJydXB0IGNhbm5vdCB0ZWxsCj4gKwkJICogV2FrZS1vbi1MQU4gZnJvbSBhIGxp bmsgY2hhbmdlIHRoZSBNQUMgY2F1c2VzLgo+ICsJCSAqLwo+ICsJCWlmIChuZXRkZXYgJiYgIXBo eWRldi0+bWFjX21hbmFnZWRfcG0pIHsKPiAgCQkJc3RydWN0IGRldmljZSAqcGFyZW50ID0gbmV0 ZGV2LT5kZXYucGFyZW50Owo+ICAKPiAgCQkJaWYgKG5ldGRldi0+ZXRodG9vbC0+d29sX2VuYWJs ZWQpCgpbU2V2ZXJpdHk6IE1lZGl1bV0KV2l0aCB0aGlzIHBhdGNoLCBhIE1BQy1tYW5hZ2VkIFBI WSBnZXRzIGlycV9zdXNwZW5kZWQgc2V0IGluCm1kaW9fYnVzX3BoeV9zdXNwZW5kKCkgYmVmb3Jl IHRoZSBNQUMncyBvd24gc3VzcGVuZCBjYWxsYmFjayBydW5zLiBBbnkKUEhZIGludGVycnVwdCBm cm9tIHRoZW4gdW50aWwgbWRpb19idXNfcGh5X3Jlc3VtZSgpIHRha2VzIHRoaXMgcG9zdHBvbmVk CnBhdGguIEZvciBtYWNfbWFuYWdlZF9wbSBubyB3YWtldXAgaXMgcmVwb3J0ZWQsIGJ1dCB0aGUg bGluZSBpcyBzdGlsbApkaXNhYmxlZDoKCgkJaWYgKCFwaHlkZXYtPmlycV9yZXJ1bikgewoJCQlw aHlkZXYtPmlycV9yZXJ1biA9IHRydWU7CgkJCWRpc2FibGVfaXJxX25vc3luYyhpcnEpOwoJCX0K CkNvdWxkIHRoaXMgbG9zZSBQSFkgV2FrZS1vbi1MQU4gZm9yIHRoZSB3aG9sZSBzbGVlcCBvbiBQ SFlzIHdob3NlCmludGVycnVwdCBsaW5lIGlzIGFsc28gdGhlaXIgd2FrZSBJUlE/IEJvdGggcnRs ODIxMWZfcHJvYmUoKSBhbmQKYW44ODAxcl9wcm9iZSgpIHJlZ2lzdGVyIHBoeWRldi0+aXJxIGFz IHRoZSB3YWtlIElSUToKCgkJZGV2bV9wbV9zZXRfd2FrZV9pcnEoZGV2LCBwaHlkZXYtPmlycSk7 CgpJbiB0aGUgbm9pcnEgcGhhc2UsIHN1c3BlbmRfZGV2aWNlX2lycSgpIHJlLWVuYWJsZXMgYSBk aXNhYmxlZAp3YWtlLWFybWVkIGxpbmUgb25seSB3aGVuIHRoZSBpcnFjaGlwIGhhcwpJUlFDSElQ X0VOQUJMRV9XQUtFVVBfT05fU1VTUEVORDoKCmtlcm5lbC9pcnEvcG0uYzpzdXNwZW5kX2Rldmlj ZV9pcnEoKSB7CiAgICAuLi4KCQlpZiAoKGNoaXBmbGFncyAmIElSUUNISVBfRU5BQkxFX1dBS0VV UF9PTl9TVVNQRU5EKSAmJgoJCSAgICAgaXJxZF9pcnFfZGlzYWJsZWQoaXJxZCkpIHsKCQkJLi4u CgkJCV9fZW5hYmxlX2lycShkZXNjKTsKICAgIC4uLgp9CgpPbiBvdGhlciBpcnFjaGlwcyB0aGUg bGluZSB3b3VsZCBzdGF5IG1hc2tlZCB1bnRpbCByZXN1bWUuIEEgbGF0ZXIgUE1FCm9yIG1hZ2lj IHBhY2tldCBpbnRlcnJ1cHQgdGhlbiBjb3VsZCBub3Qgd2FrZSB0aGUgc3lzdGVtLgoKT25lIGNv bmNyZXRlIGNhc2UgaXMgc3RtbWFjIHdpdGggYW4gUlRMODIxMUYgYW5kIFBIWSBXb0wgZW5hYmxl ZC4gVGhlCmxpbmsgcGFydG5lciBjaGFuZ2VzIHRoZSBsaW5rIGFmdGVyIGlycV9zdXNwZW5kZWQg aXMgc2V0LCBidXQgYmVmb3JlCnJ0bDgyMTFmX3N1c3BlbmQoKSBzd2l0Y2hlcyBJTkVSIHRvIFBN RSBvbmx5OgoKCWlmIChkZXZpY2VfbWF5X3dha2V1cCgmcGh5ZGV2LT5tZGlvLmRldikpIHsKCQly ZXQgPSBwaHlfd3JpdGVfcGFnZWQocGh5ZGV2LCAweGE0MiwgUlRMODIxeF9JTkVSLAoJCQkJICAg ICAgUlRMODIxMUZfSU5FUl9QTUUpOwoKcnRsODIxMWZfc3VzcGVuZCgpIHRoZW4gY2xlYXJzIElO VEIuIFRoZSBzb2Z0d2FyZSBkaXNhYmxlIG9mIHRoZSBsaW5lCnN0YXlzIGluIHBsYWNlIHVudGls IG1kaW9fYnVzX3BoeV9yZXN1bWVfaXJxKCkuCgpCZWZvcmUgdGhpcyBwYXRjaCwgcGh5X2ludGVy cnVwdCgpIHJhbiBoYW5kbGVfaW50ZXJydXB0KCkgaGVyZSBhbmQgdGhlCm9uZXNob3QgbGluZSB3 YXMgdW5tYXNrZWQgYWdhaW4uIE9uIGJvYXJkcyB3aG9zZSBNRElPIGJ1cyBzdGF5cwpwb3dlcmVk LCBXb0wga2VwdCB3b3JraW5nIGluIHRoaXMgY2FzZS4KClRoZSBwaHlsaW5rX3NwZWVkX2Rvd24o KSByZW5lZ290aWF0aW9uIGluIHBoeWxpbmtfc3VzcGVuZCgpIGRvZXMgbm90CmFwcGVhciB0byB0 cmlnZ2VyIHRoaXMgZm9yIFJUTDgyMTFGIG9yIEFOODgwMS4KcGh5bGlua19zdG9wKCktPnBoeV9z dG9wKCktPnBoeV9zdXNwZW5kKCkgYWxyZWFkeSByZXN0cmljdHMgdGhlCmludGVycnVwdCBtYXNr IGJlZm9yZSB0aGF0IHBvaW50LiBJdCB3b3VsZCBvbmx5IG1hdHRlciBmb3IgYSB3YWtlIElSUQpQ SFkgdGhhdCBsZWF2ZXMgbGluayBpbnRlcnJ1cHRzIHVubWFza2VkIGluIHN1c3BlbmQuCgpUaGUg Y29tbWl0IG1lc3NhZ2Ugc2F5cyB0aGUgbGluZSAibWF5IHRoZW4gc3RheSBtYXNrZWQgdW50aWwg cmVzdW1lLCBzbwpzdWNoIGEgUEhZIG1heSBub3Qgd2FrZSB0aGUgc3lzdGVtIGZyb20gdGhhdCBz bGVlcCIuIEl0IGRvZXMgbm90IHNheQp0aGF0IGFueSBsaW5rIGV2ZW50IGluIHRoaXMgd2luZG93 IGRpc2FibGVzIFdvTCBmb3IgdGhlIHdob2xlIHNsZWVwCmN5Y2xlLgoKVGhlIEhlbGlvczY0IFdv TCB0ZXN0IGFsc28gcnVucyBvbiBncGlvLXJvY2tjaGlwLCBhbmQKcm9ja2NoaXBfaXJxX3N1c3Bl bmQoKSBkb2VzIHRoaXM6CgoJaXJxX3JlZ193cml0ZWwoZ2MsIH5nYy0+d2FrZV9hY3RpdmUsIGJh bmstPmdwaW9fcmVncy0+aW50X21hc2spOwoKVGhhdCB1bm1hc2tzIHdha2UgcGlucyBpbiBoYXJk d2FyZSB3aGF0ZXZlciB0aGUgc29mdHdhcmUgZGlzYWJsZSBzdGF0ZQppcy4gV291bGQgdGhhdCB0 ZXN0IGJlIGFibGUgdG8gc2hvdyB0aGlzIHJlZ3Jlc3Npb24/Cgo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL25ldC9waHkvcGh5X2RldmljZS5jIGIvZHJpdmVycy9uZXQvcGh5L3BoeV9kZXZpY2UuYwo+ IGluZGV4IDM5ZTIzMmEzMTQ0YTIuLmMwNDMwNzE3ODRmNWIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9uZXQvcGh5L3BoeV9kZXZpY2UuYwo+ICsrKyBiL2RyaXZlcnMvbmV0L3BoeS9waHlfZGV2aWNl LmMKPiBAQCAtMzY5LDExICszNjksMTQgQEAgc3RhdGljIF9fbWF5YmVfdW51c2VkIGludCBtZGlv X2J1c19waHlfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gIAlzdHJ1Y3QgcGh5X2Rldmlj ZSAqcGh5ZGV2ID0gdG9fcGh5X2RldmljZShkZXYpOwo+ICAJaW50IHJldDsKPiAgCj4gKwkvKiBB biBpbnRlcnJ1cHQgY2FuIGZpcmUgd2hpbGUgdGhlIE1BQyBoYXMgdGhlIE1ESU8gYnVzIHBvd2Vy ZWQKPiArCSAqIGRvd24sIHdoZXRoZXIgb3Igbm90IHRoZSBNQUMgbWFuYWdlcyBQSFkgUE0uCj4g KwkgKi8KPiArCW1kaW9fYnVzX3BoeV9zdXNwZW5kX2lycShwaHlkZXYpOwo+ICsKPiAgCWlmIChw aHlkZXYtPm1hY19tYW5hZ2VkX3BtKQo+ICAJCXJldHVybiAwOwoKW1NldmVyaXR5OiBNZWRpdW1d CkZvciBhIE1BQy1tYW5hZ2VkIFBIWSwgaXJxX3N1c3BlbmRlZCBpcyBub3cgc2V0IGhlcmUsIGJl Zm9yZSB0aGUgTUFDJ3MKc3VzcGVuZCBjYWxsYmFjayBydW5zLiBjcHN3IGFuZCBjcHN3X25ldyBz ZXQgbWFjX21hbmFnZWRfcG0sIGFuZCB0aGV5CmFsc28gZGlzY29ubmVjdCB0aGUgUEhZIGZyb20g dGhhdCBjYWxsYmFjay4gY3Bzd19zdXNwZW5kKCkgY2FsbHMKY3Bzd19uZG9fc3RvcCgpLCB3aGlj aCBlbmRzIGluIHBoeV9kaXNjb25uZWN0KCksIGFuZCBjcHN3X3Jlc3VtZSgpCmNvbm5lY3RzIHRo ZSBQSFkgYWdhaW4uCgpDYW4gdGhpcyBsZWF2ZSBhIHN0YWxlIGlycV9yZXJ1biBhbmQgYW4gdW5i YWxhbmNlZCBlbmFibGVfaXJxKCkgb24gYQpib2FyZCB3aGVyZSB0aGUgdHdvIHNsYXZlIFBIWXMg c2hhcmUgb25lIGludGVycnVwdCBsaW5lPwoKcGh5X3JlcXVlc3RfaW50ZXJydXB0KCkgdXNlcyBJ UlFGX09ORVNIT1QgfCBJUlFGX1NIQVJFRCwgc28gcGh5MCBhbmQKcGh5MSBlYWNoIGhhdmUgYW4g YWN0aW9uIG9uIHRoZSBzYW1lIGlycV9kZXNjLiBJZiB0aGUgbGluZSBmaXJlcyBhZnRlcgpib3Ro IG1kaW9fYnVzX3BoeV9zdXNwZW5kKCkgY2FsbHMsIGJvdGggdGhyZWFkcyBydW4uIEVhY2gKcGh5 X2ludGVycnVwdCgpIHRha2VzIHRoZSBwb3N0cG9uZWQgcGF0aCwgc2V0cyBpdHMgb3duIGlycV9y ZXJ1biBhbmQKY2FsbHMgZGlzYWJsZV9pcnFfbm9zeW5jKCkuIFRoZSBkZXB0aCBpcyB0aGVuIDIu CgpjcHN3X3N1c3BlbmQoKSB0aGVuIGRpc2Nvbm5lY3RzIHBoeTAuIHBoeV9mcmVlX2ludGVycnVw dCgpIGtlZXBzCnBoeTAtPmlycV9yZXJ1biBzZXQsIGJlY2F1c2UgcGh5MSBzdGlsbCBoYXMgYW4g YWN0aW9uIG9uIHRoZSBsaW5lOgoKCWlmICghaXJxX2hhc19hY3Rpb24ocGh5ZGV2LT5pcnEpKQoJ CXBoeWRldi0+aXJxX3JlcnVuID0gZmFsc2U7CgpEaXNjb25uZWN0aW5nIHBoeTEgcmVtb3ZlcyB0 aGUgbGFzdCBhY3Rpb24uIGZyZWVfaXJxKCkgc2h1dHMgdGhlIGxpbmUKZG93biBhbmQgcGh5MS0+ aXJxX3JlcnVuIGlzIGNsZWFyZWQsIGJ1dCBwaHkwLT5pcnFfcmVydW4gc3RheXMgdHJ1ZS4KCk9u IHJlc3VtZSwgY3Bzd19yZXN1bWUoKSBydW5zIGJlZm9yZSBtZGlvX2J1c19waHlfcmVzdW1lKCkg YW5kIGNhbGxzCnBoeV9yZXF1ZXN0X2ludGVycnVwdCgpIGFnYWluLiBXaXRoIG5vIGFjdGlvbnMg bGVmdCBvbiB0aGUgbGluZSwKX19zZXR1cF9pcnEoKSBjYWxscyBpcnFfc3RhcnR1cCgpIGFuZCB0 aGUgZGVwdGggZ29lcyBiYWNrIHRvIDAuCm1kaW9fYnVzX3BoeV9yZXN1bWVfaXJxKCkgZm9yIHBo eTAgc3RpbGwgc2VlcyBpcnFfcmVydW46CgoJaWYgKHBoeWRldi0+aXJxX3JlcnVuKSB7CgkJcGh5 ZGV2LT5pcnFfcmVydW4gPSBmYWxzZTsKCQllbmFibGVfaXJxKHBoeWRldi0+aXJxKTsKCQlpcnFf d2FrZV90aHJlYWQocGh5ZGV2LT5pcnEsIHBoeWRldik7Cgl9CgpXb3VsZG4ndCB0aGF0IGVuYWJs ZV9pcnEoKSBoaXQgdGhlIHVuYmFsYW5jZWQgZW5hYmxlIFdBUk4gaW4KX19lbmFibGVfaXJxKCk/ CgpUaGUgc3RhbGUgZmxhZyBhbHNvIG1hdHRlcnMgYmVmb3JlIHRoYXQgcG9pbnQuIFN1cHBvc2Ug dGhlIGxpbmUgZmlyZXMKYWZ0ZXIgY3Bzd19yZXN1bWUoKSBoYXMgcmVxdWVzdGVkIHBoeTAncyBJ UlEgYnV0IGJlZm9yZQptZGlvX2J1c19waHlfcmVzdW1lKCkuIHBoeV9pbnRlcnJ1cHQoKSBmb3Ig cGh5MCBzZWVzIGlycV9yZXJ1biBhbHJlYWR5CnNldCBhbmQgc2tpcHMgZGlzYWJsZV9pcnFfbm9z eW5jKCkuIEl0IHJldHVybnMgSVJRX0hBTkRMRUQgd2l0aG91dAp0b3VjaGluZyB0aGUgUEhZLiBJ ZiBwaHkxIGhhcyBub3QgYmVlbiByZWNvbm5lY3RlZCB5ZXQsIG5vdGhpbmcgbWFza3MgYQpsZXZl bC10cmlnZ2VyZWQgbGluZSwgc28gdGhlIG9uZXNob3QgdGhyZWFkIGtlZXBzIGJlaW5nIHdva2Vu LgoKTUFDLW1hbmFnZWQgUEhZcyBjb3VsZCBub3QgZ2V0IGhlcmUgYmVmb3JlLCBiZWNhdXNlIGly cV9zdXNwZW5kZWQgd2FzCm5ldmVyIHNldCBmb3IgdGhlbS4gU2hvdWxkIHBoeV9mcmVlX2ludGVy cnVwdCgpIHVuZG8gdGhpcyBQSFkncyBvd24KZGlzYWJsZV9pcnFfbm9zeW5jKCkgd2hlbmV2ZXIg aXJxX3JlcnVuIGlzIHNldCwgaW5zdGVhZCBvZiBiYXNpbmcgdGhlCmNsZWFudXAgb24gaXJxX2hh c19hY3Rpb24oKT8KCltTZXZlcml0eTogTWVkaXVtXQpGb3IgTUFDLW1hbmFnZWQgUEhZcywgaXJx X3N1c3BlbmRlZCBpcyBub3cgc2V0IGhlcmUgYW5kIGNsZWFyZWQgb25seSBpbgptZGlvX2J1c19w aHlfcmVzdW1lKCkuIFRoYXQgcnVucyBhZnRlciB0aGUgTUFDJ3MgcmVzdW1lIGNhbGxiYWNrLCBz bwp0aGUgZmxhZyBpcyBzdGlsbCB0cnVlIHdoaWxlIHRoZSBNQUMgcmVzdW1lcy4KCnJhdmIgYW5k IHNoX2V0aCBzZXQgbWFjX21hbmFnZWRfcG0uIFRoZXkgY2FsbCBwaHlfZGlzY29ubmVjdCgpIGlu CnN1c3BlbmQgYW5kIG9mX3BoeV9jb25uZWN0KCkgaW4gcmVzdW1lLiBTbyB0aGUgUEhZIElSUSBp cyByZXF1ZXN0ZWQKYWdhaW4gd2hpbGUgaXJxX3N1c3BlbmRlZCBpcyB0cnVlOgoKcmF2Yl9yZXN1 bWUoKS0+cmF2Yl9vcGVuKCktPi4uLi0+cGh5X3JlcXVlc3RfaW50ZXJydXB0KCkKCkNhbiB0aGlz IGxlYXZlIGEgc2hhcmVkIElSUSBsaW5lIGRpc2FibGVkPwoKT24gYW4gSVJRRl9TSEFSRUQgbGlu ZSwgdGhlIG90aGVyIGRldmljZSBjYW4gaW50ZXJydXB0IGFmdGVyCnJlcXVlc3RfdGhyZWFkZWRf aXJxKCkuIHBoeV9pbnRlcnJ1cHQoKSB0aGVuIHRha2VzIHRoZSBwb3N0cG9uZWQgcGF0aCwKc2V0 cyBpcnFfcmVydW4gYW5kIGNhbGxzIGRpc2FibGVfaXJxX25vc3luYygpLiBTdXBwb3NlCnBoeV9l bmFibGVfaW50ZXJydXB0cygpIHRoZW4gZmFpbHM6Cgpkcml2ZXJzL25ldC9waHkvcGh5LmM6cGh5 X3JlcXVlc3RfaW50ZXJydXB0KCkgewogICAgLi4uCgkJaWYgKHBoeV9lbmFibGVfaW50ZXJydXB0 cyhwaHlkZXYpKSB7CgkJCXBoeWRldl93YXJuKHBoeWRldiwgIkNhbid0IGVuYWJsZSBpbnRlcnJ1 cHQsIGZhbGxpbmcgYmFjayB0byBwb2xsaW5nXG4iKTsKCQkJcGh5X2ZyZWVfaW50ZXJydXB0KHBo eWRldik7CgkJCXBoeWRldi0+aXJxID0gUEhZX1BPTEw7CgkJfQogICAgLi4uCn0KCnBoeV9mcmVl X2ludGVycnVwdCgpIGNsZWFycyBpcnFfcmVydW4gb25seSB3aGVuIHRoZSBsaW5lIGhhcyBubyBv dGhlcgphY3Rpb25zIGxlZnQuIE9uIGEgc2hhcmVkIGxpbmUgaXQgc3RpbGwgaGFzIG9uZToKCglp ZiAoIWlycV9oYXNfYWN0aW9uKHBoeWRldi0+aXJxKSkKCQlwaHlkZXYtPmlycV9yZXJ1biA9IGZh bHNlOwoKbWRpb19idXNfcGh5X3Jlc3VtZV9pcnEoKSB0aGVuIHJldHVybnMgZWFybHkgYmVjYXVz ZSB0aGUgSVJRIGlzIG5vdwpQSFlfUE9MTDoKCglXUklURV9PTkNFKHBoeWRldi0+aXJxX3N1c3Bl bmRlZCwgZmFsc2UpOwoJaWYgKCFwaHlfaW50ZXJydXB0X2lzX3ZhbGlkKHBoeWRldikpCgkJcmV0 dXJuOwoKVGhlIG1hdGNoaW5nIGVuYWJsZV9pcnEoKSBuZXZlciBydW5zLiBXb3VsZG4ndCB0aGUg b3RoZXIgZGV2aWNlIG9uIHRoYXQKbGluZSBzdG9wIGdldHRpbmcgaW50ZXJydXB0cywgd2l0aCBp cnFfcmVydW4gbGVmdCBzdGFsZT8KCk1BQy1tYW5hZ2VkIFBIWXMgY291bGQgbm90IHJlYWNoIHRo aXMgcGF0aCBiZWZvcmUsIGJlY2F1c2UgaXJxX3N1c3BlbmRlZAp3YXMgbmV2ZXIgc2V0IGZvciB0 aGVtLgoKPiAgCj4gLQltZGlvX2J1c19waHlfc3VzcGVuZF9pcnEocGh5ZGV2KTsKPiAtCj4gIAkv KiBXZSBtdXN0IHN0b3AgdGhlIHN0YXRlIG1hY2hpbmUgbWFudWFsbHksIG90aGVyd2lzZSBpdCBz dG9wcyBvdXQgb2YKPiAgCSAqIGNvbnRyb2wsIHBvc3NpYmx5IHdpdGggdGhlIHBoeWRldi0+bG9j ayBoZWxkLiBVcG9uIHJlc3VtZSwgbmV0ZGV2Cj4gIAkgKiBtYXkgY2FsbCBwaHkgcm91dGluZXMg dGhhdCB0cnkgdG8gZ3JhYiB0aGUgc2FtZSBsb2NrLCBhbmQgdGhhdCBtYXkKClsgLi4uIF0KCj4g QEAgLTQwNiw4ICs0MDksMTAgQEAgc3RhdGljIF9fbWF5YmVfdW51c2VkIGludCBtZGlvX2J1c19w aHlfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKPiAgCXN0cnVjdCBwaHlfZGV2aWNlICpwaHlk ZXYgPSB0b19waHlfZGV2aWNlKGRldik7Cj4gIAlpbnQgcmV0Owo+ICAKPiAtCWlmIChwaHlkZXYt Pm1hY19tYW5hZ2VkX3BtKQo+ICsJaWYgKHBoeWRldi0+bWFjX21hbmFnZWRfcG0pIHsKPiArCQlt ZGlvX2J1c19waHlfcmVzdW1lX2lycShwaHlkZXYpOwo+ICAJCXJldHVybiAwOwo+ICsJfQoKW1Nl dmVyaXR5OiBIaWdoXQpUaGUgb3JkZXJpbmcgYXJndW1lbnQgaW4gdGhlIGNvbW1pdCBtZXNzYWdl IG5lZWRzIHRoZSBNQUMgdG8gYmUgdGhlCk1ESU8gYnVzIHBhcmVudCBvciBvbmUgb2YgaXRzIGFu Y2VzdG9ycy4gVGhhdCBkb2VzIG5vdCBob2xkIHdoZW4gdGhlClBIWSBzaXRzIG9uIGFuIE1ESU8g YnVzIG93bmVkIGJ5IGFub3RoZXIgZGV2aWNlLiBJbiB0aGF0IGNhc2UKcGh5X2F0dGFjaF9kaXJl Y3QoKSBjYWxscyBkZXZpY2VfbGlua19hZGQoKSB3aXRoIGRldi0+ZGV2LnBhcmVudCBhcwpjb25z dW1lciBhbmQgJnBoeWRldi0+bWRpby5kZXYgYXMgc3VwcGxpZXIuCgpkZXZpY2VfbGlua19hZGQo KSBtb3ZlcyB0aGUgY29uc3VtZXIgdG8gdGhlIHRhaWwgb2YgZHBtX2xpc3QuIFRoZSBNQUMKdGhl biBzdXNwZW5kcyBiZWZvcmUgbWRpb19idXNfcGh5X3N1c3BlbmQoKSBhbmQgcmVzdW1lcyBhZnRl cgptZGlvX2J1c19waHlfcmVzdW1lKCkuIEV4YW1wbGVzIGFyZSB0d28gRkVDIGluc3RhbmNlcyB3 aXRoCkZFQ19RVUlSS19TSU5HTEVfTURJTywgZHVhbCBzdG1tYWMgb3IgbWFjYiBzaGFyaW5nIG9u ZSBNRElPIGJ1cywgYW5kCk1BQ3MgYmVoaW5kIGFuIG1kaW8tbXV4LgoKT24gcmVzdW1lLCBtZGlv X2J1c19waHlfcmVzdW1lKCkgZm9yIHN1Y2ggYSBQSFkgY2xlYXJzIGlycV9zdXNwZW5kZWQKYW5k IHJlcGxheXMgdGhlIHBvc3Rwb25lZCBpbnRlcnJ1cHQgYmVmb3JlIHRoZSBjb25zdW1lcidzIHJl c3VtZQpjYWxsYmFjayBoYXMgcnVuLiBoYW5kbGVfaW50ZXJydXB0KCkgdGhlbiByZWFkcyB0aGUg UEhZIGJlZm9yZQpmZWNfcmVzdW1lKCkgaGFzIHJlLWVuYWJsZWQgZmVwLT5yZWdfcGh5IGFuZCBm ZXAtPmNsa19lbmV0X291dC4gSXQKYWxzbyBydW5zIGJlZm9yZSBwaHlfcmVzdW1lKCkgaGFzIHR1 cm5lZCB0aGUgUEhZIGRyaXZlcidzIG93biBjbG9jawpiYWNrIG9uLCBhcyBydGw4MjF4X3Jlc3Vt ZSgpIGRvZXMgd2l0aCBwcml2LT5jbGsuIEludGVycnVwdHMgYWZ0ZXIgdGhpcwpwb2ludCBhcmUg bm90IHBvc3Rwb25lZCBlaXRoZXIuCgpJZiB0aGF0IE1ESU8gYWNjZXNzIGZhaWxzLCB0aGUgaGFu ZGxlciBjYWxscyBwaHlfZXJyb3IoKSBhbmQgdGhlIHN0YXRlCmJlY29tZXMgUEhZX0VSUk9SLiBw aHlfc3RhcnQoKSBmcm9tIHRoZSBNQUMncyByZXN1bWUgb25seSBhY2NlcHRzClBIWV9SRUFEWSBv ciBQSFlfSEFMVEVELCBzbyBpdCBoaXRzIGl0cyBXQVJOIGFuZCByZXR1cm5zIHdpdGhvdXQKc3Rh cnRpbmcgdGhlIFBIWS4gVGhlIGxpbmsgdGhlbiBzdGF5cyBkb3duIGFmdGVyIHJlc3VtZS4KCklm IHRoZSBhY2Nlc3Mgc3VjY2VlZHMsIHBoeWRldi0+c3RhdGUgaXMgc3RpbGwgUEhZX0hBTFRFRC4K cGh5X3RyaWdnZXJfbWFjaGluZSgpIHRoZW4gcXVldWVzIGEgc3RhdGUgbWFjaGluZSBydW4gdGhh dCB0YWtlcyB0aGUKUEhZX1NUQVRFX1dPUktfU1VTUEVORCBwYXRoIGFuZCBjYWxscyBwaHlfc3Vz cGVuZCgpIG91dHNpZGUKcGh5ZGV2LT5sb2NrLiBDYW4gdGhhdCByYWNlIHdpdGggdGhlIE1BQydz IGxhdGVyCnBoeV9zdGFydCgpLT5fX3BoeV9yZXN1bWUoKT8KClRoZSBzdXNwZW5kIHNpZGUgaXMg bm90IGNvdmVyZWQgZm9yIHRoaXMgdG9wb2xvZ3kgZWl0aGVyLiBUaGUKY29uc3VtZXIncyBzdXNw ZW5kIGNhbGxiYWNrIHJ1bnMgYmVmb3JlIG1kaW9fYnVzX3BoeV9zdXNwZW5kKCkgc2V0cwppcnFf c3VzcGVuZGVkLiBUaGF0IGNhbGxiYWNrIG1heSBjYWxsIHBoeV9zdG9wKCksIGNhbGwKcGh5bGlu a19zcGVlZF9kb3duKCkgYXMgc3RtbWFjX3N1c3BlbmQoKSBkb2VzLCBvciBnYXRlIGNsb2NrcyBh bmQKcmVndWxhdG9ycyBhcyBmZWNfc3VzcGVuZCgpIGRvZXMuIEEgbGluay1kb3duIGludGVycnVw dCBjYXVzZWQgdGhlcmUKc3RpbGwgcnVucyB0aGUgaGFuZGxlciBkaXJlY3RseS4KClNvIGZvciB0 aGVzZSBQSFlzIHRoZSBwYXRjaCBvbmx5IG1vdmVzIHRoZSBoYW5kbGVyIGZyb20KcmVzdW1lX2Rl dmljZV9pcnFzKCkgdG8gbWRpb19idXNfcGh5X3Jlc3VtZSgpLCBzdGlsbCBhaGVhZCBvZiB0aGUg TUFDLgpTaG91bGQgdGhlIHJlcGxheSBmb3IgYSBQSFkgd2l0aCBwaHlkZXYtPmRldmxpbmsgd2Fp dCB1bnRpbCB0aGUKY29uc3VtZXIgaGFzIHJlc3VtZWQ/IE9yIHNob3VsZCB0aGUgY29tbWl0IG1l c3NhZ2Ugc2F5IHRoYXQgdGhpcwp0b3BvbG9neSBpcyBub3QgY292ZXJlZD8KCltTZXZlcml0eTog TWVkaXVtXQpGb3IgYSBNQUMtbWFuYWdlZCBQSFksIHRoaXMgcmVwbGF5IG5vdyBydW5zIHdpdGhv dXQgYSBwaHlfaW5pdF9odygpIGNhbGwKYmVmb3JlIGl0OgoKCWlmIChwaHlkZXYtPmlycV9yZXJ1 bikgewoJCXBoeWRldi0+aXJxX3JlcnVuID0gZmFsc2U7CgkJZW5hYmxlX2lycShwaHlkZXYtPmly cSk7CgkJaXJxX3dha2VfdGhyZWFkKHBoeWRldi0+aXJxLCBwaHlkZXYpOwoJfQoKSXMgdGhlIHBv c3Rwb25lZCBpbnRlcnJ1cHQgbG9zdCB3aGVuIHRoZSBQSFkgaW50ZXJydXB0IGlzIGEgbmVzdGVk CnRocmVhZGVkIElSUT8gT25lIGV4YW1wbGUgaXMgYSBQSFkgSU5UIHJvdXRlZCB0aHJvdWdoIGFu IEkyQyBvciBTUEkgR1BJTwpleHBhbmRlciBzdWNoIGFzIHBjYTk1M3guCgpGb3IgYSBuZXN0ZWQg SVJRLCBfX3NldHVwX2lycSgpIGNyZWF0ZXMgbm8gdGhyZWFkLiBpcnFfd2FrZV90aHJlYWQoKQpv bmx5IHdha2VzIGEgdGhyZWFkIHRoYXQgZXhpc3RzOgoKa2VybmVsL2lycS9tYW5hZ2UuYzppcnFf d2FrZV90aHJlYWQoKSB7CiAgICAuLi4KCQlpZiAoYWN0aW9uLT5kZXZfaWQgPT0gZGV2X2lkKSB7 CgkJCWlmIChhY3Rpb24tPnRocmVhZCkKCQkJCV9faXJxX3dha2VfdGhyZWFkKGRlc2MsIGFjdGlv bik7CgkJCWJyZWFrOwoJCX0KICAgIC4uLgp9CgpUaGUgcG9zdHBvbmVkIHBhdGggaW4gcGh5X2lu dGVycnVwdCgpIGRpc2FibGVkIHRoZSBsaW5lIHdpdGhvdXQgcmVhZGluZwp0aGUgUEhZJ3MgaW50 ZXJydXB0IHN0YXR1cy4gR2V0dGluZyB0aGVyZSBvbmx5IHRha2VzIHRoZSBNQUMncyBzdXNwZW5k CnN0b3BwaW5nIHRoZSBQSFkgYW5kIHRoZSBsaW5rIGdvaW5nIGRvd24sIGFzIHRoZSBjb21taXQg bWVzc2FnZQpkZXNjcmliZXMuCgpBZnRlciByZXN1bWUsIG5vdGhpbmcgcmVhZHMgdGhlIGxhdGNo ZWQgc3RhdHVzIChmb3IgZXhhbXBsZSBSVEw4MjExRgpJTlNSKSwgc28gSU5UIHN0YXlzIGFzc2Vy dGVkLiBBbiBlZGdlLXRyaWdnZXJlZCBleHBhbmRlciBpbnB1dCB3b3VsZAp0aGVuIG5ldmVyIHNl ZSBhIG5ldyBlZGdlLgoKRm9yIG5vbi1NQUMtbWFuYWdlZCBQSFlzIHRoaXMgaXMgaGlkZGVuOiBt ZGlvX2J1c19waHlfcmVzdW1lKCkgY2FsbHMKcGh5X2luaXRfaHcoKS0+Y29uZmlnX2ludHIoKSBi ZWZvcmUgdGhlIHJlcGxheS4gc3RtbWFjX3Jlc3VtZSgpIGRvZXMgbm90CmNhbGwgcGh5X2luaXRf aHcoKSwgd2hpbGUgZmVjX3Jlc3VtZSgpIGRvZXMuCgpUaGUgc3RhdGUgbWFjaGluZSBpcyBpbiBp bnRlcnJ1cHQgbW9kZSBhbmQgZG9lcyBub3QgcG9sbC4gT24gc3VjaCBzdG1tYWMKYm9hcmRzLCBj b3VsZCBsaW5rIHVwIGdvIHVucmVwb3J0ZWQgYWZ0ZXIgcmVzdW1lLCBsZWF2aW5nIHRoZSBuZXR3 b3JrCmRvd24gdW50aWwgdGhlIGludGVyZmFjZSBpcyByZWluaXRpYWxpc2VkPwoKPiAgCj4gIAlp ZiAoIXBoeWRldi0+c3VzcGVuZGVkX2J5X21kaW9fYnVzKQo+ICAJCWdvdG8gbm9fcmVzdW1lOwoK LS0gClNhc2hpa28gQUkgcmV2aWV3IMK3IGh0dHBzOi8vbmV0ZGV2LWFpLmJvdHMubGludXguZGV2 L3Nhc2hpa28vIy9wYXRjaHNldC8yMDI2MTExMy1iNC1waHlsaWItbWFjLXBtLWlycS12My12Ni0w LTA1YWYyNTAzY2IyMyU0MGlhdi5sdgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KTGludXgtcm9ja2NoaXAgbWFpbGluZyBsaXN0CkxpbnV4LXJvY2tjaGlw QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9saW51eC1yb2NrY2hpcAo=