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 01067FF887E for ; Wed, 29 Apr 2026 01:06:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To: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=8aJgie6zMTtvjn865beHqyfVSRNxA89z4rM6r8PB1kg=; b=06A0jhro90vs68nRDA7duuEuoA 5n6RPjbq7t0KUVzMQOXWe/gacznuVcruw7e/WoX6H/wsvuTZVI6i925jFfBf/rEMXDKsvufV1ZWRD PC5uEd/XLk7SeLmxGl99fODOK8Kj6VsBz0nwg3k8xQuqNZagUWugL/epT3Oxj3DLhZNiR3W64Li6n XeM5Mx69s+MpC4QWMNDLXQP5eRfhk79L2Mx/iUjL/ucQYSzJt5tNbvnHTbc8yuYsThHBJiP4CTG3H FIxHwqxlRaFT3RSc3Dn+lxq85Uxjs6AW1uKuLFaX8a0PrjdkfQv7QwBPqYxLMYJOewL/z6/4OCOuV py4ZzNbg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1wHtNm-00000002gqC-3VWG; Wed, 29 Apr 2026 01:06:30 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1wHtNk-00000002gps-3qSm; Wed, 29 Apr 2026 01:06:29 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id C16C56015B; Wed, 29 Apr 2026 01:06:27 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 506A3C2BCB7; Wed, 29 Apr 2026 01:06:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1777424787; bh=Xxrd0KVB9QYgYHmSehbX4FGUyhOGOqhtmad+b+hyHQU=; h=Date:From:To:Cc:Subject:In-Reply-To:References:From; b=FTIePY1KYIGjuALHWVK25ANCyWGrczUVdCjVhrVEidGTyuzd5zP0i7r4HYSZbHXlc 2c6rOe63916uRvcVFZBFZSmATqVqQCe43XZcQMOw9sSjmaDOmiUKhZyEpuIzIjGjUG fegeXMMBvM1E1hZeOq+uoJHMwHz3T7iz0UnYtV1hbWhKeotUbi9kPjC+8qlvHwnvjs dlOd2urUos2JNtHCC9F3+hrLAhbYjhnHDwggrE9fqhYesdAbeRsYiIlxc75W2vGcuj vKneQ+AWmIzzZoX4ZqwCvqppdrXIL+rjB9RPJgezSfWxEEFuq5/sqWa9cFvQ0MTx1R drjDD77m0+PTg== Date: Tue, 28 Apr 2026 18:06:25 -0700 From: Jakub Kicinski To: lizhi2@eswincomputing.com Cc: devicetree@vger.kernel.org, andrew+netdev@lunn.ch, davem@davemloft.net, edumazet@google.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, netdev@vger.kernel.org, pabeni@redhat.com, mcoquelin.stm32@gmail.com, alexandre.torgue@foss.st.com, rmk+kernel@armlinux.org.uk, pjw@kernel.org, palmer@dabbelt.com, aou@eecs.berkeley.edu, alex@ghiti.fr, linux-riscv@lists.infradead.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, maxime.chevallier@bootlin.com, ningyu@eswincomputing.com, linmin@eswincomputing.com, pinkesh.vaghela@einfochips.com, pritesh.patel@einfochips.com, weishangjuan@eswincomputing.com, horms@kernel.org Subject: Re: [PATCH net-next v7 2/4] net: stmmac: eic7700: enable clocks before syscon access and correct RX sampling timing Message-ID: <20260428180625.738223cf@kernel.org> In-Reply-To: <20260427072508.1151-1-lizhi2@eswincomputing.com> References: <20260427072353.1114-1-lizhi2@eswincomputing.com> <20260427072508.1151-1-lizhi2@eswincomputing.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org On Mon, 27 Apr 2026 15:25:05 +0800 lizhi2@eswincomputing.com wrote: > From: Zhi Li >=20 > The second Ethernet controller (eth1) on the Eswin EIC7700 SoC may fail > to sample RX data correctly at Gigabit speed due to EIC7700-specific > receive clock to data skew at the MAC input in the silicon. >=20 > The existing internal delay configuration does not provide sufficient > adjustment range to compensate for this condition at 1000Mbps. > Update the EIC7700 DWMAC glue driver to apply EIC7700-specific clock > sampling inversion only during Gigabit operation on MAC instances > that require it. >=20 > TXD and RXD delay registers are explicitly cleared during initialization > to override any residual configuration left by the bootloader. All HSP > CSR register accesses are performed only after the required clocks are > enabled. >=20 > Fixes: ea77dbbdbc4e ("net: stmmac: add Eswin EIC7700 glue driver") Why Fixes? If eth1 never worked this is not a fix but new functionality If you want to make this a fix to prevent incompatibility - cut it down just to the eth0 changes. > Signed-off-by: Zhi Li > --- > .../ethernet/stmicro/stmmac/dwmac-eic7700.c | 183 ++++++++++++++---- > 1 file changed, 140 insertions(+), 43 deletions(-) >=20 > diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-eic7700.c b/driver= s/net/ethernet/stmicro/stmmac/dwmac-eic7700.c > index bcb8e000e720..33144611da8d 100644 > --- a/drivers/net/ethernet/stmicro/stmmac/dwmac-eic7700.c > +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-eic7700.c > @@ -28,20 +28,40 @@ > =20 > /* > * TX/RX Clock Delay Bit Masks: > - * - TX Delay: bits [14:8] =E2=80=94 TX_CLK delay (unit: 0.1ns per bit) > - * - RX Delay: bits [30:24] =E2=80=94 RX_CLK delay (unit: 0.1ns per bit) > + * - TX Delay: bits [14:8] =E2=80=94 TX_CLK delay (unit: 0.02ns per bit) > + * - TX Invert : bit [15] > + * - RX Delay: bits [30:24] =E2=80=94 RX_CLK delay (unit: 0.02ns per bit) > + * - RX Invert : bit [31] > */ > #define EIC7700_ETH_TX_ADJ_DELAY GENMASK(14, 8) > #define EIC7700_ETH_RX_ADJ_DELAY GENMASK(30, 24) > +#define EIC7700_ETH_TX_INV_DELAY BIT(15) > +#define EIC7700_ETH_RX_INV_DELAY BIT(31) > =20 > -#define EIC7700_MAX_DELAY_UNIT 0x7F > +#define EIC7700_MAX_DELAY_STEPS 0x7F > +#define EIC7700_DELAY_STEP_PS 20 > +#define EIC7700_MAX_DELAY_PS \ > + (EIC7700_MAX_DELAY_STEPS * EIC7700_DELAY_STEP_PS) AI says: The step unit is being silently changed from 0.1 ns (delay_ps / 100) to 0.02 ns (delay_ps / 20). The same DT value now programs 5x the number of delay steps into the hardware. > static const char * const eic7700_clk_names[] =3D { > "tx", "axi", "cfg", > }; > =20 > +struct eic7700_dwmac_data { > + bool rgmii_rx_clk_invert; > +}; > + > struct eic7700_qos_priv { > + struct device *dev; > struct plat_stmmacenet_data *plat_dat; > + struct regmap *eic7700_hsp_regmap; > + u32 eth_axi_lp_ctrl_offset; > + u32 eth_phy_ctrl_offset; > + u32 eth_txd_offset; > + u32 eth_clk_offset; > + u32 eth_rxd_offset; > + u32 eth_clk_dly_param; > + bool eth_rx_clk_inv; > }; > =20 > static int eic7700_clks_config(void *priv, bool enabled) > @@ -61,8 +81,28 @@ static int eic7700_clks_config(void *priv, bool enable= d) > static int eic7700_dwmac_init(struct device *dev, void *priv) > { > struct eic7700_qos_priv *dwc =3D priv; > + int ret; > + > + ret =3D eic7700_clks_config(dwc, true); > + if (ret) > + return ret; > + > + ret =3D regmap_set_bits(dwc->eic7700_hsp_regmap, > + dwc->eth_phy_ctrl_offset, > + EIC7700_ETH_TX_CLK_SEL | > + EIC7700_ETH_PHY_INTF_SELI); > + if (ret) { > + eic7700_clks_config(dwc, false); > + return ret; > + } > + > + regmap_write(dwc->eic7700_hsp_regmap, dwc->eth_axi_lp_ctrl_offset, > + EIC7700_ETH_CSYSREQ_VAL); > + > + regmap_write(dwc->eic7700_hsp_regmap, dwc->eth_txd_offset, 0); > + regmap_write(dwc->eic7700_hsp_regmap, dwc->eth_rxd_offset, 0); > =20 > - return eic7700_clks_config(dwc, true); > + return 0; > } > =20 > static void eic7700_dwmac_exit(struct device *dev, void *priv) > @@ -88,18 +128,35 @@ static int eic7700_dwmac_resume(struct device *dev, = void *priv) > return ret; > } > =20 > +static void eic7700_dwmac_fix_speed(void *priv, phy_interface_t interfac= e, > + int speed, unsigned int mode) > +{ > + struct eic7700_qos_priv *dwc =3D (struct eic7700_qos_priv *)priv; > + u32 dly_param =3D dwc->eth_clk_dly_param; > + > + switch (speed) { > + case SPEED_1000: > + if (dwc->eth_rx_clk_inv) > + dly_param |=3D EIC7700_ETH_RX_INV_DELAY; > + break; > + case SPEED_100: > + case SPEED_10: > + break; > + default: > + dev_err(dwc->dev, "invalid speed %u\n", speed); > + break; > + } > + > + regmap_write(dwc->eic7700_hsp_regmap, dwc->eth_clk_offset, dly_param); AI says In the default case this logs "invalid speed %u" but then falls through and still executes the regmap_write() with the base dly_param. An unsupported speed reports an error and reprograms the hardware anyway. Should the default path return without writing, or should the write be moved into the valid cases only? > +} > + > static int eic7700_dwmac_probe(struct platform_device *pdev) > { > + const struct eic7700_dwmac_data *data; > struct plat_stmmacenet_data *plat_dat; > struct stmmac_resources stmmac_res; > struct eic7700_qos_priv *dwc_priv; > - struct regmap *eic7700_hsp_regmap; > - u32 eth_axi_lp_ctrl_offset; > - u32 eth_phy_ctrl_offset; > - u32 eth_phy_ctrl_regset; > - u32 eth_rxd_dly_offset; > - u32 eth_dly_param =3D 0; > - u32 delay_ps; > + u32 delay_ps, val; > int i, ret; > =20 > ret =3D stmmac_get_platform_resources(pdev, &stmmac_res); > @@ -116,70 +173,95 @@ static int eic7700_dwmac_probe(struct platform_devi= ce *pdev) > if (!dwc_priv) > return -ENOMEM; > =20 > + dwc_priv->dev =3D &pdev->dev; > + > + data =3D device_get_match_data(&pdev->dev); > + if (!data) > + return dev_err_probe(&pdev->dev, > + -EINVAL, "no match data found\n"); > + > + dwc_priv->eth_rx_clk_inv =3D data->rgmii_rx_clk_invert; > + > /* Read rx-internal-delay-ps and update rx_clk delay */ > if (!of_property_read_u32(pdev->dev.of_node, > "rx-internal-delay-ps", &delay_ps)) { > - u32 val =3D min(delay_ps / 100, EIC7700_MAX_DELAY_UNIT); > + if (delay_ps % EIC7700_DELAY_STEP_PS) > + return dev_err_probe(&pdev->dev, -EINVAL, > + "rx delay must be multiple of %dps\n", > + EIC7700_DELAY_STEP_PS); > + > + if (delay_ps > EIC7700_MAX_DELAY_PS) > + return dev_err_probe(&pdev->dev, -EINVAL, > + "rx delay out of range\n"); > =20 > - eth_dly_param &=3D ~EIC7700_ETH_RX_ADJ_DELAY; > - eth_dly_param |=3D FIELD_PREP(EIC7700_ETH_RX_ADJ_DELAY, val); > - } else { > - return dev_err_probe(&pdev->dev, -EINVAL, > - "missing required property rx-internal-delay-ps\n"); > + val =3D delay_ps / EIC7700_DELAY_STEP_PS; > + > + dwc_priv->eth_clk_dly_param &=3D ~EIC7700_ETH_RX_ADJ_DELAY; > + dwc_priv->eth_clk_dly_param |=3D > + FIELD_PREP(EIC7700_ETH_RX_ADJ_DELAY, val); > } > =20 > /* Read tx-internal-delay-ps and update tx_clk delay */ > if (!of_property_read_u32(pdev->dev.of_node, > "tx-internal-delay-ps", &delay_ps)) { > - u32 val =3D min(delay_ps / 100, EIC7700_MAX_DELAY_UNIT); > + if (delay_ps % EIC7700_DELAY_STEP_PS) > + return dev_err_probe(&pdev->dev, -EINVAL, > + "tx delay must be multiple of %dps\n", > + EIC7700_DELAY_STEP_PS); > + > + if (delay_ps > EIC7700_MAX_DELAY_PS) > + return dev_err_probe(&pdev->dev, -EINVAL, > + "tx delay out of range\n"); > + > + val =3D delay_ps / EIC7700_DELAY_STEP_PS; > =20 > - eth_dly_param &=3D ~EIC7700_ETH_TX_ADJ_DELAY; > - eth_dly_param |=3D FIELD_PREP(EIC7700_ETH_TX_ADJ_DELAY, val); > - } else { > - return dev_err_probe(&pdev->dev, -EINVAL, > - "missing required property tx-internal-delay-ps\n"); > + dwc_priv->eth_clk_dly_param &=3D ~EIC7700_ETH_TX_ADJ_DELAY; > + dwc_priv->eth_clk_dly_param |=3D > + FIELD_PREP(EIC7700_ETH_TX_ADJ_DELAY, val); > } AI says: First, rx-internal-delay-ps and tx-internal-delay-ps are silently demoted from required to optional. The previous driver returned -EINVAL with "missing required property ..." when either was absent; the else branches have been removed, so missing properties now leave eth_clk_dly_param at zero and fix_mac_speed() programs zero delay without diagnostic. Is this intentional, and if so should the commit message and the DT binding reflect it? =20 Second, the previous code silently clamped out-of-range values via min() and only required non-zero step units by integer truncation. The new code rejects non-multiples of 20 and values greater than 2540 ps with -EINVAL at probe time. DTBs that previously probed with clamped delays will now fail probe. Should this stricter validation also be called out in the commit message? > - eic7700_hsp_regmap =3D syscon_regmap_lookup_by_phandle(pdev->dev.of_nod= e, > - "eswin,hsp-sp-csr"); > - if (IS_ERR(eic7700_hsp_regmap)) > + dwc_priv->eic7700_hsp_regmap =3D > + syscon_regmap_lookup_by_phandle(pdev->dev.of_node, > + "eswin,hsp-sp-csr"); > + if (IS_ERR(dwc_priv->eic7700_hsp_regmap)) > return dev_err_probe(&pdev->dev, > - PTR_ERR(eic7700_hsp_regmap), > + PTR_ERR(dwc_priv->eic7700_hsp_regmap), > "Failed to get hsp-sp-csr regmap\n"); > =20 > ret =3D of_property_read_u32_index(pdev->dev.of_node, > "eswin,hsp-sp-csr", > - 1, ð_phy_ctrl_offset); > + 1, &dwc_priv->eth_phy_ctrl_offset); > if (ret) > return dev_err_probe(&pdev->dev, ret, > "can't get eth_phy_ctrl_offset\n"); > =20 > - regmap_read(eic7700_hsp_regmap, eth_phy_ctrl_offset, > - ð_phy_ctrl_regset); > - eth_phy_ctrl_regset |=3D > - (EIC7700_ETH_TX_CLK_SEL | EIC7700_ETH_PHY_INTF_SELI); > - regmap_write(eic7700_hsp_regmap, eth_phy_ctrl_offset, > - eth_phy_ctrl_regset); > - > ret =3D of_property_read_u32_index(pdev->dev.of_node, > "eswin,hsp-sp-csr", > - 2, ð_axi_lp_ctrl_offset); > + 2, &dwc_priv->eth_axi_lp_ctrl_offset); > if (ret) > return dev_err_probe(&pdev->dev, ret, > "can't get eth_axi_lp_ctrl_offset\n"); > =20 > - regmap_write(eic7700_hsp_regmap, eth_axi_lp_ctrl_offset, > - EIC7700_ETH_CSYSREQ_VAL); > + ret =3D of_property_read_u32_index(pdev->dev.of_node, > + "eswin,hsp-sp-csr", > + 3, &dwc_priv->eth_clk_offset); > + if (ret) > + return dev_err_probe(&pdev->dev, ret, > + "can't get eth_clk_offset\n"); > =20 > ret =3D of_property_read_u32_index(pdev->dev.of_node, > "eswin,hsp-sp-csr", > - 3, ð_rxd_dly_offset); > + 4, &dwc_priv->eth_txd_offset); > if (ret) > return dev_err_probe(&pdev->dev, ret, > - "can't get eth_rxd_dly_offset\n"); > + "can't get eth_txd_offset\n"); > =20 > - regmap_write(eic7700_hsp_regmap, eth_rxd_dly_offset, > - eth_dly_param); > + ret =3D of_property_read_u32_index(pdev->dev.of_node, > + "eswin,hsp-sp-csr", > + 5, &dwc_priv->eth_rxd_offset); > + if (ret) > + return dev_err_probe(&pdev->dev, ret, > + "can't get eth_rxd_offset\n"); AI says: The eswin,hsp-sp-csr phandle-args layout is expanded from 4 cells (phandle + 3 offsets) to 6 cells (phandle + 5 offsets), with new indices 3/4/5 now required. Any DTB produced against the original ea77dbbdbc4e binding will fail probe here with -EINVAL. --=20 pw-bot: cr 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 47707FF885A for ; Wed, 29 Apr 2026 01:06:37 +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:MIME-Version:References:In-Reply-To: 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=fehIQjzzw9SDyNmxYb9NmFnMiITNCTM6QzBeGwgdzFY=; b=aNZZmLhlwgfxyT FUS5T0t9VbxSiKGLjDyUevW2Lv+IEHJhCgkloGMGTqOhS48YlYkWpHPDnWpqWu2wF8wWwQ+Zg/HhI SyI9Ywrfl20BX7foxGrKDirZH9EEjCGlWi68QbNYovGU6NWjlyORrousIuLObBMV6550lDn6f/rlV AGidVdn4hR14oolR8Iej0gJCxrmgZwNoaH9rmHR2YZd3flZPUNxbgDAT5a4eCOxdvuArYkUKheOla kxj+T0nrYTCqeCXS40mbqhA4Ob7Hbb8sNTXlcZDSIWTJeHv/M2FDRJlzL44TMMzEMI801At+QdvL+ iYS0TOOVi1m167vIfNPQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1wHtNn-00000002gqI-0W7Y; Wed, 29 Apr 2026 01:06:31 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1wHtNk-00000002gps-3qSm; Wed, 29 Apr 2026 01:06:29 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id C16C56015B; Wed, 29 Apr 2026 01:06:27 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 506A3C2BCB7; Wed, 29 Apr 2026 01:06:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1777424787; bh=Xxrd0KVB9QYgYHmSehbX4FGUyhOGOqhtmad+b+hyHQU=; h=Date:From:To:Cc:Subject:In-Reply-To:References:From; b=FTIePY1KYIGjuALHWVK25ANCyWGrczUVdCjVhrVEidGTyuzd5zP0i7r4HYSZbHXlc 2c6rOe63916uRvcVFZBFZSmATqVqQCe43XZcQMOw9sSjmaDOmiUKhZyEpuIzIjGjUG fegeXMMBvM1E1hZeOq+uoJHMwHz3T7iz0UnYtV1hbWhKeotUbi9kPjC+8qlvHwnvjs dlOd2urUos2JNtHCC9F3+hrLAhbYjhnHDwggrE9fqhYesdAbeRsYiIlxc75W2vGcuj vKneQ+AWmIzzZoX4ZqwCvqppdrXIL+rjB9RPJgezSfWxEEFuq5/sqWa9cFvQ0MTx1R drjDD77m0+PTg== Date: Tue, 28 Apr 2026 18:06:25 -0700 From: Jakub Kicinski To: lizhi2@eswincomputing.com Cc: devicetree@vger.kernel.org, andrew+netdev@lunn.ch, davem@davemloft.net, edumazet@google.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, netdev@vger.kernel.org, pabeni@redhat.com, mcoquelin.stm32@gmail.com, alexandre.torgue@foss.st.com, rmk+kernel@armlinux.org.uk, pjw@kernel.org, palmer@dabbelt.com, aou@eecs.berkeley.edu, alex@ghiti.fr, linux-riscv@lists.infradead.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, maxime.chevallier@bootlin.com, ningyu@eswincomputing.com, linmin@eswincomputing.com, pinkesh.vaghela@einfochips.com, pritesh.patel@einfochips.com, weishangjuan@eswincomputing.com, horms@kernel.org Subject: Re: [PATCH net-next v7 2/4] net: stmmac: eic7700: enable clocks before syscon access and correct RX sampling timing Message-ID: <20260428180625.738223cf@kernel.org> In-Reply-To: <20260427072508.1151-1-lizhi2@eswincomputing.com> References: <20260427072353.1114-1-lizhi2@eswincomputing.com> <20260427072508.1151-1-lizhi2@eswincomputing.com> MIME-Version: 1.0 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 T24gTW9uLCAyNyBBcHIgMjAyNiAxNToyNTowNSArMDgwMCBsaXpoaTJAZXN3aW5jb21wdXRpbmcu Y29tIHdyb3RlOgo+IEZyb206IFpoaSBMaSA8bGl6aGkyQGVzd2luY29tcHV0aW5nLmNvbT4KPiAK PiBUaGUgc2Vjb25kIEV0aGVybmV0IGNvbnRyb2xsZXIgKGV0aDEpIG9uIHRoZSBFc3dpbiBFSUM3 NzAwIFNvQyBtYXkgZmFpbAo+IHRvIHNhbXBsZSBSWCBkYXRhIGNvcnJlY3RseSBhdCBHaWdhYml0 IHNwZWVkIGR1ZSB0byBFSUM3NzAwLXNwZWNpZmljCj4gcmVjZWl2ZSBjbG9jayB0byBkYXRhIHNr ZXcgYXQgdGhlIE1BQyBpbnB1dCBpbiB0aGUgc2lsaWNvbi4KPiAKPiBUaGUgZXhpc3RpbmcgaW50 ZXJuYWwgZGVsYXkgY29uZmlndXJhdGlvbiBkb2VzIG5vdCBwcm92aWRlIHN1ZmZpY2llbnQKPiBh ZGp1c3RtZW50IHJhbmdlIHRvIGNvbXBlbnNhdGUgZm9yIHRoaXMgY29uZGl0aW9uIGF0IDEwMDBN YnBzLgo+IFVwZGF0ZSB0aGUgRUlDNzcwMCBEV01BQyBnbHVlIGRyaXZlciB0byBhcHBseSBFSUM3 NzAwLXNwZWNpZmljIGNsb2NrCj4gc2FtcGxpbmcgaW52ZXJzaW9uIG9ubHkgZHVyaW5nIEdpZ2Fi aXQgb3BlcmF0aW9uIG9uIE1BQyBpbnN0YW5jZXMKPiB0aGF0IHJlcXVpcmUgaXQuCj4gCj4gVFhE IGFuZCBSWEQgZGVsYXkgcmVnaXN0ZXJzIGFyZSBleHBsaWNpdGx5IGNsZWFyZWQgZHVyaW5nIGlu aXRpYWxpemF0aW9uCj4gdG8gb3ZlcnJpZGUgYW55IHJlc2lkdWFsIGNvbmZpZ3VyYXRpb24gbGVm dCBieSB0aGUgYm9vdGxvYWRlci4gQWxsIEhTUAo+IENTUiByZWdpc3RlciBhY2Nlc3NlcyBhcmUg cGVyZm9ybWVkIG9ubHkgYWZ0ZXIgdGhlIHJlcXVpcmVkIGNsb2NrcyBhcmUKPiBlbmFibGVkLgo+ IAo+IEZpeGVzOiBlYTc3ZGJiZGJjNGUgKCJuZXQ6IHN0bW1hYzogYWRkIEVzd2luIEVJQzc3MDAg Z2x1ZSBkcml2ZXIiKQoKV2h5IEZpeGVzPyBJZiBldGgxIG5ldmVyIHdvcmtlZCB0aGlzIGlzIG5v dCBhIGZpeCBidXQgbmV3IGZ1bmN0aW9uYWxpdHkKSWYgeW91IHdhbnQgdG8gbWFrZSB0aGlzIGEg Zml4IHRvIHByZXZlbnQgaW5jb21wYXRpYmlsaXR5IC0gY3V0IGl0IGRvd24KanVzdCB0byB0aGUg ZXRoMCBjaGFuZ2VzLgoKPiBTaWduZWQtb2ZmLWJ5OiBaaGkgTGkgPGxpemhpMkBlc3dpbmNvbXB1 dGluZy5jb20+Cj4gLS0tCj4gIC4uLi9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9kd21hYy1laWM3 NzAwLmMgICB8IDE4MyArKysrKysrKysrKysrKy0tLS0KPiAgMSBmaWxlIGNoYW5nZWQsIDE0MCBp bnNlcnRpb25zKCspLCA0MyBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9u ZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMtZWljNzcwMC5jIGIvZHJpdmVycy9uZXQv ZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMtZWljNzcwMC5jCj4gaW5kZXggYmNiOGUwMDBl NzIwLi4zMzE0NDYxMWRhOGQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3Rt aWNyby9zdG1tYWMvZHdtYWMtZWljNzcwMC5jCj4gKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQv c3RtaWNyby9zdG1tYWMvZHdtYWMtZWljNzcwMC5jCj4gQEAgLTI4LDIwICsyOCw0MCBAQAo+ICAK PiAgLyoKPiAgICogVFgvUlggQ2xvY2sgRGVsYXkgQml0IE1hc2tzOgo+IC0gKiAtIFRYIERlbGF5 OiBiaXRzIFsxNDo4XSDigJQgVFhfQ0xLIGRlbGF5ICh1bml0OiAwLjFucyBwZXIgYml0KQo+IC0g KiAtIFJYIERlbGF5OiBiaXRzIFszMDoyNF0g4oCUIFJYX0NMSyBkZWxheSAodW5pdDogMC4xbnMg cGVyIGJpdCkKPiArICogLSBUWCBEZWxheTogYml0cyBbMTQ6OF0g4oCUIFRYX0NMSyBkZWxheSAo dW5pdDogMC4wMm5zIHBlciBiaXQpCj4gKyAqIC0gVFggSW52ZXJ0IDogYml0ICBbMTVdCj4gKyAq IC0gUlggRGVsYXk6IGJpdHMgWzMwOjI0XSDigJQgUlhfQ0xLIGRlbGF5ICh1bml0OiAwLjAybnMg cGVyIGJpdCkKPiArICogLSBSWCBJbnZlcnQgOiBiaXQgIFszMV0KPiAgICovCj4gICNkZWZpbmUg RUlDNzcwMF9FVEhfVFhfQURKX0RFTEFZCUdFTk1BU0soMTQsIDgpCj4gICNkZWZpbmUgRUlDNzcw MF9FVEhfUlhfQURKX0RFTEFZCUdFTk1BU0soMzAsIDI0KQo+ICsjZGVmaW5lIEVJQzc3MDBfRVRI X1RYX0lOVl9ERUxBWQlCSVQoMTUpCj4gKyNkZWZpbmUgRUlDNzcwMF9FVEhfUlhfSU5WX0RFTEFZ CUJJVCgzMSkKPiAgCj4gLSNkZWZpbmUgRUlDNzcwMF9NQVhfREVMQVlfVU5JVCAweDdGCj4gKyNk ZWZpbmUgRUlDNzcwMF9NQVhfREVMQVlfU1RFUFMJCTB4N0YKPiArI2RlZmluZSBFSUM3NzAwX0RF TEFZX1NURVBfUFMJCTIwCj4gKyNkZWZpbmUgRUlDNzcwMF9NQVhfREVMQVlfUFMJXAo+ICsJKEVJ Qzc3MDBfTUFYX0RFTEFZX1NURVBTICogRUlDNzcwMF9ERUxBWV9TVEVQX1BTKQoKQUkgc2F5czoK CiAgVGhlIHN0ZXAgdW5pdCBpcyBiZWluZyBzaWxlbnRseSBjaGFuZ2VkIGZyb20gMC4xIG5zIChk ZWxheV9wcyAvIDEwMCkKICB0byAwLjAyIG5zIChkZWxheV9wcyAvIDIwKS4gIFRoZSBzYW1lIERU IHZhbHVlIG5vdyBwcm9ncmFtcyA1eCB0aGUgbnVtYmVyCiAgb2YgZGVsYXkgc3RlcHMgaW50byB0 aGUgaGFyZHdhcmUuCgo+ICBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVpYzc3MDBfY2xrX25h bWVzW10gPSB7Cj4gIAkidHgiLCAiYXhpIiwgImNmZyIsCj4gIH07Cj4gIAo+ICtzdHJ1Y3QgZWlj NzcwMF9kd21hY19kYXRhIHsKPiArCWJvb2wgcmdtaWlfcnhfY2xrX2ludmVydDsKPiArfTsKPiAr Cj4gIHN0cnVjdCBlaWM3NzAwX3Fvc19wcml2IHsKPiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPiAg CXN0cnVjdCBwbGF0X3N0bW1hY2VuZXRfZGF0YSAqcGxhdF9kYXQ7Cj4gKwlzdHJ1Y3QgcmVnbWFw ICplaWM3NzAwX2hzcF9yZWdtYXA7Cj4gKwl1MzIgZXRoX2F4aV9scF9jdHJsX29mZnNldDsKPiAr CXUzMiBldGhfcGh5X2N0cmxfb2Zmc2V0Owo+ICsJdTMyIGV0aF90eGRfb2Zmc2V0Owo+ICsJdTMy IGV0aF9jbGtfb2Zmc2V0Owo+ICsJdTMyIGV0aF9yeGRfb2Zmc2V0Owo+ICsJdTMyIGV0aF9jbGtf ZGx5X3BhcmFtOwo+ICsJYm9vbCBldGhfcnhfY2xrX2ludjsKPiAgfTsKPiAgCj4gIHN0YXRpYyBp bnQgZWljNzcwMF9jbGtzX2NvbmZpZyh2b2lkICpwcml2LCBib29sIGVuYWJsZWQpCj4gQEAgLTYx LDggKzgxLDI4IEBAIHN0YXRpYyBpbnQgZWljNzcwMF9jbGtzX2NvbmZpZyh2b2lkICpwcml2LCBi b29sIGVuYWJsZWQpCj4gIHN0YXRpYyBpbnQgZWljNzcwMF9kd21hY19pbml0KHN0cnVjdCBkZXZp Y2UgKmRldiwgdm9pZCAqcHJpdikKPiAgewo+ICAJc3RydWN0IGVpYzc3MDBfcW9zX3ByaXYgKmR3 YyA9IHByaXY7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGVpYzc3MDBfY2xrc19jb25maWco ZHdjLCB0cnVlKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSBy ZWdtYXBfc2V0X2JpdHMoZHdjLT5laWM3NzAwX2hzcF9yZWdtYXAsCj4gKwkJCSAgICAgIGR3Yy0+ ZXRoX3BoeV9jdHJsX29mZnNldCwKPiArCQkJICAgICAgRUlDNzcwMF9FVEhfVFhfQ0xLX1NFTCB8 Cj4gKwkJCSAgICAgIEVJQzc3MDBfRVRIX1BIWV9JTlRGX1NFTEkpOwo+ICsJaWYgKHJldCkgewo+ ICsJCWVpYzc3MDBfY2xrc19jb25maWcoZHdjLCBmYWxzZSk7Cj4gKwkJcmV0dXJuIHJldDsKPiAr CX0KPiArCj4gKwlyZWdtYXBfd3JpdGUoZHdjLT5laWM3NzAwX2hzcF9yZWdtYXAsIGR3Yy0+ZXRo X2F4aV9scF9jdHJsX29mZnNldCwKPiArCQkgICAgIEVJQzc3MDBfRVRIX0NTWVNSRVFfVkFMKTsK PiArCj4gKwlyZWdtYXBfd3JpdGUoZHdjLT5laWM3NzAwX2hzcF9yZWdtYXAsIGR3Yy0+ZXRoX3R4 ZF9vZmZzZXQsIDApOwo+ICsJcmVnbWFwX3dyaXRlKGR3Yy0+ZWljNzcwMF9oc3BfcmVnbWFwLCBk d2MtPmV0aF9yeGRfb2Zmc2V0LCAwKTsKPiAgCj4gLQlyZXR1cm4gZWljNzcwMF9jbGtzX2NvbmZp Zyhkd2MsIHRydWUpOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyB2b2lkIGVpYzc3 MDBfZHdtYWNfZXhpdChzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKnByaXYpCj4gQEAgLTg4LDE4 ICsxMjgsMzUgQEAgc3RhdGljIGludCBlaWM3NzAwX2R3bWFjX3Jlc3VtZShzdHJ1Y3QgZGV2aWNl ICpkZXYsIHZvaWQgKnByaXYpCj4gIAlyZXR1cm4gcmV0Owo+ICB9Cj4gIAo+ICtzdGF0aWMgdm9p ZCBlaWM3NzAwX2R3bWFjX2ZpeF9zcGVlZCh2b2lkICpwcml2LCBwaHlfaW50ZXJmYWNlX3QgaW50 ZXJmYWNlLAo+ICsJCQkJICAgIGludCBzcGVlZCwgdW5zaWduZWQgaW50IG1vZGUpCj4gK3sKPiAr CXN0cnVjdCBlaWM3NzAwX3Fvc19wcml2ICpkd2MgPSAoc3RydWN0IGVpYzc3MDBfcW9zX3ByaXYg Kilwcml2Owo+ICsJdTMyIGRseV9wYXJhbSA9IGR3Yy0+ZXRoX2Nsa19kbHlfcGFyYW07Cj4gKwo+ ICsJc3dpdGNoIChzcGVlZCkgewo+ICsJY2FzZSBTUEVFRF8xMDAwOgo+ICsJCWlmIChkd2MtPmV0 aF9yeF9jbGtfaW52KQo+ICsJCQlkbHlfcGFyYW0gfD0gRUlDNzcwMF9FVEhfUlhfSU5WX0RFTEFZ Owo+ICsJCWJyZWFrOwo+ICsJY2FzZSBTUEVFRF8xMDA6Cj4gKwljYXNlIFNQRUVEXzEwOgo+ICsJ CWJyZWFrOwo+ICsJZGVmYXVsdDoKPiArCQlkZXZfZXJyKGR3Yy0+ZGV2LCAiaW52YWxpZCBzcGVl ZCAldVxuIiwgc3BlZWQpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsKPiArCXJlZ21hcF93cml0ZShk d2MtPmVpYzc3MDBfaHNwX3JlZ21hcCwgZHdjLT5ldGhfY2xrX29mZnNldCwgZGx5X3BhcmFtKTsK CkFJIHNheXMKCiAgSW4gdGhlIGRlZmF1bHQgY2FzZSB0aGlzIGxvZ3MgImludmFsaWQgc3BlZWQg JXUiIGJ1dCB0aGVuIGZhbGxzCiAgdGhyb3VnaCBhbmQgc3RpbGwgZXhlY3V0ZXMgdGhlIHJlZ21h cF93cml0ZSgpIHdpdGggdGhlIGJhc2UgZGx5X3BhcmFtLiAgQW4KICB1bnN1cHBvcnRlZCBzcGVl ZCByZXBvcnRzIGFuIGVycm9yIGFuZCByZXByb2dyYW1zIHRoZSBoYXJkd2FyZSBhbnl3YXkuCgog IFNob3VsZCB0aGUgZGVmYXVsdCBwYXRoIHJldHVybiB3aXRob3V0IHdyaXRpbmcsIG9yIHNob3Vs ZCB0aGUgd3JpdGUgYmUKICBtb3ZlZCBpbnRvIHRoZSB2YWxpZCBjYXNlcyBvbmx5PwoKPiArfQo+ ICsKPiAgc3RhdGljIGludCBlaWM3NzAwX2R3bWFjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCj4gIHsKPiArCWNvbnN0IHN0cnVjdCBlaWM3NzAwX2R3bWFjX2RhdGEgKmRhdGE7 Cj4gIAlzdHJ1Y3QgcGxhdF9zdG1tYWNlbmV0X2RhdGEgKnBsYXRfZGF0Owo+ICAJc3RydWN0IHN0 bW1hY19yZXNvdXJjZXMgc3RtbWFjX3JlczsKPiAgCXN0cnVjdCBlaWM3NzAwX3Fvc19wcml2ICpk d2NfcHJpdjsKPiAtCXN0cnVjdCByZWdtYXAgKmVpYzc3MDBfaHNwX3JlZ21hcDsKPiAtCXUzMiBl dGhfYXhpX2xwX2N0cmxfb2Zmc2V0Owo+IC0JdTMyIGV0aF9waHlfY3RybF9vZmZzZXQ7Cj4gLQl1 MzIgZXRoX3BoeV9jdHJsX3JlZ3NldDsKPiAtCXUzMiBldGhfcnhkX2RseV9vZmZzZXQ7Cj4gLQl1 MzIgZXRoX2RseV9wYXJhbSA9IDA7Cj4gLQl1MzIgZGVsYXlfcHM7Cj4gKwl1MzIgZGVsYXlfcHMs IHZhbDsKPiAgCWludCBpLCByZXQ7Cj4gIAo+ICAJcmV0ID0gc3RtbWFjX2dldF9wbGF0Zm9ybV9y ZXNvdXJjZXMocGRldiwgJnN0bW1hY19yZXMpOwo+IEBAIC0xMTYsNzAgKzE3Myw5NSBAQCBzdGF0 aWMgaW50IGVpYzc3MDBfZHdtYWNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK PiAgCWlmICghZHdjX3ByaXYpCj4gIAkJcmV0dXJuIC1FTk9NRU07Cj4gIAo+ICsJZHdjX3ByaXYt PmRldiA9ICZwZGV2LT5kZXY7Cj4gKwo+ICsJZGF0YSA9IGRldmljZV9nZXRfbWF0Y2hfZGF0YSgm cGRldi0+ZGV2KTsKPiArCWlmICghZGF0YSkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmcGRl di0+ZGV2LAo+ICsJCQkJICAgICAtRUlOVkFMLCAibm8gbWF0Y2ggZGF0YSBmb3VuZFxuIik7Cj4g Kwo+ICsJZHdjX3ByaXYtPmV0aF9yeF9jbGtfaW52ID0gZGF0YS0+cmdtaWlfcnhfY2xrX2ludmVy dDsKPiArCj4gIAkvKiBSZWFkIHJ4LWludGVybmFsLWRlbGF5LXBzIGFuZCB1cGRhdGUgcnhfY2xr IGRlbGF5ICovCj4gIAlpZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKHBkZXYtPmRldi5vZl9ub2Rl LAo+ICAJCQkJICAicngtaW50ZXJuYWwtZGVsYXktcHMiLCAmZGVsYXlfcHMpKSB7Cj4gLQkJdTMy IHZhbCA9IG1pbihkZWxheV9wcyAvIDEwMCwgRUlDNzcwMF9NQVhfREVMQVlfVU5JVCk7Cj4gKwkJ aWYgKGRlbGF5X3BzICUgRUlDNzcwMF9ERUxBWV9TVEVQX1BTKQo+ICsJCQlyZXR1cm4gZGV2X2Vy cl9wcm9iZSgmcGRldi0+ZGV2LCAtRUlOVkFMLAo+ICsJCQkJInJ4IGRlbGF5IG11c3QgYmUgbXVs dGlwbGUgb2YgJWRwc1xuIiwKPiArCQkJCUVJQzc3MDBfREVMQVlfU1RFUF9QUyk7Cj4gKwo+ICsJ CWlmIChkZWxheV9wcyA+IEVJQzc3MDBfTUFYX0RFTEFZX1BTKQo+ICsJCQlyZXR1cm4gZGV2X2Vy cl9wcm9iZSgmcGRldi0+ZGV2LCAtRUlOVkFMLAo+ICsJCQkJInJ4IGRlbGF5IG91dCBvZiByYW5n ZVxuIik7Cj4gIAo+IC0JCWV0aF9kbHlfcGFyYW0gJj0gfkVJQzc3MDBfRVRIX1JYX0FESl9ERUxB WTsKPiAtCQlldGhfZGx5X3BhcmFtIHw9IEZJRUxEX1BSRVAoRUlDNzcwMF9FVEhfUlhfQURKX0RF TEFZLCB2YWwpOwo+IC0JfSBlbHNlIHsKPiAtCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmcGRldi0+ ZGV2LCAtRUlOVkFMLAo+IC0JCQkibWlzc2luZyByZXF1aXJlZCBwcm9wZXJ0eSByeC1pbnRlcm5h bC1kZWxheS1wc1xuIik7Cj4gKwkJdmFsID0gZGVsYXlfcHMgLyBFSUM3NzAwX0RFTEFZX1NURVBf UFM7Cj4gKwo+ICsJCWR3Y19wcml2LT5ldGhfY2xrX2RseV9wYXJhbSAmPSB+RUlDNzcwMF9FVEhf UlhfQURKX0RFTEFZOwo+ICsJCWR3Y19wcml2LT5ldGhfY2xrX2RseV9wYXJhbSB8PQo+ICsJCQkJ IEZJRUxEX1BSRVAoRUlDNzcwMF9FVEhfUlhfQURKX0RFTEFZLCB2YWwpOwo+ICAJfQo+ICAKPiAg CS8qIFJlYWQgdHgtaW50ZXJuYWwtZGVsYXktcHMgYW5kIHVwZGF0ZSB0eF9jbGsgZGVsYXkgKi8K PiAgCWlmICghb2ZfcHJvcGVydHlfcmVhZF91MzIocGRldi0+ZGV2Lm9mX25vZGUsCj4gIAkJCQkg ICJ0eC1pbnRlcm5hbC1kZWxheS1wcyIsICZkZWxheV9wcykpIHsKPiAtCQl1MzIgdmFsID0gbWlu KGRlbGF5X3BzIC8gMTAwLCBFSUM3NzAwX01BWF9ERUxBWV9VTklUKTsKPiArCQlpZiAoZGVsYXlf cHMgJSBFSUM3NzAwX0RFTEFZX1NURVBfUFMpCj4gKwkJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZw ZGV2LT5kZXYsIC1FSU5WQUwsCj4gKwkJCQkidHggZGVsYXkgbXVzdCBiZSBtdWx0aXBsZSBvZiAl ZHBzXG4iLAo+ICsJCQkJRUlDNzcwMF9ERUxBWV9TVEVQX1BTKTsKPiArCj4gKwkJaWYgKGRlbGF5 X3BzID4gRUlDNzcwMF9NQVhfREVMQVlfUFMpCj4gKwkJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZw ZGV2LT5kZXYsIC1FSU5WQUwsCj4gKwkJCQkidHggZGVsYXkgb3V0IG9mIHJhbmdlXG4iKTsKPiAr Cj4gKwkJdmFsID0gZGVsYXlfcHMgLyBFSUM3NzAwX0RFTEFZX1NURVBfUFM7Cj4gIAo+IC0JCWV0 aF9kbHlfcGFyYW0gJj0gfkVJQzc3MDBfRVRIX1RYX0FESl9ERUxBWTsKPiAtCQlldGhfZGx5X3Bh cmFtIHw9IEZJRUxEX1BSRVAoRUlDNzcwMF9FVEhfVFhfQURKX0RFTEFZLCB2YWwpOwo+IC0JfSBl bHNlIHsKPiAtCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmcGRldi0+ZGV2LCAtRUlOVkFMLAo+IC0J CQkibWlzc2luZyByZXF1aXJlZCBwcm9wZXJ0eSB0eC1pbnRlcm5hbC1kZWxheS1wc1xuIik7Cj4g KwkJZHdjX3ByaXYtPmV0aF9jbGtfZGx5X3BhcmFtICY9IH5FSUM3NzAwX0VUSF9UWF9BREpfREVM QVk7Cj4gKwkJZHdjX3ByaXYtPmV0aF9jbGtfZGx5X3BhcmFtIHw9Cj4gKwkJCQkgRklFTERfUFJF UChFSUM3NzAwX0VUSF9UWF9BREpfREVMQVksIHZhbCk7Cj4gIAl9CgpBSSBzYXlzOgoKICBGaXJz dCwgcngtaW50ZXJuYWwtZGVsYXktcHMgYW5kIHR4LWludGVybmFsLWRlbGF5LXBzIGFyZSBzaWxl bnRseQogIGRlbW90ZWQgZnJvbSByZXF1aXJlZCB0byBvcHRpb25hbC4gIFRoZSBwcmV2aW91cyBk cml2ZXIgcmV0dXJuZWQKICAtRUlOVkFMIHdpdGggIm1pc3NpbmcgcmVxdWlyZWQgcHJvcGVydHkg Li4uIiB3aGVuIGVpdGhlciB3YXMgYWJzZW50OwogIHRoZSBlbHNlIGJyYW5jaGVzIGhhdmUgYmVl biByZW1vdmVkLCBzbyBtaXNzaW5nIHByb3BlcnRpZXMgbm93IGxlYXZlCiAgZXRoX2Nsa19kbHlf cGFyYW0gYXQgemVybyBhbmQgZml4X21hY19zcGVlZCgpIHByb2dyYW1zIHplcm8gZGVsYXkKICB3 aXRob3V0IGRpYWdub3N0aWMuICBJcyB0aGlzIGludGVudGlvbmFsLCBhbmQgaWYgc28gc2hvdWxk IHRoZSBjb21taXQKICBtZXNzYWdlIGFuZCB0aGUgRFQgYmluZGluZyByZWZsZWN0IGl0PwogCiAg U2Vjb25kLCB0aGUgcHJldmlvdXMgY29kZSBzaWxlbnRseSBjbGFtcGVkIG91dC1vZi1yYW5nZSB2 YWx1ZXMgdmlhCiAgbWluKCkgYW5kIG9ubHkgcmVxdWlyZWQgbm9uLXplcm8gc3RlcCB1bml0cyBi eSBpbnRlZ2VyIHRydW5jYXRpb24uCiAgVGhlIG5ldyBjb2RlIHJlamVjdHMgbm9uLW11bHRpcGxl cyBvZiAyMCBhbmQgdmFsdWVzIGdyZWF0ZXIgdGhhbiAyNTQwCiAgcHMgd2l0aCAtRUlOVkFMIGF0 IHByb2JlIHRpbWUuICBEVEJzIHRoYXQgcHJldmlvdXNseSBwcm9iZWQgd2l0aAogIGNsYW1wZWQg ZGVsYXlzIHdpbGwgbm93IGZhaWwgcHJvYmUuICBTaG91bGQgdGhpcyBzdHJpY3RlciB2YWxpZGF0 aW9uCiAgYWxzbyBiZSBjYWxsZWQgb3V0IGluIHRoZSBjb21taXQgbWVzc2FnZT8KCgo+IC0JZWlj NzcwMF9oc3BfcmVnbWFwID0gc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfcGhhbmRsZShwZGV2LT5k ZXYub2Zfbm9kZSwKPiAtCQkJCQkJCSAgICAgImVzd2luLGhzcC1zcC1jc3IiKTsKPiAtCWlmIChJ U19FUlIoZWljNzcwMF9oc3BfcmVnbWFwKSkKPiArCWR3Y19wcml2LT5laWM3NzAwX2hzcF9yZWdt YXAgPQo+ICsJCQlzeXNjb25fcmVnbWFwX2xvb2t1cF9ieV9waGFuZGxlKHBkZXYtPmRldi5vZl9u b2RlLAo+ICsJCQkJCQkJImVzd2luLGhzcC1zcC1jc3IiKTsKPiArCWlmIChJU19FUlIoZHdjX3By aXYtPmVpYzc3MDBfaHNwX3JlZ21hcCkpCj4gIAkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJnBkZXYt PmRldiwKPiAtCQkJCVBUUl9FUlIoZWljNzcwMF9oc3BfcmVnbWFwKSwKPiArCQkJCVBUUl9FUlIo ZHdjX3ByaXYtPmVpYzc3MDBfaHNwX3JlZ21hcCksCj4gIAkJCQkiRmFpbGVkIHRvIGdldCBoc3At c3AtY3NyIHJlZ21hcFxuIik7Cj4gIAo+ICAJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzJfaW5k ZXgocGRldi0+ZGV2Lm9mX25vZGUsCj4gIAkJCQkJICJlc3dpbixoc3Atc3AtY3NyIiwKPiAtCQkJ CQkgMSwgJmV0aF9waHlfY3RybF9vZmZzZXQpOwo+ICsJCQkJCSAxLCAmZHdjX3ByaXYtPmV0aF9w aHlfY3RybF9vZmZzZXQpOwo+ICAJaWYgKHJldCkKPiAgCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgm cGRldi0+ZGV2LCByZXQsCj4gIAkJCQkgICAgICJjYW4ndCBnZXQgZXRoX3BoeV9jdHJsX29mZnNl dFxuIik7Cj4gIAo+IC0JcmVnbWFwX3JlYWQoZWljNzcwMF9oc3BfcmVnbWFwLCBldGhfcGh5X2N0 cmxfb2Zmc2V0LAo+IC0JCSAgICAmZXRoX3BoeV9jdHJsX3JlZ3NldCk7Cj4gLQlldGhfcGh5X2N0 cmxfcmVnc2V0IHw9Cj4gLQkJKEVJQzc3MDBfRVRIX1RYX0NMS19TRUwgfCBFSUM3NzAwX0VUSF9Q SFlfSU5URl9TRUxJKTsKPiAtCXJlZ21hcF93cml0ZShlaWM3NzAwX2hzcF9yZWdtYXAsIGV0aF9w aHlfY3RybF9vZmZzZXQsCj4gLQkJICAgICBldGhfcGh5X2N0cmxfcmVnc2V0KTsKPiAtCj4gIAly ZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMl9pbmRleChwZGV2LT5kZXYub2Zfbm9kZSwKPiAgCQkJ CQkgImVzd2luLGhzcC1zcC1jc3IiLAo+IC0JCQkJCSAyLCAmZXRoX2F4aV9scF9jdHJsX29mZnNl dCk7Cj4gKwkJCQkJIDIsICZkd2NfcHJpdi0+ZXRoX2F4aV9scF9jdHJsX29mZnNldCk7Cj4gIAlp ZiAocmV0KQo+ICAJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZwZGV2LT5kZXYsIHJldCwKPiAgCQkJ CSAgICAgImNhbid0IGdldCBldGhfYXhpX2xwX2N0cmxfb2Zmc2V0XG4iKTsKPiAgCj4gLQlyZWdt YXBfd3JpdGUoZWljNzcwMF9oc3BfcmVnbWFwLCBldGhfYXhpX2xwX2N0cmxfb2Zmc2V0LAo+IC0J CSAgICAgRUlDNzcwMF9FVEhfQ1NZU1JFUV9WQUwpOwo+ICsJcmV0ID0gb2ZfcHJvcGVydHlfcmVh ZF91MzJfaW5kZXgocGRldi0+ZGV2Lm9mX25vZGUsCj4gKwkJCQkJICJlc3dpbixoc3Atc3AtY3Ny IiwKPiArCQkJCQkgMywgJmR3Y19wcml2LT5ldGhfY2xrX29mZnNldCk7Cj4gKwlpZiAocmV0KQo+ ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZwZGV2LT5kZXYsIHJldCwKPiArCQkJCSAgICAgImNh bid0IGdldCBldGhfY2xrX29mZnNldFxuIik7Cj4gIAo+ICAJcmV0ID0gb2ZfcHJvcGVydHlfcmVh ZF91MzJfaW5kZXgocGRldi0+ZGV2Lm9mX25vZGUsCj4gIAkJCQkJICJlc3dpbixoc3Atc3AtY3Ny IiwKPiAtCQkJCQkgMywgJmV0aF9yeGRfZGx5X29mZnNldCk7Cj4gKwkJCQkJIDQsICZkd2NfcHJp di0+ZXRoX3R4ZF9vZmZzZXQpOwo+ICAJaWYgKHJldCkKPiAgCQlyZXR1cm4gZGV2X2Vycl9wcm9i ZSgmcGRldi0+ZGV2LCByZXQsCj4gLQkJCQkgICAgICJjYW4ndCBnZXQgZXRoX3J4ZF9kbHlfb2Zm c2V0XG4iKTsKPiArCQkJCSAgICAgImNhbid0IGdldCBldGhfdHhkX29mZnNldFxuIik7Cj4gIAo+ IC0JcmVnbWFwX3dyaXRlKGVpYzc3MDBfaHNwX3JlZ21hcCwgZXRoX3J4ZF9kbHlfb2Zmc2V0LAo+ IC0JCSAgICAgZXRoX2RseV9wYXJhbSk7Cj4gKwlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMl9p bmRleChwZGV2LT5kZXYub2Zfbm9kZSwKPiArCQkJCQkgImVzd2luLGhzcC1zcC1jc3IiLAo+ICsJ CQkJCSA1LCAmZHdjX3ByaXYtPmV0aF9yeGRfb2Zmc2V0KTsKPiArCWlmIChyZXQpCj4gKwkJcmV0 dXJuIGRldl9lcnJfcHJvYmUoJnBkZXYtPmRldiwgcmV0LAo+ICsJCQkJICAgICAiY2FuJ3QgZ2V0 IGV0aF9yeGRfb2Zmc2V0XG4iKTsKCkFJIHNheXM6CgogIFRoZSBlc3dpbixoc3Atc3AtY3NyIHBo YW5kbGUtYXJncyBsYXlvdXQgaXMgZXhwYW5kZWQgZnJvbSA0IGNlbGxzCiAgKHBoYW5kbGUgKyAz IG9mZnNldHMpIHRvIDYgY2VsbHMgKHBoYW5kbGUgKyA1IG9mZnNldHMpLCB3aXRoIG5ldwogIGlu ZGljZXMgMy80LzUgbm93IHJlcXVpcmVkLiAgQW55IERUQiBwcm9kdWNlZCBhZ2FpbnN0IHRoZSBv cmlnaW5hbAogIGVhNzdkYmJkYmM0ZSBiaW5kaW5nIHdpbGwgZmFpbCBwcm9iZSBoZXJlIHdpdGgg LUVJTlZBTC4KLS0gCnB3LWJvdDogY3IKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0 cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGlu Zm8vbGludXgtcmlzY3YK