From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from pandora.armlinux.org.uk (pandora.armlinux.org.uk [78.32.30.218]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 39CE22D8370 for ; Wed, 11 Mar 2026 17:47:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=78.32.30.218 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773251227; cv=none; b=KbFCJMqUp7Wkaw0Gw+UJnMQvh0qM9k/aLZK8JFyctpOlaezQTtOS/e3qsG/qX9ZRD9VBMI6LEQZPLyxS0fTXRCjUPcRMP3L+8qtsRyg5jAgs916z/gneSaFIxeAVdhAOPW7TE19ZXMLniZ6yKKAcAuGgy6vfAZrs538mNJsiAcI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773251227; c=relaxed/simple; bh=h6jbeDA9gXyuSmNcuXaj3JWcgu0pBi+oJOGx496T/Hs=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=OsijrCNR856h4/bWulanLvqVHMYiCH+DqODSh1MxxzxQt/B/AEJsctBQsIs/xPJcXdZ3+l0CVM3jW2gIJ5UdK626zD02V4XkF77qr7FrSpsaoSNwSvyDUGrGyefJJpuFnzKLPjfTHFhKa9S3VQ81jmH2DaZH2B/VoKqkTHG6i18= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=armlinux.org.uk; spf=none smtp.mailfrom=armlinux.org.uk; dkim=pass (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.b=Mngfxk09; arc=none smtp.client-ip=78.32.30.218 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=armlinux.org.uk Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=armlinux.org.uk Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.b="Mngfxk09" DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=vkA02cIf1bCPsbEnaLlFrwiwhwE6F8sIdO8MLg/HiWE=; b=Mngfxk09kt4/krUPKb1Zn6lcvE l9OOliC67agWfQrQug9P+Kg4KqL8K9pG1JGagHPp977ZBgRBJPBA6B3n6Nq7ZZjzNhNHBa04Aggd5 OxtnrJvRSidT247vak7uZRx4sFwM4zso4bxtCfWNXqbI/zKGUIPSu5Xf8u404kZVl3eFXdmVr6G4K lO0ZoDXT9gXriqFDdnx8nO6ED36JLZ/Tw859kbvSISGE+Y5EZTdKRfgl8TrhT+cd35X399OGNYGsB A9ja4GIOef9lTvNcGssfOGnV0KFRzjeIBBAF4bFnXTDE4eQQekh/xdRvVuaMtrlshIqYyXcwouNb5 LGP1XvZg==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:35300) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1w0Ndi-000000006l7-0H7T; Wed, 11 Mar 2026 17:46:34 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.98.2) (envelope-from ) id 1w0Nde-000000006RR-1cKu; Wed, 11 Mar 2026 17:46:30 +0000 Date: Wed, 11 Mar 2026 17:46:30 +0000 From: "Russell King (Oracle)" To: Bartosz Golaszewski Cc: Bartosz Golaszewski , Bjorn Andersson , Konrad Dybcio , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Andrew Lunn , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Maxime Coquelin , Alexandre Torgue , Vinod Koul , Giuseppe Cavallaro , Chen-Yu Tsai , Jernej Skrabec , Neil Armstrong , Kevin Hilman , Jerome Brunet , Shawn Guo , Fabio Estevam , Jan Petrous , s32@nxp.com, Romain Gantois , Geert Uytterhoeven , Magnus Damm , Maxime Ripard , Christophe Roullier , Radu Rendec , linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, Drew Fustini , linux-sunxi@lists.linux.dev, linux-amlogic@lists.infradead.org, linux-mips@vger.kernel.org, imx@lists.linux.dev, linux-renesas-soc@vger.kernel.org, linux-rockchip@lists.infradead.org, sophgo@lists.linux.dev, linux-riscv@lists.infradead.org, Bartosz Golaszewski Subject: Re: [PATCH net-next v8 2/6] net: stmmac: qcom-ethqos: use generic device properties Message-ID: References: <20260311-qcom-sa8255p-emac-v8-0-58227bcf1018@oss.qualcomm.com> <20260311-qcom-sa8255p-emac-v8-2-58227bcf1018@oss.qualcomm.com> Precedence: bulk X-Mailing-List: imx@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: Sender: Russell King (Oracle) On Wed, Mar 11, 2026 at 06:18:00PM +0100, Bartosz Golaszewski wrote: > On Wed, Mar 11, 2026 at 6:14 PM Russell King (Oracle) > wrote: > > > > On Wed, Mar 11, 2026 at 06:03:37PM +0100, Bartosz Golaszewski wrote: > > > From: Bartosz Golaszewski > > > > > > In order to drop the dependency on CONFIG_OF, convert all device property > > > getters from OF-specific to generic device properties and stop pulling > > > in any linux/of.h symbols. > > > > > > Signed-off-by: Bartosz Golaszewski > > > Signed-off-by: Bartosz Golaszewski > > > > Please postpone this for the time being - I'm trying to get stmmac's > > pain-in-the-arse PCS support sorted, and I've patch series out there > > and pending that make a large number of changes to this driver. This > > is likely to conflict with my work. > > > > I'm limited by the rate at which patches can be applied to net-next > > and the rate at which Mohd can provide me feedback. On that, I notice > > you haven't Cc'd Mohd who is now in MAINTAINERS for qcom-ethqos. > > > > Do these two changesets interact with each other a lot? Do you have a > WIP branch I could take a look at? This has been post-poned several > times already, there always seem to be some new changes coming in. :/ I don't have a public branch because this work is subject to rework depending on the feedback I receive. Mohd has another version of the series that I'm waiting for feedback for. As soon as I hear that it's fine, I will be sending it. The problem I refer to has been a pain point for phylink since stmmac was converted in 2019, which pre-dates qcom-ethqos, the merging of which has made solving sthis much more painful as qcom-ethqos completely bypasses phylink by forcing the PCS inband state behind phylink's back. Honestly, over recent months, I've been washing that I'd NACK'd the merging of dwmac-qcom-ethqos at the time over this, but I didn't have any solution for stmmac at that point (it wasn't my responsibility, the broken phylink conversion of stmmac was merged without my knowledge, without even a Cc to me.) One of the biggest changes that will definitely conflict with your changes is the move of qcom-ethqos' SerDes support into stmmac core code - because the stmmac PCS code needs to know whether the SerDes can support 2.5Gbps speed. I got the changes for the generic PHY part of that merged last week. Another change that will conflict is your patch 3, where masses of changes in qcom_ethqos_probe() which will conflict with my "net: stmmac: qcom-ethqos: enable 2500BASE-X" patch. I've posted patches for that a couple of weeks ago, but Mohd reported problems, so I've had to rework the series - and now those patches are part of a follow-on series after sorting the bulk of the stmmac PCS mess. I'm currently waiting for Mohd's feedback on the reworked series. https://lore.kernel.org/r/aZ7ggfQanc8jeCb9@shell.armlinux.org.uk https://lore.kernel.org/r/aafxqCvJ_XY4YbWw@shell.armlinux.org.uk Latest version waiting for Mohd's feedback: https://lore.kernel.org/r/aa6sofjFxyi2nkpr@shell.armlinux.org.uk Below are the two patches which add and convert qcom-ethqos serdes support. Note that these two depend on other patches. From: "Russell King (Oracle)" Subject: [PATCH net-next] net: stmmac: add stmmac core serdes support Rather than having platform glue implement SerDes PHY support, add it to the core driver, specifically to the stmmac integrated PCS driver as the SerDes is connected to the integrated PCS. Platforms using external PCS can also populate plat->serdes, and the core driver will call phy_init() and phy_exit() when the administrative state of the interface changes, but the other phy methods will not be called. Reviewed-by: Maxime Chevallier Signed-off-by: Russell King (Oracle) -- rfc->v1: avoid calling phy_get_mode() with NULL serdes PHY v2: add cleanup when dwmac_serdes_set_mode() fails, so that failure at any point in the internal PCS enable method leaves the overall state unchanged. v3: in a pending change to generic PHY documentation indicated by Vinod recently, calling phy_set_mode(_ext)() before phy_power_on() will be preferred, so re-organise to use that ordering. v4: move phy_set_mode() into .mac_finish(), add dwmac_has_serdes() to make serdes calls conditional on dwmac's active phy interface, with the exception of phy_init()/phy_exit() calls. --- drivers/net/ethernet/stmicro/stmmac/Makefile | 2 +- .../net/ethernet/stmicro/stmmac/stmmac_main.c | 37 +++++++- .../net/ethernet/stmicro/stmmac/stmmac_pcs.c | 44 +++++++-- .../ethernet/stmicro/stmmac/stmmac_serdes.c | 92 +++++++++++++++++++ .../ethernet/stmicro/stmmac/stmmac_serdes.h | 15 +++ include/linux/stmmac.h | 2 + 6 files changed, 181 insertions(+), 11 deletions(-) create mode 100644 drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.c create mode 100644 drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.h diff --git a/drivers/net/ethernet/stmicro/stmmac/Makefile b/drivers/net/ethernet/stmicro/stmmac/Makefile index c9263987ef8d..a3c2cd5d0c91 100644 --- a/drivers/net/ethernet/stmicro/stmmac/Makefile +++ b/drivers/net/ethernet/stmicro/stmmac/Makefile @@ -7,7 +7,7 @@ stmmac-objs:= stmmac_main.o stmmac_ethtool.o stmmac_mdio.o ring_mode.o \ dwmac4_dma.o dwmac4_lib.o dwmac4_core.o dwmac5.o hwif.o \ stmmac_tc.o dwxgmac2_core.o dwxgmac2_dma.o dwxgmac2_descs.o \ stmmac_xdp.o stmmac_est.o stmmac_fpe.o stmmac_vlan.o \ - stmmac_pcs.o $(stmmac-y) + stmmac_pcs.o stmmac_serdes.o $(stmmac-y) stmmac-$(CONFIG_STMMAC_SELFTESTS) += stmmac_selftests.o diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c index 37f6ee7566be..428b2e5bb4c4 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c @@ -49,6 +49,7 @@ #include "stmmac_fpe.h" #include "stmmac.h" #include "stmmac_pcs.h" +#include "stmmac_serdes.h" #include "stmmac_xdp.h" #include #include @@ -969,7 +970,7 @@ static int stmmac_mac_finish(struct phylink_config *config, unsigned int mode, priv->plat->mac_finish(ndev, priv->plat->bsp_priv, mode, interface); - return 0; + return dwmac_serdes_set_mode(priv, interface); } static void stmmac_mac_link_down(struct phylink_config *config, @@ -3592,12 +3593,14 @@ static void stmmac_safety_feat_configuration(struct stmmac_priv *priv) static void stmmac_clk_rx_i_require(struct stmmac_priv *priv) { + dwmac_serdes_power_on(priv); phylink_rx_clk_stop_block(priv->phylink); } static void stmmac_clk_rx_i_release(struct stmmac_priv *priv) { phylink_rx_clk_stop_unblock(priv->phylink); + dwmac_serdes_power_off(priv); } /** @@ -4153,6 +4156,10 @@ static int stmmac_open(struct net_device *dev) if (ret) goto err_runtime_pm; + ret = dwmac_serdes_init(priv); + if (ret < 0) + goto err_disconnect_phy; + if (!(priv->plat->flags & STMMAC_FLAG_SERDES_UP_AFTER_PHY_LINKUP)) { ret = stmmac_legacy_serdes_power_up(priv); if (ret < 0) @@ -4172,6 +4179,7 @@ static int stmmac_open(struct net_device *dev) err_serdes: stmmac_legacy_serdes_power_down(priv); + dwmac_serdes_exit(priv); err_disconnect_phy: phylink_disconnect_phy(priv->phylink); err_runtime_pm: @@ -4232,6 +4240,7 @@ static int stmmac_release(struct net_device *dev) __stmmac_release(dev); stmmac_legacy_serdes_power_down(priv); + dwmac_serdes_exit(priv); phylink_disconnect_phy(priv->phylink); pm_runtime_put(priv->device); @@ -7781,6 +7790,13 @@ static int __stmmac_dvr_probe(struct device *device, return -EINVAL; } + if (plat_dat->serdes && + (plat_dat->serdes_powerup || plat_dat->serdes_powerdown)) { + dev_err(device, + "generic PHY and SerDes platform callbacks are incompatible\n"); + return -EINVAL; + } + ndev = devm_alloc_etherdev_mqs(device, sizeof(struct stmmac_priv), MTL_MAX_TX_QUEUES, MTL_MAX_RX_QUEUES); if (!ndev) @@ -8194,6 +8210,15 @@ int stmmac_suspend(struct device *dev) rtnl_lock(); phylink_suspend(priv->phylink, !!priv->wolopts); + + /* If the MAC has WoL enabled, the SerDes needs to remain active. + * Otherwise, phylink will have stopped the MAC and the PCS will + * have been disabled, meaning the SerDes is already powered off. + * Call its exit function so we can call init during resume. + */ + if (!priv->wolopts) + dwmac_serdes_exit(priv); + rtnl_unlock(); if (stmmac_fpe_supported(priv)) @@ -8290,6 +8315,15 @@ int stmmac_resume(struct device *dev) rtnl_lock(); + /* If the MAC has WoL enabled, the SerDes was left active */ + if (!priv->wolopts) { + ret = dwmac_serdes_init(priv); + if (ret) { + rtnl_unlock(); + return ret; + } + } + /* Prepare the PHY to resume, ensuring that its clocks which are * necessary for the MAC DMA reset to complete are running */ @@ -8307,6 +8341,7 @@ int stmmac_resume(struct device *dev) netdev_err(priv->dev, "%s: Hw setup failed\n", __func__); stmmac_legacy_serdes_power_down(priv); mutex_unlock(&priv->lock); + dwmac_serdes_exit(priv); rtnl_unlock(); return ret; } diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_pcs.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_pcs.c index 0c0eb9e30b95..298d3c00b2fa 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_pcs.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_pcs.c @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0-only #include "stmmac.h" #include "stmmac_pcs.h" +#include "stmmac_serdes.h" /* * GMAC_AN_STATUS is equivalent to MII_BMSR @@ -60,8 +61,14 @@ static unsigned int dwmac_integrated_pcs_inband_caps(struct phylink_pcs *pcs, static int dwmac_integrated_pcs_enable(struct phylink_pcs *pcs) { struct stmmac_pcs *spcs = phylink_pcs_to_stmmac_pcs(pcs); + struct stmmac_priv *priv = spcs->priv; + int ret; - stmmac_mac_irq_modify(spcs->priv, 0, spcs->int_mask); + ret = dwmac_serdes_power_on(priv); + if (ret) + return ret; + + stmmac_mac_irq_modify(priv, 0, spcs->int_mask); return 0; } @@ -69,8 +76,11 @@ static int dwmac_integrated_pcs_enable(struct phylink_pcs *pcs) static void dwmac_integrated_pcs_disable(struct phylink_pcs *pcs) { struct stmmac_pcs *spcs = phylink_pcs_to_stmmac_pcs(pcs); + struct stmmac_priv *priv = spcs->priv; + + stmmac_mac_irq_modify(priv, spcs->int_mask, 0); - stmmac_mac_irq_modify(spcs->priv, spcs->int_mask, 0); + dwmac_serdes_power_off(priv); } static void dwmac_integrated_pcs_get_state(struct phylink_pcs *pcs, @@ -220,6 +230,22 @@ int stmmac_integrated_pcs_get_phy_intf_sel(struct phylink_pcs *pcs, return -EINVAL; } +static void stmmac_integrated_pcs_check_support(struct stmmac_priv *priv, + struct stmmac_pcs *spcs, + phy_interface_t interface, + unsigned int flag) +{ + bool supported; + + if (priv->plat->serdes) + supported = dwmac_serdes_validate(priv, interface) == 0; + else + supported = !flag || priv->plat->flags & flag; + + if (supported) + __set_bit(interface, spcs->pcs.supported_interfaces); +} + int stmmac_integrated_pcs_init(struct stmmac_priv *priv, const struct stmmac_pcs_info *pcs_info) { @@ -243,13 +269,13 @@ int stmmac_integrated_pcs_init(struct stmmac_priv *priv, if (readl(spcs->base + GMAC_AN_STATUS) & BMSR_ESTATEN) spcs->support_tbi_rtbi = true; - __set_bit(PHY_INTERFACE_MODE_SGMII, spcs->pcs.supported_interfaces); - __set_bit(PHY_INTERFACE_MODE_1000BASEX, spcs->pcs.supported_interfaces); - - /* Only allow 2500BASE-X if the SerDes has support. */ - if (priv->plat->flags & STMMAC_FLAG_SERDES_SUPPORTS_2500M) - __set_bit(PHY_INTERFACE_MODE_2500BASEX, - spcs->pcs.supported_interfaces); + stmmac_integrated_pcs_check_support(priv, spcs, + PHY_INTERFACE_MODE_SGMII, 0); + stmmac_integrated_pcs_check_support(priv, spcs, + PHY_INTERFACE_MODE_1000BASEX, 0); + stmmac_integrated_pcs_check_support(priv, spcs, + PHY_INTERFACE_MODE_2500BASEX, + STMMAC_FLAG_SERDES_SUPPORTS_2500M); priv->integrated_pcs = spcs; diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.c new file mode 100644 index 000000000000..a767c0553604 --- /dev/null +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.c @@ -0,0 +1,92 @@ +#include + +#include "stmmac.h" +#include "stmmac_serdes.h" + +static bool dwmac_has_serdes(struct stmmac_priv *priv) +{ + if (priv->plat->core_type == DWMAC_CORE_XGMAC) + return false; + + return priv->dma_cap.actphyif == PHY_INTF_SEL_SGMII || + priv->dma_cap.actphyif == PHY_INTF_SEL_TBI || + priv->dma_cap.actphyif == PHY_INTF_SEL_RTBI; +} + +int dwmac_serdes_validate(struct stmmac_priv *priv, phy_interface_t interface) +{ + struct phy *serdes = priv->plat->serdes; + + return phy_validate(serdes, PHY_MODE_ETHERNET, interface, NULL); +} + +int dwmac_serdes_init(struct stmmac_priv *priv) +{ + struct phy *serdes = priv->plat->serdes; + int ret; + + ret = phy_init(serdes); + if (ret) + dev_err(priv->device, "failed to initialize SerDes: %pe\n", + ERR_PTR(ret)); + + return ret; +} + +int dwmac_serdes_power_on(struct stmmac_priv *priv) +{ + struct phy *serdes = priv->plat->serdes; + int ret; + + if (!dwmac_has_serdes(priv)) + return 0; + + ret = phy_power_on(serdes); + if (ret) + dev_err(priv->device, "failed to power on SerDes: %pe\n", + ERR_PTR(ret)); + + return ret; +} + +int dwmac_serdes_set_mode(struct stmmac_priv *priv, phy_interface_t interface) +{ + struct phy *serdes = priv->plat->serdes; + int ret; + + if (!dwmac_has_serdes(priv)) + return 0; + + ret = phy_set_mode_ext(serdes, PHY_MODE_ETHERNET, interface); + if (ret) + dev_err(priv->device, + "failed to set SerDes mode %s: %pe\n", + phy_modes(interface), ERR_PTR(ret)); + + return ret; +} + +void dwmac_serdes_power_off(struct stmmac_priv *priv) +{ + struct phy *serdes = priv->plat->serdes; + int ret; + + if (!dwmac_has_serdes(priv)) + return; + + ret = phy_power_off(serdes); + if (ret) + dev_err(priv->device, "failed to power off SerDes: %pe\n", + ERR_PTR(ret)); +} + +void dwmac_serdes_exit(struct stmmac_priv *priv) +{ + struct phy *serdes = priv->plat->serdes; + int ret; + + ret = phy_exit(serdes); + if (ret) + dev_err(priv->device, "failed to shutdown SerDes: %pe\n", + ERR_PTR(ret)); +} diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.h b/drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.h new file mode 100644 index 000000000000..2ca37a7d0fde --- /dev/null +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_serdes.h @@ -0,0 +1,15 @@ +#ifndef STMMAC_SERDES_H +#define STMMAC_SERDES_H + +#include + +struct stmmac_priv; + +int dwmac_serdes_validate(struct stmmac_priv *priv, phy_interface_t interface); +int dwmac_serdes_init(struct stmmac_priv *priv); +int dwmac_serdes_power_on(struct stmmac_priv *priv); +int dwmac_serdes_set_mode(struct stmmac_priv *priv, phy_interface_t interface); +void dwmac_serdes_power_off(struct stmmac_priv *priv); +void dwmac_serdes_exit(struct stmmac_priv *priv); + +#endif diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h index a8e9b5d3289f..bedba4e23088 100644 --- a/include/linux/stmmac.h +++ b/include/linux/stmmac.h @@ -216,6 +216,7 @@ enum dwmac_core_type { #define STMMAC_FLAG_SERDES_SUPPORTS_2500M BIT(15) struct mac_device_info; +struct phy; struct plat_stmmacenet_data { enum dwmac_core_type core_type; @@ -245,6 +246,7 @@ struct plat_stmmacenet_data { * that phylink uses. */ phy_interface_t phy_interface; + struct phy *serdes; struct stmmac_mdio_bus_data *mdio_bus_data; struct device_node *phy_node; struct device_node *mdio_node; -- 2.47.3 From: "Russell King (Oracle)" Subject: [PATCH net-next] net: stmmac: qcom-ethqos: convert to dwmac core SerDes support Convert qcom-ethqos to use the dwmac core's generic SerDes support, which will handle SerDes initialisation, powering, and mode setting. Note that generic support requires the SerDes to support phy_validate() in order to probe which PHY interface modes are supported, and phy_set_mode_ext() to configure the appropriate PHY interface mode (and thus the speed.) Signed-off-by: Russell King (Oracle) --- .../stmicro/stmmac/dwmac-qcom-ethqos.c | 45 ++----------------- 1 file changed, 4 insertions(+), 41 deletions(-) diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c index 9a2194fccb9b..a40a4bca197d 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c @@ -104,7 +104,6 @@ struct qcom_ethqos { phy_interface_t interface, int speed); struct clk *link_clk; - struct phy *serdes_phy; phy_interface_t phy_mode; const struct ethqos_emac_por *rgmii_por; @@ -627,45 +626,15 @@ static void ethqos_fix_mac_speed(void *priv, phy_interface_t interface, ethqos_configure(ethqos, interface, speed); } -static int qcom_ethqos_serdes_powerup(struct net_device *ndev, void *priv) -{ - struct qcom_ethqos *ethqos = priv; - int ret; - - ret = phy_init(ethqos->serdes_phy); - if (ret) - return ret; - - ret = phy_power_on(ethqos->serdes_phy); - if (ret) - phy_exit(ethqos->serdes_phy); - - return ret; -} - -static void qcom_ethqos_serdes_powerdown(struct net_device *ndev, void *priv) -{ - struct qcom_ethqos *ethqos = priv; - - phy_power_off(ethqos->serdes_phy); - phy_exit(ethqos->serdes_phy); -} - static int ethqos_mac_finish_serdes(struct net_device *ndev, void *priv, unsigned int mode, phy_interface_t interface) { struct qcom_ethqos *ethqos = priv; - int ret = 0; qcom_ethqos_set_sgmii_loopback(ethqos, false); - if (interface == PHY_INTERFACE_MODE_SGMII || - interface == PHY_INTERFACE_MODE_2500BASEX) - ret = phy_set_mode_ext(ethqos->serdes_phy, PHY_MODE_ETHERNET, - interface); - - return ret; + return 0; } static int ethqos_clks_config(void *priv, bool enabled) @@ -789,9 +758,9 @@ static int qcom_ethqos_probe(struct platform_device *pdev) if (ret) return ret; - ethqos->serdes_phy = devm_phy_optional_get(dev, "serdes"); - if (IS_ERR(ethqos->serdes_phy)) - return dev_err_probe(dev, PTR_ERR(ethqos->serdes_phy), + plat_dat->serdes = devm_phy_optional_get(dev, "serdes"); + if (IS_ERR(plat_dat->serdes)) + return dev_err_probe(dev, PTR_ERR(plat_dat->serdes), "Failed to get serdes phy\n"); ethqos_set_clk_tx_rate(ethqos, NULL, plat_dat->phy_interface, @@ -816,12 +785,6 @@ static int qcom_ethqos_probe(struct platform_device *pdev) if (data->dma_addr_width) plat_dat->host_dma_width = data->dma_addr_width; - if (ethqos->serdes_phy) { - plat_dat->serdes_powerup = qcom_ethqos_serdes_powerup; - plat_dat->serdes_powerdown = qcom_ethqos_serdes_powerdown; - plat_dat->flags |= STMMAC_FLAG_SERDES_SUPPORTS_2500M; - } - /* Enable TSO on queue0 and enable TBS on rest of the queues */ for (i = 1; i < plat_dat->tx_queues_to_use; i++) plat_dat->tx_queues_cfg[i].tbs_en = 1; -- 2.47.3 -- RMK's Patch system: https://www.armlinux.org.uk/developer/patches/ FTTP is here! 80Mbps down 10Mbps up. Decent connectivity at last! From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 21A691125858 for ; Wed, 11 Mar 2026 17:47:13 +0000 (UTC) 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:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=ahfb133VSS71wufWvW/YaRi3snhk4Eqe4UHCr7rhHgA=; b=JqZPRg61+/5zJA YS7uQyynYVcNsOdND0ReNcGEoHq8EA6v7mS/YUySl2ZbHm/1iJDNxj2VWeGtnmTIF+VLFhCiOEP6c BK05z1SsFkQ1G6b4PTnF/u2hpax/cQ8HdHgZPEsqXolgR+/elrD7ISB4/JOMWSDDEHGf4T8RUtGy6 HsjKCIa1sdMW8FI+baZwJnOjIU6IPnut1oJrH5hLtiL5JGXERb413HJVOThEg0snGnMdwSf10zeoU 4TCEsZGsXvWtMY2bAi2AZyTFBfTCL9hvYZsjmjK5Axl7jSTjG0Ud403b/9VBiOgkrHLinrAgYK5jz woW7UZmHkJ+k8rDjVukw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1w0NeD-0000000C4hD-0pJf; Wed, 11 Mar 2026 17:47:05 +0000 Received: from pandora.armlinux.org.uk ([2001:4d48:ad52:32c8:5054:ff:fe00:142]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1w0Ne9-0000000C4eV-3kSY; Wed, 11 Mar 2026 17:47:03 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=vkA02cIf1bCPsbEnaLlFrwiwhwE6F8sIdO8MLg/HiWE=; b=Mngfxk09kt4/krUPKb1Zn6lcvE l9OOliC67agWfQrQug9P+Kg4KqL8K9pG1JGagHPp977ZBgRBJPBA6B3n6Nq7ZZjzNhNHBa04Aggd5 OxtnrJvRSidT247vak7uZRx4sFwM4zso4bxtCfWNXqbI/zKGUIPSu5Xf8u404kZVl3eFXdmVr6G4K lO0ZoDXT9gXriqFDdnx8nO6ED36JLZ/Tw859kbvSISGE+Y5EZTdKRfgl8TrhT+cd35X399OGNYGsB A9ja4GIOef9lTvNcGssfOGnV0KFRzjeIBBAF4bFnXTDE4eQQekh/xdRvVuaMtrlshIqYyXcwouNb5 LGP1XvZg==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:35300) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1w0Ndi-000000006l7-0H7T; Wed, 11 Mar 2026 17:46:34 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.98.2) (envelope-from ) id 1w0Nde-000000006RR-1cKu; Wed, 11 Mar 2026 17:46:30 +0000 Date: Wed, 11 Mar 2026 17:46:30 +0000 From: "Russell King (Oracle)" To: Bartosz Golaszewski Cc: Bartosz Golaszewski , Bjorn Andersson , Konrad Dybcio , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Andrew Lunn , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Maxime Coquelin , Alexandre Torgue , Vinod Koul , Giuseppe Cavallaro , Chen-Yu Tsai , Jernej Skrabec , Neil Armstrong , Kevin Hilman , Jerome Brunet , Shawn Guo , Fabio Estevam , Jan Petrous , s32@nxp.com, Romain Gantois , Geert Uytterhoeven , Magnus Damm , Maxime Ripard , Christophe Roullier , Radu Rendec , linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, Drew Fustini , linux-sunxi@lists.linux.dev, linux-amlogic@lists.infradead.org, linux-mips@vger.kernel.org, imx@lists.linux.dev, linux-renesas-soc@vger.kernel.org, linux-rockchip@lists.infradead.org, sophgo@lists.linux.dev, linux-riscv@lists.infradead.org, Bartosz Golaszewski Subject: Re: [PATCH net-next v8 2/6] net: stmmac: qcom-ethqos: use generic device properties Message-ID: References: <20260311-qcom-sa8255p-emac-v8-0-58227bcf1018@oss.qualcomm.com> <20260311-qcom-sa8255p-emac-v8-2-58227bcf1018@oss.qualcomm.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260311_104702_252613_54624287 X-CRM114-Status: GOOD ( 45.89 ) X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org T24gV2VkLCBNYXIgMTEsIDIwMjYgYXQgMDY6MTg6MDBQTSArMDEwMCwgQmFydG9zeiBHb2xhc3pl d3NraSB3cm90ZToKPiBPbiBXZWQsIE1hciAxMSwgMjAyNiBhdCA2OjE04oCvUE0gUnVzc2VsbCBL aW5nIChPcmFjbGUpCj4gPGxpbnV4QGFybWxpbnV4Lm9yZy51az4gd3JvdGU6Cj4gPgo+ID4gT24g V2VkLCBNYXIgMTEsIDIwMjYgYXQgMDY6MDM6MzdQTSArMDEwMCwgQmFydG9zeiBHb2xhc3pld3Nr aSB3cm90ZToKPiA+ID4gRnJvbTogQmFydG9zeiBHb2xhc3pld3NraSA8YmFydG9zei5nb2xhc3pl d3NraUBsaW5hcm8ub3JnPgo+ID4gPgo+ID4gPiBJbiBvcmRlciB0byBkcm9wIHRoZSBkZXBlbmRl bmN5IG9uIENPTkZJR19PRiwgY29udmVydCBhbGwgZGV2aWNlIHByb3BlcnR5Cj4gPiA+IGdldHRl cnMgZnJvbSBPRi1zcGVjaWZpYyB0byBnZW5lcmljIGRldmljZSBwcm9wZXJ0aWVzIGFuZCBzdG9w IHB1bGxpbmcKPiA+ID4gaW4gYW55IGxpbnV4L29mLmggc3ltYm9scy4KPiA+ID4KPiA+ID4gU2ln bmVkLW9mZi1ieTogQmFydG9zeiBHb2xhc3pld3NraSA8YmFydG9zei5nb2xhc3pld3NraUBsaW5h cm8ub3JnPgo+ID4gPiBTaWduZWQtb2ZmLWJ5OiBCYXJ0b3N6IEdvbGFzemV3c2tpIDxiYXJ0b3N6 LmdvbGFzemV3c2tpQG9zcy5xdWFsY29tbS5jb20+Cj4gPgo+ID4gUGxlYXNlIHBvc3Rwb25lIHRo aXMgZm9yIHRoZSB0aW1lIGJlaW5nIC0gSSdtIHRyeWluZyB0byBnZXQgc3RtbWFjJ3MKPiA+IHBh aW4taW4tdGhlLWFyc2UgUENTIHN1cHBvcnQgc29ydGVkLCBhbmQgSSd2ZSBwYXRjaCBzZXJpZXMg b3V0IHRoZXJlCj4gPiBhbmQgcGVuZGluZyB0aGF0IG1ha2UgYSBsYXJnZSBudW1iZXIgb2YgY2hh bmdlcyB0byB0aGlzIGRyaXZlci4gVGhpcwo+ID4gaXMgbGlrZWx5IHRvIGNvbmZsaWN0IHdpdGgg bXkgd29yay4KPiA+Cj4gPiBJJ20gbGltaXRlZCBieSB0aGUgcmF0ZSBhdCB3aGljaCBwYXRjaGVz IGNhbiBiZSBhcHBsaWVkIHRvIG5ldC1uZXh0Cj4gPiBhbmQgdGhlIHJhdGUgYXQgd2hpY2ggTW9o ZCBjYW4gcHJvdmlkZSBtZSBmZWVkYmFjay4gT24gdGhhdCwgSSBub3RpY2UKPiA+IHlvdSBoYXZl bid0IENjJ2QgTW9oZCB3aG8gaXMgbm93IGluIE1BSU5UQUlORVJTIGZvciBxY29tLWV0aHFvcy4K PiA+Cj4gCj4gRG8gdGhlc2UgdHdvIGNoYW5nZXNldHMgaW50ZXJhY3Qgd2l0aCBlYWNoIG90aGVy IGEgbG90PyBEbyB5b3UgaGF2ZSBhCj4gV0lQIGJyYW5jaCBJIGNvdWxkIHRha2UgYSBsb29rIGF0 PyBUaGlzIGhhcyBiZWVuIHBvc3QtcG9uZWQgc2V2ZXJhbAo+IHRpbWVzIGFscmVhZHksIHRoZXJl IGFsd2F5cyBzZWVtIHRvIGJlIHNvbWUgbmV3IGNoYW5nZXMgY29taW5nIGluLiA6LwoKSSBkb24n dCBoYXZlIGEgcHVibGljIGJyYW5jaCBiZWNhdXNlIHRoaXMgd29yayBpcyBzdWJqZWN0IHRvIHJl d29yawpkZXBlbmRpbmcgb24gdGhlIGZlZWRiYWNrIEkgcmVjZWl2ZS4gTW9oZCBoYXMgYW5vdGhl ciB2ZXJzaW9uIG9mIHRoZQpzZXJpZXMgdGhhdCBJJ20gd2FpdGluZyBmb3IgZmVlZGJhY2sgZm9y LiBBcyBzb29uIGFzIEkgaGVhciB0aGF0IGl0J3MKZmluZSwgSSB3aWxsIGJlIHNlbmRpbmcgaXQu CgpUaGUgcHJvYmxlbSBJIHJlZmVyIHRvIGhhcyBiZWVuIGEgcGFpbiBwb2ludCBmb3IgcGh5bGlu ayBzaW5jZSBzdG1tYWMKd2FzIGNvbnZlcnRlZCBpbiAyMDE5LCB3aGljaCBwcmUtZGF0ZXMgcWNv bS1ldGhxb3MsIHRoZSBtZXJnaW5nIG9mCndoaWNoIGhhcyBtYWRlIHNvbHZpbmcgc3RoaXMgbXVj aCBtb3JlIHBhaW5mdWwgYXMgcWNvbS1ldGhxb3MKY29tcGxldGVseSBieXBhc3NlcyBwaHlsaW5r IGJ5IGZvcmNpbmcgdGhlIFBDUyBpbmJhbmQgc3RhdGUgYmVoaW5kCnBoeWxpbmsncyBiYWNrLgoK SG9uZXN0bHksIG92ZXIgcmVjZW50IG1vbnRocywgSSd2ZSBiZWVuIHdhc2hpbmcgdGhhdCBJJ2Qg TkFDSydkIHRoZQptZXJnaW5nIG9mIGR3bWFjLXFjb20tZXRocW9zIGF0IHRoZSB0aW1lIG92ZXIg dGhpcywgYnV0IEkgZGlkbid0CmhhdmUgYW55IHNvbHV0aW9uIGZvciBzdG1tYWMgYXQgdGhhdCBw b2ludCAoaXQgd2Fzbid0IG15CnJlc3BvbnNpYmlsaXR5LCB0aGUgYnJva2VuIHBoeWxpbmsgY29u dmVyc2lvbiBvZiBzdG1tYWMgd2FzIG1lcmdlZAp3aXRob3V0IG15IGtub3dsZWRnZSwgd2l0aG91 dCBldmVuIGEgQ2MgdG8gbWUuKQoKT25lIG9mIHRoZSBiaWdnZXN0IGNoYW5nZXMgdGhhdCB3aWxs IGRlZmluaXRlbHkgY29uZmxpY3Qgd2l0aCB5b3VyCmNoYW5nZXMgaXMgdGhlIG1vdmUgb2YgcWNv bS1ldGhxb3MnIFNlckRlcyBzdXBwb3J0IGludG8gc3RtbWFjIGNvcmUKY29kZSAtIGJlY2F1c2Ug dGhlIHN0bW1hYyBQQ1MgY29kZSBuZWVkcyB0byBrbm93IHdoZXRoZXIgdGhlIFNlckRlcwpjYW4g c3VwcG9ydCAyLjVHYnBzIHNwZWVkLiBJIGdvdCB0aGUgY2hhbmdlcyBmb3IgdGhlIGdlbmVyaWMg UEhZIHBhcnQKb2YgdGhhdCBtZXJnZWQgbGFzdCB3ZWVrLgoKQW5vdGhlciBjaGFuZ2UgdGhhdCB3 aWxsIGNvbmZsaWN0IGlzIHlvdXIgcGF0Y2ggMywgd2hlcmUgbWFzc2VzIG9mCmNoYW5nZXMgaW4g cWNvbV9ldGhxb3NfcHJvYmUoKSB3aGljaCB3aWxsIGNvbmZsaWN0IHdpdGggbXkKIm5ldDogc3Rt bWFjOiBxY29tLWV0aHFvczogZW5hYmxlIDI1MDBCQVNFLVgiIHBhdGNoLgoKSSd2ZSBwb3N0ZWQg cGF0Y2hlcyBmb3IgdGhhdCBhIGNvdXBsZSBvZiB3ZWVrcyBhZ28sIGJ1dCBNb2hkIHJlcG9ydGVk CnByb2JsZW1zLCBzbyBJJ3ZlIGhhZCB0byByZXdvcmsgdGhlIHNlcmllcyAtIGFuZCBub3cgdGhv c2UgcGF0Y2hlcwphcmUgcGFydCBvZiBhIGZvbGxvdy1vbiBzZXJpZXMgYWZ0ZXIgc29ydGluZyB0 aGUgYnVsayBvZiB0aGUgc3RtbWFjClBDUyBtZXNzLgoKSSdtIGN1cnJlbnRseSB3YWl0aW5nIGZv ciBNb2hkJ3MgZmVlZGJhY2sgb24gdGhlIHJld29ya2VkIHNlcmllcy4KCmh0dHBzOi8vbG9yZS5r ZXJuZWwub3JnL3IvYVo3Z2dmUWFuYzhqZUNiOUBzaGVsbC5hcm1saW51eC5vcmcudWsKaHR0cHM6 Ly9sb3JlLmtlcm5lbC5vcmcvci9hYWZ4cUN2Sl9YWTRZYld3QHNoZWxsLmFybWxpbnV4Lm9yZy51 awoKTGF0ZXN0IHZlcnNpb24gd2FpdGluZyBmb3IgTW9oZCdzIGZlZWRiYWNrOgoKaHR0cHM6Ly9s b3JlLmtlcm5lbC5vcmcvci9hYTZzb2ZqRnh5aTJua3ByQHNoZWxsLmFybWxpbnV4Lm9yZy51awoK QmVsb3cgYXJlIHRoZSB0d28gcGF0Y2hlcyB3aGljaCBhZGQgYW5kIGNvbnZlcnQgcWNvbS1ldGhx b3Mgc2VyZGVzCnN1cHBvcnQuIE5vdGUgdGhhdCB0aGVzZSB0d28gZGVwZW5kIG9uIG90aGVyIHBh dGNoZXMuCgoKRnJvbTogIlJ1c3NlbGwgS2luZyAoT3JhY2xlKSIgPHJtaytrZXJuZWxAYXJtbGlu dXgub3JnLnVrPgpTdWJqZWN0OiBbUEFUQ0ggbmV0LW5leHRdIG5ldDogc3RtbWFjOiBhZGQgc3Rt bWFjIGNvcmUgc2VyZGVzIHN1cHBvcnQKClJhdGhlciB0aGFuIGhhdmluZyBwbGF0Zm9ybSBnbHVl IGltcGxlbWVudCBTZXJEZXMgUEhZIHN1cHBvcnQsIGFkZCBpdAp0byB0aGUgY29yZSBkcml2ZXIs IHNwZWNpZmljYWxseSB0byB0aGUgc3RtbWFjIGludGVncmF0ZWQgUENTIGRyaXZlcgphcyB0aGUg U2VyRGVzIGlzIGNvbm5lY3RlZCB0byB0aGUgaW50ZWdyYXRlZCBQQ1MuCgpQbGF0Zm9ybXMgdXNp bmcgZXh0ZXJuYWwgUENTIGNhbiBhbHNvIHBvcHVsYXRlIHBsYXQtPnNlcmRlcywgYW5kIHRoZQpj b3JlIGRyaXZlciB3aWxsIGNhbGwgcGh5X2luaXQoKSBhbmQgcGh5X2V4aXQoKSB3aGVuIHRoZSBh ZG1pbmlzdHJhdGl2ZQpzdGF0ZSBvZiB0aGUgaW50ZXJmYWNlIGNoYW5nZXMsIGJ1dCB0aGUgb3Ro ZXIgcGh5IG1ldGhvZHMgd2lsbCBub3QgYmUKY2FsbGVkLgoKUmV2aWV3ZWQtYnk6IE1heGltZSBD aGV2YWxsaWVyIDxtYXhpbWUuY2hldmFsbGllckBib290bGluLmNvbT4KU2lnbmVkLW9mZi1ieTog UnVzc2VsbCBLaW5nIChPcmFjbGUpIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KLS0KcmZj LT52MTogYXZvaWQgY2FsbGluZyBwaHlfZ2V0X21vZGUoKSB3aXRoIE5VTEwgc2VyZGVzIFBIWQp2 MjogYWRkIGNsZWFudXAgd2hlbiBkd21hY19zZXJkZXNfc2V0X21vZGUoKSBmYWlscywgc28gdGhh dCBmYWlsdXJlIGF0CiAgYW55IHBvaW50IGluIHRoZSBpbnRlcm5hbCBQQ1MgZW5hYmxlIG1ldGhv ZCBsZWF2ZXMgdGhlIG92ZXJhbGwgc3RhdGUKICB1bmNoYW5nZWQuCnYzOiBpbiBhIHBlbmRpbmcg Y2hhbmdlIHRvIGdlbmVyaWMgUEhZIGRvY3VtZW50YXRpb24gaW5kaWNhdGVkIGJ5IFZpbm9kCiAg cmVjZW50bHksIGNhbGxpbmcgcGh5X3NldF9tb2RlKF9leHQpKCkgYmVmb3JlIHBoeV9wb3dlcl9v bigpIHdpbGwgYmUKICBwcmVmZXJyZWQsIHNvIHJlLW9yZ2FuaXNlIHRvIHVzZSB0aGF0IG9yZGVy aW5nLgp2NDogbW92ZSBwaHlfc2V0X21vZGUoKSBpbnRvIC5tYWNfZmluaXNoKCksIGFkZCBkd21h Y19oYXNfc2VyZGVzKCkgdG8KICBtYWtlIHNlcmRlcyBjYWxscyBjb25kaXRpb25hbCBvbiBkd21h YydzIGFjdGl2ZSBwaHkgaW50ZXJmYWNlLCB3aXRoCiAgdGhlIGV4Y2VwdGlvbiBvZiBwaHlfaW5p dCgpL3BoeV9leGl0KCkgY2FsbHMuCi0tLQogZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvTWFrZWZpbGUgIHwgIDIgKy0KIC4uLi9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv c3RtbWFjX21haW4uYyB8IDM3ICsrKysrKystCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3Rt bWFjL3N0bW1hY19wY3MuYyAgfCA0NCArKysrKysrLS0KIC4uLi9ldGhlcm5ldC9zdG1pY3JvL3N0 bW1hYy9zdG1tYWNfc2VyZGVzLmMgICB8IDkyICsrKysrKysrKysrKysrKysrKysKIC4uLi9ldGhl cm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmggICB8IDE1ICsrKwogaW5jbHVkZS9s aW51eC9zdG1tYWMuaCAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKwogNiBmaWxlcyBjaGFu Z2VkLCAxODEgaW5zZXJ0aW9ucygrKSwgMTEgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX3NlcmRlcy5jCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3Rt bWFjX3NlcmRlcy5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvTWFrZWZpbGUgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9NYWtl ZmlsZQppbmRleCBjOTI2Mzk4N2VmOGQuLmEzYzJjZDVkMGM5MSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9uZXQv ZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUKQEAgLTcsNyArNyw3IEBAIHN0bW1hYy1v YmpzOj0gc3RtbWFjX21haW4ubyBzdG1tYWNfZXRodG9vbC5vIHN0bW1hY19tZGlvLm8gcmluZ19t b2RlLm8JXAogCSAgICAgIGR3bWFjNF9kbWEubyBkd21hYzRfbGliLm8gZHdtYWM0X2NvcmUubyBk d21hYzUubyBod2lmLm8gXAogCSAgICAgIHN0bW1hY190Yy5vIGR3eGdtYWMyX2NvcmUubyBkd3hn bWFjMl9kbWEubyBkd3hnbWFjMl9kZXNjcy5vIFwKIAkgICAgICBzdG1tYWNfeGRwLm8gc3RtbWFj X2VzdC5vIHN0bW1hY19mcGUubyBzdG1tYWNfdmxhbi5vIFwKLQkgICAgICBzdG1tYWNfcGNzLm8g JChzdG1tYWMteSkKKwkgICAgICBzdG1tYWNfcGNzLm8gc3RtbWFjX3NlcmRlcy5vICQoc3RtbWFj LXkpCiAKIHN0bW1hYy0kKENPTkZJR19TVE1NQUNfU0VMRlRFU1RTKSArPSBzdG1tYWNfc2VsZnRl c3RzLm8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv c3RtbWFjX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1h Y19tYWluLmMKaW5kZXggMzdmNmVlNzU2NmJlLi40MjhiMmU1YmI0YzQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMKKysrIGIvZHJp dmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYwpAQCAtNDksNiAr NDksNyBAQAogI2luY2x1ZGUgInN0bW1hY19mcGUuaCIKICNpbmNsdWRlICJzdG1tYWMuaCIKICNp bmNsdWRlICJzdG1tYWNfcGNzLmgiCisjaW5jbHVkZSAic3RtbWFjX3NlcmRlcy5oIgogI2luY2x1 ZGUgInN0bW1hY194ZHAuaCIKICNpbmNsdWRlIDxsaW51eC9yZXNldC5oPgogI2luY2x1ZGUgPGxp bnV4L29mX21kaW8uaD4KQEAgLTk2OSw3ICs5NzAsNyBAQCBzdGF0aWMgaW50IHN0bW1hY19tYWNf ZmluaXNoKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwK IAkJcHJpdi0+cGxhdC0+bWFjX2ZpbmlzaChuZGV2LCBwcml2LT5wbGF0LT5ic3BfcHJpdiwgbW9k ZSwKIAkJCQkgICAgICAgaW50ZXJmYWNlKTsKIAotCXJldHVybiAwOworCXJldHVybiBkd21hY19z ZXJkZXNfc2V0X21vZGUocHJpdiwgaW50ZXJmYWNlKTsKIH0KIAogc3RhdGljIHZvaWQgc3RtbWFj X21hY19saW5rX2Rvd24oc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsCkBAIC0zNTkyLDEy ICszNTkzLDE0IEBAIHN0YXRpYyB2b2lkIHN0bW1hY19zYWZldHlfZmVhdF9jb25maWd1cmF0aW9u KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKIAogc3RhdGljIHZvaWQgc3RtbWFjX2Nsa19yeF9p X3JlcXVpcmUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQogeworCWR3bWFjX3NlcmRlc19wb3dl cl9vbihwcml2KTsKIAlwaHlsaW5rX3J4X2Nsa19zdG9wX2Jsb2NrKHByaXYtPnBoeWxpbmspOwog fQogCiBzdGF0aWMgdm9pZCBzdG1tYWNfY2xrX3J4X2lfcmVsZWFzZShzdHJ1Y3Qgc3RtbWFjX3By aXYgKnByaXYpCiB7CiAJcGh5bGlua19yeF9jbGtfc3RvcF91bmJsb2NrKHByaXYtPnBoeWxpbmsp OworCWR3bWFjX3NlcmRlc19wb3dlcl9vZmYocHJpdik7CiB9CiAKIC8qKgpAQCAtNDE1Myw2ICs0 MTU2LDEwIEBAIHN0YXRpYyBpbnQgc3RtbWFjX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldikK IAlpZiAocmV0KQogCQlnb3RvIGVycl9ydW50aW1lX3BtOwogCisJcmV0ID0gZHdtYWNfc2VyZGVz X2luaXQocHJpdik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyX2Rpc2Nvbm5lY3RfcGh5Owor CiAJaWYgKCEocHJpdi0+cGxhdC0+ZmxhZ3MgJiBTVE1NQUNfRkxBR19TRVJERVNfVVBfQUZURVJf UEhZX0xJTktVUCkpIHsKIAkJcmV0ID0gc3RtbWFjX2xlZ2FjeV9zZXJkZXNfcG93ZXJfdXAocHJp dik7CiAJCWlmIChyZXQgPCAwKQpAQCAtNDE3Miw2ICs0MTc5LDcgQEAgc3RhdGljIGludCBzdG1t YWNfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCiBlcnJfc2VyZGVzOgogCXN0bW1hY19s ZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJpdik7CisJZHdtYWNfc2VyZGVzX2V4aXQocHJpdik7 CiBlcnJfZGlzY29ubmVjdF9waHk6CiAJcGh5bGlua19kaXNjb25uZWN0X3BoeShwcml2LT5waHls aW5rKTsKIGVycl9ydW50aW1lX3BtOgpAQCAtNDIzMiw2ICs0MjQwLDcgQEAgc3RhdGljIGludCBz dG1tYWNfcmVsZWFzZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCV9fc3RtbWFjX3JlbGVhc2Uo ZGV2KTsKIAogCXN0bW1hY19sZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJpdik7CisJZHdtYWNf c2VyZGVzX2V4aXQocHJpdik7CiAJcGh5bGlua19kaXNjb25uZWN0X3BoeShwcml2LT5waHlsaW5r KTsKIAlwbV9ydW50aW1lX3B1dChwcml2LT5kZXZpY2UpOwogCkBAIC03NzgxLDYgKzc3OTAsMTMg QEAgc3RhdGljIGludCBfX3N0bW1hY19kdnJfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2aWNlLAog CQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwlpZiAocGxhdF9kYXQtPnNlcmRlcyAmJgorCSAgICAo cGxhdF9kYXQtPnNlcmRlc19wb3dlcnVwIHx8IHBsYXRfZGF0LT5zZXJkZXNfcG93ZXJkb3duKSkg eworCQlkZXZfZXJyKGRldmljZSwKKwkJCSJnZW5lcmljIFBIWSBhbmQgU2VyRGVzIHBsYXRmb3Jt IGNhbGxiYWNrcyBhcmUgaW5jb21wYXRpYmxlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQor CiAJbmRldiA9IGRldm1fYWxsb2NfZXRoZXJkZXZfbXFzKGRldmljZSwgc2l6ZW9mKHN0cnVjdCBz dG1tYWNfcHJpdiksCiAJCQkJICAgICAgIE1UTF9NQVhfVFhfUVVFVUVTLCBNVExfTUFYX1JYX1FV RVVFUyk7CiAJaWYgKCFuZGV2KQpAQCAtODE5NCw2ICs4MjEwLDE1IEBAIGludCBzdG1tYWNfc3Vz cGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiAKIAlydG5sX2xvY2soKTsKIAlwaHlsaW5rX3N1c3Bl bmQocHJpdi0+cGh5bGluaywgISFwcml2LT53b2xvcHRzKTsKKworCS8qIElmIHRoZSBNQUMgaGFz IFdvTCBlbmFibGVkLCB0aGUgU2VyRGVzIG5lZWRzIHRvIHJlbWFpbiBhY3RpdmUuCisJICogT3Ro ZXJ3aXNlLCBwaHlsaW5rIHdpbGwgaGF2ZSBzdG9wcGVkIHRoZSBNQUMgYW5kIHRoZSBQQ1Mgd2ls bAorCSAqIGhhdmUgYmVlbiBkaXNhYmxlZCwgbWVhbmluZyB0aGUgU2VyRGVzIGlzIGFscmVhZHkg cG93ZXJlZCBvZmYuCisJICogQ2FsbCBpdHMgZXhpdCBmdW5jdGlvbiBzbyB3ZSBjYW4gY2FsbCBp bml0IGR1cmluZyByZXN1bWUuCisJICovCisJaWYgKCFwcml2LT53b2xvcHRzKQorCQlkd21hY19z ZXJkZXNfZXhpdChwcml2KTsKKwogCXJ0bmxfdW5sb2NrKCk7CiAKIAlpZiAoc3RtbWFjX2ZwZV9z dXBwb3J0ZWQocHJpdikpCkBAIC04MjkwLDYgKzgzMTUsMTUgQEAgaW50IHN0bW1hY19yZXN1bWUo c3RydWN0IGRldmljZSAqZGV2KQogCiAJcnRubF9sb2NrKCk7CiAKKwkvKiBJZiB0aGUgTUFDIGhh cyBXb0wgZW5hYmxlZCwgdGhlIFNlckRlcyB3YXMgbGVmdCBhY3RpdmUgKi8KKwlpZiAoIXByaXYt PndvbG9wdHMpIHsKKwkJcmV0ID0gZHdtYWNfc2VyZGVzX2luaXQocHJpdik7CisJCWlmIChyZXQp IHsKKwkJCXJ0bmxfdW5sb2NrKCk7CisJCQlyZXR1cm4gcmV0OworCQl9CisJfQorCiAJLyogUHJl cGFyZSB0aGUgUEhZIHRvIHJlc3VtZSwgZW5zdXJpbmcgdGhhdCBpdHMgY2xvY2tzIHdoaWNoIGFy ZQogCSAqIG5lY2Vzc2FyeSBmb3IgdGhlIE1BQyBETUEgcmVzZXQgdG8gY29tcGxldGUgYXJlIHJ1 bm5pbmcKIAkgKi8KQEAgLTgzMDcsNiArODM0MSw3IEBAIGludCBzdG1tYWNfcmVzdW1lKHN0cnVj dCBkZXZpY2UgKmRldikKIAkJbmV0ZGV2X2Vycihwcml2LT5kZXYsICIlczogSHcgc2V0dXAgZmFp bGVkXG4iLCBfX2Z1bmNfXyk7CiAJCXN0bW1hY19sZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJp dik7CiAJCW11dGV4X3VubG9jaygmcHJpdi0+bG9jayk7CisJCWR3bWFjX3NlcmRlc19leGl0KHBy aXYpOwogCQlydG5sX3VubG9jaygpOwogCQlyZXR1cm4gcmV0OwogCX0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19wY3MuYyBiL2RyaXZlcnMv bmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19wY3MuYwppbmRleCAwYzBlYjllMzBi OTUuLjI5OGQzYzAwYjJmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNy by9zdG1tYWMvc3RtbWFjX3Bjcy5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8v c3RtbWFjL3N0bW1hY19wY3MuYwpAQCAtMSw2ICsxLDcgQEAKIC8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wLW9ubHkKICNpbmNsdWRlICJzdG1tYWMuaCIKICNpbmNsdWRlICJzdG1t YWNfcGNzLmgiCisjaW5jbHVkZSAic3RtbWFjX3NlcmRlcy5oIgogCiAvKgogICogR01BQ19BTl9T VEFUVVMgaXMgZXF1aXZhbGVudCB0byBNSUlfQk1TUgpAQCAtNjAsOCArNjEsMTQgQEAgc3RhdGlj IHVuc2lnbmVkIGludCBkd21hY19pbnRlZ3JhdGVkX3Bjc19pbmJhbmRfY2FwcyhzdHJ1Y3QgcGh5 bGlua19wY3MgKnBjcywKIHN0YXRpYyBpbnQgZHdtYWNfaW50ZWdyYXRlZF9wY3NfZW5hYmxlKHN0 cnVjdCBwaHlsaW5rX3BjcyAqcGNzKQogewogCXN0cnVjdCBzdG1tYWNfcGNzICpzcGNzID0gcGh5 bGlua19wY3NfdG9fc3RtbWFjX3BjcyhwY3MpOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9 IHNwY3MtPnByaXY7CisJaW50IHJldDsKIAotCXN0bW1hY19tYWNfaXJxX21vZGlmeShzcGNzLT5w cml2LCAwLCBzcGNzLT5pbnRfbWFzayk7CisJcmV0ID0gZHdtYWNfc2VyZGVzX3Bvd2VyX29uKHBy aXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlzdG1tYWNfbWFjX2lycV9tb2RpZnko cHJpdiwgMCwgc3Bjcy0+aW50X21hc2spOwogCiAJcmV0dXJuIDA7CiB9CkBAIC02OSw4ICs3Niwx MSBAQCBzdGF0aWMgaW50IGR3bWFjX2ludGVncmF0ZWRfcGNzX2VuYWJsZShzdHJ1Y3QgcGh5bGlu a19wY3MgKnBjcykKIHN0YXRpYyB2b2lkIGR3bWFjX2ludGVncmF0ZWRfcGNzX2Rpc2FibGUoc3Ry dWN0IHBoeWxpbmtfcGNzICpwY3MpCiB7CiAJc3RydWN0IHN0bW1hY19wY3MgKnNwY3MgPSBwaHls aW5rX3Bjc190b19zdG1tYWNfcGNzKHBjcyk7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0g c3Bjcy0+cHJpdjsKKworCXN0bW1hY19tYWNfaXJxX21vZGlmeShwcml2LCBzcGNzLT5pbnRfbWFz aywgMCk7CiAKLQlzdG1tYWNfbWFjX2lycV9tb2RpZnkoc3Bjcy0+cHJpdiwgc3Bjcy0+aW50X21h c2ssIDApOworCWR3bWFjX3NlcmRlc19wb3dlcl9vZmYocHJpdik7CiB9CiAKIHN0YXRpYyB2b2lk IGR3bWFjX2ludGVncmF0ZWRfcGNzX2dldF9zdGF0ZShzdHJ1Y3QgcGh5bGlua19wY3MgKnBjcywK QEAgLTIyMCw2ICsyMzAsMjIgQEAgaW50IHN0bW1hY19pbnRlZ3JhdGVkX3Bjc19nZXRfcGh5X2lu dGZfc2VsKHN0cnVjdCBwaHlsaW5rX3BjcyAqcGNzLAogCXJldHVybiAtRUlOVkFMOwogfQogCitz dGF0aWMgdm9pZCBzdG1tYWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChzdHJ1Y3Qgc3Rt bWFjX3ByaXYgKnByaXYsCisJCQkJCQlzdHJ1Y3Qgc3RtbWFjX3BjcyAqc3BjcywKKwkJCQkJCXBo eV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UsCisJCQkJCQl1bnNpZ25lZCBpbnQgZmxhZykKK3sKKwli b29sIHN1cHBvcnRlZDsKKworCWlmIChwcml2LT5wbGF0LT5zZXJkZXMpCisJCXN1cHBvcnRlZCA9 IGR3bWFjX3NlcmRlc192YWxpZGF0ZShwcml2LCBpbnRlcmZhY2UpID09IDA7CisJZWxzZQorCQlz dXBwb3J0ZWQgPSAhZmxhZyB8fCBwcml2LT5wbGF0LT5mbGFncyAmIGZsYWc7CisKKwlpZiAoc3Vw cG9ydGVkKQorCQlfX3NldF9iaXQoaW50ZXJmYWNlLCBzcGNzLT5wY3Muc3VwcG9ydGVkX2ludGVy ZmFjZXMpOworfQorCiBpbnQgc3RtbWFjX2ludGVncmF0ZWRfcGNzX2luaXQoc3RydWN0IHN0bW1h Y19wcml2ICpwcml2LAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCBzdG1tYWNfcGNzX2luZm8gKnBj c19pbmZvKQogewpAQCAtMjQzLDEzICsyNjksMTMgQEAgaW50IHN0bW1hY19pbnRlZ3JhdGVkX3Bj c19pbml0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwKIAlpZiAocmVhZGwoc3Bjcy0+YmFzZSAr IEdNQUNfQU5fU1RBVFVTKSAmIEJNU1JfRVNUQVRFTikKIAkJc3Bjcy0+c3VwcG9ydF90YmlfcnRi aSA9IHRydWU7CiAKLQlfX3NldF9iaXQoUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJLCBzcGNzLT5w Y3Muc3VwcG9ydGVkX2ludGVyZmFjZXMpOwotCV9fc2V0X2JpdChQSFlfSU5URVJGQUNFX01PREVf MTAwMEJBU0VYLCBzcGNzLT5wY3Muc3VwcG9ydGVkX2ludGVyZmFjZXMpOwotCi0JLyogT25seSBh bGxvdyAyNTAwQkFTRS1YIGlmIHRoZSBTZXJEZXMgaGFzIHN1cHBvcnQuICovCi0JaWYgKHByaXYt PnBsYXQtPmZsYWdzICYgU1RNTUFDX0ZMQUdfU0VSREVTX1NVUFBPUlRTXzI1MDBNKQotCQlfX3Nl dF9iaXQoUEhZX0lOVEVSRkFDRV9NT0RFXzI1MDBCQVNFWCwKLQkJCSAgc3Bjcy0+cGNzLnN1cHBv cnRlZF9pbnRlcmZhY2VzKTsKKwlzdG1tYWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChw cml2LCBzcGNzLAorCQkJCQkgICAgUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJLCAwKTsKKwlzdG1t YWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChwcml2LCBzcGNzLAorCQkJCQkgICAgUEhZ X0lOVEVSRkFDRV9NT0RFXzEwMDBCQVNFWCwgMCk7CisJc3RtbWFjX2ludGVncmF0ZWRfcGNzX2No ZWNrX3N1cHBvcnQocHJpdiwgc3BjcywKKwkJCQkJICAgIFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAw QkFTRVgsCisJCQkJCSAgICBTVE1NQUNfRkxBR19TRVJERVNfU1VQUE9SVFNfMjUwME0pOwogCiAJ cHJpdi0+aW50ZWdyYXRlZF9wY3MgPSBzcGNzOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9l dGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMgYi9kcml2ZXJzL25ldC9ldGhl cm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5hNzY3YzA1NTM2MDQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMKQEAgLTAsMCAr MSw5MiBAQAorI2luY2x1ZGUgPGxpbnV4L3BoeS9waHkuaD4KKworI2luY2x1ZGUgInN0bW1hYy5o IgorI2luY2x1ZGUgInN0bW1hY19zZXJkZXMuaCIKKworc3RhdGljIGJvb2wgZHdtYWNfaGFzX3Nl cmRlcyhzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJaWYgKHByaXYtPnBsYXQtPmNvcmVf dHlwZSA9PSBEV01BQ19DT1JFX1hHTUFDKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gcHJp di0+ZG1hX2NhcC5hY3RwaHlpZiA9PSBQSFlfSU5URl9TRUxfU0dNSUkgfHwKKwkgICAgICAgcHJp di0+ZG1hX2NhcC5hY3RwaHlpZiA9PSBQSFlfSU5URl9TRUxfVEJJIHx8CisJICAgICAgIHByaXYt PmRtYV9jYXAuYWN0cGh5aWYgPT0gUEhZX0lOVEZfU0VMX1JUQkk7Cit9CisKK2ludCBkd21hY19z ZXJkZXNfdmFsaWRhdGUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBwaHlfaW50ZXJmYWNlX3Qg aW50ZXJmYWNlKQoreworCXN0cnVjdCBwaHkgKnNlcmRlcyA9IHByaXYtPnBsYXQtPnNlcmRlczsK KworCXJldHVybiBwaHlfdmFsaWRhdGUoc2VyZGVzLCBQSFlfTU9ERV9FVEhFUk5FVCwgaW50ZXJm YWNlLCBOVUxMKTsKK30KKworaW50IGR3bWFjX3NlcmRlc19pbml0KHN0cnVjdCBzdG1tYWNfcHJp diAqcHJpdikKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMgPSBwcml2LT5wbGF0LT5zZXJkZXM7CisJ aW50IHJldDsKKworCXJldCA9IHBoeV9pbml0KHNlcmRlcyk7CisJaWYgKHJldCkKKwkJZGV2X2Vy cihwcml2LT5kZXZpY2UsICJmYWlsZWQgdG8gaW5pdGlhbGl6ZSBTZXJEZXM6ICVwZVxuIiwKKwkJ CUVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQgZHdtYWNfc2VyZGVzX3Bv d2VyX29uKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMg PSBwcml2LT5wbGF0LT5zZXJkZXM7CisJaW50IHJldDsKKworCWlmICghZHdtYWNfaGFzX3NlcmRl cyhwcml2KSkKKwkJcmV0dXJuIDA7CisKKwlyZXQgPSBwaHlfcG93ZXJfb24oc2VyZGVzKTsKKwlp ZiAocmV0KQorCQlkZXZfZXJyKHByaXYtPmRldmljZSwgImZhaWxlZCB0byBwb3dlciBvbiBTZXJE ZXM6ICVwZVxuIiwKKwkJCUVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQg ZHdtYWNfc2VyZGVzX3NldF9tb2RlKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwgcGh5X2ludGVy ZmFjZV90IGludGVyZmFjZSkKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMgPSBwcml2LT5wbGF0LT5z ZXJkZXM7CisJaW50IHJldDsKKworCWlmICghZHdtYWNfaGFzX3NlcmRlcyhwcml2KSkKKwkJcmV0 dXJuIDA7CisKKwlyZXQgPSBwaHlfc2V0X21vZGVfZXh0KHNlcmRlcywgUEhZX01PREVfRVRIRVJO RVQsIGludGVyZmFjZSk7CisJaWYgKHJldCkKKwkJZGV2X2Vycihwcml2LT5kZXZpY2UsCisJCQki ZmFpbGVkIHRvIHNldCBTZXJEZXMgbW9kZSAlczogJXBlXG4iLAorCQkJcGh5X21vZGVzKGludGVy ZmFjZSksIEVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIGR3bWFjX3Nl cmRlc19wb3dlcl9vZmYoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQoreworCXN0cnVjdCBwaHkg KnNlcmRlcyA9IHByaXYtPnBsYXQtPnNlcmRlczsKKwlpbnQgcmV0OworCisJaWYgKCFkd21hY19o YXNfc2VyZGVzKHByaXYpKQorCQlyZXR1cm47CisKKwlyZXQgPSBwaHlfcG93ZXJfb2ZmKHNlcmRl cyk7CisJaWYgKHJldCkKKwkJZGV2X2Vycihwcml2LT5kZXZpY2UsICJmYWlsZWQgdG8gcG93ZXIg b2ZmIFNlckRlczogJXBlXG4iLAorCQkJRVJSX1BUUihyZXQpKTsKK30KKwordm9pZCBkd21hY19z ZXJkZXNfZXhpdChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJc3RydWN0IHBoeSAqc2Vy ZGVzID0gcHJpdi0+cGxhdC0+c2VyZGVzOworCWludCByZXQ7CisKKwlyZXQgPSBwaHlfZXhpdChz ZXJkZXMpOworCWlmIChyZXQpCisJCWRldl9lcnIocHJpdi0+ZGV2aWNlLCAiZmFpbGVkIHRvIHNo dXRkb3duIFNlckRlczogJXBlXG4iLAorCQkJRVJSX1BUUihyZXQpKTsKK30KZGlmZiAtLWdpdCBh L2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJkZXMuaCBiL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJkZXMuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjJjYTM3YTdkMGZkZQotLS0gL2Rldi9u dWxsCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJk ZXMuaApAQCAtMCwwICsxLDE1IEBACisjaWZuZGVmIFNUTU1BQ19TRVJERVNfSAorI2RlZmluZSBT VE1NQUNfU0VSREVTX0gKKworI2luY2x1ZGUgPGxpbnV4L3BoeS5oPgorCitzdHJ1Y3Qgc3RtbWFj X3ByaXY7CisKK2ludCBkd21hY19zZXJkZXNfdmFsaWRhdGUoc3RydWN0IHN0bW1hY19wcml2ICpw cml2LCBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKTsKK2ludCBkd21hY19zZXJkZXNfaW5pdChz dHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpOworaW50IGR3bWFjX3NlcmRlc19wb3dlcl9vbihzdHJ1 Y3Qgc3RtbWFjX3ByaXYgKnByaXYpOworaW50IGR3bWFjX3NlcmRlc19zZXRfbW9kZShzdHJ1Y3Qg c3RtbWFjX3ByaXYgKnByaXYsIHBoeV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UpOwordm9pZCBkd21h Y19zZXJkZXNfcG93ZXJfb2ZmKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdik7Cit2b2lkIGR3bWFj X3NlcmRlc19leGl0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdik7CisKKyNlbmRpZgpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9zdG1tYWMuaCBiL2luY2x1ZGUvbGludXgvc3RtbWFjLmgKaW5k ZXggYThlOWI1ZDMyODlmLi5iZWRiYTRlMjMwODggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv c3RtbWFjLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdG1tYWMuaApAQCAtMjE2LDYgKzIxNiw3IEBA IGVudW0gZHdtYWNfY29yZV90eXBlIHsKICNkZWZpbmUgU1RNTUFDX0ZMQUdfU0VSREVTX1NVUFBP UlRTXzI1MDBNCUJJVCgxNSkKIAogc3RydWN0IG1hY19kZXZpY2VfaW5mbzsKK3N0cnVjdCBwaHk7 CiAKIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0YSB7CiAJZW51bSBkd21hY19jb3JlX3R5cGUg Y29yZV90eXBlOwpAQCAtMjQ1LDYgKzI0Niw3IEBAIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0 YSB7CiAJICogdGhhdCBwaHlsaW5rIHVzZXMuCiAJICovCiAJcGh5X2ludGVyZmFjZV90IHBoeV9p bnRlcmZhY2U7CisJc3RydWN0IHBoeSAqc2VyZGVzOwogCXN0cnVjdCBzdG1tYWNfbWRpb19idXNf ZGF0YSAqbWRpb19idXNfZGF0YTsKIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKnBoeV9ub2RlOwogCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbWRpb19ub2RlOwotLSAKMi40Ny4zCgoKCkZyb206ICJSdXNzZWxs IEtpbmcgKE9yYWNsZSkiIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KU3ViamVjdDogW1BB VENIIG5ldC1uZXh0XSBuZXQ6IHN0bW1hYzogcWNvbS1ldGhxb3M6IGNvbnZlcnQgdG8gZHdtYWMg Y29yZQogU2VyRGVzIHN1cHBvcnQKCkNvbnZlcnQgcWNvbS1ldGhxb3MgdG8gdXNlIHRoZSBkd21h YyBjb3JlJ3MgZ2VuZXJpYyBTZXJEZXMgc3VwcG9ydCwKd2hpY2ggd2lsbCBoYW5kbGUgU2VyRGVz IGluaXRpYWxpc2F0aW9uLCBwb3dlcmluZywgYW5kIG1vZGUgc2V0dGluZy4KCk5vdGUgdGhhdCBn ZW5lcmljIHN1cHBvcnQgcmVxdWlyZXMgdGhlIFNlckRlcyB0byBzdXBwb3J0IHBoeV92YWxpZGF0 ZSgpCmluIG9yZGVyIHRvIHByb2JlIHdoaWNoIFBIWSBpbnRlcmZhY2UgbW9kZXMgYXJlIHN1cHBv cnRlZCwgYW5kCnBoeV9zZXRfbW9kZV9leHQoKSB0byBjb25maWd1cmUgdGhlIGFwcHJvcHJpYXRl IFBIWSBpbnRlcmZhY2UgbW9kZQooYW5kIHRodXMgdGhlIHNwZWVkLikKClNpZ25lZC1vZmYtYnk6 IFJ1c3NlbGwgS2luZyAoT3JhY2xlKSA8cm1rK2tlcm5lbEBhcm1saW51eC5vcmcudWs+Ci0tLQog Li4uL3N0bWljcm8vc3RtbWFjL2R3bWFjLXFjb20tZXRocW9zLmMgICAgICAgIHwgNDUgKystLS0t LS0tLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKSwgNDEgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv ZHdtYWMtcWNvbS1ldGhxb3MuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFj L2R3bWFjLXFjb20tZXRocW9zLmMKaW5kZXggOWEyMTk0ZmNjYjliLi5hNDBhNGJjYTE5N2QgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjLXFjb20t ZXRocW9zLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMt cWNvbS1ldGhxb3MuYwpAQCAtMTA0LDcgKzEwNCw2IEBAIHN0cnVjdCBxY29tX2V0aHFvcyB7CiAJ CQkgICAgICAgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSwgaW50IHNwZWVkKTsKIAogCXN0cnVj dCBjbGsgKmxpbmtfY2xrOwotCXN0cnVjdCBwaHkgKnNlcmRlc19waHk7CiAJcGh5X2ludGVyZmFj ZV90IHBoeV9tb2RlOwogCiAJY29uc3Qgc3RydWN0IGV0aHFvc19lbWFjX3BvciAqcmdtaWlfcG9y OwpAQCAtNjI3LDQ1ICs2MjYsMTUgQEAgc3RhdGljIHZvaWQgZXRocW9zX2ZpeF9tYWNfc3BlZWQo dm9pZCAqcHJpdiwgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSwKIAlldGhxb3NfY29uZmlndXJl KGV0aHFvcywgaW50ZXJmYWNlLCBzcGVlZCk7CiB9CiAKLXN0YXRpYyBpbnQgcWNvbV9ldGhxb3Nf c2VyZGVzX3Bvd2VydXAoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnByaXYpCi17Ci0J c3RydWN0IHFjb21fZXRocW9zICpldGhxb3MgPSBwcml2OwotCWludCByZXQ7Ci0KLQlyZXQgPSBw aHlfaW5pdChldGhxb3MtPnNlcmRlc19waHkpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0K LQlyZXQgPSBwaHlfcG93ZXJfb24oZXRocW9zLT5zZXJkZXNfcGh5KTsKLQlpZiAocmV0KQotCQlw aHlfZXhpdChldGhxb3MtPnNlcmRlc19waHkpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGlj IHZvaWQgcWNvbV9ldGhxb3Nfc2VyZGVzX3Bvd2VyZG93bihzdHJ1Y3QgbmV0X2RldmljZSAqbmRl diwgdm9pZCAqcHJpdikKLXsKLQlzdHJ1Y3QgcWNvbV9ldGhxb3MgKmV0aHFvcyA9IHByaXY7Ci0K LQlwaHlfcG93ZXJfb2ZmKGV0aHFvcy0+c2VyZGVzX3BoeSk7Ci0JcGh5X2V4aXQoZXRocW9zLT5z ZXJkZXNfcGh5KTsKLX0KLQogc3RhdGljIGludCBldGhxb3NfbWFjX2ZpbmlzaF9zZXJkZXMoc3Ry dWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnByaXYsCiAJCQkJICAgIHVuc2lnbmVkIGludCBt b2RlLAogCQkJCSAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQogewogCXN0cnVjdCBxY29t X2V0aHFvcyAqZXRocW9zID0gcHJpdjsKLQlpbnQgcmV0ID0gMDsKIAogCXFjb21fZXRocW9zX3Nl dF9zZ21paV9sb29wYmFjayhldGhxb3MsIGZhbHNlKTsKIAotCWlmIChpbnRlcmZhY2UgPT0gUEhZ X0lOVEVSRkFDRV9NT0RFX1NHTUlJIHx8Ci0JICAgIGludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNF X01PREVfMjUwMEJBU0VYKQotCQlyZXQgPSBwaHlfc2V0X21vZGVfZXh0KGV0aHFvcy0+c2VyZGVz X3BoeSwgUEhZX01PREVfRVRIRVJORVQsCi0JCQkJICAgICAgIGludGVyZmFjZSk7Ci0KLQlyZXR1 cm4gcmV0OworCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IGV0aHFvc19jbGtzX2NvbmZpZyh2 b2lkICpwcml2LCBib29sIGVuYWJsZWQpCkBAIC03ODksOSArNzU4LDkgQEAgc3RhdGljIGludCBx Y29tX2V0aHFvc19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChyZXQp CiAJCXJldHVybiByZXQ7CiAKLQlldGhxb3MtPnNlcmRlc19waHkgPSBkZXZtX3BoeV9vcHRpb25h bF9nZXQoZGV2LCAic2VyZGVzIik7Ci0JaWYgKElTX0VSUihldGhxb3MtPnNlcmRlc19waHkpKQot CQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIoZXRocW9zLT5zZXJkZXNfcGh5KSwK KwlwbGF0X2RhdC0+c2VyZGVzID0gZGV2bV9waHlfb3B0aW9uYWxfZ2V0KGRldiwgInNlcmRlcyIp OworCWlmIChJU19FUlIocGxhdF9kYXQtPnNlcmRlcykpCisJCXJldHVybiBkZXZfZXJyX3Byb2Jl KGRldiwgUFRSX0VSUihwbGF0X2RhdC0+c2VyZGVzKSwKIAkJCQkgICAgICJGYWlsZWQgdG8gZ2V0 IHNlcmRlcyBwaHlcbiIpOwogCiAJZXRocW9zX3NldF9jbGtfdHhfcmF0ZShldGhxb3MsIE5VTEws IHBsYXRfZGF0LT5waHlfaW50ZXJmYWNlLApAQCAtODE2LDEyICs3ODUsNiBAQCBzdGF0aWMgaW50 IHFjb21fZXRocW9zX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKGRh dGEtPmRtYV9hZGRyX3dpZHRoKQogCQlwbGF0X2RhdC0+aG9zdF9kbWFfd2lkdGggPSBkYXRhLT5k bWFfYWRkcl93aWR0aDsKIAotCWlmIChldGhxb3MtPnNlcmRlc19waHkpIHsKLQkJcGxhdF9kYXQt PnNlcmRlc19wb3dlcnVwID0gcWNvbV9ldGhxb3Nfc2VyZGVzX3Bvd2VydXA7Ci0JCXBsYXRfZGF0 LT5zZXJkZXNfcG93ZXJkb3duICA9IHFjb21fZXRocW9zX3NlcmRlc19wb3dlcmRvd247Ci0JCXBs YXRfZGF0LT5mbGFncyB8PSBTVE1NQUNfRkxBR19TRVJERVNfU1VQUE9SVFNfMjUwME07Ci0JfQot CiAJLyogRW5hYmxlIFRTTyBvbiBxdWV1ZTAgYW5kIGVuYWJsZSBUQlMgb24gcmVzdCBvZiB0aGUg cXVldWVzICovCiAJZm9yIChpID0gMTsgaSA8IHBsYXRfZGF0LT50eF9xdWV1ZXNfdG9fdXNlOyBp KyspCiAJCXBsYXRfZGF0LT50eF9xdWV1ZXNfY2ZnW2ldLnRic19lbiA9IDE7Ci0tIAoyLjQ3LjMK CgotLSAKUk1LJ3MgUGF0Y2ggc3lzdGVtOiBodHRwczovL3d3dy5hcm1saW51eC5vcmcudWsvZGV2 ZWxvcGVyL3BhdGNoZXMvCkZUVFAgaXMgaGVyZSEgODBNYnBzIGRvd24gMTBNYnBzIHVwLiBEZWNl bnQgY29ubmVjdGl2aXR5IGF0IGxhc3QhCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1hbWxvZ2ljIG1haWxpbmcgbGlzdApsaW51eC1hbWxvZ2lj QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9saW51eC1hbWxvZ2ljCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 46C3B1125857 for ; Wed, 11 Mar 2026 17:47:10 +0000 (UTC) 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:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=uf5XDn5LKT7sj0ql5dQqMA9MHrSDxptZfELcLDIuSyY=; b=bIMLzR2DJSE6Ta d6oOIcZ833FCY2Fwa/8K6fSrwFU+gnrbGgLaAhUprPoog/VNpGWQLl2Ya7opnzllLFJHRfwb/u+ZT VchrPqFCfI6RQrErsMsONdhwkQGOsiimefxUhu3KsQeVSV4ShaHgpUlir+ReEQBE625J3sD0FI1Kd ZoD4xsuu+Yiy/ULKMc0afVUaa6dS1j81D88/O9SHdfLxxMiReUwa9WzKsLgT9D57AnGndC6S5gsAl lZ7WNamI9O5o+q3FOqm6VsHLGKQR9qYrfgATsJkPLsElFxhhXNKEBRhxyRBahXKdJbx6hvekNY6Dk w9wJ5xbTw5mqDvs1xt3g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1w0NeD-0000000C4hO-21Qh; Wed, 11 Mar 2026 17:47:05 +0000 Received: from pandora.armlinux.org.uk ([2001:4d48:ad52:32c8:5054:ff:fe00:142]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1w0Ne9-0000000C4eV-3kSY; Wed, 11 Mar 2026 17:47:03 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=vkA02cIf1bCPsbEnaLlFrwiwhwE6F8sIdO8MLg/HiWE=; b=Mngfxk09kt4/krUPKb1Zn6lcvE l9OOliC67agWfQrQug9P+Kg4KqL8K9pG1JGagHPp977ZBgRBJPBA6B3n6Nq7ZZjzNhNHBa04Aggd5 OxtnrJvRSidT247vak7uZRx4sFwM4zso4bxtCfWNXqbI/zKGUIPSu5Xf8u404kZVl3eFXdmVr6G4K lO0ZoDXT9gXriqFDdnx8nO6ED36JLZ/Tw859kbvSISGE+Y5EZTdKRfgl8TrhT+cd35X399OGNYGsB A9ja4GIOef9lTvNcGssfOGnV0KFRzjeIBBAF4bFnXTDE4eQQekh/xdRvVuaMtrlshIqYyXcwouNb5 LGP1XvZg==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:35300) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1w0Ndi-000000006l7-0H7T; Wed, 11 Mar 2026 17:46:34 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.98.2) (envelope-from ) id 1w0Nde-000000006RR-1cKu; Wed, 11 Mar 2026 17:46:30 +0000 Date: Wed, 11 Mar 2026 17:46:30 +0000 From: "Russell King (Oracle)" To: Bartosz Golaszewski Cc: Bartosz Golaszewski , Bjorn Andersson , Konrad Dybcio , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Andrew Lunn , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Maxime Coquelin , Alexandre Torgue , Vinod Koul , Giuseppe Cavallaro , Chen-Yu Tsai , Jernej Skrabec , Neil Armstrong , Kevin Hilman , Jerome Brunet , Shawn Guo , Fabio Estevam , Jan Petrous , s32@nxp.com, Romain Gantois , Geert Uytterhoeven , Magnus Damm , Maxime Ripard , Christophe Roullier , Radu Rendec , linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, Drew Fustini , linux-sunxi@lists.linux.dev, linux-amlogic@lists.infradead.org, linux-mips@vger.kernel.org, imx@lists.linux.dev, linux-renesas-soc@vger.kernel.org, linux-rockchip@lists.infradead.org, sophgo@lists.linux.dev, linux-riscv@lists.infradead.org, Bartosz Golaszewski Subject: Re: [PATCH net-next v8 2/6] net: stmmac: qcom-ethqos: use generic device properties Message-ID: References: <20260311-qcom-sa8255p-emac-v8-0-58227bcf1018@oss.qualcomm.com> <20260311-qcom-sa8255p-emac-v8-2-58227bcf1018@oss.qualcomm.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260311_104702_252613_54624287 X-CRM114-Status: GOOD ( 45.89 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org T24gV2VkLCBNYXIgMTEsIDIwMjYgYXQgMDY6MTg6MDBQTSArMDEwMCwgQmFydG9zeiBHb2xhc3pl d3NraSB3cm90ZToKPiBPbiBXZWQsIE1hciAxMSwgMjAyNiBhdCA2OjE04oCvUE0gUnVzc2VsbCBL aW5nIChPcmFjbGUpCj4gPGxpbnV4QGFybWxpbnV4Lm9yZy51az4gd3JvdGU6Cj4gPgo+ID4gT24g V2VkLCBNYXIgMTEsIDIwMjYgYXQgMDY6MDM6MzdQTSArMDEwMCwgQmFydG9zeiBHb2xhc3pld3Nr aSB3cm90ZToKPiA+ID4gRnJvbTogQmFydG9zeiBHb2xhc3pld3NraSA8YmFydG9zei5nb2xhc3pl d3NraUBsaW5hcm8ub3JnPgo+ID4gPgo+ID4gPiBJbiBvcmRlciB0byBkcm9wIHRoZSBkZXBlbmRl bmN5IG9uIENPTkZJR19PRiwgY29udmVydCBhbGwgZGV2aWNlIHByb3BlcnR5Cj4gPiA+IGdldHRl cnMgZnJvbSBPRi1zcGVjaWZpYyB0byBnZW5lcmljIGRldmljZSBwcm9wZXJ0aWVzIGFuZCBzdG9w IHB1bGxpbmcKPiA+ID4gaW4gYW55IGxpbnV4L29mLmggc3ltYm9scy4KPiA+ID4KPiA+ID4gU2ln bmVkLW9mZi1ieTogQmFydG9zeiBHb2xhc3pld3NraSA8YmFydG9zei5nb2xhc3pld3NraUBsaW5h cm8ub3JnPgo+ID4gPiBTaWduZWQtb2ZmLWJ5OiBCYXJ0b3N6IEdvbGFzemV3c2tpIDxiYXJ0b3N6 LmdvbGFzemV3c2tpQG9zcy5xdWFsY29tbS5jb20+Cj4gPgo+ID4gUGxlYXNlIHBvc3Rwb25lIHRo aXMgZm9yIHRoZSB0aW1lIGJlaW5nIC0gSSdtIHRyeWluZyB0byBnZXQgc3RtbWFjJ3MKPiA+IHBh aW4taW4tdGhlLWFyc2UgUENTIHN1cHBvcnQgc29ydGVkLCBhbmQgSSd2ZSBwYXRjaCBzZXJpZXMg b3V0IHRoZXJlCj4gPiBhbmQgcGVuZGluZyB0aGF0IG1ha2UgYSBsYXJnZSBudW1iZXIgb2YgY2hh bmdlcyB0byB0aGlzIGRyaXZlci4gVGhpcwo+ID4gaXMgbGlrZWx5IHRvIGNvbmZsaWN0IHdpdGgg bXkgd29yay4KPiA+Cj4gPiBJJ20gbGltaXRlZCBieSB0aGUgcmF0ZSBhdCB3aGljaCBwYXRjaGVz IGNhbiBiZSBhcHBsaWVkIHRvIG5ldC1uZXh0Cj4gPiBhbmQgdGhlIHJhdGUgYXQgd2hpY2ggTW9o ZCBjYW4gcHJvdmlkZSBtZSBmZWVkYmFjay4gT24gdGhhdCwgSSBub3RpY2UKPiA+IHlvdSBoYXZl bid0IENjJ2QgTW9oZCB3aG8gaXMgbm93IGluIE1BSU5UQUlORVJTIGZvciBxY29tLWV0aHFvcy4K PiA+Cj4gCj4gRG8gdGhlc2UgdHdvIGNoYW5nZXNldHMgaW50ZXJhY3Qgd2l0aCBlYWNoIG90aGVy IGEgbG90PyBEbyB5b3UgaGF2ZSBhCj4gV0lQIGJyYW5jaCBJIGNvdWxkIHRha2UgYSBsb29rIGF0 PyBUaGlzIGhhcyBiZWVuIHBvc3QtcG9uZWQgc2V2ZXJhbAo+IHRpbWVzIGFscmVhZHksIHRoZXJl IGFsd2F5cyBzZWVtIHRvIGJlIHNvbWUgbmV3IGNoYW5nZXMgY29taW5nIGluLiA6LwoKSSBkb24n dCBoYXZlIGEgcHVibGljIGJyYW5jaCBiZWNhdXNlIHRoaXMgd29yayBpcyBzdWJqZWN0IHRvIHJl d29yawpkZXBlbmRpbmcgb24gdGhlIGZlZWRiYWNrIEkgcmVjZWl2ZS4gTW9oZCBoYXMgYW5vdGhl ciB2ZXJzaW9uIG9mIHRoZQpzZXJpZXMgdGhhdCBJJ20gd2FpdGluZyBmb3IgZmVlZGJhY2sgZm9y LiBBcyBzb29uIGFzIEkgaGVhciB0aGF0IGl0J3MKZmluZSwgSSB3aWxsIGJlIHNlbmRpbmcgaXQu CgpUaGUgcHJvYmxlbSBJIHJlZmVyIHRvIGhhcyBiZWVuIGEgcGFpbiBwb2ludCBmb3IgcGh5bGlu ayBzaW5jZSBzdG1tYWMKd2FzIGNvbnZlcnRlZCBpbiAyMDE5LCB3aGljaCBwcmUtZGF0ZXMgcWNv bS1ldGhxb3MsIHRoZSBtZXJnaW5nIG9mCndoaWNoIGhhcyBtYWRlIHNvbHZpbmcgc3RoaXMgbXVj aCBtb3JlIHBhaW5mdWwgYXMgcWNvbS1ldGhxb3MKY29tcGxldGVseSBieXBhc3NlcyBwaHlsaW5r IGJ5IGZvcmNpbmcgdGhlIFBDUyBpbmJhbmQgc3RhdGUgYmVoaW5kCnBoeWxpbmsncyBiYWNrLgoK SG9uZXN0bHksIG92ZXIgcmVjZW50IG1vbnRocywgSSd2ZSBiZWVuIHdhc2hpbmcgdGhhdCBJJ2Qg TkFDSydkIHRoZQptZXJnaW5nIG9mIGR3bWFjLXFjb20tZXRocW9zIGF0IHRoZSB0aW1lIG92ZXIg dGhpcywgYnV0IEkgZGlkbid0CmhhdmUgYW55IHNvbHV0aW9uIGZvciBzdG1tYWMgYXQgdGhhdCBw b2ludCAoaXQgd2Fzbid0IG15CnJlc3BvbnNpYmlsaXR5LCB0aGUgYnJva2VuIHBoeWxpbmsgY29u dmVyc2lvbiBvZiBzdG1tYWMgd2FzIG1lcmdlZAp3aXRob3V0IG15IGtub3dsZWRnZSwgd2l0aG91 dCBldmVuIGEgQ2MgdG8gbWUuKQoKT25lIG9mIHRoZSBiaWdnZXN0IGNoYW5nZXMgdGhhdCB3aWxs IGRlZmluaXRlbHkgY29uZmxpY3Qgd2l0aCB5b3VyCmNoYW5nZXMgaXMgdGhlIG1vdmUgb2YgcWNv bS1ldGhxb3MnIFNlckRlcyBzdXBwb3J0IGludG8gc3RtbWFjIGNvcmUKY29kZSAtIGJlY2F1c2Ug dGhlIHN0bW1hYyBQQ1MgY29kZSBuZWVkcyB0byBrbm93IHdoZXRoZXIgdGhlIFNlckRlcwpjYW4g c3VwcG9ydCAyLjVHYnBzIHNwZWVkLiBJIGdvdCB0aGUgY2hhbmdlcyBmb3IgdGhlIGdlbmVyaWMg UEhZIHBhcnQKb2YgdGhhdCBtZXJnZWQgbGFzdCB3ZWVrLgoKQW5vdGhlciBjaGFuZ2UgdGhhdCB3 aWxsIGNvbmZsaWN0IGlzIHlvdXIgcGF0Y2ggMywgd2hlcmUgbWFzc2VzIG9mCmNoYW5nZXMgaW4g cWNvbV9ldGhxb3NfcHJvYmUoKSB3aGljaCB3aWxsIGNvbmZsaWN0IHdpdGggbXkKIm5ldDogc3Rt bWFjOiBxY29tLWV0aHFvczogZW5hYmxlIDI1MDBCQVNFLVgiIHBhdGNoLgoKSSd2ZSBwb3N0ZWQg cGF0Y2hlcyBmb3IgdGhhdCBhIGNvdXBsZSBvZiB3ZWVrcyBhZ28sIGJ1dCBNb2hkIHJlcG9ydGVk CnByb2JsZW1zLCBzbyBJJ3ZlIGhhZCB0byByZXdvcmsgdGhlIHNlcmllcyAtIGFuZCBub3cgdGhv c2UgcGF0Y2hlcwphcmUgcGFydCBvZiBhIGZvbGxvdy1vbiBzZXJpZXMgYWZ0ZXIgc29ydGluZyB0 aGUgYnVsayBvZiB0aGUgc3RtbWFjClBDUyBtZXNzLgoKSSdtIGN1cnJlbnRseSB3YWl0aW5nIGZv ciBNb2hkJ3MgZmVlZGJhY2sgb24gdGhlIHJld29ya2VkIHNlcmllcy4KCmh0dHBzOi8vbG9yZS5r ZXJuZWwub3JnL3IvYVo3Z2dmUWFuYzhqZUNiOUBzaGVsbC5hcm1saW51eC5vcmcudWsKaHR0cHM6 Ly9sb3JlLmtlcm5lbC5vcmcvci9hYWZ4cUN2Sl9YWTRZYld3QHNoZWxsLmFybWxpbnV4Lm9yZy51 awoKTGF0ZXN0IHZlcnNpb24gd2FpdGluZyBmb3IgTW9oZCdzIGZlZWRiYWNrOgoKaHR0cHM6Ly9s b3JlLmtlcm5lbC5vcmcvci9hYTZzb2ZqRnh5aTJua3ByQHNoZWxsLmFybWxpbnV4Lm9yZy51awoK QmVsb3cgYXJlIHRoZSB0d28gcGF0Y2hlcyB3aGljaCBhZGQgYW5kIGNvbnZlcnQgcWNvbS1ldGhx b3Mgc2VyZGVzCnN1cHBvcnQuIE5vdGUgdGhhdCB0aGVzZSB0d28gZGVwZW5kIG9uIG90aGVyIHBh dGNoZXMuCgoKRnJvbTogIlJ1c3NlbGwgS2luZyAoT3JhY2xlKSIgPHJtaytrZXJuZWxAYXJtbGlu dXgub3JnLnVrPgpTdWJqZWN0OiBbUEFUQ0ggbmV0LW5leHRdIG5ldDogc3RtbWFjOiBhZGQgc3Rt bWFjIGNvcmUgc2VyZGVzIHN1cHBvcnQKClJhdGhlciB0aGFuIGhhdmluZyBwbGF0Zm9ybSBnbHVl IGltcGxlbWVudCBTZXJEZXMgUEhZIHN1cHBvcnQsIGFkZCBpdAp0byB0aGUgY29yZSBkcml2ZXIs IHNwZWNpZmljYWxseSB0byB0aGUgc3RtbWFjIGludGVncmF0ZWQgUENTIGRyaXZlcgphcyB0aGUg U2VyRGVzIGlzIGNvbm5lY3RlZCB0byB0aGUgaW50ZWdyYXRlZCBQQ1MuCgpQbGF0Zm9ybXMgdXNp bmcgZXh0ZXJuYWwgUENTIGNhbiBhbHNvIHBvcHVsYXRlIHBsYXQtPnNlcmRlcywgYW5kIHRoZQpj b3JlIGRyaXZlciB3aWxsIGNhbGwgcGh5X2luaXQoKSBhbmQgcGh5X2V4aXQoKSB3aGVuIHRoZSBh ZG1pbmlzdHJhdGl2ZQpzdGF0ZSBvZiB0aGUgaW50ZXJmYWNlIGNoYW5nZXMsIGJ1dCB0aGUgb3Ro ZXIgcGh5IG1ldGhvZHMgd2lsbCBub3QgYmUKY2FsbGVkLgoKUmV2aWV3ZWQtYnk6IE1heGltZSBD aGV2YWxsaWVyIDxtYXhpbWUuY2hldmFsbGllckBib290bGluLmNvbT4KU2lnbmVkLW9mZi1ieTog UnVzc2VsbCBLaW5nIChPcmFjbGUpIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KLS0KcmZj LT52MTogYXZvaWQgY2FsbGluZyBwaHlfZ2V0X21vZGUoKSB3aXRoIE5VTEwgc2VyZGVzIFBIWQp2 MjogYWRkIGNsZWFudXAgd2hlbiBkd21hY19zZXJkZXNfc2V0X21vZGUoKSBmYWlscywgc28gdGhh dCBmYWlsdXJlIGF0CiAgYW55IHBvaW50IGluIHRoZSBpbnRlcm5hbCBQQ1MgZW5hYmxlIG1ldGhv ZCBsZWF2ZXMgdGhlIG92ZXJhbGwgc3RhdGUKICB1bmNoYW5nZWQuCnYzOiBpbiBhIHBlbmRpbmcg Y2hhbmdlIHRvIGdlbmVyaWMgUEhZIGRvY3VtZW50YXRpb24gaW5kaWNhdGVkIGJ5IFZpbm9kCiAg cmVjZW50bHksIGNhbGxpbmcgcGh5X3NldF9tb2RlKF9leHQpKCkgYmVmb3JlIHBoeV9wb3dlcl9v bigpIHdpbGwgYmUKICBwcmVmZXJyZWQsIHNvIHJlLW9yZ2FuaXNlIHRvIHVzZSB0aGF0IG9yZGVy aW5nLgp2NDogbW92ZSBwaHlfc2V0X21vZGUoKSBpbnRvIC5tYWNfZmluaXNoKCksIGFkZCBkd21h Y19oYXNfc2VyZGVzKCkgdG8KICBtYWtlIHNlcmRlcyBjYWxscyBjb25kaXRpb25hbCBvbiBkd21h YydzIGFjdGl2ZSBwaHkgaW50ZXJmYWNlLCB3aXRoCiAgdGhlIGV4Y2VwdGlvbiBvZiBwaHlfaW5p dCgpL3BoeV9leGl0KCkgY2FsbHMuCi0tLQogZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvTWFrZWZpbGUgIHwgIDIgKy0KIC4uLi9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv c3RtbWFjX21haW4uYyB8IDM3ICsrKysrKystCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3Rt bWFjL3N0bW1hY19wY3MuYyAgfCA0NCArKysrKysrLS0KIC4uLi9ldGhlcm5ldC9zdG1pY3JvL3N0 bW1hYy9zdG1tYWNfc2VyZGVzLmMgICB8IDkyICsrKysrKysrKysrKysrKysrKysKIC4uLi9ldGhl cm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmggICB8IDE1ICsrKwogaW5jbHVkZS9s aW51eC9zdG1tYWMuaCAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKwogNiBmaWxlcyBjaGFu Z2VkLCAxODEgaW5zZXJ0aW9ucygrKSwgMTEgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX3NlcmRlcy5jCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3Rt bWFjX3NlcmRlcy5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvTWFrZWZpbGUgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9NYWtl ZmlsZQppbmRleCBjOTI2Mzk4N2VmOGQuLmEzYzJjZDVkMGM5MSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9uZXQv ZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUKQEAgLTcsNyArNyw3IEBAIHN0bW1hYy1v YmpzOj0gc3RtbWFjX21haW4ubyBzdG1tYWNfZXRodG9vbC5vIHN0bW1hY19tZGlvLm8gcmluZ19t b2RlLm8JXAogCSAgICAgIGR3bWFjNF9kbWEubyBkd21hYzRfbGliLm8gZHdtYWM0X2NvcmUubyBk d21hYzUubyBod2lmLm8gXAogCSAgICAgIHN0bW1hY190Yy5vIGR3eGdtYWMyX2NvcmUubyBkd3hn bWFjMl9kbWEubyBkd3hnbWFjMl9kZXNjcy5vIFwKIAkgICAgICBzdG1tYWNfeGRwLm8gc3RtbWFj X2VzdC5vIHN0bW1hY19mcGUubyBzdG1tYWNfdmxhbi5vIFwKLQkgICAgICBzdG1tYWNfcGNzLm8g JChzdG1tYWMteSkKKwkgICAgICBzdG1tYWNfcGNzLm8gc3RtbWFjX3NlcmRlcy5vICQoc3RtbWFj LXkpCiAKIHN0bW1hYy0kKENPTkZJR19TVE1NQUNfU0VMRlRFU1RTKSArPSBzdG1tYWNfc2VsZnRl c3RzLm8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv c3RtbWFjX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1h Y19tYWluLmMKaW5kZXggMzdmNmVlNzU2NmJlLi40MjhiMmU1YmI0YzQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMKKysrIGIvZHJp dmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYwpAQCAtNDksNiAr NDksNyBAQAogI2luY2x1ZGUgInN0bW1hY19mcGUuaCIKICNpbmNsdWRlICJzdG1tYWMuaCIKICNp bmNsdWRlICJzdG1tYWNfcGNzLmgiCisjaW5jbHVkZSAic3RtbWFjX3NlcmRlcy5oIgogI2luY2x1 ZGUgInN0bW1hY194ZHAuaCIKICNpbmNsdWRlIDxsaW51eC9yZXNldC5oPgogI2luY2x1ZGUgPGxp bnV4L29mX21kaW8uaD4KQEAgLTk2OSw3ICs5NzAsNyBAQCBzdGF0aWMgaW50IHN0bW1hY19tYWNf ZmluaXNoKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwK IAkJcHJpdi0+cGxhdC0+bWFjX2ZpbmlzaChuZGV2LCBwcml2LT5wbGF0LT5ic3BfcHJpdiwgbW9k ZSwKIAkJCQkgICAgICAgaW50ZXJmYWNlKTsKIAotCXJldHVybiAwOworCXJldHVybiBkd21hY19z ZXJkZXNfc2V0X21vZGUocHJpdiwgaW50ZXJmYWNlKTsKIH0KIAogc3RhdGljIHZvaWQgc3RtbWFj X21hY19saW5rX2Rvd24oc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsCkBAIC0zNTkyLDEy ICszNTkzLDE0IEBAIHN0YXRpYyB2b2lkIHN0bW1hY19zYWZldHlfZmVhdF9jb25maWd1cmF0aW9u KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKIAogc3RhdGljIHZvaWQgc3RtbWFjX2Nsa19yeF9p X3JlcXVpcmUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQogeworCWR3bWFjX3NlcmRlc19wb3dl cl9vbihwcml2KTsKIAlwaHlsaW5rX3J4X2Nsa19zdG9wX2Jsb2NrKHByaXYtPnBoeWxpbmspOwog fQogCiBzdGF0aWMgdm9pZCBzdG1tYWNfY2xrX3J4X2lfcmVsZWFzZShzdHJ1Y3Qgc3RtbWFjX3By aXYgKnByaXYpCiB7CiAJcGh5bGlua19yeF9jbGtfc3RvcF91bmJsb2NrKHByaXYtPnBoeWxpbmsp OworCWR3bWFjX3NlcmRlc19wb3dlcl9vZmYocHJpdik7CiB9CiAKIC8qKgpAQCAtNDE1Myw2ICs0 MTU2LDEwIEBAIHN0YXRpYyBpbnQgc3RtbWFjX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldikK IAlpZiAocmV0KQogCQlnb3RvIGVycl9ydW50aW1lX3BtOwogCisJcmV0ID0gZHdtYWNfc2VyZGVz X2luaXQocHJpdik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyX2Rpc2Nvbm5lY3RfcGh5Owor CiAJaWYgKCEocHJpdi0+cGxhdC0+ZmxhZ3MgJiBTVE1NQUNfRkxBR19TRVJERVNfVVBfQUZURVJf UEhZX0xJTktVUCkpIHsKIAkJcmV0ID0gc3RtbWFjX2xlZ2FjeV9zZXJkZXNfcG93ZXJfdXAocHJp dik7CiAJCWlmIChyZXQgPCAwKQpAQCAtNDE3Miw2ICs0MTc5LDcgQEAgc3RhdGljIGludCBzdG1t YWNfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCiBlcnJfc2VyZGVzOgogCXN0bW1hY19s ZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJpdik7CisJZHdtYWNfc2VyZGVzX2V4aXQocHJpdik7 CiBlcnJfZGlzY29ubmVjdF9waHk6CiAJcGh5bGlua19kaXNjb25uZWN0X3BoeShwcml2LT5waHls aW5rKTsKIGVycl9ydW50aW1lX3BtOgpAQCAtNDIzMiw2ICs0MjQwLDcgQEAgc3RhdGljIGludCBz dG1tYWNfcmVsZWFzZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCV9fc3RtbWFjX3JlbGVhc2Uo ZGV2KTsKIAogCXN0bW1hY19sZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJpdik7CisJZHdtYWNf c2VyZGVzX2V4aXQocHJpdik7CiAJcGh5bGlua19kaXNjb25uZWN0X3BoeShwcml2LT5waHlsaW5r KTsKIAlwbV9ydW50aW1lX3B1dChwcml2LT5kZXZpY2UpOwogCkBAIC03NzgxLDYgKzc3OTAsMTMg QEAgc3RhdGljIGludCBfX3N0bW1hY19kdnJfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2aWNlLAog CQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwlpZiAocGxhdF9kYXQtPnNlcmRlcyAmJgorCSAgICAo cGxhdF9kYXQtPnNlcmRlc19wb3dlcnVwIHx8IHBsYXRfZGF0LT5zZXJkZXNfcG93ZXJkb3duKSkg eworCQlkZXZfZXJyKGRldmljZSwKKwkJCSJnZW5lcmljIFBIWSBhbmQgU2VyRGVzIHBsYXRmb3Jt IGNhbGxiYWNrcyBhcmUgaW5jb21wYXRpYmxlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQor CiAJbmRldiA9IGRldm1fYWxsb2NfZXRoZXJkZXZfbXFzKGRldmljZSwgc2l6ZW9mKHN0cnVjdCBz dG1tYWNfcHJpdiksCiAJCQkJICAgICAgIE1UTF9NQVhfVFhfUVVFVUVTLCBNVExfTUFYX1JYX1FV RVVFUyk7CiAJaWYgKCFuZGV2KQpAQCAtODE5NCw2ICs4MjEwLDE1IEBAIGludCBzdG1tYWNfc3Vz cGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiAKIAlydG5sX2xvY2soKTsKIAlwaHlsaW5rX3N1c3Bl bmQocHJpdi0+cGh5bGluaywgISFwcml2LT53b2xvcHRzKTsKKworCS8qIElmIHRoZSBNQUMgaGFz IFdvTCBlbmFibGVkLCB0aGUgU2VyRGVzIG5lZWRzIHRvIHJlbWFpbiBhY3RpdmUuCisJICogT3Ro ZXJ3aXNlLCBwaHlsaW5rIHdpbGwgaGF2ZSBzdG9wcGVkIHRoZSBNQUMgYW5kIHRoZSBQQ1Mgd2ls bAorCSAqIGhhdmUgYmVlbiBkaXNhYmxlZCwgbWVhbmluZyB0aGUgU2VyRGVzIGlzIGFscmVhZHkg cG93ZXJlZCBvZmYuCisJICogQ2FsbCBpdHMgZXhpdCBmdW5jdGlvbiBzbyB3ZSBjYW4gY2FsbCBp bml0IGR1cmluZyByZXN1bWUuCisJICovCisJaWYgKCFwcml2LT53b2xvcHRzKQorCQlkd21hY19z ZXJkZXNfZXhpdChwcml2KTsKKwogCXJ0bmxfdW5sb2NrKCk7CiAKIAlpZiAoc3RtbWFjX2ZwZV9z dXBwb3J0ZWQocHJpdikpCkBAIC04MjkwLDYgKzgzMTUsMTUgQEAgaW50IHN0bW1hY19yZXN1bWUo c3RydWN0IGRldmljZSAqZGV2KQogCiAJcnRubF9sb2NrKCk7CiAKKwkvKiBJZiB0aGUgTUFDIGhh cyBXb0wgZW5hYmxlZCwgdGhlIFNlckRlcyB3YXMgbGVmdCBhY3RpdmUgKi8KKwlpZiAoIXByaXYt PndvbG9wdHMpIHsKKwkJcmV0ID0gZHdtYWNfc2VyZGVzX2luaXQocHJpdik7CisJCWlmIChyZXQp IHsKKwkJCXJ0bmxfdW5sb2NrKCk7CisJCQlyZXR1cm4gcmV0OworCQl9CisJfQorCiAJLyogUHJl cGFyZSB0aGUgUEhZIHRvIHJlc3VtZSwgZW5zdXJpbmcgdGhhdCBpdHMgY2xvY2tzIHdoaWNoIGFy ZQogCSAqIG5lY2Vzc2FyeSBmb3IgdGhlIE1BQyBETUEgcmVzZXQgdG8gY29tcGxldGUgYXJlIHJ1 bm5pbmcKIAkgKi8KQEAgLTgzMDcsNiArODM0MSw3IEBAIGludCBzdG1tYWNfcmVzdW1lKHN0cnVj dCBkZXZpY2UgKmRldikKIAkJbmV0ZGV2X2Vycihwcml2LT5kZXYsICIlczogSHcgc2V0dXAgZmFp bGVkXG4iLCBfX2Z1bmNfXyk7CiAJCXN0bW1hY19sZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJp dik7CiAJCW11dGV4X3VubG9jaygmcHJpdi0+bG9jayk7CisJCWR3bWFjX3NlcmRlc19leGl0KHBy aXYpOwogCQlydG5sX3VubG9jaygpOwogCQlyZXR1cm4gcmV0OwogCX0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19wY3MuYyBiL2RyaXZlcnMv bmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19wY3MuYwppbmRleCAwYzBlYjllMzBi OTUuLjI5OGQzYzAwYjJmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNy by9zdG1tYWMvc3RtbWFjX3Bjcy5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8v c3RtbWFjL3N0bW1hY19wY3MuYwpAQCAtMSw2ICsxLDcgQEAKIC8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wLW9ubHkKICNpbmNsdWRlICJzdG1tYWMuaCIKICNpbmNsdWRlICJzdG1t YWNfcGNzLmgiCisjaW5jbHVkZSAic3RtbWFjX3NlcmRlcy5oIgogCiAvKgogICogR01BQ19BTl9T VEFUVVMgaXMgZXF1aXZhbGVudCB0byBNSUlfQk1TUgpAQCAtNjAsOCArNjEsMTQgQEAgc3RhdGlj IHVuc2lnbmVkIGludCBkd21hY19pbnRlZ3JhdGVkX3Bjc19pbmJhbmRfY2FwcyhzdHJ1Y3QgcGh5 bGlua19wY3MgKnBjcywKIHN0YXRpYyBpbnQgZHdtYWNfaW50ZWdyYXRlZF9wY3NfZW5hYmxlKHN0 cnVjdCBwaHlsaW5rX3BjcyAqcGNzKQogewogCXN0cnVjdCBzdG1tYWNfcGNzICpzcGNzID0gcGh5 bGlua19wY3NfdG9fc3RtbWFjX3BjcyhwY3MpOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9 IHNwY3MtPnByaXY7CisJaW50IHJldDsKIAotCXN0bW1hY19tYWNfaXJxX21vZGlmeShzcGNzLT5w cml2LCAwLCBzcGNzLT5pbnRfbWFzayk7CisJcmV0ID0gZHdtYWNfc2VyZGVzX3Bvd2VyX29uKHBy aXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlzdG1tYWNfbWFjX2lycV9tb2RpZnko cHJpdiwgMCwgc3Bjcy0+aW50X21hc2spOwogCiAJcmV0dXJuIDA7CiB9CkBAIC02OSw4ICs3Niwx MSBAQCBzdGF0aWMgaW50IGR3bWFjX2ludGVncmF0ZWRfcGNzX2VuYWJsZShzdHJ1Y3QgcGh5bGlu a19wY3MgKnBjcykKIHN0YXRpYyB2b2lkIGR3bWFjX2ludGVncmF0ZWRfcGNzX2Rpc2FibGUoc3Ry dWN0IHBoeWxpbmtfcGNzICpwY3MpCiB7CiAJc3RydWN0IHN0bW1hY19wY3MgKnNwY3MgPSBwaHls aW5rX3Bjc190b19zdG1tYWNfcGNzKHBjcyk7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0g c3Bjcy0+cHJpdjsKKworCXN0bW1hY19tYWNfaXJxX21vZGlmeShwcml2LCBzcGNzLT5pbnRfbWFz aywgMCk7CiAKLQlzdG1tYWNfbWFjX2lycV9tb2RpZnkoc3Bjcy0+cHJpdiwgc3Bjcy0+aW50X21h c2ssIDApOworCWR3bWFjX3NlcmRlc19wb3dlcl9vZmYocHJpdik7CiB9CiAKIHN0YXRpYyB2b2lk IGR3bWFjX2ludGVncmF0ZWRfcGNzX2dldF9zdGF0ZShzdHJ1Y3QgcGh5bGlua19wY3MgKnBjcywK QEAgLTIyMCw2ICsyMzAsMjIgQEAgaW50IHN0bW1hY19pbnRlZ3JhdGVkX3Bjc19nZXRfcGh5X2lu dGZfc2VsKHN0cnVjdCBwaHlsaW5rX3BjcyAqcGNzLAogCXJldHVybiAtRUlOVkFMOwogfQogCitz dGF0aWMgdm9pZCBzdG1tYWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChzdHJ1Y3Qgc3Rt bWFjX3ByaXYgKnByaXYsCisJCQkJCQlzdHJ1Y3Qgc3RtbWFjX3BjcyAqc3BjcywKKwkJCQkJCXBo eV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UsCisJCQkJCQl1bnNpZ25lZCBpbnQgZmxhZykKK3sKKwli b29sIHN1cHBvcnRlZDsKKworCWlmIChwcml2LT5wbGF0LT5zZXJkZXMpCisJCXN1cHBvcnRlZCA9 IGR3bWFjX3NlcmRlc192YWxpZGF0ZShwcml2LCBpbnRlcmZhY2UpID09IDA7CisJZWxzZQorCQlz dXBwb3J0ZWQgPSAhZmxhZyB8fCBwcml2LT5wbGF0LT5mbGFncyAmIGZsYWc7CisKKwlpZiAoc3Vw cG9ydGVkKQorCQlfX3NldF9iaXQoaW50ZXJmYWNlLCBzcGNzLT5wY3Muc3VwcG9ydGVkX2ludGVy ZmFjZXMpOworfQorCiBpbnQgc3RtbWFjX2ludGVncmF0ZWRfcGNzX2luaXQoc3RydWN0IHN0bW1h Y19wcml2ICpwcml2LAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCBzdG1tYWNfcGNzX2luZm8gKnBj c19pbmZvKQogewpAQCAtMjQzLDEzICsyNjksMTMgQEAgaW50IHN0bW1hY19pbnRlZ3JhdGVkX3Bj c19pbml0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwKIAlpZiAocmVhZGwoc3Bjcy0+YmFzZSAr IEdNQUNfQU5fU1RBVFVTKSAmIEJNU1JfRVNUQVRFTikKIAkJc3Bjcy0+c3VwcG9ydF90YmlfcnRi aSA9IHRydWU7CiAKLQlfX3NldF9iaXQoUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJLCBzcGNzLT5w Y3Muc3VwcG9ydGVkX2ludGVyZmFjZXMpOwotCV9fc2V0X2JpdChQSFlfSU5URVJGQUNFX01PREVf MTAwMEJBU0VYLCBzcGNzLT5wY3Muc3VwcG9ydGVkX2ludGVyZmFjZXMpOwotCi0JLyogT25seSBh bGxvdyAyNTAwQkFTRS1YIGlmIHRoZSBTZXJEZXMgaGFzIHN1cHBvcnQuICovCi0JaWYgKHByaXYt PnBsYXQtPmZsYWdzICYgU1RNTUFDX0ZMQUdfU0VSREVTX1NVUFBPUlRTXzI1MDBNKQotCQlfX3Nl dF9iaXQoUEhZX0lOVEVSRkFDRV9NT0RFXzI1MDBCQVNFWCwKLQkJCSAgc3Bjcy0+cGNzLnN1cHBv cnRlZF9pbnRlcmZhY2VzKTsKKwlzdG1tYWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChw cml2LCBzcGNzLAorCQkJCQkgICAgUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJLCAwKTsKKwlzdG1t YWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChwcml2LCBzcGNzLAorCQkJCQkgICAgUEhZ X0lOVEVSRkFDRV9NT0RFXzEwMDBCQVNFWCwgMCk7CisJc3RtbWFjX2ludGVncmF0ZWRfcGNzX2No ZWNrX3N1cHBvcnQocHJpdiwgc3BjcywKKwkJCQkJICAgIFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAw QkFTRVgsCisJCQkJCSAgICBTVE1NQUNfRkxBR19TRVJERVNfU1VQUE9SVFNfMjUwME0pOwogCiAJ cHJpdi0+aW50ZWdyYXRlZF9wY3MgPSBzcGNzOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9l dGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMgYi9kcml2ZXJzL25ldC9ldGhl cm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5hNzY3YzA1NTM2MDQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMKQEAgLTAsMCAr MSw5MiBAQAorI2luY2x1ZGUgPGxpbnV4L3BoeS9waHkuaD4KKworI2luY2x1ZGUgInN0bW1hYy5o IgorI2luY2x1ZGUgInN0bW1hY19zZXJkZXMuaCIKKworc3RhdGljIGJvb2wgZHdtYWNfaGFzX3Nl cmRlcyhzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJaWYgKHByaXYtPnBsYXQtPmNvcmVf dHlwZSA9PSBEV01BQ19DT1JFX1hHTUFDKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gcHJp di0+ZG1hX2NhcC5hY3RwaHlpZiA9PSBQSFlfSU5URl9TRUxfU0dNSUkgfHwKKwkgICAgICAgcHJp di0+ZG1hX2NhcC5hY3RwaHlpZiA9PSBQSFlfSU5URl9TRUxfVEJJIHx8CisJICAgICAgIHByaXYt PmRtYV9jYXAuYWN0cGh5aWYgPT0gUEhZX0lOVEZfU0VMX1JUQkk7Cit9CisKK2ludCBkd21hY19z ZXJkZXNfdmFsaWRhdGUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBwaHlfaW50ZXJmYWNlX3Qg aW50ZXJmYWNlKQoreworCXN0cnVjdCBwaHkgKnNlcmRlcyA9IHByaXYtPnBsYXQtPnNlcmRlczsK KworCXJldHVybiBwaHlfdmFsaWRhdGUoc2VyZGVzLCBQSFlfTU9ERV9FVEhFUk5FVCwgaW50ZXJm YWNlLCBOVUxMKTsKK30KKworaW50IGR3bWFjX3NlcmRlc19pbml0KHN0cnVjdCBzdG1tYWNfcHJp diAqcHJpdikKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMgPSBwcml2LT5wbGF0LT5zZXJkZXM7CisJ aW50IHJldDsKKworCXJldCA9IHBoeV9pbml0KHNlcmRlcyk7CisJaWYgKHJldCkKKwkJZGV2X2Vy cihwcml2LT5kZXZpY2UsICJmYWlsZWQgdG8gaW5pdGlhbGl6ZSBTZXJEZXM6ICVwZVxuIiwKKwkJ CUVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQgZHdtYWNfc2VyZGVzX3Bv d2VyX29uKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMg PSBwcml2LT5wbGF0LT5zZXJkZXM7CisJaW50IHJldDsKKworCWlmICghZHdtYWNfaGFzX3NlcmRl cyhwcml2KSkKKwkJcmV0dXJuIDA7CisKKwlyZXQgPSBwaHlfcG93ZXJfb24oc2VyZGVzKTsKKwlp ZiAocmV0KQorCQlkZXZfZXJyKHByaXYtPmRldmljZSwgImZhaWxlZCB0byBwb3dlciBvbiBTZXJE ZXM6ICVwZVxuIiwKKwkJCUVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQg ZHdtYWNfc2VyZGVzX3NldF9tb2RlKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwgcGh5X2ludGVy ZmFjZV90IGludGVyZmFjZSkKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMgPSBwcml2LT5wbGF0LT5z ZXJkZXM7CisJaW50IHJldDsKKworCWlmICghZHdtYWNfaGFzX3NlcmRlcyhwcml2KSkKKwkJcmV0 dXJuIDA7CisKKwlyZXQgPSBwaHlfc2V0X21vZGVfZXh0KHNlcmRlcywgUEhZX01PREVfRVRIRVJO RVQsIGludGVyZmFjZSk7CisJaWYgKHJldCkKKwkJZGV2X2Vycihwcml2LT5kZXZpY2UsCisJCQki ZmFpbGVkIHRvIHNldCBTZXJEZXMgbW9kZSAlczogJXBlXG4iLAorCQkJcGh5X21vZGVzKGludGVy ZmFjZSksIEVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIGR3bWFjX3Nl cmRlc19wb3dlcl9vZmYoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQoreworCXN0cnVjdCBwaHkg KnNlcmRlcyA9IHByaXYtPnBsYXQtPnNlcmRlczsKKwlpbnQgcmV0OworCisJaWYgKCFkd21hY19o YXNfc2VyZGVzKHByaXYpKQorCQlyZXR1cm47CisKKwlyZXQgPSBwaHlfcG93ZXJfb2ZmKHNlcmRl cyk7CisJaWYgKHJldCkKKwkJZGV2X2Vycihwcml2LT5kZXZpY2UsICJmYWlsZWQgdG8gcG93ZXIg b2ZmIFNlckRlczogJXBlXG4iLAorCQkJRVJSX1BUUihyZXQpKTsKK30KKwordm9pZCBkd21hY19z ZXJkZXNfZXhpdChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJc3RydWN0IHBoeSAqc2Vy ZGVzID0gcHJpdi0+cGxhdC0+c2VyZGVzOworCWludCByZXQ7CisKKwlyZXQgPSBwaHlfZXhpdChz ZXJkZXMpOworCWlmIChyZXQpCisJCWRldl9lcnIocHJpdi0+ZGV2aWNlLCAiZmFpbGVkIHRvIHNo dXRkb3duIFNlckRlczogJXBlXG4iLAorCQkJRVJSX1BUUihyZXQpKTsKK30KZGlmZiAtLWdpdCBh L2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJkZXMuaCBiL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJkZXMuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjJjYTM3YTdkMGZkZQotLS0gL2Rldi9u dWxsCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJk ZXMuaApAQCAtMCwwICsxLDE1IEBACisjaWZuZGVmIFNUTU1BQ19TRVJERVNfSAorI2RlZmluZSBT VE1NQUNfU0VSREVTX0gKKworI2luY2x1ZGUgPGxpbnV4L3BoeS5oPgorCitzdHJ1Y3Qgc3RtbWFj X3ByaXY7CisKK2ludCBkd21hY19zZXJkZXNfdmFsaWRhdGUoc3RydWN0IHN0bW1hY19wcml2ICpw cml2LCBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKTsKK2ludCBkd21hY19zZXJkZXNfaW5pdChz dHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpOworaW50IGR3bWFjX3NlcmRlc19wb3dlcl9vbihzdHJ1 Y3Qgc3RtbWFjX3ByaXYgKnByaXYpOworaW50IGR3bWFjX3NlcmRlc19zZXRfbW9kZShzdHJ1Y3Qg c3RtbWFjX3ByaXYgKnByaXYsIHBoeV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UpOwordm9pZCBkd21h Y19zZXJkZXNfcG93ZXJfb2ZmKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdik7Cit2b2lkIGR3bWFj X3NlcmRlc19leGl0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdik7CisKKyNlbmRpZgpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9zdG1tYWMuaCBiL2luY2x1ZGUvbGludXgvc3RtbWFjLmgKaW5k ZXggYThlOWI1ZDMyODlmLi5iZWRiYTRlMjMwODggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv c3RtbWFjLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdG1tYWMuaApAQCAtMjE2LDYgKzIxNiw3IEBA IGVudW0gZHdtYWNfY29yZV90eXBlIHsKICNkZWZpbmUgU1RNTUFDX0ZMQUdfU0VSREVTX1NVUFBP UlRTXzI1MDBNCUJJVCgxNSkKIAogc3RydWN0IG1hY19kZXZpY2VfaW5mbzsKK3N0cnVjdCBwaHk7 CiAKIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0YSB7CiAJZW51bSBkd21hY19jb3JlX3R5cGUg Y29yZV90eXBlOwpAQCAtMjQ1LDYgKzI0Niw3IEBAIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0 YSB7CiAJICogdGhhdCBwaHlsaW5rIHVzZXMuCiAJICovCiAJcGh5X2ludGVyZmFjZV90IHBoeV9p bnRlcmZhY2U7CisJc3RydWN0IHBoeSAqc2VyZGVzOwogCXN0cnVjdCBzdG1tYWNfbWRpb19idXNf ZGF0YSAqbWRpb19idXNfZGF0YTsKIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKnBoeV9ub2RlOwogCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbWRpb19ub2RlOwotLSAKMi40Ny4zCgoKCkZyb206ICJSdXNzZWxs IEtpbmcgKE9yYWNsZSkiIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KU3ViamVjdDogW1BB VENIIG5ldC1uZXh0XSBuZXQ6IHN0bW1hYzogcWNvbS1ldGhxb3M6IGNvbnZlcnQgdG8gZHdtYWMg Y29yZQogU2VyRGVzIHN1cHBvcnQKCkNvbnZlcnQgcWNvbS1ldGhxb3MgdG8gdXNlIHRoZSBkd21h YyBjb3JlJ3MgZ2VuZXJpYyBTZXJEZXMgc3VwcG9ydCwKd2hpY2ggd2lsbCBoYW5kbGUgU2VyRGVz IGluaXRpYWxpc2F0aW9uLCBwb3dlcmluZywgYW5kIG1vZGUgc2V0dGluZy4KCk5vdGUgdGhhdCBn ZW5lcmljIHN1cHBvcnQgcmVxdWlyZXMgdGhlIFNlckRlcyB0byBzdXBwb3J0IHBoeV92YWxpZGF0 ZSgpCmluIG9yZGVyIHRvIHByb2JlIHdoaWNoIFBIWSBpbnRlcmZhY2UgbW9kZXMgYXJlIHN1cHBv cnRlZCwgYW5kCnBoeV9zZXRfbW9kZV9leHQoKSB0byBjb25maWd1cmUgdGhlIGFwcHJvcHJpYXRl IFBIWSBpbnRlcmZhY2UgbW9kZQooYW5kIHRodXMgdGhlIHNwZWVkLikKClNpZ25lZC1vZmYtYnk6 IFJ1c3NlbGwgS2luZyAoT3JhY2xlKSA8cm1rK2tlcm5lbEBhcm1saW51eC5vcmcudWs+Ci0tLQog Li4uL3N0bWljcm8vc3RtbWFjL2R3bWFjLXFjb20tZXRocW9zLmMgICAgICAgIHwgNDUgKystLS0t LS0tLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKSwgNDEgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv ZHdtYWMtcWNvbS1ldGhxb3MuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFj L2R3bWFjLXFjb20tZXRocW9zLmMKaW5kZXggOWEyMTk0ZmNjYjliLi5hNDBhNGJjYTE5N2QgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjLXFjb20t ZXRocW9zLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMt cWNvbS1ldGhxb3MuYwpAQCAtMTA0LDcgKzEwNCw2IEBAIHN0cnVjdCBxY29tX2V0aHFvcyB7CiAJ CQkgICAgICAgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSwgaW50IHNwZWVkKTsKIAogCXN0cnVj dCBjbGsgKmxpbmtfY2xrOwotCXN0cnVjdCBwaHkgKnNlcmRlc19waHk7CiAJcGh5X2ludGVyZmFj ZV90IHBoeV9tb2RlOwogCiAJY29uc3Qgc3RydWN0IGV0aHFvc19lbWFjX3BvciAqcmdtaWlfcG9y OwpAQCAtNjI3LDQ1ICs2MjYsMTUgQEAgc3RhdGljIHZvaWQgZXRocW9zX2ZpeF9tYWNfc3BlZWQo dm9pZCAqcHJpdiwgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSwKIAlldGhxb3NfY29uZmlndXJl KGV0aHFvcywgaW50ZXJmYWNlLCBzcGVlZCk7CiB9CiAKLXN0YXRpYyBpbnQgcWNvbV9ldGhxb3Nf c2VyZGVzX3Bvd2VydXAoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnByaXYpCi17Ci0J c3RydWN0IHFjb21fZXRocW9zICpldGhxb3MgPSBwcml2OwotCWludCByZXQ7Ci0KLQlyZXQgPSBw aHlfaW5pdChldGhxb3MtPnNlcmRlc19waHkpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0K LQlyZXQgPSBwaHlfcG93ZXJfb24oZXRocW9zLT5zZXJkZXNfcGh5KTsKLQlpZiAocmV0KQotCQlw aHlfZXhpdChldGhxb3MtPnNlcmRlc19waHkpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGlj IHZvaWQgcWNvbV9ldGhxb3Nfc2VyZGVzX3Bvd2VyZG93bihzdHJ1Y3QgbmV0X2RldmljZSAqbmRl diwgdm9pZCAqcHJpdikKLXsKLQlzdHJ1Y3QgcWNvbV9ldGhxb3MgKmV0aHFvcyA9IHByaXY7Ci0K LQlwaHlfcG93ZXJfb2ZmKGV0aHFvcy0+c2VyZGVzX3BoeSk7Ci0JcGh5X2V4aXQoZXRocW9zLT5z ZXJkZXNfcGh5KTsKLX0KLQogc3RhdGljIGludCBldGhxb3NfbWFjX2ZpbmlzaF9zZXJkZXMoc3Ry dWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnByaXYsCiAJCQkJICAgIHVuc2lnbmVkIGludCBt b2RlLAogCQkJCSAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQogewogCXN0cnVjdCBxY29t X2V0aHFvcyAqZXRocW9zID0gcHJpdjsKLQlpbnQgcmV0ID0gMDsKIAogCXFjb21fZXRocW9zX3Nl dF9zZ21paV9sb29wYmFjayhldGhxb3MsIGZhbHNlKTsKIAotCWlmIChpbnRlcmZhY2UgPT0gUEhZ X0lOVEVSRkFDRV9NT0RFX1NHTUlJIHx8Ci0JICAgIGludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNF X01PREVfMjUwMEJBU0VYKQotCQlyZXQgPSBwaHlfc2V0X21vZGVfZXh0KGV0aHFvcy0+c2VyZGVz X3BoeSwgUEhZX01PREVfRVRIRVJORVQsCi0JCQkJICAgICAgIGludGVyZmFjZSk7Ci0KLQlyZXR1 cm4gcmV0OworCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IGV0aHFvc19jbGtzX2NvbmZpZyh2 b2lkICpwcml2LCBib29sIGVuYWJsZWQpCkBAIC03ODksOSArNzU4LDkgQEAgc3RhdGljIGludCBx Y29tX2V0aHFvc19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChyZXQp CiAJCXJldHVybiByZXQ7CiAKLQlldGhxb3MtPnNlcmRlc19waHkgPSBkZXZtX3BoeV9vcHRpb25h bF9nZXQoZGV2LCAic2VyZGVzIik7Ci0JaWYgKElTX0VSUihldGhxb3MtPnNlcmRlc19waHkpKQot CQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIoZXRocW9zLT5zZXJkZXNfcGh5KSwK KwlwbGF0X2RhdC0+c2VyZGVzID0gZGV2bV9waHlfb3B0aW9uYWxfZ2V0KGRldiwgInNlcmRlcyIp OworCWlmIChJU19FUlIocGxhdF9kYXQtPnNlcmRlcykpCisJCXJldHVybiBkZXZfZXJyX3Byb2Jl KGRldiwgUFRSX0VSUihwbGF0X2RhdC0+c2VyZGVzKSwKIAkJCQkgICAgICJGYWlsZWQgdG8gZ2V0 IHNlcmRlcyBwaHlcbiIpOwogCiAJZXRocW9zX3NldF9jbGtfdHhfcmF0ZShldGhxb3MsIE5VTEws IHBsYXRfZGF0LT5waHlfaW50ZXJmYWNlLApAQCAtODE2LDEyICs3ODUsNiBAQCBzdGF0aWMgaW50 IHFjb21fZXRocW9zX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKGRh dGEtPmRtYV9hZGRyX3dpZHRoKQogCQlwbGF0X2RhdC0+aG9zdF9kbWFfd2lkdGggPSBkYXRhLT5k bWFfYWRkcl93aWR0aDsKIAotCWlmIChldGhxb3MtPnNlcmRlc19waHkpIHsKLQkJcGxhdF9kYXQt PnNlcmRlc19wb3dlcnVwID0gcWNvbV9ldGhxb3Nfc2VyZGVzX3Bvd2VydXA7Ci0JCXBsYXRfZGF0 LT5zZXJkZXNfcG93ZXJkb3duICA9IHFjb21fZXRocW9zX3NlcmRlc19wb3dlcmRvd247Ci0JCXBs YXRfZGF0LT5mbGFncyB8PSBTVE1NQUNfRkxBR19TRVJERVNfU1VQUE9SVFNfMjUwME07Ci0JfQot CiAJLyogRW5hYmxlIFRTTyBvbiBxdWV1ZTAgYW5kIGVuYWJsZSBUQlMgb24gcmVzdCBvZiB0aGUg cXVldWVzICovCiAJZm9yIChpID0gMTsgaSA8IHBsYXRfZGF0LT50eF9xdWV1ZXNfdG9fdXNlOyBp KyspCiAJCXBsYXRfZGF0LT50eF9xdWV1ZXNfY2ZnW2ldLnRic19lbiA9IDE7Ci0tIAoyLjQ3LjMK CgotLSAKUk1LJ3MgUGF0Y2ggc3lzdGVtOiBodHRwczovL3d3dy5hcm1saW51eC5vcmcudWsvZGV2 ZWxvcGVyL3BhdGNoZXMvCkZUVFAgaXMgaGVyZSEgODBNYnBzIGRvd24gMTBNYnBzIHVwLiBEZWNl bnQgY29ubmVjdGl2aXR5IGF0IGxhc3QhCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpMaW51eC1yb2NrY2hpcCBtYWlsaW5nIGxpc3QKTGludXgtcm9ja2No aXBAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2xpbnV4LXJvY2tjaGlwCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A3E0B1125857 for ; Wed, 11 Mar 2026 17:47:18 +0000 (UTC) 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:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=xunD79ve/9OBxxN8rLBOO29QUvIvMMYCCUg9ChYmYwk=; b=NiQyztG788Qj/W 76dwmWLFdhS3z+y+tIMXEmmdj5NgoF0LB0xshgzbC0FmfQdGTakd+LH6tT3DnmT8EPSyz8bwrVawc JbL400vzhsvUlYS36hSVtEG6ddZ5arHV7QmRqpj+Scaw/OwUbuqic3QMQcdQJUIJlHydUGeXrhyc8 5dKhcdq0QLN2+8UCzRs0mWeDstZRBtAzNU1LbWeg4nbpUN6MMaKDzX2xqVyYc+3P1NFExTeER4RmJ Fxj+O1WEsGdVYP3wCFaO9g3Y52VLiuGO6cakm39ZwYIkqyH/jIOL7jiajQg9qgZ37PavQdaKc/Xfb RERdPmGJ3bIazc76EKGA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1w0NeD-0000000C4hX-3CGW; Wed, 11 Mar 2026 17:47:05 +0000 Received: from pandora.armlinux.org.uk ([2001:4d48:ad52:32c8:5054:ff:fe00:142]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1w0Ne9-0000000C4eV-3kSY; Wed, 11 Mar 2026 17:47:03 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=vkA02cIf1bCPsbEnaLlFrwiwhwE6F8sIdO8MLg/HiWE=; b=Mngfxk09kt4/krUPKb1Zn6lcvE l9OOliC67agWfQrQug9P+Kg4KqL8K9pG1JGagHPp977ZBgRBJPBA6B3n6Nq7ZZjzNhNHBa04Aggd5 OxtnrJvRSidT247vak7uZRx4sFwM4zso4bxtCfWNXqbI/zKGUIPSu5Xf8u404kZVl3eFXdmVr6G4K lO0ZoDXT9gXriqFDdnx8nO6ED36JLZ/Tw859kbvSISGE+Y5EZTdKRfgl8TrhT+cd35X399OGNYGsB A9ja4GIOef9lTvNcGssfOGnV0KFRzjeIBBAF4bFnXTDE4eQQekh/xdRvVuaMtrlshIqYyXcwouNb5 LGP1XvZg==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:35300) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1w0Ndi-000000006l7-0H7T; Wed, 11 Mar 2026 17:46:34 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.98.2) (envelope-from ) id 1w0Nde-000000006RR-1cKu; Wed, 11 Mar 2026 17:46:30 +0000 Date: Wed, 11 Mar 2026 17:46:30 +0000 From: "Russell King (Oracle)" To: Bartosz Golaszewski Cc: Bartosz Golaszewski , Bjorn Andersson , Konrad Dybcio , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Andrew Lunn , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Maxime Coquelin , Alexandre Torgue , Vinod Koul , Giuseppe Cavallaro , Chen-Yu Tsai , Jernej Skrabec , Neil Armstrong , Kevin Hilman , Jerome Brunet , Shawn Guo , Fabio Estevam , Jan Petrous , s32@nxp.com, Romain Gantois , Geert Uytterhoeven , Magnus Damm , Maxime Ripard , Christophe Roullier , Radu Rendec , linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, Drew Fustini , linux-sunxi@lists.linux.dev, linux-amlogic@lists.infradead.org, linux-mips@vger.kernel.org, imx@lists.linux.dev, linux-renesas-soc@vger.kernel.org, linux-rockchip@lists.infradead.org, sophgo@lists.linux.dev, linux-riscv@lists.infradead.org, Bartosz Golaszewski Subject: Re: [PATCH net-next v8 2/6] net: stmmac: qcom-ethqos: use generic device properties Message-ID: References: <20260311-qcom-sa8255p-emac-v8-0-58227bcf1018@oss.qualcomm.com> <20260311-qcom-sa8255p-emac-v8-2-58227bcf1018@oss.qualcomm.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260311_104702_252613_54624287 X-CRM114-Status: GOOD ( 45.89 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gV2VkLCBNYXIgMTEsIDIwMjYgYXQgMDY6MTg6MDBQTSArMDEwMCwgQmFydG9zeiBHb2xhc3pl d3NraSB3cm90ZToKPiBPbiBXZWQsIE1hciAxMSwgMjAyNiBhdCA2OjE04oCvUE0gUnVzc2VsbCBL aW5nIChPcmFjbGUpCj4gPGxpbnV4QGFybWxpbnV4Lm9yZy51az4gd3JvdGU6Cj4gPgo+ID4gT24g V2VkLCBNYXIgMTEsIDIwMjYgYXQgMDY6MDM6MzdQTSArMDEwMCwgQmFydG9zeiBHb2xhc3pld3Nr aSB3cm90ZToKPiA+ID4gRnJvbTogQmFydG9zeiBHb2xhc3pld3NraSA8YmFydG9zei5nb2xhc3pl d3NraUBsaW5hcm8ub3JnPgo+ID4gPgo+ID4gPiBJbiBvcmRlciB0byBkcm9wIHRoZSBkZXBlbmRl bmN5IG9uIENPTkZJR19PRiwgY29udmVydCBhbGwgZGV2aWNlIHByb3BlcnR5Cj4gPiA+IGdldHRl cnMgZnJvbSBPRi1zcGVjaWZpYyB0byBnZW5lcmljIGRldmljZSBwcm9wZXJ0aWVzIGFuZCBzdG9w IHB1bGxpbmcKPiA+ID4gaW4gYW55IGxpbnV4L29mLmggc3ltYm9scy4KPiA+ID4KPiA+ID4gU2ln bmVkLW9mZi1ieTogQmFydG9zeiBHb2xhc3pld3NraSA8YmFydG9zei5nb2xhc3pld3NraUBsaW5h cm8ub3JnPgo+ID4gPiBTaWduZWQtb2ZmLWJ5OiBCYXJ0b3N6IEdvbGFzemV3c2tpIDxiYXJ0b3N6 LmdvbGFzemV3c2tpQG9zcy5xdWFsY29tbS5jb20+Cj4gPgo+ID4gUGxlYXNlIHBvc3Rwb25lIHRo aXMgZm9yIHRoZSB0aW1lIGJlaW5nIC0gSSdtIHRyeWluZyB0byBnZXQgc3RtbWFjJ3MKPiA+IHBh aW4taW4tdGhlLWFyc2UgUENTIHN1cHBvcnQgc29ydGVkLCBhbmQgSSd2ZSBwYXRjaCBzZXJpZXMg b3V0IHRoZXJlCj4gPiBhbmQgcGVuZGluZyB0aGF0IG1ha2UgYSBsYXJnZSBudW1iZXIgb2YgY2hh bmdlcyB0byB0aGlzIGRyaXZlci4gVGhpcwo+ID4gaXMgbGlrZWx5IHRvIGNvbmZsaWN0IHdpdGgg bXkgd29yay4KPiA+Cj4gPiBJJ20gbGltaXRlZCBieSB0aGUgcmF0ZSBhdCB3aGljaCBwYXRjaGVz IGNhbiBiZSBhcHBsaWVkIHRvIG5ldC1uZXh0Cj4gPiBhbmQgdGhlIHJhdGUgYXQgd2hpY2ggTW9o ZCBjYW4gcHJvdmlkZSBtZSBmZWVkYmFjay4gT24gdGhhdCwgSSBub3RpY2UKPiA+IHlvdSBoYXZl bid0IENjJ2QgTW9oZCB3aG8gaXMgbm93IGluIE1BSU5UQUlORVJTIGZvciBxY29tLWV0aHFvcy4K PiA+Cj4gCj4gRG8gdGhlc2UgdHdvIGNoYW5nZXNldHMgaW50ZXJhY3Qgd2l0aCBlYWNoIG90aGVy IGEgbG90PyBEbyB5b3UgaGF2ZSBhCj4gV0lQIGJyYW5jaCBJIGNvdWxkIHRha2UgYSBsb29rIGF0 PyBUaGlzIGhhcyBiZWVuIHBvc3QtcG9uZWQgc2V2ZXJhbAo+IHRpbWVzIGFscmVhZHksIHRoZXJl IGFsd2F5cyBzZWVtIHRvIGJlIHNvbWUgbmV3IGNoYW5nZXMgY29taW5nIGluLiA6LwoKSSBkb24n dCBoYXZlIGEgcHVibGljIGJyYW5jaCBiZWNhdXNlIHRoaXMgd29yayBpcyBzdWJqZWN0IHRvIHJl d29yawpkZXBlbmRpbmcgb24gdGhlIGZlZWRiYWNrIEkgcmVjZWl2ZS4gTW9oZCBoYXMgYW5vdGhl ciB2ZXJzaW9uIG9mIHRoZQpzZXJpZXMgdGhhdCBJJ20gd2FpdGluZyBmb3IgZmVlZGJhY2sgZm9y LiBBcyBzb29uIGFzIEkgaGVhciB0aGF0IGl0J3MKZmluZSwgSSB3aWxsIGJlIHNlbmRpbmcgaXQu CgpUaGUgcHJvYmxlbSBJIHJlZmVyIHRvIGhhcyBiZWVuIGEgcGFpbiBwb2ludCBmb3IgcGh5bGlu ayBzaW5jZSBzdG1tYWMKd2FzIGNvbnZlcnRlZCBpbiAyMDE5LCB3aGljaCBwcmUtZGF0ZXMgcWNv bS1ldGhxb3MsIHRoZSBtZXJnaW5nIG9mCndoaWNoIGhhcyBtYWRlIHNvbHZpbmcgc3RoaXMgbXVj aCBtb3JlIHBhaW5mdWwgYXMgcWNvbS1ldGhxb3MKY29tcGxldGVseSBieXBhc3NlcyBwaHlsaW5r IGJ5IGZvcmNpbmcgdGhlIFBDUyBpbmJhbmQgc3RhdGUgYmVoaW5kCnBoeWxpbmsncyBiYWNrLgoK SG9uZXN0bHksIG92ZXIgcmVjZW50IG1vbnRocywgSSd2ZSBiZWVuIHdhc2hpbmcgdGhhdCBJJ2Qg TkFDSydkIHRoZQptZXJnaW5nIG9mIGR3bWFjLXFjb20tZXRocW9zIGF0IHRoZSB0aW1lIG92ZXIg dGhpcywgYnV0IEkgZGlkbid0CmhhdmUgYW55IHNvbHV0aW9uIGZvciBzdG1tYWMgYXQgdGhhdCBw b2ludCAoaXQgd2Fzbid0IG15CnJlc3BvbnNpYmlsaXR5LCB0aGUgYnJva2VuIHBoeWxpbmsgY29u dmVyc2lvbiBvZiBzdG1tYWMgd2FzIG1lcmdlZAp3aXRob3V0IG15IGtub3dsZWRnZSwgd2l0aG91 dCBldmVuIGEgQ2MgdG8gbWUuKQoKT25lIG9mIHRoZSBiaWdnZXN0IGNoYW5nZXMgdGhhdCB3aWxs IGRlZmluaXRlbHkgY29uZmxpY3Qgd2l0aCB5b3VyCmNoYW5nZXMgaXMgdGhlIG1vdmUgb2YgcWNv bS1ldGhxb3MnIFNlckRlcyBzdXBwb3J0IGludG8gc3RtbWFjIGNvcmUKY29kZSAtIGJlY2F1c2Ug dGhlIHN0bW1hYyBQQ1MgY29kZSBuZWVkcyB0byBrbm93IHdoZXRoZXIgdGhlIFNlckRlcwpjYW4g c3VwcG9ydCAyLjVHYnBzIHNwZWVkLiBJIGdvdCB0aGUgY2hhbmdlcyBmb3IgdGhlIGdlbmVyaWMg UEhZIHBhcnQKb2YgdGhhdCBtZXJnZWQgbGFzdCB3ZWVrLgoKQW5vdGhlciBjaGFuZ2UgdGhhdCB3 aWxsIGNvbmZsaWN0IGlzIHlvdXIgcGF0Y2ggMywgd2hlcmUgbWFzc2VzIG9mCmNoYW5nZXMgaW4g cWNvbV9ldGhxb3NfcHJvYmUoKSB3aGljaCB3aWxsIGNvbmZsaWN0IHdpdGggbXkKIm5ldDogc3Rt bWFjOiBxY29tLWV0aHFvczogZW5hYmxlIDI1MDBCQVNFLVgiIHBhdGNoLgoKSSd2ZSBwb3N0ZWQg cGF0Y2hlcyBmb3IgdGhhdCBhIGNvdXBsZSBvZiB3ZWVrcyBhZ28sIGJ1dCBNb2hkIHJlcG9ydGVk CnByb2JsZW1zLCBzbyBJJ3ZlIGhhZCB0byByZXdvcmsgdGhlIHNlcmllcyAtIGFuZCBub3cgdGhv c2UgcGF0Y2hlcwphcmUgcGFydCBvZiBhIGZvbGxvdy1vbiBzZXJpZXMgYWZ0ZXIgc29ydGluZyB0 aGUgYnVsayBvZiB0aGUgc3RtbWFjClBDUyBtZXNzLgoKSSdtIGN1cnJlbnRseSB3YWl0aW5nIGZv ciBNb2hkJ3MgZmVlZGJhY2sgb24gdGhlIHJld29ya2VkIHNlcmllcy4KCmh0dHBzOi8vbG9yZS5r ZXJuZWwub3JnL3IvYVo3Z2dmUWFuYzhqZUNiOUBzaGVsbC5hcm1saW51eC5vcmcudWsKaHR0cHM6 Ly9sb3JlLmtlcm5lbC5vcmcvci9hYWZ4cUN2Sl9YWTRZYld3QHNoZWxsLmFybWxpbnV4Lm9yZy51 awoKTGF0ZXN0IHZlcnNpb24gd2FpdGluZyBmb3IgTW9oZCdzIGZlZWRiYWNrOgoKaHR0cHM6Ly9s b3JlLmtlcm5lbC5vcmcvci9hYTZzb2ZqRnh5aTJua3ByQHNoZWxsLmFybWxpbnV4Lm9yZy51awoK QmVsb3cgYXJlIHRoZSB0d28gcGF0Y2hlcyB3aGljaCBhZGQgYW5kIGNvbnZlcnQgcWNvbS1ldGhx b3Mgc2VyZGVzCnN1cHBvcnQuIE5vdGUgdGhhdCB0aGVzZSB0d28gZGVwZW5kIG9uIG90aGVyIHBh dGNoZXMuCgoKRnJvbTogIlJ1c3NlbGwgS2luZyAoT3JhY2xlKSIgPHJtaytrZXJuZWxAYXJtbGlu dXgub3JnLnVrPgpTdWJqZWN0OiBbUEFUQ0ggbmV0LW5leHRdIG5ldDogc3RtbWFjOiBhZGQgc3Rt bWFjIGNvcmUgc2VyZGVzIHN1cHBvcnQKClJhdGhlciB0aGFuIGhhdmluZyBwbGF0Zm9ybSBnbHVl IGltcGxlbWVudCBTZXJEZXMgUEhZIHN1cHBvcnQsIGFkZCBpdAp0byB0aGUgY29yZSBkcml2ZXIs IHNwZWNpZmljYWxseSB0byB0aGUgc3RtbWFjIGludGVncmF0ZWQgUENTIGRyaXZlcgphcyB0aGUg U2VyRGVzIGlzIGNvbm5lY3RlZCB0byB0aGUgaW50ZWdyYXRlZCBQQ1MuCgpQbGF0Zm9ybXMgdXNp bmcgZXh0ZXJuYWwgUENTIGNhbiBhbHNvIHBvcHVsYXRlIHBsYXQtPnNlcmRlcywgYW5kIHRoZQpj b3JlIGRyaXZlciB3aWxsIGNhbGwgcGh5X2luaXQoKSBhbmQgcGh5X2V4aXQoKSB3aGVuIHRoZSBh ZG1pbmlzdHJhdGl2ZQpzdGF0ZSBvZiB0aGUgaW50ZXJmYWNlIGNoYW5nZXMsIGJ1dCB0aGUgb3Ro ZXIgcGh5IG1ldGhvZHMgd2lsbCBub3QgYmUKY2FsbGVkLgoKUmV2aWV3ZWQtYnk6IE1heGltZSBD aGV2YWxsaWVyIDxtYXhpbWUuY2hldmFsbGllckBib290bGluLmNvbT4KU2lnbmVkLW9mZi1ieTog UnVzc2VsbCBLaW5nIChPcmFjbGUpIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KLS0KcmZj LT52MTogYXZvaWQgY2FsbGluZyBwaHlfZ2V0X21vZGUoKSB3aXRoIE5VTEwgc2VyZGVzIFBIWQp2 MjogYWRkIGNsZWFudXAgd2hlbiBkd21hY19zZXJkZXNfc2V0X21vZGUoKSBmYWlscywgc28gdGhh dCBmYWlsdXJlIGF0CiAgYW55IHBvaW50IGluIHRoZSBpbnRlcm5hbCBQQ1MgZW5hYmxlIG1ldGhv ZCBsZWF2ZXMgdGhlIG92ZXJhbGwgc3RhdGUKICB1bmNoYW5nZWQuCnYzOiBpbiBhIHBlbmRpbmcg Y2hhbmdlIHRvIGdlbmVyaWMgUEhZIGRvY3VtZW50YXRpb24gaW5kaWNhdGVkIGJ5IFZpbm9kCiAg cmVjZW50bHksIGNhbGxpbmcgcGh5X3NldF9tb2RlKF9leHQpKCkgYmVmb3JlIHBoeV9wb3dlcl9v bigpIHdpbGwgYmUKICBwcmVmZXJyZWQsIHNvIHJlLW9yZ2FuaXNlIHRvIHVzZSB0aGF0IG9yZGVy aW5nLgp2NDogbW92ZSBwaHlfc2V0X21vZGUoKSBpbnRvIC5tYWNfZmluaXNoKCksIGFkZCBkd21h Y19oYXNfc2VyZGVzKCkgdG8KICBtYWtlIHNlcmRlcyBjYWxscyBjb25kaXRpb25hbCBvbiBkd21h YydzIGFjdGl2ZSBwaHkgaW50ZXJmYWNlLCB3aXRoCiAgdGhlIGV4Y2VwdGlvbiBvZiBwaHlfaW5p dCgpL3BoeV9leGl0KCkgY2FsbHMuCi0tLQogZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvTWFrZWZpbGUgIHwgIDIgKy0KIC4uLi9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv c3RtbWFjX21haW4uYyB8IDM3ICsrKysrKystCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3Rt bWFjL3N0bW1hY19wY3MuYyAgfCA0NCArKysrKysrLS0KIC4uLi9ldGhlcm5ldC9zdG1pY3JvL3N0 bW1hYy9zdG1tYWNfc2VyZGVzLmMgICB8IDkyICsrKysrKysrKysrKysrKysrKysKIC4uLi9ldGhl cm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmggICB8IDE1ICsrKwogaW5jbHVkZS9s aW51eC9zdG1tYWMuaCAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKwogNiBmaWxlcyBjaGFu Z2VkLCAxODEgaW5zZXJ0aW9ucygrKSwgMTEgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX3NlcmRlcy5jCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3Rt bWFjX3NlcmRlcy5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvTWFrZWZpbGUgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9NYWtl ZmlsZQppbmRleCBjOTI2Mzk4N2VmOGQuLmEzYzJjZDVkMGM5MSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9uZXQv ZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUKQEAgLTcsNyArNyw3IEBAIHN0bW1hYy1v YmpzOj0gc3RtbWFjX21haW4ubyBzdG1tYWNfZXRodG9vbC5vIHN0bW1hY19tZGlvLm8gcmluZ19t b2RlLm8JXAogCSAgICAgIGR3bWFjNF9kbWEubyBkd21hYzRfbGliLm8gZHdtYWM0X2NvcmUubyBk d21hYzUubyBod2lmLm8gXAogCSAgICAgIHN0bW1hY190Yy5vIGR3eGdtYWMyX2NvcmUubyBkd3hn bWFjMl9kbWEubyBkd3hnbWFjMl9kZXNjcy5vIFwKIAkgICAgICBzdG1tYWNfeGRwLm8gc3RtbWFj X2VzdC5vIHN0bW1hY19mcGUubyBzdG1tYWNfdmxhbi5vIFwKLQkgICAgICBzdG1tYWNfcGNzLm8g JChzdG1tYWMteSkKKwkgICAgICBzdG1tYWNfcGNzLm8gc3RtbWFjX3NlcmRlcy5vICQoc3RtbWFj LXkpCiAKIHN0bW1hYy0kKENPTkZJR19TVE1NQUNfU0VMRlRFU1RTKSArPSBzdG1tYWNfc2VsZnRl c3RzLm8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv c3RtbWFjX21haW4uYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1h Y19tYWluLmMKaW5kZXggMzdmNmVlNzU2NmJlLi40MjhiMmU1YmI0YzQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMKKysrIGIvZHJp dmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYwpAQCAtNDksNiAr NDksNyBAQAogI2luY2x1ZGUgInN0bW1hY19mcGUuaCIKICNpbmNsdWRlICJzdG1tYWMuaCIKICNp bmNsdWRlICJzdG1tYWNfcGNzLmgiCisjaW5jbHVkZSAic3RtbWFjX3NlcmRlcy5oIgogI2luY2x1 ZGUgInN0bW1hY194ZHAuaCIKICNpbmNsdWRlIDxsaW51eC9yZXNldC5oPgogI2luY2x1ZGUgPGxp bnV4L29mX21kaW8uaD4KQEAgLTk2OSw3ICs5NzAsNyBAQCBzdGF0aWMgaW50IHN0bW1hY19tYWNf ZmluaXNoKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwK IAkJcHJpdi0+cGxhdC0+bWFjX2ZpbmlzaChuZGV2LCBwcml2LT5wbGF0LT5ic3BfcHJpdiwgbW9k ZSwKIAkJCQkgICAgICAgaW50ZXJmYWNlKTsKIAotCXJldHVybiAwOworCXJldHVybiBkd21hY19z ZXJkZXNfc2V0X21vZGUocHJpdiwgaW50ZXJmYWNlKTsKIH0KIAogc3RhdGljIHZvaWQgc3RtbWFj X21hY19saW5rX2Rvd24oc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsCkBAIC0zNTkyLDEy ICszNTkzLDE0IEBAIHN0YXRpYyB2b2lkIHN0bW1hY19zYWZldHlfZmVhdF9jb25maWd1cmF0aW9u KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKIAogc3RhdGljIHZvaWQgc3RtbWFjX2Nsa19yeF9p X3JlcXVpcmUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQogeworCWR3bWFjX3NlcmRlc19wb3dl cl9vbihwcml2KTsKIAlwaHlsaW5rX3J4X2Nsa19zdG9wX2Jsb2NrKHByaXYtPnBoeWxpbmspOwog fQogCiBzdGF0aWMgdm9pZCBzdG1tYWNfY2xrX3J4X2lfcmVsZWFzZShzdHJ1Y3Qgc3RtbWFjX3By aXYgKnByaXYpCiB7CiAJcGh5bGlua19yeF9jbGtfc3RvcF91bmJsb2NrKHByaXYtPnBoeWxpbmsp OworCWR3bWFjX3NlcmRlc19wb3dlcl9vZmYocHJpdik7CiB9CiAKIC8qKgpAQCAtNDE1Myw2ICs0 MTU2LDEwIEBAIHN0YXRpYyBpbnQgc3RtbWFjX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldikK IAlpZiAocmV0KQogCQlnb3RvIGVycl9ydW50aW1lX3BtOwogCisJcmV0ID0gZHdtYWNfc2VyZGVz X2luaXQocHJpdik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyX2Rpc2Nvbm5lY3RfcGh5Owor CiAJaWYgKCEocHJpdi0+cGxhdC0+ZmxhZ3MgJiBTVE1NQUNfRkxBR19TRVJERVNfVVBfQUZURVJf UEhZX0xJTktVUCkpIHsKIAkJcmV0ID0gc3RtbWFjX2xlZ2FjeV9zZXJkZXNfcG93ZXJfdXAocHJp dik7CiAJCWlmIChyZXQgPCAwKQpAQCAtNDE3Miw2ICs0MTc5LDcgQEAgc3RhdGljIGludCBzdG1t YWNfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCiBlcnJfc2VyZGVzOgogCXN0bW1hY19s ZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJpdik7CisJZHdtYWNfc2VyZGVzX2V4aXQocHJpdik7 CiBlcnJfZGlzY29ubmVjdF9waHk6CiAJcGh5bGlua19kaXNjb25uZWN0X3BoeShwcml2LT5waHls aW5rKTsKIGVycl9ydW50aW1lX3BtOgpAQCAtNDIzMiw2ICs0MjQwLDcgQEAgc3RhdGljIGludCBz dG1tYWNfcmVsZWFzZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCV9fc3RtbWFjX3JlbGVhc2Uo ZGV2KTsKIAogCXN0bW1hY19sZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJpdik7CisJZHdtYWNf c2VyZGVzX2V4aXQocHJpdik7CiAJcGh5bGlua19kaXNjb25uZWN0X3BoeShwcml2LT5waHlsaW5r KTsKIAlwbV9ydW50aW1lX3B1dChwcml2LT5kZXZpY2UpOwogCkBAIC03NzgxLDYgKzc3OTAsMTMg QEAgc3RhdGljIGludCBfX3N0bW1hY19kdnJfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2aWNlLAog CQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwlpZiAocGxhdF9kYXQtPnNlcmRlcyAmJgorCSAgICAo cGxhdF9kYXQtPnNlcmRlc19wb3dlcnVwIHx8IHBsYXRfZGF0LT5zZXJkZXNfcG93ZXJkb3duKSkg eworCQlkZXZfZXJyKGRldmljZSwKKwkJCSJnZW5lcmljIFBIWSBhbmQgU2VyRGVzIHBsYXRmb3Jt IGNhbGxiYWNrcyBhcmUgaW5jb21wYXRpYmxlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQor CiAJbmRldiA9IGRldm1fYWxsb2NfZXRoZXJkZXZfbXFzKGRldmljZSwgc2l6ZW9mKHN0cnVjdCBz dG1tYWNfcHJpdiksCiAJCQkJICAgICAgIE1UTF9NQVhfVFhfUVVFVUVTLCBNVExfTUFYX1JYX1FV RVVFUyk7CiAJaWYgKCFuZGV2KQpAQCAtODE5NCw2ICs4MjEwLDE1IEBAIGludCBzdG1tYWNfc3Vz cGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiAKIAlydG5sX2xvY2soKTsKIAlwaHlsaW5rX3N1c3Bl bmQocHJpdi0+cGh5bGluaywgISFwcml2LT53b2xvcHRzKTsKKworCS8qIElmIHRoZSBNQUMgaGFz IFdvTCBlbmFibGVkLCB0aGUgU2VyRGVzIG5lZWRzIHRvIHJlbWFpbiBhY3RpdmUuCisJICogT3Ro ZXJ3aXNlLCBwaHlsaW5rIHdpbGwgaGF2ZSBzdG9wcGVkIHRoZSBNQUMgYW5kIHRoZSBQQ1Mgd2ls bAorCSAqIGhhdmUgYmVlbiBkaXNhYmxlZCwgbWVhbmluZyB0aGUgU2VyRGVzIGlzIGFscmVhZHkg cG93ZXJlZCBvZmYuCisJICogQ2FsbCBpdHMgZXhpdCBmdW5jdGlvbiBzbyB3ZSBjYW4gY2FsbCBp bml0IGR1cmluZyByZXN1bWUuCisJICovCisJaWYgKCFwcml2LT53b2xvcHRzKQorCQlkd21hY19z ZXJkZXNfZXhpdChwcml2KTsKKwogCXJ0bmxfdW5sb2NrKCk7CiAKIAlpZiAoc3RtbWFjX2ZwZV9z dXBwb3J0ZWQocHJpdikpCkBAIC04MjkwLDYgKzgzMTUsMTUgQEAgaW50IHN0bW1hY19yZXN1bWUo c3RydWN0IGRldmljZSAqZGV2KQogCiAJcnRubF9sb2NrKCk7CiAKKwkvKiBJZiB0aGUgTUFDIGhh cyBXb0wgZW5hYmxlZCwgdGhlIFNlckRlcyB3YXMgbGVmdCBhY3RpdmUgKi8KKwlpZiAoIXByaXYt PndvbG9wdHMpIHsKKwkJcmV0ID0gZHdtYWNfc2VyZGVzX2luaXQocHJpdik7CisJCWlmIChyZXQp IHsKKwkJCXJ0bmxfdW5sb2NrKCk7CisJCQlyZXR1cm4gcmV0OworCQl9CisJfQorCiAJLyogUHJl cGFyZSB0aGUgUEhZIHRvIHJlc3VtZSwgZW5zdXJpbmcgdGhhdCBpdHMgY2xvY2tzIHdoaWNoIGFy ZQogCSAqIG5lY2Vzc2FyeSBmb3IgdGhlIE1BQyBETUEgcmVzZXQgdG8gY29tcGxldGUgYXJlIHJ1 bm5pbmcKIAkgKi8KQEAgLTgzMDcsNiArODM0MSw3IEBAIGludCBzdG1tYWNfcmVzdW1lKHN0cnVj dCBkZXZpY2UgKmRldikKIAkJbmV0ZGV2X2Vycihwcml2LT5kZXYsICIlczogSHcgc2V0dXAgZmFp bGVkXG4iLCBfX2Z1bmNfXyk7CiAJCXN0bW1hY19sZWdhY3lfc2VyZGVzX3Bvd2VyX2Rvd24ocHJp dik7CiAJCW11dGV4X3VubG9jaygmcHJpdi0+bG9jayk7CisJCWR3bWFjX3NlcmRlc19leGl0KHBy aXYpOwogCQlydG5sX3VubG9jaygpOwogCQlyZXR1cm4gcmV0OwogCX0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19wY3MuYyBiL2RyaXZlcnMv bmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19wY3MuYwppbmRleCAwYzBlYjllMzBi OTUuLjI5OGQzYzAwYjJmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNy by9zdG1tYWMvc3RtbWFjX3Bjcy5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8v c3RtbWFjL3N0bW1hY19wY3MuYwpAQCAtMSw2ICsxLDcgQEAKIC8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wLW9ubHkKICNpbmNsdWRlICJzdG1tYWMuaCIKICNpbmNsdWRlICJzdG1t YWNfcGNzLmgiCisjaW5jbHVkZSAic3RtbWFjX3NlcmRlcy5oIgogCiAvKgogICogR01BQ19BTl9T VEFUVVMgaXMgZXF1aXZhbGVudCB0byBNSUlfQk1TUgpAQCAtNjAsOCArNjEsMTQgQEAgc3RhdGlj IHVuc2lnbmVkIGludCBkd21hY19pbnRlZ3JhdGVkX3Bjc19pbmJhbmRfY2FwcyhzdHJ1Y3QgcGh5 bGlua19wY3MgKnBjcywKIHN0YXRpYyBpbnQgZHdtYWNfaW50ZWdyYXRlZF9wY3NfZW5hYmxlKHN0 cnVjdCBwaHlsaW5rX3BjcyAqcGNzKQogewogCXN0cnVjdCBzdG1tYWNfcGNzICpzcGNzID0gcGh5 bGlua19wY3NfdG9fc3RtbWFjX3BjcyhwY3MpOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9 IHNwY3MtPnByaXY7CisJaW50IHJldDsKIAotCXN0bW1hY19tYWNfaXJxX21vZGlmeShzcGNzLT5w cml2LCAwLCBzcGNzLT5pbnRfbWFzayk7CisJcmV0ID0gZHdtYWNfc2VyZGVzX3Bvd2VyX29uKHBy aXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlzdG1tYWNfbWFjX2lycV9tb2RpZnko cHJpdiwgMCwgc3Bjcy0+aW50X21hc2spOwogCiAJcmV0dXJuIDA7CiB9CkBAIC02OSw4ICs3Niwx MSBAQCBzdGF0aWMgaW50IGR3bWFjX2ludGVncmF0ZWRfcGNzX2VuYWJsZShzdHJ1Y3QgcGh5bGlu a19wY3MgKnBjcykKIHN0YXRpYyB2b2lkIGR3bWFjX2ludGVncmF0ZWRfcGNzX2Rpc2FibGUoc3Ry dWN0IHBoeWxpbmtfcGNzICpwY3MpCiB7CiAJc3RydWN0IHN0bW1hY19wY3MgKnNwY3MgPSBwaHls aW5rX3Bjc190b19zdG1tYWNfcGNzKHBjcyk7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0g c3Bjcy0+cHJpdjsKKworCXN0bW1hY19tYWNfaXJxX21vZGlmeShwcml2LCBzcGNzLT5pbnRfbWFz aywgMCk7CiAKLQlzdG1tYWNfbWFjX2lycV9tb2RpZnkoc3Bjcy0+cHJpdiwgc3Bjcy0+aW50X21h c2ssIDApOworCWR3bWFjX3NlcmRlc19wb3dlcl9vZmYocHJpdik7CiB9CiAKIHN0YXRpYyB2b2lk IGR3bWFjX2ludGVncmF0ZWRfcGNzX2dldF9zdGF0ZShzdHJ1Y3QgcGh5bGlua19wY3MgKnBjcywK QEAgLTIyMCw2ICsyMzAsMjIgQEAgaW50IHN0bW1hY19pbnRlZ3JhdGVkX3Bjc19nZXRfcGh5X2lu dGZfc2VsKHN0cnVjdCBwaHlsaW5rX3BjcyAqcGNzLAogCXJldHVybiAtRUlOVkFMOwogfQogCitz dGF0aWMgdm9pZCBzdG1tYWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChzdHJ1Y3Qgc3Rt bWFjX3ByaXYgKnByaXYsCisJCQkJCQlzdHJ1Y3Qgc3RtbWFjX3BjcyAqc3BjcywKKwkJCQkJCXBo eV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UsCisJCQkJCQl1bnNpZ25lZCBpbnQgZmxhZykKK3sKKwli b29sIHN1cHBvcnRlZDsKKworCWlmIChwcml2LT5wbGF0LT5zZXJkZXMpCisJCXN1cHBvcnRlZCA9 IGR3bWFjX3NlcmRlc192YWxpZGF0ZShwcml2LCBpbnRlcmZhY2UpID09IDA7CisJZWxzZQorCQlz dXBwb3J0ZWQgPSAhZmxhZyB8fCBwcml2LT5wbGF0LT5mbGFncyAmIGZsYWc7CisKKwlpZiAoc3Vw cG9ydGVkKQorCQlfX3NldF9iaXQoaW50ZXJmYWNlLCBzcGNzLT5wY3Muc3VwcG9ydGVkX2ludGVy ZmFjZXMpOworfQorCiBpbnQgc3RtbWFjX2ludGVncmF0ZWRfcGNzX2luaXQoc3RydWN0IHN0bW1h Y19wcml2ICpwcml2LAogCQkJICAgICAgIGNvbnN0IHN0cnVjdCBzdG1tYWNfcGNzX2luZm8gKnBj c19pbmZvKQogewpAQCAtMjQzLDEzICsyNjksMTMgQEAgaW50IHN0bW1hY19pbnRlZ3JhdGVkX3Bj c19pbml0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwKIAlpZiAocmVhZGwoc3Bjcy0+YmFzZSAr IEdNQUNfQU5fU1RBVFVTKSAmIEJNU1JfRVNUQVRFTikKIAkJc3Bjcy0+c3VwcG9ydF90YmlfcnRi aSA9IHRydWU7CiAKLQlfX3NldF9iaXQoUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJLCBzcGNzLT5w Y3Muc3VwcG9ydGVkX2ludGVyZmFjZXMpOwotCV9fc2V0X2JpdChQSFlfSU5URVJGQUNFX01PREVf MTAwMEJBU0VYLCBzcGNzLT5wY3Muc3VwcG9ydGVkX2ludGVyZmFjZXMpOwotCi0JLyogT25seSBh bGxvdyAyNTAwQkFTRS1YIGlmIHRoZSBTZXJEZXMgaGFzIHN1cHBvcnQuICovCi0JaWYgKHByaXYt PnBsYXQtPmZsYWdzICYgU1RNTUFDX0ZMQUdfU0VSREVTX1NVUFBPUlRTXzI1MDBNKQotCQlfX3Nl dF9iaXQoUEhZX0lOVEVSRkFDRV9NT0RFXzI1MDBCQVNFWCwKLQkJCSAgc3Bjcy0+cGNzLnN1cHBv cnRlZF9pbnRlcmZhY2VzKTsKKwlzdG1tYWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChw cml2LCBzcGNzLAorCQkJCQkgICAgUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJLCAwKTsKKwlzdG1t YWNfaW50ZWdyYXRlZF9wY3NfY2hlY2tfc3VwcG9ydChwcml2LCBzcGNzLAorCQkJCQkgICAgUEhZ X0lOVEVSRkFDRV9NT0RFXzEwMDBCQVNFWCwgMCk7CisJc3RtbWFjX2ludGVncmF0ZWRfcGNzX2No ZWNrX3N1cHBvcnQocHJpdiwgc3BjcywKKwkJCQkJICAgIFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAw QkFTRVgsCisJCQkJCSAgICBTVE1NQUNfRkxBR19TRVJERVNfU1VQUE9SVFNfMjUwME0pOwogCiAJ cHJpdi0+aW50ZWdyYXRlZF9wY3MgPSBzcGNzOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9l dGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMgYi9kcml2ZXJzL25ldC9ldGhl cm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5hNzY3YzA1NTM2MDQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfc2VyZGVzLmMKQEAgLTAsMCAr MSw5MiBAQAorI2luY2x1ZGUgPGxpbnV4L3BoeS9waHkuaD4KKworI2luY2x1ZGUgInN0bW1hYy5o IgorI2luY2x1ZGUgInN0bW1hY19zZXJkZXMuaCIKKworc3RhdGljIGJvb2wgZHdtYWNfaGFzX3Nl cmRlcyhzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJaWYgKHByaXYtPnBsYXQtPmNvcmVf dHlwZSA9PSBEV01BQ19DT1JFX1hHTUFDKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gcHJp di0+ZG1hX2NhcC5hY3RwaHlpZiA9PSBQSFlfSU5URl9TRUxfU0dNSUkgfHwKKwkgICAgICAgcHJp di0+ZG1hX2NhcC5hY3RwaHlpZiA9PSBQSFlfSU5URl9TRUxfVEJJIHx8CisJICAgICAgIHByaXYt PmRtYV9jYXAuYWN0cGh5aWYgPT0gUEhZX0lOVEZfU0VMX1JUQkk7Cit9CisKK2ludCBkd21hY19z ZXJkZXNfdmFsaWRhdGUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBwaHlfaW50ZXJmYWNlX3Qg aW50ZXJmYWNlKQoreworCXN0cnVjdCBwaHkgKnNlcmRlcyA9IHByaXYtPnBsYXQtPnNlcmRlczsK KworCXJldHVybiBwaHlfdmFsaWRhdGUoc2VyZGVzLCBQSFlfTU9ERV9FVEhFUk5FVCwgaW50ZXJm YWNlLCBOVUxMKTsKK30KKworaW50IGR3bWFjX3NlcmRlc19pbml0KHN0cnVjdCBzdG1tYWNfcHJp diAqcHJpdikKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMgPSBwcml2LT5wbGF0LT5zZXJkZXM7CisJ aW50IHJldDsKKworCXJldCA9IHBoeV9pbml0KHNlcmRlcyk7CisJaWYgKHJldCkKKwkJZGV2X2Vy cihwcml2LT5kZXZpY2UsICJmYWlsZWQgdG8gaW5pdGlhbGl6ZSBTZXJEZXM6ICVwZVxuIiwKKwkJ CUVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQgZHdtYWNfc2VyZGVzX3Bv d2VyX29uKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMg PSBwcml2LT5wbGF0LT5zZXJkZXM7CisJaW50IHJldDsKKworCWlmICghZHdtYWNfaGFzX3NlcmRl cyhwcml2KSkKKwkJcmV0dXJuIDA7CisKKwlyZXQgPSBwaHlfcG93ZXJfb24oc2VyZGVzKTsKKwlp ZiAocmV0KQorCQlkZXZfZXJyKHByaXYtPmRldmljZSwgImZhaWxlZCB0byBwb3dlciBvbiBTZXJE ZXM6ICVwZVxuIiwKKwkJCUVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQg ZHdtYWNfc2VyZGVzX3NldF9tb2RlKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwgcGh5X2ludGVy ZmFjZV90IGludGVyZmFjZSkKK3sKKwlzdHJ1Y3QgcGh5ICpzZXJkZXMgPSBwcml2LT5wbGF0LT5z ZXJkZXM7CisJaW50IHJldDsKKworCWlmICghZHdtYWNfaGFzX3NlcmRlcyhwcml2KSkKKwkJcmV0 dXJuIDA7CisKKwlyZXQgPSBwaHlfc2V0X21vZGVfZXh0KHNlcmRlcywgUEhZX01PREVfRVRIRVJO RVQsIGludGVyZmFjZSk7CisJaWYgKHJldCkKKwkJZGV2X2Vycihwcml2LT5kZXZpY2UsCisJCQki ZmFpbGVkIHRvIHNldCBTZXJEZXMgbW9kZSAlczogJXBlXG4iLAorCQkJcGh5X21vZGVzKGludGVy ZmFjZSksIEVSUl9QVFIocmV0KSk7CisKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIGR3bWFjX3Nl cmRlc19wb3dlcl9vZmYoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQoreworCXN0cnVjdCBwaHkg KnNlcmRlcyA9IHByaXYtPnBsYXQtPnNlcmRlczsKKwlpbnQgcmV0OworCisJaWYgKCFkd21hY19o YXNfc2VyZGVzKHByaXYpKQorCQlyZXR1cm47CisKKwlyZXQgPSBwaHlfcG93ZXJfb2ZmKHNlcmRl cyk7CisJaWYgKHJldCkKKwkJZGV2X2Vycihwcml2LT5kZXZpY2UsICJmYWlsZWQgdG8gcG93ZXIg b2ZmIFNlckRlczogJXBlXG4iLAorCQkJRVJSX1BUUihyZXQpKTsKK30KKwordm9pZCBkd21hY19z ZXJkZXNfZXhpdChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJc3RydWN0IHBoeSAqc2Vy ZGVzID0gcHJpdi0+cGxhdC0+c2VyZGVzOworCWludCByZXQ7CisKKwlyZXQgPSBwaHlfZXhpdChz ZXJkZXMpOworCWlmIChyZXQpCisJCWRldl9lcnIocHJpdi0+ZGV2aWNlLCAiZmFpbGVkIHRvIHNo dXRkb3duIFNlckRlczogJXBlXG4iLAorCQkJRVJSX1BUUihyZXQpKTsKK30KZGlmZiAtLWdpdCBh L2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJkZXMuaCBiL2Ry aXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJkZXMuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjJjYTM3YTdkMGZkZQotLS0gL2Rldi9u dWxsCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19zZXJk ZXMuaApAQCAtMCwwICsxLDE1IEBACisjaWZuZGVmIFNUTU1BQ19TRVJERVNfSAorI2RlZmluZSBT VE1NQUNfU0VSREVTX0gKKworI2luY2x1ZGUgPGxpbnV4L3BoeS5oPgorCitzdHJ1Y3Qgc3RtbWFj X3ByaXY7CisKK2ludCBkd21hY19zZXJkZXNfdmFsaWRhdGUoc3RydWN0IHN0bW1hY19wcml2ICpw cml2LCBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKTsKK2ludCBkd21hY19zZXJkZXNfaW5pdChz dHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpOworaW50IGR3bWFjX3NlcmRlc19wb3dlcl9vbihzdHJ1 Y3Qgc3RtbWFjX3ByaXYgKnByaXYpOworaW50IGR3bWFjX3NlcmRlc19zZXRfbW9kZShzdHJ1Y3Qg c3RtbWFjX3ByaXYgKnByaXYsIHBoeV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UpOwordm9pZCBkd21h Y19zZXJkZXNfcG93ZXJfb2ZmKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdik7Cit2b2lkIGR3bWFj X3NlcmRlc19leGl0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdik7CisKKyNlbmRpZgpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9zdG1tYWMuaCBiL2luY2x1ZGUvbGludXgvc3RtbWFjLmgKaW5k ZXggYThlOWI1ZDMyODlmLi5iZWRiYTRlMjMwODggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv c3RtbWFjLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdG1tYWMuaApAQCAtMjE2LDYgKzIxNiw3IEBA IGVudW0gZHdtYWNfY29yZV90eXBlIHsKICNkZWZpbmUgU1RNTUFDX0ZMQUdfU0VSREVTX1NVUFBP UlRTXzI1MDBNCUJJVCgxNSkKIAogc3RydWN0IG1hY19kZXZpY2VfaW5mbzsKK3N0cnVjdCBwaHk7 CiAKIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0YSB7CiAJZW51bSBkd21hY19jb3JlX3R5cGUg Y29yZV90eXBlOwpAQCAtMjQ1LDYgKzI0Niw3IEBAIHN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0 YSB7CiAJICogdGhhdCBwaHlsaW5rIHVzZXMuCiAJICovCiAJcGh5X2ludGVyZmFjZV90IHBoeV9p bnRlcmZhY2U7CisJc3RydWN0IHBoeSAqc2VyZGVzOwogCXN0cnVjdCBzdG1tYWNfbWRpb19idXNf ZGF0YSAqbWRpb19idXNfZGF0YTsKIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKnBoeV9ub2RlOwogCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbWRpb19ub2RlOwotLSAKMi40Ny4zCgoKCkZyb206ICJSdXNzZWxs IEtpbmcgKE9yYWNsZSkiIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KU3ViamVjdDogW1BB VENIIG5ldC1uZXh0XSBuZXQ6IHN0bW1hYzogcWNvbS1ldGhxb3M6IGNvbnZlcnQgdG8gZHdtYWMg Y29yZQogU2VyRGVzIHN1cHBvcnQKCkNvbnZlcnQgcWNvbS1ldGhxb3MgdG8gdXNlIHRoZSBkd21h YyBjb3JlJ3MgZ2VuZXJpYyBTZXJEZXMgc3VwcG9ydCwKd2hpY2ggd2lsbCBoYW5kbGUgU2VyRGVz IGluaXRpYWxpc2F0aW9uLCBwb3dlcmluZywgYW5kIG1vZGUgc2V0dGluZy4KCk5vdGUgdGhhdCBn ZW5lcmljIHN1cHBvcnQgcmVxdWlyZXMgdGhlIFNlckRlcyB0byBzdXBwb3J0IHBoeV92YWxpZGF0 ZSgpCmluIG9yZGVyIHRvIHByb2JlIHdoaWNoIFBIWSBpbnRlcmZhY2UgbW9kZXMgYXJlIHN1cHBv cnRlZCwgYW5kCnBoeV9zZXRfbW9kZV9leHQoKSB0byBjb25maWd1cmUgdGhlIGFwcHJvcHJpYXRl IFBIWSBpbnRlcmZhY2UgbW9kZQooYW5kIHRodXMgdGhlIHNwZWVkLikKClNpZ25lZC1vZmYtYnk6 IFJ1c3NlbGwgS2luZyAoT3JhY2xlKSA8cm1rK2tlcm5lbEBhcm1saW51eC5vcmcudWs+Ci0tLQog Li4uL3N0bWljcm8vc3RtbWFjL2R3bWFjLXFjb20tZXRocW9zLmMgICAgICAgIHwgNDUgKystLS0t LS0tLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKSwgNDEgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMv ZHdtYWMtcWNvbS1ldGhxb3MuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFj L2R3bWFjLXFjb20tZXRocW9zLmMKaW5kZXggOWEyMTk0ZmNjYjliLi5hNDBhNGJjYTE5N2QgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjLXFjb20t ZXRocW9zLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMt cWNvbS1ldGhxb3MuYwpAQCAtMTA0LDcgKzEwNCw2IEBAIHN0cnVjdCBxY29tX2V0aHFvcyB7CiAJ CQkgICAgICAgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSwgaW50IHNwZWVkKTsKIAogCXN0cnVj dCBjbGsgKmxpbmtfY2xrOwotCXN0cnVjdCBwaHkgKnNlcmRlc19waHk7CiAJcGh5X2ludGVyZmFj ZV90IHBoeV9tb2RlOwogCiAJY29uc3Qgc3RydWN0IGV0aHFvc19lbWFjX3BvciAqcmdtaWlfcG9y OwpAQCAtNjI3LDQ1ICs2MjYsMTUgQEAgc3RhdGljIHZvaWQgZXRocW9zX2ZpeF9tYWNfc3BlZWQo dm9pZCAqcHJpdiwgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSwKIAlldGhxb3NfY29uZmlndXJl KGV0aHFvcywgaW50ZXJmYWNlLCBzcGVlZCk7CiB9CiAKLXN0YXRpYyBpbnQgcWNvbV9ldGhxb3Nf c2VyZGVzX3Bvd2VydXAoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnByaXYpCi17Ci0J c3RydWN0IHFjb21fZXRocW9zICpldGhxb3MgPSBwcml2OwotCWludCByZXQ7Ci0KLQlyZXQgPSBw aHlfaW5pdChldGhxb3MtPnNlcmRlc19waHkpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0K LQlyZXQgPSBwaHlfcG93ZXJfb24oZXRocW9zLT5zZXJkZXNfcGh5KTsKLQlpZiAocmV0KQotCQlw aHlfZXhpdChldGhxb3MtPnNlcmRlc19waHkpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGlj IHZvaWQgcWNvbV9ldGhxb3Nfc2VyZGVzX3Bvd2VyZG93bihzdHJ1Y3QgbmV0X2RldmljZSAqbmRl diwgdm9pZCAqcHJpdikKLXsKLQlzdHJ1Y3QgcWNvbV9ldGhxb3MgKmV0aHFvcyA9IHByaXY7Ci0K LQlwaHlfcG93ZXJfb2ZmKGV0aHFvcy0+c2VyZGVzX3BoeSk7Ci0JcGh5X2V4aXQoZXRocW9zLT5z ZXJkZXNfcGh5KTsKLX0KLQogc3RhdGljIGludCBldGhxb3NfbWFjX2ZpbmlzaF9zZXJkZXMoc3Ry dWN0IG5ldF9kZXZpY2UgKm5kZXYsIHZvaWQgKnByaXYsCiAJCQkJICAgIHVuc2lnbmVkIGludCBt b2RlLAogCQkJCSAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQogewogCXN0cnVjdCBxY29t X2V0aHFvcyAqZXRocW9zID0gcHJpdjsKLQlpbnQgcmV0ID0gMDsKIAogCXFjb21fZXRocW9zX3Nl dF9zZ21paV9sb29wYmFjayhldGhxb3MsIGZhbHNlKTsKIAotCWlmIChpbnRlcmZhY2UgPT0gUEhZ X0lOVEVSRkFDRV9NT0RFX1NHTUlJIHx8Ci0JICAgIGludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNF X01PREVfMjUwMEJBU0VYKQotCQlyZXQgPSBwaHlfc2V0X21vZGVfZXh0KGV0aHFvcy0+c2VyZGVz X3BoeSwgUEhZX01PREVfRVRIRVJORVQsCi0JCQkJICAgICAgIGludGVyZmFjZSk7Ci0KLQlyZXR1 cm4gcmV0OworCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IGV0aHFvc19jbGtzX2NvbmZpZyh2 b2lkICpwcml2LCBib29sIGVuYWJsZWQpCkBAIC03ODksOSArNzU4LDkgQEAgc3RhdGljIGludCBx Y29tX2V0aHFvc19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChyZXQp CiAJCXJldHVybiByZXQ7CiAKLQlldGhxb3MtPnNlcmRlc19waHkgPSBkZXZtX3BoeV9vcHRpb25h bF9nZXQoZGV2LCAic2VyZGVzIik7Ci0JaWYgKElTX0VSUihldGhxb3MtPnNlcmRlc19waHkpKQot CQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIoZXRocW9zLT5zZXJkZXNfcGh5KSwK KwlwbGF0X2RhdC0+c2VyZGVzID0gZGV2bV9waHlfb3B0aW9uYWxfZ2V0KGRldiwgInNlcmRlcyIp OworCWlmIChJU19FUlIocGxhdF9kYXQtPnNlcmRlcykpCisJCXJldHVybiBkZXZfZXJyX3Byb2Jl KGRldiwgUFRSX0VSUihwbGF0X2RhdC0+c2VyZGVzKSwKIAkJCQkgICAgICJGYWlsZWQgdG8gZ2V0 IHNlcmRlcyBwaHlcbiIpOwogCiAJZXRocW9zX3NldF9jbGtfdHhfcmF0ZShldGhxb3MsIE5VTEws IHBsYXRfZGF0LT5waHlfaW50ZXJmYWNlLApAQCAtODE2LDEyICs3ODUsNiBAQCBzdGF0aWMgaW50 IHFjb21fZXRocW9zX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKGRh dGEtPmRtYV9hZGRyX3dpZHRoKQogCQlwbGF0X2RhdC0+aG9zdF9kbWFfd2lkdGggPSBkYXRhLT5k bWFfYWRkcl93aWR0aDsKIAotCWlmIChldGhxb3MtPnNlcmRlc19waHkpIHsKLQkJcGxhdF9kYXQt PnNlcmRlc19wb3dlcnVwID0gcWNvbV9ldGhxb3Nfc2VyZGVzX3Bvd2VydXA7Ci0JCXBsYXRfZGF0 LT5zZXJkZXNfcG93ZXJkb3duICA9IHFjb21fZXRocW9zX3NlcmRlc19wb3dlcmRvd247Ci0JCXBs YXRfZGF0LT5mbGFncyB8PSBTVE1NQUNfRkxBR19TRVJERVNfU1VQUE9SVFNfMjUwME07Ci0JfQot CiAJLyogRW5hYmxlIFRTTyBvbiBxdWV1ZTAgYW5kIGVuYWJsZSBUQlMgb24gcmVzdCBvZiB0aGUg cXVldWVzICovCiAJZm9yIChpID0gMTsgaSA8IHBsYXRfZGF0LT50eF9xdWV1ZXNfdG9fdXNlOyBp KyspCiAJCXBsYXRfZGF0LT50eF9xdWV1ZXNfY2ZnW2ldLnRic19lbiA9IDE7Ci0tIAoyLjQ3LjMK CgotLSAKUk1LJ3MgUGF0Y2ggc3lzdGVtOiBodHRwczovL3d3dy5hcm1saW51eC5vcmcudWsvZGV2 ZWxvcGVyL3BhdGNoZXMvCkZUVFAgaXMgaGVyZSEgODBNYnBzIGRvd24gMTBNYnBzIHVwLiBEZWNl bnQgY29ubmVjdGl2aXR5IGF0IGxhc3QhCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlz dHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LXJpc2N2Cg==