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 X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 91DC0C76186 for ; Wed, 24 Jul 2019 20:37:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 538E321841 for ; Wed, 24 Jul 2019 20:37:08 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="JrXLofDY" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387935AbfGXTYO (ORCPT ); Wed, 24 Jul 2019 15:24:14 -0400 Received: from mx.0dd.nl ([5.2.79.48]:52814 "EHLO mx.0dd.nl" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728972AbfGXTYM (ORCPT ); Wed, 24 Jul 2019 15:24:12 -0400 Received: from mail.vdorst.com (mail.vdorst.com [IPv6:fd01::250]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mx.0dd.nl (Postfix) with ESMTPS id 360425FD5A; Wed, 24 Jul 2019 21:24:08 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="JrXLofDY"; dkim-atps=neutral Received: from pc-rene.vdorst.com (pc-rene.vdorst.com [192.168.2.125]) by mail.vdorst.com (Postfix) with ESMTPA id E81B81D25CF6; Wed, 24 Jul 2019 21:24:07 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com E81B81D25CF6 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1563996248; bh=zAiy8WozL3kDKmIXJSly9TIfcgQnBBoIVCRbUWuCR/s=; h=From:To:Cc:Subject:Date:From; b=JrXLofDYpSFH9tHt67gsSMwVmbwFYat5F0bpmQ6Z0eJNjn/SN39Izm+VxO73lqlCA +vL8X8xxowumqtKxG/j80MM1mrBIyVqf/SF52AKfI9qsL2xXRlJXDrRshrC8mPB5VM IKDS2gLekzryQjyOM3gSyWFVXinzfm2ezJfvhvDxpO8SazAYCskvJRorsiNpgfI1Xo kfWVPjHHRyhpsE72whQxe0cMhD0GzwOSJvLQ9zQrUCNF7ET5XDAsXs+Q69ASW1r88O k8S4zbgbUhgaRjiNwgJPiB2RK6uEceaJWMYVeYFgpVZOUKBRVMJkSWYQ0w2gb9yO8q vH5Sklr8CJv/Q== From: =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= To: netdev@vger.kernel.org Cc: frank-w@public-files.de, sean.wang@mediatek.com, f.fainelli@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, matthias.bgg@gmail.com, andrew@lunn.ch, vivien.didelot@gmail.com, john@phrozen.org, linux-mediatek@lists.infradead.org, linux-mips@vger.kernel.org, robh+dt@kernel.org, devicetree@vger.kernel.org, =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= Subject: [PATCH net-next 2/3] net: ethernet: mediatek: Re-add support SGMII Date: Wed, 24 Jul 2019 21:23:59 +0200 Message-Id: <20190724192359.19808-1-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-mips-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-mips@vger.kernel.org * Re-add SGMII support but now with PHYLINK API support So the SGMII changes are more clear * Move SGMII block setup from mtk_gmac_sgmii_path_setup() to mtk_mac_config() * Merge mtk_setup_hw_path() into mtk_mac_config() * Remove mediatek,physpeed property, fixed-link supports now any speed so speed = <2500>; is now valid with PHYLINK. * Demagic SGMII register values * Use phylink state to setup fixed-link mode Signed-off-by: René van Dorst Tested-by: Frank Wunderlich --- drivers/net/ethernet/mediatek/mtk_eth_path.c | 72 +--------- drivers/net/ethernet/mediatek/mtk_eth_soc.c | 130 +++++++++++++++---- drivers/net/ethernet/mediatek/mtk_eth_soc.h | 37 +++++- drivers/net/ethernet/mediatek/mtk_sgmii.c | 65 ++++++---- 4 files changed, 188 insertions(+), 116 deletions(-) diff --git a/drivers/net/ethernet/mediatek/mtk_eth_path.c b/drivers/net/ethernet/mediatek/mtk_eth_path.c index 7f05880cf9ef..9a205b9ab1c3 100644 --- a/drivers/net/ethernet/mediatek/mtk_eth_path.c +++ b/drivers/net/ethernet/mediatek/mtk_eth_path.c @@ -239,10 +239,9 @@ static int mtk_eth_mux_setup(struct mtk_eth *eth, int path) return err; } -static int mtk_gmac_sgmii_path_setup(struct mtk_eth *eth, int mac_id) +int mtk_gmac_sgmii_path_setup(struct mtk_eth *eth, int mac_id) { - unsigned int val = 0; - int sid, err, path; + int err, path; path = (mac_id == 0) ? MTK_ETH_PATH_GMAC1_SGMII : MTK_ETH_PATH_GMAC2_SGMII; @@ -252,33 +251,10 @@ static int mtk_gmac_sgmii_path_setup(struct mtk_eth *eth, int mac_id) if (err) return err; - /* The path GMAC to SGMII will be enabled once the SGMIISYS is being - * setup done. - */ - regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val); - - regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0, - SYSCFG0_SGMII_MASK, ~(u32)SYSCFG0_SGMII_MASK); - - /* Decide how GMAC and SGMIISYS be mapped */ - sid = (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_SGMII)) ? 0 : mac_id; - - /* Setup SGMIISYS with the determined property */ - if (MTK_HAS_FLAGS(eth->sgmii->flags[sid], MTK_SGMII_PHYSPEED_AN)) - err = mtk_sgmii_setup_mode_an(eth->sgmii, sid); - else - err = mtk_sgmii_setup_mode_force(eth->sgmii, sid); - - if (err) - return err; - - regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0, - SYSCFG0_SGMII_MASK, val); - return 0; } -static int mtk_gmac_gephy_path_setup(struct mtk_eth *eth, int mac_id) +int mtk_gmac_gephy_path_setup(struct mtk_eth *eth, int mac_id) { int err, path = 0; @@ -296,7 +272,7 @@ static int mtk_gmac_gephy_path_setup(struct mtk_eth *eth, int mac_id) return 0; } -static int mtk_gmac_rgmii_path_setup(struct mtk_eth *eth, int mac_id) +int mtk_gmac_rgmii_path_setup(struct mtk_eth *eth, int mac_id) { int err, path; @@ -310,43 +286,3 @@ static int mtk_gmac_rgmii_path_setup(struct mtk_eth *eth, int mac_id) return 0; } - -int mtk_setup_hw_path(struct mtk_eth *eth, int mac_id, int phymode) -{ - int err; - - switch (phymode) { - case PHY_INTERFACE_MODE_TRGMII: - case PHY_INTERFACE_MODE_RGMII_TXID: - case PHY_INTERFACE_MODE_RGMII_RXID: - case PHY_INTERFACE_MODE_RGMII_ID: - case PHY_INTERFACE_MODE_RGMII: - case PHY_INTERFACE_MODE_MII: - case PHY_INTERFACE_MODE_REVMII: - case PHY_INTERFACE_MODE_RMII: - if (MTK_HAS_CAPS(eth->soc->caps, MTK_RGMII)) { - err = mtk_gmac_rgmii_path_setup(eth, mac_id); - if (err) - return err; - } - break; - case PHY_INTERFACE_MODE_SGMII: - if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII)) { - err = mtk_gmac_sgmii_path_setup(eth, mac_id); - if (err) - return err; - } - break; - case PHY_INTERFACE_MODE_GMII: - if (MTK_HAS_CAPS(eth->soc->caps, MTK_GEPHY)) { - err = mtk_gmac_gephy_path_setup(eth, mac_id); - if (err) - return err; - } - break; - default: - break; - } - - return 0; -} diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c index 853929070cb3..02831166da3c 100644 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c @@ -194,7 +194,8 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, phylink_config); struct mtk_eth *eth = mac->hw; - u32 ge_mode = 0, val, mcr_cur, mcr_new; + u32 ge_mode = 0, val, mcr_cur, mcr_new, err = -EINVAL; + u32 sid; if (mac->interface != state->interface) { /* Setup soc pin functions */ @@ -210,24 +211,35 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, case PHY_INTERFACE_MODE_RGMII_RXID: case PHY_INTERFACE_MODE_RGMII_ID: case PHY_INTERFACE_MODE_RGMII: - break; case PHY_INTERFACE_MODE_MII: - ge_mode = 1; - break; case PHY_INTERFACE_MODE_REVMII: - ge_mode = 2; - break; case PHY_INTERFACE_MODE_RMII: - if (mac->id) - goto err_phy; - ge_mode = 3; + if (MTK_HAS_CAPS(eth->soc->caps, MTK_RGMII)) { + err = mtk_gmac_rgmii_path_setup(eth, mac->id); + if (err) + goto init_err; + } + break; + case PHY_INTERFACE_MODE_SGMII: + if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII)) { + err = mtk_gmac_sgmii_path_setup(eth, mac->id); + if (err) + goto init_err; + } + break; + case PHY_INTERFACE_MODE_GMII: + if (MTK_HAS_CAPS(eth->soc->caps, MTK_GEPHY)) { + err = mtk_gmac_gephy_path_setup(eth, mac->id); + if (err) + goto init_err; + } break; default: goto err_phy; } /* Setup clock for 1st gmac */ - if (!mac->id && + if (!mac->id && state->interface != PHY_INTERFACE_MODE_SGMII && MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GMAC1_TRGMII)) { if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_TRGMII_MT7621_CLK)) { @@ -242,6 +254,22 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, } } + switch (state->interface) { + case PHY_INTERFACE_MODE_MII: + ge_mode = 1; + break; + case PHY_INTERFACE_MODE_REVMII: + ge_mode = 2; + break; + case PHY_INTERFACE_MODE_RMII: + if (mac->id) + goto err_phy; + ge_mode = 3; + break; + default: + break; + } + /* put the gmac into the right mode */ regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val); val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, mac->id); @@ -251,7 +279,38 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, mac->interface = state->interface; } - /* Setup gmac */ + /* SGMII */ + if (state->interface == PHY_INTERFACE_MODE_SGMII) { + /* The path GMAC to SGMII will be enabled once the SGMIISYS is + * being setup done. + */ + regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val); + + regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0, + SYSCFG0_SGMII_MASK, + ~(u32)SYSCFG0_SGMII_MASK); + + /* Decide how GMAC and SGMIISYS be mapped */ + sid = (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_SGMII)) ? + 0 : mac->id; + + /* Setup SGMIISYS with the determined property */ + if (phylink_autoneg_inband(mode)) + err = mtk_sgmii_setup_mode_an(eth->sgmii, sid); + else + err = mtk_sgmii_setup_mode_force(eth->sgmii, sid, + state); + if (err) + goto init_err; + + regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0, + SYSCFG0_SGMII_MASK, val); + } else if (phylink_autoneg_inband(mode)) { + dev_err(eth->dev, "In-band mode not supported in non SGMII mode!\n"); + return; + } + + /* Setup GMAC */ mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id)); mcr_new = mcr_cur; mcr_new &= ~(MAC_MCR_SPEED_100 | MAC_MCR_SPEED_1000 | @@ -261,6 +320,7 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, MAC_MCR_BACKOFF_EN | MAC_MCR_BACKPR_EN | MAC_MCR_FORCE_LINK; switch (state->speed) { + case SPEED_2500: case SPEED_1000: mcr_new |= MAC_MCR_SPEED_1000; break; @@ -285,6 +345,11 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode, err_phy: dev_err(eth->dev, "%s: GMAC%d mode %s not supported!\n", __func__, mac->id, phy_modes(state->interface)); + return; + +init_err: + dev_err(eth->dev, "%s: GMAC%d mode %s err: %d!\n", __func__, + mac->id, phy_modes(state->interface), err); } static int mtk_mac_link_state(struct phylink_config *config, @@ -325,7 +390,10 @@ static int mtk_mac_link_state(struct phylink_config *config, static void mtk_mac_an_restart(struct phylink_config *config) { - /* Do nothing */ + struct mtk_mac *mac = container_of(config, struct mtk_mac, + phylink_config); + + mtk_sgmii_restart_an(mac->hw, mac->id); } static void mtk_mac_link_down(struct phylink_config *config, unsigned int mode, @@ -362,7 +430,10 @@ static void mtk_validate(struct phylink_config *config, state->interface != PHY_INTERFACE_MODE_MII && !(!mac->id && state->interface == PHY_INTERFACE_MODE_TRGMII && MTK_HAS_CAPS(mac->hw->soc->caps, MTK_TRGMII)) && - !phy_interface_mode_is_rgmii(state->interface)) { + !phy_interface_mode_is_rgmii(state->interface) && + !(MTK_HAS_CAPS(mac->hw->soc->caps, MTK_SGMII) && + (state->interface == PHY_INTERFACE_MODE_SGMII || + phy_interface_mode_is_8023z(state->interface)))) { linkmode_zero(supported); return; } @@ -370,17 +441,27 @@ static void mtk_validate(struct phylink_config *config, phylink_set_port_modes(mask); phylink_set(mask, Autoneg); - if (state->interface == PHY_INTERFACE_MODE_TRGMII) { - phylink_set(mask, 1000baseT_Full); + if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_SGMII)) { + if (state->interface != PHY_INTERFACE_MODE_2500BASEX) { + phylink_set(mask, 1000baseT_Full); + phylink_set(mask, 1000baseX_Full); + } else { + phylink_set(mask, 2500baseT_Full); + phylink_set(mask, 2500baseX_Full); + } } else { - phylink_set(mask, 10baseT_Half); - phylink_set(mask, 10baseT_Full); - phylink_set(mask, 100baseT_Half); - phylink_set(mask, 100baseT_Full); - - if (state->interface != PHY_INTERFACE_MODE_MII) { - phylink_set(mask, 1000baseT_Half); + if (state->interface == PHY_INTERFACE_MODE_TRGMII) { phylink_set(mask, 1000baseT_Full); + } else { + phylink_set(mask, 10baseT_Half); + phylink_set(mask, 10baseT_Full); + phylink_set(mask, 100baseT_Half); + phylink_set(mask, 100baseT_Full); + + if (state->interface != PHY_INTERFACE_MODE_MII) { + phylink_set(mask, 1000baseT_Half); + phylink_set(mask, 1000baseT_Full); + } } } @@ -389,6 +470,11 @@ static void mtk_validate(struct phylink_config *config, linkmode_and(supported, supported, mask); linkmode_and(state->advertising, state->advertising, mask); + + /* We can only operate at 2500BaseX or 1000BaseX. If requested + * to advertise both, only report advertising at 2500BaseX. + */ + phylink_helper_basex_speed(state); } static const struct phylink_mac_ops mtk_phylink_ops = { diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.h b/drivers/net/ethernet/mediatek/mtk_eth_soc.h index 3bfcba9ffb58..c25d611f38c6 100644 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.h +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.h @@ -401,14 +401,38 @@ /* Register to auto-negotiation restart */ #define SGMSYS_PCS_CONTROL_1 0x0 #define SGMII_AN_RESTART BIT(9) +#define SGMII_ISOLATE BIT(10) +#define SGMII_AN_ENABLE BIT(12) +#define SGMII_LINK_STATYS BIT(18) +#define SGMII_AN_ABILITY BIT(19) +#define SGMII_AN_COMPLETE BIT(21) +#define SGMII_PCS_FAULT BIT(23) +#define SGMII_AN_EXPANSION_CLR BIT(30) /* Register to programmable link timer, the unit in 2 * 8ns */ #define SGMSYS_PCS_LINK_TIMER 0x18 #define SGMII_LINK_TIMER_DEFAULT (0x186a0 & GENMASK(19, 0)) /* Register to control remote fault */ -#define SGMSYS_SGMII_MODE 0x20 -#define SGMII_REMOTE_FAULT_DIS BIT(8) +#define SGMSYS_SGMII_MODE 0x20 +#define SGMII_IF_MODE_BIT0 BIT(0) +#define SGMII_SPEED_DUPLEX_AN BIT(1) +#define SGMII_SPEED_10 0x0 +#define SGMII_SPEED_100 BIT(2) +#define SGMII_SPEED_1000 BIT(3) +#define SGMII_DUPLEX_FULL BIT(4) +#define SGMII_IF_MODE_BIT5 BIT(5) +#define SGMII_REMOTE_FAULT_DIS BIT(8) +#define SGMII_CODE_SYNC_SET_VAL BIT(9) +#define SGMII_CODE_SYNC_SET_EN BIT(10) +#define SGMII_SEND_AN_ERROR_EN BIT(11) +#define SGMII_IF_MODE_MASK GENMASK(5, 1) + +/* Register to set SGMII speed, ANA RG_ Control Signals III*/ +#define SGMSYS_ANA_RG_CS3 0x2028 +#define RG_PHY_SPEED_MASK (BIT(2) | BIT(3)) +#define RG_PHY_SPEED_1_25G 0x0 +#define RG_PHY_SPEED_3_125G BIT(2) /* Register to power up QPHY */ #define SGMSYS_QPHY_PWR_STATE_CTRL 0xe8 @@ -853,7 +877,12 @@ u32 mtk_r32(struct mtk_eth *eth, unsigned reg); int mtk_sgmii_init(struct mtk_sgmii *ss, struct device_node *np, u32 ana_rgc3); int mtk_sgmii_setup_mode_an(struct mtk_sgmii *ss, int id); -int mtk_sgmii_setup_mode_force(struct mtk_sgmii *ss, int id); -int mtk_setup_hw_path(struct mtk_eth *eth, int mac_id, int phymode); +int mtk_sgmii_setup_mode_force(struct mtk_sgmii *ss, int id, + const struct phylink_link_state *state); +void mtk_sgmii_restart_an(struct mtk_eth *eth, int mac_id); + +int mtk_gmac_sgmii_path_setup(struct mtk_eth *eth, int mac_id); +int mtk_gmac_gephy_path_setup(struct mtk_eth *eth, int mac_id); +int mtk_gmac_rgmii_path_setup(struct mtk_eth *eth, int mac_id); #endif /* MTK_ETH_H */ diff --git a/drivers/net/ethernet/mediatek/mtk_sgmii.c b/drivers/net/ethernet/mediatek/mtk_sgmii.c index ff509d42d818..3032c54403d2 100644 --- a/drivers/net/ethernet/mediatek/mtk_sgmii.c +++ b/drivers/net/ethernet/mediatek/mtk_sgmii.c @@ -16,8 +16,7 @@ int mtk_sgmii_init(struct mtk_sgmii *ss, struct device_node *r, u32 ana_rgc3) { struct device_node *np; - const char *str; - int i, err; + int i; ss->ana_rgc3 = ana_rgc3; @@ -29,19 +28,6 @@ int mtk_sgmii_init(struct mtk_sgmii *ss, struct device_node *r, u32 ana_rgc3) ss->regmap[i] = syscon_node_to_regmap(np); if (IS_ERR(ss->regmap[i])) return PTR_ERR(ss->regmap[i]); - - err = of_property_read_string(np, "mediatek,physpeed", &str); - if (err) - return err; - - if (!strcmp(str, "2500")) - ss->flags[i] |= MTK_SGMII_PHYSPEED_2500; - else if (!strcmp(str, "1000")) - ss->flags[i] |= MTK_SGMII_PHYSPEED_1000; - else if (!strcmp(str, "auto")) - ss->flags[i] |= MTK_SGMII_PHYSPEED_AN; - else - return -EINVAL; } return 0; @@ -73,27 +59,45 @@ int mtk_sgmii_setup_mode_an(struct mtk_sgmii *ss, int id) return 0; } -int mtk_sgmii_setup_mode_force(struct mtk_sgmii *ss, int id) +int mtk_sgmii_setup_mode_force(struct mtk_sgmii *ss, int id, + const struct phylink_link_state *state) { unsigned int val; - int mode; if (!ss->regmap[id]) return -EINVAL; regmap_read(ss->regmap[id], ss->ana_rgc3, &val); - val &= ~GENMASK(3, 2); - mode = ss->flags[id] & MTK_SGMII_PHYSPEED_MASK; - val |= (mode == MTK_SGMII_PHYSPEED_1000) ? 0 : BIT(2); + val &= ~RG_PHY_SPEED_MASK; + if (state->speed == SPEED_2500) + val |= RG_PHY_SPEED_3_125G; regmap_write(ss->regmap[id], ss->ana_rgc3, val); /* Disable SGMII AN */ regmap_read(ss->regmap[id], SGMSYS_PCS_CONTROL_1, &val); - val &= ~BIT(12); + val &= ~SGMII_AN_ENABLE; regmap_write(ss->regmap[id], SGMSYS_PCS_CONTROL_1, val); /* SGMII force mode setting */ - val = 0x31120019; + regmap_read(ss->regmap[id], SGMSYS_SGMII_MODE, &val); + val &= ~SGMII_IF_MODE_MASK; + + switch (state->speed) { + case SPEED_10: + val |= SGMII_SPEED_10; + break; + case SPEED_100: + val |= SGMII_SPEED_100; + break; + case SPEED_2500: + case SPEED_1000: + val |= SGMII_SPEED_1000; + break; + }; + + if (state->duplex == DUPLEX_FULL) + val |= SGMII_DUPLEX_FULL; + regmap_write(ss->regmap[id], SGMSYS_SGMII_MODE, val); /* Release PHYA power down state */ @@ -103,3 +107,20 @@ int mtk_sgmii_setup_mode_force(struct mtk_sgmii *ss, int id) return 0; } + +void mtk_sgmii_restart_an(struct mtk_eth *eth, int mac_id) +{ + struct mtk_sgmii *ss = eth->sgmii; + unsigned int val, sid; + + /* Decide how GMAC and SGMIISYS be mapped */ + sid = (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_SGMII)) ? + 0 : mac_id; + + if (!ss->regmap[sid]) + return; + + regmap_read(ss->regmap[sid], SGMSYS_PCS_CONTROL_1, &val); + val |= SGMII_AN_RESTART; + regmap_write(ss->regmap[sid], SGMSYS_PCS_CONTROL_1, val); +} -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= Subject: [PATCH net-next 2/3] net: ethernet: mediatek: Re-add support SGMII Date: Wed, 24 Jul 2019 21:23:59 +0200 Message-ID: <20190724192359.19808-1-opensource@vdorst.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+glpam-linux-mediatek=m.gmane.org-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org To: netdev-u79uwXL29TY76Z2rM5mHXA@public.gmane.org Cc: andrew-g2DYL2Zd6BY@public.gmane.org, f.fainelli-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, frank-w-SipyoOjXbOMoAHOVJHB0wA@public.gmane.org, sean.wang-NuS5LvNUpcJWk0Htik3J/w@public.gmane.org, linux-I+IVW8TIWO2tmTQ+vhA3Yw@public.gmane.org, vivien.didelot-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= , devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, robh+dt-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, linux-mediatek-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, john-Pj+rj9U5foFAfugRpC6u6w@public.gmane.org, matthias.bgg-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, linux-mips-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, davem-fT/PcQaiUtIeIZ0/mPfg9Q@public.gmane.org List-Id: linux-mediatek@lists.infradead.org KiBSZS1hZGQgU0dNSUkgc3VwcG9ydCBidXQgbm93IHdpdGggUEhZTElOSyBBUEkgc3VwcG9ydAog IFNvIHRoZSBTR01JSSBjaGFuZ2VzIGFyZSBtb3JlIGNsZWFyCiogTW92ZSBTR01JSSBibG9jayBz ZXR1cCBmcm9tIG10a19nbWFjX3NnbWlpX3BhdGhfc2V0dXAoKSB0bwogIG10a19tYWNfY29uZmln KCkKKiBNZXJnZSBtdGtfc2V0dXBfaHdfcGF0aCgpIGludG8gbXRrX21hY19jb25maWcoKQoqIFJl bW92ZSBtZWRpYXRlayxwaHlzcGVlZCBwcm9wZXJ0eSwgZml4ZWQtbGluayBzdXBwb3J0cyBub3cg YW55IHNwZWVkIHNvCiAgc3BlZWQgPSA8MjUwMD47IGlzIG5vdyB2YWxpZCB3aXRoIFBIWUxJTksu CiogRGVtYWdpYyBTR01JSSByZWdpc3RlciB2YWx1ZXMKKiBVc2UgcGh5bGluayBzdGF0ZSB0byBz ZXR1cCBmaXhlZC1saW5rIG1vZGUKClNpZ25lZC1vZmYtYnk6IFJlbsOpIHZhbiBEb3JzdCA8b3Bl bnNvdXJjZUB2ZG9yc3QuY29tPgpUZXN0ZWQtYnk6IEZyYW5rIFd1bmRlcmxpY2ggPGZyYW5rLXdA cHVibGljLWZpbGVzLmRlPgotLS0KIGRyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19l dGhfcGF0aC5jIHwgIDcyICstLS0tLS0tLS0KIGRyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVr L210a19ldGhfc29jLmMgIHwgMTMwICsrKysrKysrKysrKysrKy0tLS0KIGRyaXZlcnMvbmV0L2V0 aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmggIHwgIDM3ICsrKysrLQogZHJpdmVycy9uZXQv ZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX3NnbWlpLmMgICAgfCAgNjUgKysrKysrLS0tLQogNCBmaWxl cyBjaGFuZ2VkLCAxODggaW5zZXJ0aW9ucygrKSwgMTE2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfcGF0aC5jIGIvZHJpdmVy cy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9wYXRoLmMKaW5kZXggN2YwNTg4MGNmOWVm Li45YTIwNWI5YWIxYzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVr L210a19ldGhfcGF0aC5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19l dGhfcGF0aC5jCkBAIC0yMzksMTAgKzIzOSw5IEBAIHN0YXRpYyBpbnQgbXRrX2V0aF9tdXhfc2V0 dXAoc3RydWN0IG10a19ldGggKmV0aCwgaW50IHBhdGgpCiAJcmV0dXJuIGVycjsKIH0KIAotc3Rh dGljIGludCBtdGtfZ21hY19zZ21paV9wYXRoX3NldHVwKHN0cnVjdCBtdGtfZXRoICpldGgsIGlu dCBtYWNfaWQpCitpbnQgbXRrX2dtYWNfc2dtaWlfcGF0aF9zZXR1cChzdHJ1Y3QgbXRrX2V0aCAq ZXRoLCBpbnQgbWFjX2lkKQogewotCXVuc2lnbmVkIGludCB2YWwgPSAwOwotCWludCBzaWQsIGVy ciwgcGF0aDsKKwlpbnQgZXJyLCBwYXRoOwogCiAJcGF0aCA9IChtYWNfaWQgPT0gMCkgPyAgTVRL X0VUSF9QQVRIX0dNQUMxX1NHTUlJIDoKIAkJCQlNVEtfRVRIX1BBVEhfR01BQzJfU0dNSUk7CkBA IC0yNTIsMzMgKzI1MSwxMCBAQCBzdGF0aWMgaW50IG10a19nbWFjX3NnbWlpX3BhdGhfc2V0dXAo c3RydWN0IG10a19ldGggKmV0aCwgaW50IG1hY19pZCkKIAlpZiAoZXJyKQogCQlyZXR1cm4gZXJy OwogCi0JLyogVGhlIHBhdGggR01BQyB0byBTR01JSSB3aWxsIGJlIGVuYWJsZWQgb25jZSB0aGUg U0dNSUlTWVMgaXMgYmVpbmcKLQkgKiBzZXR1cCBkb25lLgotCSAqLwotCXJlZ21hcF9yZWFkKGV0 aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgJnZhbCk7Ci0KLQlyZWdtYXBfdXBkYXRlX2JpdHMo ZXRoLT5ldGhzeXMsIEVUSFNZU19TWVNDRkcwLAotCQkJICAgU1lTQ0ZHMF9TR01JSV9NQVNLLCB+ KHUzMilTWVNDRkcwX1NHTUlJX01BU0spOwotCi0JLyogRGVjaWRlIGhvdyBHTUFDIGFuZCBTR01J SVNZUyBiZSBtYXBwZWQgKi8KLQlzaWQgPSAoTVRLX0hBU19DQVBTKGV0aC0+c29jLT5jYXBzLCBN VEtfU0hBUkVEX1NHTUlJKSkgPyAwIDogbWFjX2lkOwotCi0JLyogU2V0dXAgU0dNSUlTWVMgd2l0 aCB0aGUgZGV0ZXJtaW5lZCBwcm9wZXJ0eSAqLwotCWlmIChNVEtfSEFTX0ZMQUdTKGV0aC0+c2dt aWktPmZsYWdzW3NpZF0sIE1US19TR01JSV9QSFlTUEVFRF9BTikpCi0JCWVyciA9IG10a19zZ21p aV9zZXR1cF9tb2RlX2FuKGV0aC0+c2dtaWksIHNpZCk7Ci0JZWxzZQotCQllcnIgPSBtdGtfc2dt aWlfc2V0dXBfbW9kZV9mb3JjZShldGgtPnNnbWlpLCBzaWQpOwotCi0JaWYgKGVycikKLQkJcmV0 dXJuIGVycjsKLQotCXJlZ21hcF91cGRhdGVfYml0cyhldGgtPmV0aHN5cywgRVRIU1lTX1NZU0NG RzAsCi0JCQkgICBTWVNDRkcwX1NHTUlJX01BU0ssIHZhbCk7Ci0KIAlyZXR1cm4gMDsKIH0KIAot c3RhdGljIGludCBtdGtfZ21hY19nZXBoeV9wYXRoX3NldHVwKHN0cnVjdCBtdGtfZXRoICpldGgs IGludCBtYWNfaWQpCitpbnQgbXRrX2dtYWNfZ2VwaHlfcGF0aF9zZXR1cChzdHJ1Y3QgbXRrX2V0 aCAqZXRoLCBpbnQgbWFjX2lkKQogewogCWludCBlcnIsIHBhdGggPSAwOwogCkBAIC0yOTYsNyAr MjcyLDcgQEAgc3RhdGljIGludCBtdGtfZ21hY19nZXBoeV9wYXRoX3NldHVwKHN0cnVjdCBtdGtf ZXRoICpldGgsIGludCBtYWNfaWQpCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgbXRrX2dt YWNfcmdtaWlfcGF0aF9zZXR1cChzdHJ1Y3QgbXRrX2V0aCAqZXRoLCBpbnQgbWFjX2lkKQoraW50 IG10a19nbWFjX3JnbWlpX3BhdGhfc2V0dXAoc3RydWN0IG10a19ldGggKmV0aCwgaW50IG1hY19p ZCkKIHsKIAlpbnQgZXJyLCBwYXRoOwogCkBAIC0zMTAsNDMgKzI4NiwzIEBAIHN0YXRpYyBpbnQg bXRrX2dtYWNfcmdtaWlfcGF0aF9zZXR1cChzdHJ1Y3QgbXRrX2V0aCAqZXRoLCBpbnQgbWFjX2lk KQogCiAJcmV0dXJuIDA7CiB9Ci0KLWludCBtdGtfc2V0dXBfaHdfcGF0aChzdHJ1Y3QgbXRrX2V0 aCAqZXRoLCBpbnQgbWFjX2lkLCBpbnQgcGh5bW9kZSkKLXsKLQlpbnQgZXJyOwotCi0Jc3dpdGNo IChwaHltb2RlKSB7Ci0JY2FzZSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJOgotCWNhc2UgUEhZ X0lOVEVSRkFDRV9NT0RFX1JHTUlJX1RYSUQ6Ci0JY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdN SUlfUlhJRDoKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9JRDoKLQljYXNlIFBIWV9J TlRFUkZBQ0VfTU9ERV9SR01JSToKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUk6Ci0JY2Fz ZSBQSFlfSU5URVJGQUNFX01PREVfUkVWTUlJOgotCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JN SUk6Ci0JCWlmIChNVEtfSEFTX0NBUFMoZXRoLT5zb2MtPmNhcHMsIE1US19SR01JSSkpIHsKLQkJ CWVyciA9IG10a19nbWFjX3JnbWlpX3BhdGhfc2V0dXAoZXRoLCBtYWNfaWQpOwotCQkJaWYgKGVy cikKLQkJCQlyZXR1cm4gZXJyOwotCQl9Ci0JCWJyZWFrOwotCWNhc2UgUEhZX0lOVEVSRkFDRV9N T0RFX1NHTUlJOgotCQlpZiAoTVRLX0hBU19DQVBTKGV0aC0+c29jLT5jYXBzLCBNVEtfU0dNSUkp KSB7Ci0JCQllcnIgPSBtdGtfZ21hY19zZ21paV9wYXRoX3NldHVwKGV0aCwgbWFjX2lkKTsKLQkJ CWlmIChlcnIpCi0JCQkJcmV0dXJuIGVycjsKLQkJfQotCQlicmVhazsKLQljYXNlIFBIWV9JTlRF UkZBQ0VfTU9ERV9HTUlJOgotCQlpZiAoTVRLX0hBU19DQVBTKGV0aC0+c29jLT5jYXBzLCBNVEtf R0VQSFkpKSB7Ci0JCQllcnIgPSBtdGtfZ21hY19nZXBoeV9wYXRoX3NldHVwKGV0aCwgbWFjX2lk KTsKLQkJCWlmIChlcnIpCi0JCQkJcmV0dXJuIGVycjsKLQkJfQotCQlicmVhazsKLQlkZWZhdWx0 OgotCQlicmVhazsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0 L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmMgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9t ZWRpYXRlay9tdGtfZXRoX3NvYy5jCmluZGV4IDg1MzkyOTA3MGNiMy4uMDI4MzExNjZkYTNjIDEw MDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5jCisr KyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmMKQEAgLTE5NCw3 ICsxOTQsOCBAQCBzdGF0aWMgdm9pZCBtdGtfbWFjX2NvbmZpZyhzdHJ1Y3QgcGh5bGlua19jb25m aWcgKmNvbmZpZywgdW5zaWduZWQgaW50IG1vZGUsCiAJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsK IAlzdHJ1Y3QgbXRrX2V0aCAqZXRoID0gbWFjLT5odzsKIAotCXUzMiBnZV9tb2RlID0gMCwgdmFs LCBtY3JfY3VyLCBtY3JfbmV3OworCXUzMiBnZV9tb2RlID0gMCwgdmFsLCBtY3JfY3VyLCBtY3Jf bmV3LCBlcnIgPSAtRUlOVkFMOworCXUzMiBzaWQ7CiAKIAlpZiAobWFjLT5pbnRlcmZhY2UgIT0g c3RhdGUtPmludGVyZmFjZSkgewogCQkvKiBTZXR1cCBzb2MgcGluIGZ1bmN0aW9ucyAqLwpAQCAt MjEwLDI0ICsyMTEsMzUgQEAgc3RhdGljIHZvaWQgbXRrX21hY19jb25maWcoc3RydWN0IHBoeWxp bmtfY29uZmlnICpjb25maWcsIHVuc2lnbmVkIGludCBtb2RlLAogCQljYXNlIFBIWV9JTlRFUkZB Q0VfTU9ERV9SR01JSV9SWElEOgogCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9JRDoK IAkJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdNSUk6Ci0JCQlicmVhazsKIAkJY2FzZSBQSFlf SU5URVJGQUNFX01PREVfTUlJOgotCQkJZ2VfbW9kZSA9IDE7Ci0JCQlicmVhazsKIAkJY2FzZSBQ SFlfSU5URVJGQUNFX01PREVfUkVWTUlJOgotCQkJZ2VfbW9kZSA9IDI7Ci0JCQlicmVhazsKIAkJ Y2FzZSBQSFlfSU5URVJGQUNFX01PREVfUk1JSToKLQkJCWlmIChtYWMtPmlkKQotCQkJCWdvdG8g ZXJyX3BoeTsKLQkJCWdlX21vZGUgPSAzOworCQkJaWYgKE1US19IQVNfQ0FQUyhldGgtPnNvYy0+ Y2FwcywgTVRLX1JHTUlJKSkgeworCQkJCWVyciA9IG10a19nbWFjX3JnbWlpX3BhdGhfc2V0dXAo ZXRoLCBtYWMtPmlkKTsKKwkJCQlpZiAoZXJyKQorCQkJCQlnb3RvIGluaXRfZXJyOworCQkJfQor CQkJYnJlYWs7CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJOgorCQkJaWYgKE1US19I QVNfQ0FQUyhldGgtPnNvYy0+Y2FwcywgTVRLX1NHTUlJKSkgeworCQkJCWVyciA9IG10a19nbWFj X3NnbWlpX3BhdGhfc2V0dXAoZXRoLCBtYWMtPmlkKTsKKwkJCQlpZiAoZXJyKQorCQkJCQlnb3Rv IGluaXRfZXJyOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX0dN SUk6CisJCQlpZiAoTVRLX0hBU19DQVBTKGV0aC0+c29jLT5jYXBzLCBNVEtfR0VQSFkpKSB7CisJ CQkJZXJyID0gbXRrX2dtYWNfZ2VwaHlfcGF0aF9zZXR1cChldGgsIG1hYy0+aWQpOworCQkJCWlm IChlcnIpCisJCQkJCWdvdG8gaW5pdF9lcnI7CisJCQl9CiAJCQlicmVhazsKIAkJZGVmYXVsdDoK IAkJCWdvdG8gZXJyX3BoeTsKIAkJfQogCiAJCS8qIFNldHVwIGNsb2NrIGZvciAxc3QgZ21hYyAq LwotCQlpZiAoIW1hYy0+aWQgJiYKKwkJaWYgKCFtYWMtPmlkICYmIHN0YXRlLT5pbnRlcmZhY2Ug IT0gUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJICYmCiAJCSAgICBNVEtfSEFTX0NBUFMobWFjLT5o dy0+c29jLT5jYXBzLCBNVEtfR01BQzFfVFJHTUlJKSkgewogCQkJaWYgKE1US19IQVNfQ0FQUyht YWMtPmh3LT5zb2MtPmNhcHMsCiAJCQkJCSBNVEtfVFJHTUlJX01UNzYyMV9DTEspKSB7CkBAIC0y NDIsNiArMjU0LDIyIEBAIHN0YXRpYyB2b2lkIG10a19tYWNfY29uZmlnKHN0cnVjdCBwaHlsaW5r X2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwKIAkJCX0KIAkJfQogCisJCXN3aXRj aCAoc3RhdGUtPmludGVyZmFjZSkgeworCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUk6CisJ CQlnZV9tb2RlID0gMTsKKwkJCWJyZWFrOworCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SRVZN SUk6CisJCQlnZV9tb2RlID0gMjsKKwkJCWJyZWFrOworCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9E RV9STUlJOgorCQkJaWYgKG1hYy0+aWQpCisJCQkJZ290byBlcnJfcGh5OworCQkJZ2VfbW9kZSA9 IDM7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisKIAkJLyogcHV0IHRo ZSBnbWFjIGludG8gdGhlIHJpZ2h0IG1vZGUgKi8KIAkJcmVnbWFwX3JlYWQoZXRoLT5ldGhzeXMs IEVUSFNZU19TWVNDRkcwLCAmdmFsKTsKIAkJdmFsICY9IH5TWVNDRkcwX0dFX01PREUoU1lTQ0ZH MF9HRV9NQVNLLCBtYWMtPmlkKTsKQEAgLTI1MSw3ICsyNzksMzggQEAgc3RhdGljIHZvaWQgbXRr X21hY19jb25maWcoc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsIHVuc2lnbmVkIGludCBt b2RlLAogCQltYWMtPmludGVyZmFjZSA9IHN0YXRlLT5pbnRlcmZhY2U7CiAJfQogCi0JLyogU2V0 dXAgZ21hYyAqLworCS8qIFNHTUlJICovCisJaWYgKHN0YXRlLT5pbnRlcmZhY2UgPT0gUEhZX0lO VEVSRkFDRV9NT0RFX1NHTUlJKSB7CisJCS8qIFRoZSBwYXRoIEdNQUMgdG8gU0dNSUkgd2lsbCBi ZSBlbmFibGVkIG9uY2UgdGhlIFNHTUlJU1lTIGlzCisJCSAqIGJlaW5nIHNldHVwIGRvbmUuCisJ CSAqLworCQlyZWdtYXBfcmVhZChldGgtPmV0aHN5cywgRVRIU1lTX1NZU0NGRzAsICZ2YWwpOwor CisJCXJlZ21hcF91cGRhdGVfYml0cyhldGgtPmV0aHN5cywgRVRIU1lTX1NZU0NGRzAsCisJCQkJ ICAgU1lTQ0ZHMF9TR01JSV9NQVNLLAorCQkJCSAgIH4odTMyKVNZU0NGRzBfU0dNSUlfTUFTSyk7 CisKKwkJLyogRGVjaWRlIGhvdyBHTUFDIGFuZCBTR01JSVNZUyBiZSBtYXBwZWQgKi8KKwkJc2lk ID0gKE1US19IQVNfQ0FQUyhldGgtPnNvYy0+Y2FwcywgTVRLX1NIQVJFRF9TR01JSSkpID8KKwkJ ICAgICAgIDAgOiBtYWMtPmlkOworCisJCS8qIFNldHVwIFNHTUlJU1lTIHdpdGggdGhlIGRldGVy bWluZWQgcHJvcGVydHkgKi8KKwkJaWYgKHBoeWxpbmtfYXV0b25lZ19pbmJhbmQobW9kZSkpCisJ CQllcnIgPSBtdGtfc2dtaWlfc2V0dXBfbW9kZV9hbihldGgtPnNnbWlpLCBzaWQpOworCQllbHNl CisJCQllcnIgPSBtdGtfc2dtaWlfc2V0dXBfbW9kZV9mb3JjZShldGgtPnNnbWlpLCBzaWQsCisJ CQkJCQkJIHN0YXRlKTsKKwkJaWYgKGVycikKKwkJCWdvdG8gaW5pdF9lcnI7CisKKwkJcmVnbWFw X3VwZGF0ZV9iaXRzKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwKKwkJCQkgICBTWVNDRkcw X1NHTUlJX01BU0ssIHZhbCk7CisJfSBlbHNlIGlmIChwaHlsaW5rX2F1dG9uZWdfaW5iYW5kKG1v ZGUpKSB7CisJCWRldl9lcnIoZXRoLT5kZXYsICJJbi1iYW5kIG1vZGUgbm90IHN1cHBvcnRlZCBp biBub24gU0dNSUkgbW9kZSFcbiIpOworCQlyZXR1cm47CisJfQorCisJLyogU2V0dXAgR01BQyAq LwogCW1jcl9jdXIgPSBtdGtfcjMyKG1hYy0+aHcsIE1US19NQUNfTUNSKG1hYy0+aWQpKTsKIAlt Y3JfbmV3ID0gbWNyX2N1cjsKIAltY3JfbmV3ICY9IH4oTUFDX01DUl9TUEVFRF8xMDAgfCBNQUNf TUNSX1NQRUVEXzEwMDAgfApAQCAtMjYxLDYgKzMyMCw3IEBAIHN0YXRpYyB2b2lkIG10a19tYWNf Y29uZmlnKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwK IAkJICAgTUFDX01DUl9CQUNLT0ZGX0VOIHwgTUFDX01DUl9CQUNLUFJfRU4gfCBNQUNfTUNSX0ZP UkNFX0xJTks7CiAKIAlzd2l0Y2ggKHN0YXRlLT5zcGVlZCkgeworCWNhc2UgU1BFRURfMjUwMDoK IAljYXNlIFNQRUVEXzEwMDA6CiAJCW1jcl9uZXcgfD0gTUFDX01DUl9TUEVFRF8xMDAwOwogCQli cmVhazsKQEAgLTI4NSw2ICszNDUsMTEgQEAgc3RhdGljIHZvaWQgbXRrX21hY19jb25maWcoc3Ry dWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsIHVuc2lnbmVkIGludCBtb2RlLAogZXJyX3BoeToK IAlkZXZfZXJyKGV0aC0+ZGV2LCAiJXM6IEdNQUMlZCBtb2RlICVzIG5vdCBzdXBwb3J0ZWQhXG4i LCBfX2Z1bmNfXywKIAkJbWFjLT5pZCwgcGh5X21vZGVzKHN0YXRlLT5pbnRlcmZhY2UpKTsKKwly ZXR1cm47CisKK2luaXRfZXJyOgorCWRldl9lcnIoZXRoLT5kZXYsICIlczogR01BQyVkIG1vZGUg JXMgZXJyOiAlZCFcbiIsIF9fZnVuY19fLAorCQltYWMtPmlkLCBwaHlfbW9kZXMoc3RhdGUtPmlu dGVyZmFjZSksIGVycik7CiB9CiAKIHN0YXRpYyBpbnQgbXRrX21hY19saW5rX3N0YXRlKHN0cnVj dCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLApAQCAtMzI1LDcgKzM5MCwxMCBAQCBzdGF0aWMgaW50 IG10a19tYWNfbGlua19zdGF0ZShzdHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywKIAogc3Rh dGljIHZvaWQgbXRrX21hY19hbl9yZXN0YXJ0KHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmln KQogewotCS8qIERvIG5vdGhpbmcgKi8KKwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gY29udGFpbmVy X29mKGNvbmZpZywgc3RydWN0IG10a19tYWMsCisJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsKKwor CW10a19zZ21paV9yZXN0YXJ0X2FuKG1hYy0+aHcsIG1hYy0+aWQpOwogfQogCiBzdGF0aWMgdm9p ZCBtdGtfbWFjX2xpbmtfZG93bihzdHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywgdW5zaWdu ZWQgaW50IG1vZGUsCkBAIC0zNjIsNyArNDMwLDEwIEBAIHN0YXRpYyB2b2lkIG10a192YWxpZGF0 ZShzdHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywKIAkgICAgc3RhdGUtPmludGVyZmFjZSAh PSBQSFlfSU5URVJGQUNFX01PREVfTUlJICYmCiAJICAgICEoIW1hYy0+aWQgJiYgc3RhdGUtPmlu dGVyZmFjZSA9PSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJICYmCiAJICAgICAgTVRLX0hBU19D QVBTKG1hYy0+aHctPnNvYy0+Y2FwcywgTVRLX1RSR01JSSkpICYmCi0JICAgICFwaHlfaW50ZXJm YWNlX21vZGVfaXNfcmdtaWkoc3RhdGUtPmludGVyZmFjZSkpIHsKKwkgICAgIXBoeV9pbnRlcmZh Y2VfbW9kZV9pc19yZ21paShzdGF0ZS0+aW50ZXJmYWNlKSAmJgorCSAgICAhKE1US19IQVNfQ0FQ UyhtYWMtPmh3LT5zb2MtPmNhcHMsIE1US19TR01JSSkgJiYKKwkgICAgICAoc3RhdGUtPmludGVy ZmFjZSA9PSBQSFlfSU5URVJGQUNFX01PREVfU0dNSUkgfHwKKwkgICAgICAgcGh5X2ludGVyZmFj ZV9tb2RlX2lzXzgwMjN6KHN0YXRlLT5pbnRlcmZhY2UpKSkpIHsKIAkJbGlua21vZGVfemVybyhz dXBwb3J0ZWQpOwogCQlyZXR1cm47CiAJfQpAQCAtMzcwLDE3ICs0NDEsMjcgQEAgc3RhdGljIHZv aWQgbXRrX3ZhbGlkYXRlKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLAogCXBoeWxpbmtf c2V0X3BvcnRfbW9kZXMobWFzayk7CiAJcGh5bGlua19zZXQobWFzaywgQXV0b25lZyk7CiAKLQlp ZiAoc3RhdGUtPmludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKSB7Ci0JCXBo eWxpbmtfc2V0KG1hc2ssIDEwMDBiYXNlVF9GdWxsKTsKKwlpZiAoTVRLX0hBU19DQVBTKG1hYy0+ aHctPnNvYy0+Y2FwcywgTVRLX1NHTUlJKSkgeworCQlpZiAoc3RhdGUtPmludGVyZmFjZSAhPSBQ SFlfSU5URVJGQUNFX01PREVfMjUwMEJBU0VYKSB7CisJCQlwaHlsaW5rX3NldChtYXNrLCAxMDAw YmFzZVRfRnVsbCk7CisJCQlwaHlsaW5rX3NldChtYXNrLCAxMDAwYmFzZVhfRnVsbCk7CisJCX0g ZWxzZSB7CisJCQlwaHlsaW5rX3NldChtYXNrLCAyNTAwYmFzZVRfRnVsbCk7CisJCQlwaHlsaW5r X3NldChtYXNrLCAyNTAwYmFzZVhfRnVsbCk7CisJCX0KIAl9IGVsc2UgewotCQlwaHlsaW5rX3Nl dChtYXNrLCAxMGJhc2VUX0hhbGYpOwotCQlwaHlsaW5rX3NldChtYXNrLCAxMGJhc2VUX0Z1bGwp OwotCQlwaHlsaW5rX3NldChtYXNrLCAxMDBiYXNlVF9IYWxmKTsKLQkJcGh5bGlua19zZXQobWFz aywgMTAwYmFzZVRfRnVsbCk7Ci0KLQkJaWYgKHN0YXRlLT5pbnRlcmZhY2UgIT0gUEhZX0lOVEVS RkFDRV9NT0RFX01JSSkgewotCQkJcGh5bGlua19zZXQobWFzaywgMTAwMGJhc2VUX0hhbGYpOwor CQlpZiAoc3RhdGUtPmludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKSB7CiAJ CQlwaHlsaW5rX3NldChtYXNrLCAxMDAwYmFzZVRfRnVsbCk7CisJCX0gZWxzZSB7CisJCQlwaHls aW5rX3NldChtYXNrLCAxMGJhc2VUX0hhbGYpOworCQkJcGh5bGlua19zZXQobWFzaywgMTBiYXNl VF9GdWxsKTsKKwkJCXBoeWxpbmtfc2V0KG1hc2ssIDEwMGJhc2VUX0hhbGYpOworCQkJcGh5bGlu a19zZXQobWFzaywgMTAwYmFzZVRfRnVsbCk7CisKKwkJCWlmIChzdGF0ZS0+aW50ZXJmYWNlICE9 IFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUkpIHsKKwkJCQlwaHlsaW5rX3NldChtYXNrLCAxMDAwYmFz ZVRfSGFsZik7CisJCQkJcGh5bGlua19zZXQobWFzaywgMTAwMGJhc2VUX0Z1bGwpOworCQkJfQog CQl9CiAJfQogCkBAIC0zODksNiArNDcwLDExIEBAIHN0YXRpYyB2b2lkIG10a192YWxpZGF0ZShz dHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywKIAogCWxpbmttb2RlX2FuZChzdXBwb3J0ZWQs IHN1cHBvcnRlZCwgbWFzayk7CiAJbGlua21vZGVfYW5kKHN0YXRlLT5hZHZlcnRpc2luZywgc3Rh dGUtPmFkdmVydGlzaW5nLCBtYXNrKTsKKworCS8qIFdlIGNhbiBvbmx5IG9wZXJhdGUgYXQgMjUw MEJhc2VYIG9yIDEwMDBCYXNlWC4gSWYgcmVxdWVzdGVkCisJICogdG8gYWR2ZXJ0aXNlIGJvdGgs IG9ubHkgcmVwb3J0IGFkdmVydGlzaW5nIGF0IDI1MDBCYXNlWC4KKwkgKi8KKwlwaHlsaW5rX2hl bHBlcl9iYXNleF9zcGVlZChzdGF0ZSk7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcGh5bGlu a19tYWNfb3BzIG10a19waHlsaW5rX29wcyA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0 aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmggYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRp YXRlay9tdGtfZXRoX3NvYy5oCmluZGV4IDNiZmNiYTlmZmI1OC4uYzI1ZDYxMWYzOGM2IDEwMDY0 NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5oCisrKyBi L2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmgKQEAgLTQwMSwxNCAr NDAxLDM4IEBACiAvKiBSZWdpc3RlciB0byBhdXRvLW5lZ290aWF0aW9uIHJlc3RhcnQgKi8KICNk ZWZpbmUgU0dNU1lTX1BDU19DT05UUk9MXzEJMHgwCiAjZGVmaW5lIFNHTUlJX0FOX1JFU1RBUlQJ QklUKDkpCisjZGVmaW5lIFNHTUlJX0lTT0xBVEUJCUJJVCgxMCkKKyNkZWZpbmUgU0dNSUlfQU5f RU5BQkxFCQlCSVQoMTIpCisjZGVmaW5lIFNHTUlJX0xJTktfU1RBVFlTCUJJVCgxOCkKKyNkZWZp bmUgU0dNSUlfQU5fQUJJTElUWQlCSVQoMTkpCisjZGVmaW5lIFNHTUlJX0FOX0NPTVBMRVRFCUJJ VCgyMSkKKyNkZWZpbmUgU0dNSUlfUENTX0ZBVUxUCQlCSVQoMjMpCisjZGVmaW5lIFNHTUlJX0FO X0VYUEFOU0lPTl9DTFIJQklUKDMwKQogCiAvKiBSZWdpc3RlciB0byBwcm9ncmFtbWFibGUgbGlu ayB0aW1lciwgdGhlIHVuaXQgaW4gMiAqIDhucyAqLwogI2RlZmluZSBTR01TWVNfUENTX0xJTktf VElNRVIJMHgxOAogI2RlZmluZSBTR01JSV9MSU5LX1RJTUVSX0RFRkFVTFQJKDB4MTg2YTAgJiBH RU5NQVNLKDE5LCAwKSkKIAogLyogUmVnaXN0ZXIgdG8gY29udHJvbCByZW1vdGUgZmF1bHQgKi8K LSNkZWZpbmUgU0dNU1lTX1NHTUlJX01PREUJMHgyMAotI2RlZmluZSBTR01JSV9SRU1PVEVfRkFV TFRfRElTCUJJVCg4KQorI2RlZmluZSBTR01TWVNfU0dNSUlfTU9ERQkJMHgyMAorI2RlZmluZSBT R01JSV9JRl9NT0RFX0JJVDAJCUJJVCgwKQorI2RlZmluZSBTR01JSV9TUEVFRF9EVVBMRVhfQU4J CUJJVCgxKQorI2RlZmluZSBTR01JSV9TUEVFRF8xMAkJCTB4MAorI2RlZmluZSBTR01JSV9TUEVF RF8xMDAJCQlCSVQoMikKKyNkZWZpbmUgU0dNSUlfU1BFRURfMTAwMAkJQklUKDMpCisjZGVmaW5l IFNHTUlJX0RVUExFWF9GVUxMCQlCSVQoNCkKKyNkZWZpbmUgU0dNSUlfSUZfTU9ERV9CSVQ1CQlC SVQoNSkKKyNkZWZpbmUgU0dNSUlfUkVNT1RFX0ZBVUxUX0RJUwkJQklUKDgpCisjZGVmaW5lIFNH TUlJX0NPREVfU1lOQ19TRVRfVkFMCQlCSVQoOSkKKyNkZWZpbmUgU0dNSUlfQ09ERV9TWU5DX1NF VF9FTgkJQklUKDEwKQorI2RlZmluZSBTR01JSV9TRU5EX0FOX0VSUk9SX0VOCQlCSVQoMTEpCisj ZGVmaW5lIFNHTUlJX0lGX01PREVfTUFTSwkJR0VOTUFTSyg1LCAxKQorCisvKiBSZWdpc3RlciB0 byBzZXQgU0dNSUkgc3BlZWQsIEFOQSBSR18gQ29udHJvbCBTaWduYWxzIElJSSovCisjZGVmaW5l IFNHTVNZU19BTkFfUkdfQ1MzCTB4MjAyOAorI2RlZmluZSBSR19QSFlfU1BFRURfTUFTSwkoQklU KDIpIHwgQklUKDMpKQorI2RlZmluZSBSR19QSFlfU1BFRURfMV8yNUcJMHgwCisjZGVmaW5lIFJH X1BIWV9TUEVFRF8zXzEyNUcJQklUKDIpCiAKIC8qIFJlZ2lzdGVyIHRvIHBvd2VyIHVwIFFQSFkg Ki8KICNkZWZpbmUgU0dNU1lTX1FQSFlfUFdSX1NUQVRFX0NUUkwgMHhlOApAQCAtODUzLDcgKzg3 NywxMiBAQCB1MzIgbXRrX3IzMihzdHJ1Y3QgbXRrX2V0aCAqZXRoLCB1bnNpZ25lZCByZWcpOwog aW50IG10a19zZ21paV9pbml0KHN0cnVjdCBtdGtfc2dtaWkgKnNzLCBzdHJ1Y3QgZGV2aWNlX25v ZGUgKm5wLAogCQkgICB1MzIgYW5hX3JnYzMpOwogaW50IG10a19zZ21paV9zZXR1cF9tb2RlX2Fu KHN0cnVjdCBtdGtfc2dtaWkgKnNzLCBpbnQgaWQpOwotaW50IG10a19zZ21paV9zZXR1cF9tb2Rl X2ZvcmNlKHN0cnVjdCBtdGtfc2dtaWkgKnNzLCBpbnQgaWQpOwotaW50IG10a19zZXR1cF9od19w YXRoKHN0cnVjdCBtdGtfZXRoICpldGgsIGludCBtYWNfaWQsIGludCBwaHltb2RlKTsKK2ludCBt dGtfc2dtaWlfc2V0dXBfbW9kZV9mb3JjZShzdHJ1Y3QgbXRrX3NnbWlpICpzcywgaW50IGlkLAor CQkJICAgICAgIGNvbnN0IHN0cnVjdCBwaHlsaW5rX2xpbmtfc3RhdGUgKnN0YXRlKTsKK3ZvaWQg bXRrX3NnbWlpX3Jlc3RhcnRfYW4oc3RydWN0IG10a19ldGggKmV0aCwgaW50IG1hY19pZCk7CisK K2ludCBtdGtfZ21hY19zZ21paV9wYXRoX3NldHVwKHN0cnVjdCBtdGtfZXRoICpldGgsIGludCBt YWNfaWQpOworaW50IG10a19nbWFjX2dlcGh5X3BhdGhfc2V0dXAoc3RydWN0IG10a19ldGggKmV0 aCwgaW50IG1hY19pZCk7CitpbnQgbXRrX2dtYWNfcmdtaWlfcGF0aF9zZXR1cChzdHJ1Y3QgbXRr X2V0aCAqZXRoLCBpbnQgbWFjX2lkKTsKIAogI2VuZGlmIC8qIE1US19FVEhfSCAqLwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX3NnbWlpLmMgYi9kcml2ZXJz L25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfc2dtaWkuYwppbmRleCBmZjUwOWQ0MmQ4MTguLjMw MzJjNTQ0MDNkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRr X3NnbWlpLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX3NnbWlpLmMK QEAgLTE2LDggKzE2LDcgQEAKIGludCBtdGtfc2dtaWlfaW5pdChzdHJ1Y3QgbXRrX3NnbWlpICpz cywgc3RydWN0IGRldmljZV9ub2RlICpyLCB1MzIgYW5hX3JnYzMpCiB7CiAJc3RydWN0IGRldmlj ZV9ub2RlICpucDsKLQljb25zdCBjaGFyICpzdHI7Ci0JaW50IGksIGVycjsKKwlpbnQgaTsKIAog CXNzLT5hbmFfcmdjMyA9IGFuYV9yZ2MzOwogCkBAIC0yOSwxOSArMjgsNiBAQCBpbnQgbXRrX3Nn bWlpX2luaXQoc3RydWN0IG10a19zZ21paSAqc3MsIHN0cnVjdCBkZXZpY2Vfbm9kZSAqciwgdTMy IGFuYV9yZ2MzKQogCQlzcy0+cmVnbWFwW2ldID0gc3lzY29uX25vZGVfdG9fcmVnbWFwKG5wKTsK IAkJaWYgKElTX0VSUihzcy0+cmVnbWFwW2ldKSkKIAkJCXJldHVybiBQVFJfRVJSKHNzLT5yZWdt YXBbaV0pOwotCi0JCWVyciA9IG9mX3Byb3BlcnR5X3JlYWRfc3RyaW5nKG5wLCAibWVkaWF0ZWss cGh5c3BlZWQiLCAmc3RyKTsKLQkJaWYgKGVycikKLQkJCXJldHVybiBlcnI7Ci0KLQkJaWYgKCFz dHJjbXAoc3RyLCAiMjUwMCIpKQotCQkJc3MtPmZsYWdzW2ldIHw9IE1US19TR01JSV9QSFlTUEVF RF8yNTAwOwotCQllbHNlIGlmICghc3RyY21wKHN0ciwgIjEwMDAiKSkKLQkJCXNzLT5mbGFnc1tp XSB8PSBNVEtfU0dNSUlfUEhZU1BFRURfMTAwMDsKLQkJZWxzZSBpZiAoIXN0cmNtcChzdHIsICJh dXRvIikpCi0JCQlzcy0+ZmxhZ3NbaV0gfD0gTVRLX1NHTUlJX1BIWVNQRUVEX0FOOwotCQllbHNl Ci0JCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTczLDI3ICs1OSw0NSBA QCBpbnQgbXRrX3NnbWlpX3NldHVwX21vZGVfYW4oc3RydWN0IG10a19zZ21paSAqc3MsIGludCBp ZCkKIAlyZXR1cm4gMDsKIH0KIAotaW50IG10a19zZ21paV9zZXR1cF9tb2RlX2ZvcmNlKHN0cnVj dCBtdGtfc2dtaWkgKnNzLCBpbnQgaWQpCitpbnQgbXRrX3NnbWlpX3NldHVwX21vZGVfZm9yY2Uo c3RydWN0IG10a19zZ21paSAqc3MsIGludCBpZCwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3QgcGh5 bGlua19saW5rX3N0YXRlICpzdGF0ZSkKIHsKIAl1bnNpZ25lZCBpbnQgdmFsOwotCWludCBtb2Rl OwogCiAJaWYgKCFzcy0+cmVnbWFwW2lkXSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKIAlyZWdtYXBf cmVhZChzcy0+cmVnbWFwW2lkXSwgc3MtPmFuYV9yZ2MzLCAmdmFsKTsKLQl2YWwgJj0gfkdFTk1B U0soMywgMik7Ci0JbW9kZSA9IHNzLT5mbGFnc1tpZF0gJiBNVEtfU0dNSUlfUEhZU1BFRURfTUFT SzsKLQl2YWwgfD0gKG1vZGUgPT0gTVRLX1NHTUlJX1BIWVNQRUVEXzEwMDApID8gMCA6IEJJVCgy KTsKKwl2YWwgJj0gflJHX1BIWV9TUEVFRF9NQVNLOworCWlmIChzdGF0ZS0+c3BlZWQgPT0gU1BF RURfMjUwMCkKKwkJdmFsIHw9IFJHX1BIWV9TUEVFRF8zXzEyNUc7CiAJcmVnbWFwX3dyaXRlKHNz LT5yZWdtYXBbaWRdLCBzcy0+YW5hX3JnYzMsIHZhbCk7CiAKIAkvKiBEaXNhYmxlIFNHTUlJIEFO ICovCiAJcmVnbWFwX3JlYWQoc3MtPnJlZ21hcFtpZF0sIFNHTVNZU19QQ1NfQ09OVFJPTF8xLCAm dmFsKTsKLQl2YWwgJj0gfkJJVCgxMik7CisJdmFsICY9IH5TR01JSV9BTl9FTkFCTEU7CiAJcmVn bWFwX3dyaXRlKHNzLT5yZWdtYXBbaWRdLCBTR01TWVNfUENTX0NPTlRST0xfMSwgdmFsKTsKIAog CS8qIFNHTUlJIGZvcmNlIG1vZGUgc2V0dGluZyAqLwotCXZhbCA9IDB4MzExMjAwMTk7CisJcmVn bWFwX3JlYWQoc3MtPnJlZ21hcFtpZF0sIFNHTVNZU19TR01JSV9NT0RFLCAmdmFsKTsKKwl2YWwg Jj0gflNHTUlJX0lGX01PREVfTUFTSzsKKworCXN3aXRjaCAoc3RhdGUtPnNwZWVkKSB7CisJY2Fz ZSBTUEVFRF8xMDoKKwkJdmFsIHw9IFNHTUlJX1NQRUVEXzEwOworCQlicmVhazsKKwljYXNlIFNQ RUVEXzEwMDoKKwkJdmFsIHw9IFNHTUlJX1NQRUVEXzEwMDsKKwkJYnJlYWs7CisJY2FzZSBTUEVF RF8yNTAwOgorCWNhc2UgU1BFRURfMTAwMDoKKwkJdmFsIHw9IFNHTUlJX1NQRUVEXzEwMDA7CisJ CWJyZWFrOworCX07CisKKwlpZiAoc3RhdGUtPmR1cGxleCA9PSBEVVBMRVhfRlVMTCkKKwkJdmFs IHw9IFNHTUlJX0RVUExFWF9GVUxMOworCiAJcmVnbWFwX3dyaXRlKHNzLT5yZWdtYXBbaWRdLCBT R01TWVNfU0dNSUlfTU9ERSwgdmFsKTsKIAogCS8qIFJlbGVhc2UgUEhZQSBwb3dlciBkb3duIHN0 YXRlICovCkBAIC0xMDMsMyArMTA3LDIwIEBAIGludCBtdGtfc2dtaWlfc2V0dXBfbW9kZV9mb3Jj ZShzdHJ1Y3QgbXRrX3NnbWlpICpzcywgaW50IGlkKQogCiAJcmV0dXJuIDA7CiB9CisKK3ZvaWQg bXRrX3NnbWlpX3Jlc3RhcnRfYW4oc3RydWN0IG10a19ldGggKmV0aCwgaW50IG1hY19pZCkKK3sK KwlzdHJ1Y3QgbXRrX3NnbWlpICpzcyA9IGV0aC0+c2dtaWk7CisJdW5zaWduZWQgaW50IHZhbCwg c2lkOworCisJLyogRGVjaWRlIGhvdyBHTUFDIGFuZCBTR01JSVNZUyBiZSBtYXBwZWQgKi8KKwlz aWQgPSAoTVRLX0hBU19DQVBTKGV0aC0+c29jLT5jYXBzLCBNVEtfU0hBUkVEX1NHTUlJKSkgPwor CSAgICAgICAwIDogbWFjX2lkOworCisJaWYgKCFzcy0+cmVnbWFwW3NpZF0pCisJCXJldHVybjsK KworCXJlZ21hcF9yZWFkKHNzLT5yZWdtYXBbc2lkXSwgU0dNU1lTX1BDU19DT05UUk9MXzEsICZ2 YWwpOworCXZhbCB8PSBTR01JSV9BTl9SRVNUQVJUOworCXJlZ21hcF93cml0ZShzcy0+cmVnbWFw W3NpZF0sIFNHTVNZU19QQ1NfQ09OVFJPTF8xLCB2YWwpOworfQotLSAKMi4yMC4xCgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtbWVkaWF0ZWsg bWFpbGluZyBsaXN0CkxpbnV4LW1lZGlhdGVrQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1tZWRpYXRlawo=