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 6FAAEC3A5A1 for ; Wed, 21 Aug 2019 14:44:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 31666206BA for ; Wed, 21 Aug 2019 14:44:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="NR0LCnAa" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729417AbfHUOob (ORCPT ); Wed, 21 Aug 2019 10:44:31 -0400 Received: from mx.0dd.nl ([5.2.79.48]:54024 "EHLO mx.0dd.nl" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728608AbfHUOoa (ORCPT ); Wed, 21 Aug 2019 10:44:30 -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 569725FC82; Wed, 21 Aug 2019 16:44:28 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="NR0LCnAa"; 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 EBF431D828CA; Wed, 21 Aug 2019 16:44:27 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com EBF431D828CA DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1566398668; bh=FUnehPWEvDCSZpwfMj6cIZO6tQX8OlCeuH+pkbv90RI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NR0LCnAagFEuCNsC07urBdaJxN/E70KnciwYlnxQgSx3gvjYc1droYBv16rujNytJ Wo06/JX7tNB+kZLl1Uy6oxn7rdj2KAmrWQBI5QVVmvybq0GUlnDG170DDMNH2QkHPM Qz7ugGAmuA7AsfQucbn8txYxvZIUwtM438JRA+t4/jjpdbkW971oVlfHPafDrTw5og FTudaTiKKoUrtHZ/ZZ3Z97NFtm7QpUk4PFpB8iKNA93bSmnxge31hF4P7OFCHZswG0 xuFP7AiLWuWSYDmlbTxCqIJU2L2hxQ5zyE4n7PASti8px+mY4gk+X65lqTS64oh8mQ sk0fSGnQSijlw== From: =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= To: John Crispin , Sean Wang , Nelson Chang , "David S . Miller" , Matthias Brugger Cc: netdev@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mediatek@lists.infradead.org, linux-mips@vger.kernel.org, Frank Wunderlich , Stefan Roese , =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= Subject: [PATCH net-next v2 1/3] net: ethernet: mediatek: Add basic PHYLINK support Date: Wed, 21 Aug 2019 16:43:34 +0200 Message-Id: <20190821144336.9259-2-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190821144336.9259-1-opensource@vdorst.com> References: <20190821144336.9259-1-opensource@vdorst.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This convert the basics to PHYLINK API. SGMII support is not in this patch. Signed-off-by: RenĂ© van Dorst -- v1->v2: * Also report 1000Base-X support suggested by Russell King * Reverse christmas on many places suggested by David Miller * Rebase too pickup the mt76x8 changes. --- drivers/net/ethernet/mediatek/Kconfig | 2 +- drivers/net/ethernet/mediatek/mtk_eth_soc.c | 422 +++++++++++--------- drivers/net/ethernet/mediatek/mtk_eth_soc.h | 31 +- 3 files changed, 263 insertions(+), 192 deletions(-) diff --git a/drivers/net/ethernet/mediatek/Kconfig b/drivers/net/ethernet/mediatek/Kconfig index b76cf2e1c9dc..4968352ba188 100644 --- a/drivers/net/ethernet/mediatek/Kconfig +++ b/drivers/net/ethernet/mediatek/Kconfig @@ -9,7 +9,7 @@ if NET_VENDOR_MEDIATEK config NET_MEDIATEK_SOC tristate "MediaTek SoC Gigabit Ethernet support" - select PHYLIB + select PHYLINK ---help--- This driver supports the gigabit ethernet MACs in the MediaTek SoC family. diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c index 8ddbb8dcf032..e467172f2c26 100644 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c @@ -18,6 +18,7 @@ #include #include #include +#include #include "mtk_eth_soc.h" @@ -186,168 +187,222 @@ static void mtk_gmac0_rgmii_adjust(struct mtk_eth *eth, int speed) mtk_w32(eth, val, TRGMII_TCK_CTRL); } -static void mtk_phy_link_adjust(struct net_device *dev) +static void mtk_mac_config(struct phylink_config *config, unsigned int mode, + const struct phylink_link_state *state) { - struct mtk_mac *mac = netdev_priv(dev); - u16 lcl_adv = 0, rmt_adv = 0; - u8 flowctrl; - u32 mcr = MAC_MCR_MAX_RX_1536 | MAC_MCR_IPG_CFG | - MAC_MCR_FORCE_MODE | MAC_MCR_TX_EN | - MAC_MCR_RX_EN | MAC_MCR_BACKOFF_EN | - MAC_MCR_BACKPR_EN; + struct mtk_mac *mac = container_of(config, struct mtk_mac, + phylink_config); + struct mtk_eth *eth = mac->hw; + u32 mcr_cur, mcr_new; + int val, ge_mode = 0; + + /* MT76x8 has no hardware settings between for the MAC */ + if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628) && + mac->interface != state->interface) { + /* Setup soc pin functions */ + switch (state->interface) { + case PHY_INTERFACE_MODE_TRGMII: + if (mac->id) + goto err_phy; + if (!MTK_HAS_CAPS(mac->hw->soc->caps, + MTK_GMAC1_TRGMII)) + goto err_phy; + /* fall through */ + case PHY_INTERFACE_MODE_GMII: + case PHY_INTERFACE_MODE_RGMII_TXID: + 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; + break; + default: + goto err_phy; + } - if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state))) - return; + /* Setup clock for 1st gmac */ + if (!mac->id && + MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GMAC1_TRGMII)) { + if (MTK_HAS_CAPS(mac->hw->soc->caps, + MTK_TRGMII_MT7621_CLK)) { + if (mt7621_gmac0_rgmii_adjust(mac->hw, + state->interface)) + goto err_phy; + } else { + if (state->interface != + PHY_INTERFACE_MODE_TRGMII) + mtk_gmac0_rgmii_adjust(mac->hw, + state->speed); + } + } + + /* put the gmac into the right mode */ + regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val); + val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, mac->id); + val |= SYSCFG0_GE_MODE(ge_mode, mac->id); + regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val); + + mac->interface = state->interface; + } + + /* 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 | + MAC_MCR_FORCE_DPX | MAC_MCR_FORCE_TX_FC | + MAC_MCR_FORCE_RX_FC); + mcr_new |= MAC_MCR_MAX_RX_1536 | MAC_MCR_IPG_CFG | MAC_MCR_FORCE_MODE | + MAC_MCR_BACKOFF_EN | MAC_MCR_BACKPR_EN | MAC_MCR_FORCE_LINK; - switch (dev->phydev->speed) { + switch (state->speed) { case SPEED_1000: - mcr |= MAC_MCR_SPEED_1000; + mcr_new |= MAC_MCR_SPEED_1000; break; case SPEED_100: - mcr |= MAC_MCR_SPEED_100; + mcr_new |= MAC_MCR_SPEED_100; break; } - - if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GMAC1_TRGMII) && !mac->id) { - if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_TRGMII_MT7621_CLK)) { - if (mt7621_gmac0_rgmii_adjust(mac->hw, - dev->phydev->interface)) - return; - } else { - if (!mac->trgmii) - mtk_gmac0_rgmii_adjust(mac->hw, - dev->phydev->speed); - } + if (state->duplex == DUPLEX_FULL) { + mcr_new |= MAC_MCR_FORCE_DPX; + if (state->pause & MLO_PAUSE_TX) + mcr_new |= MAC_MCR_FORCE_TX_FC; + if (state->pause & MLO_PAUSE_RX) + mcr_new |= MAC_MCR_FORCE_RX_FC; } - if (dev->phydev->link) - mcr |= MAC_MCR_FORCE_LINK; + /* Only update control register when needed! */ + if (mcr_new != mcr_cur) + mtk_w32(mac->hw, mcr_new, MTK_MAC_MCR(mac->id)); - if (dev->phydev->duplex) { - mcr |= MAC_MCR_FORCE_DPX; + return; - if (dev->phydev->pause) - rmt_adv = LPA_PAUSE_CAP; - if (dev->phydev->asym_pause) - rmt_adv |= LPA_PAUSE_ASYM; +err_phy: + dev_err(eth->dev, "%s: GMAC%d mode %s not supported!\n", __func__, + mac->id, phy_modes(state->interface)); +} - lcl_adv = linkmode_adv_to_lcl_adv_t(dev->phydev->advertising); - flowctrl = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv); +static int mtk_mac_link_state(struct phylink_config *config, + struct phylink_link_state *state) +{ + struct mtk_mac *mac = container_of(config, struct mtk_mac, + phylink_config); + u32 pmsr = mtk_r32(mac->hw, MTK_MAC_MSR(mac->id)); - if (flowctrl & FLOW_CTRL_TX) - mcr |= MAC_MCR_FORCE_TX_FC; - if (flowctrl & FLOW_CTRL_RX) - mcr |= MAC_MCR_FORCE_RX_FC; + state->link = (pmsr & MAC_MSR_LINK); + state->duplex = (pmsr & MAC_MSR_DPX) >> 1; - netif_dbg(mac->hw, link, dev, "rx pause %s, tx pause %s\n", - flowctrl & FLOW_CTRL_RX ? "enabled" : "disabled", - flowctrl & FLOW_CTRL_TX ? "enabled" : "disabled"); + switch (pmsr & (MAC_MSR_SPEED_1000 | MAC_MSR_SPEED_100)) { + case 0: + state->speed = SPEED_10; + break; + case MAC_MSR_SPEED_100: + state->speed = SPEED_100; + break; + case MAC_MSR_SPEED_1000: + state->speed = SPEED_1000; + break; + default: + state->speed = SPEED_UNKNOWN; + break; } - mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id)); + state->pause &= (MLO_PAUSE_RX | MLO_PAUSE_TX); + if (pmsr & MAC_MSR_RX_FC) + state->pause |= MLO_PAUSE_RX; + if (pmsr & MAC_MSR_TX_FC) + state->pause |= MLO_PAUSE_TX; - if (!of_phy_is_fixed_link(mac->of_node)) - phy_print_status(dev->phydev); + return 1; } -static int mtk_phy_connect_node(struct mtk_eth *eth, struct mtk_mac *mac, - struct device_node *phy_node) +static void mtk_mac_an_restart(struct phylink_config *config) { - struct phy_device *phydev; - int phy_mode; - - phy_mode = of_get_phy_mode(phy_node); - if (phy_mode < 0) { - dev_err(eth->dev, "incorrect phy-mode %d\n", phy_mode); - return -EINVAL; - } - - phydev = of_phy_connect(eth->netdev[mac->id], phy_node, - mtk_phy_link_adjust, 0, phy_mode); - if (!phydev) { - dev_err(eth->dev, "could not connect to PHY\n"); - return -ENODEV; - } + /* Do nothing */ +} - dev_info(eth->dev, - "connected mac %d to PHY at %s [uid=%08x, driver=%s]\n", - mac->id, phydev_name(phydev), phydev->phy_id, - phydev->drv->name); +static void mtk_mac_link_down(struct phylink_config *config, unsigned int mode, + phy_interface_t interface) +{ + struct mtk_mac *mac = container_of(config, struct mtk_mac, + phylink_config); - return 0; + mtk_w32(mac->hw, MAC_MCR_FORCE_LINK_DOWN, MTK_MAC_MCR(mac->id)); } -static int mtk_phy_connect(struct net_device *dev) +static void mtk_mac_link_up(struct phylink_config *config, unsigned int mode, + phy_interface_t interface, + struct phy_device *phy) { - struct mtk_mac *mac = netdev_priv(dev); - struct mtk_eth *eth; - struct device_node *np; - u32 val; - int err; + struct mtk_mac *mac = container_of(config, struct mtk_mac, + phylink_config); + u32 mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id)); - eth = mac->hw; - np = of_parse_phandle(mac->of_node, "phy-handle", 0); - if (!np && of_phy_is_fixed_link(mac->of_node)) - if (!of_phy_register_fixed_link(mac->of_node)) - np = of_node_get(mac->of_node); - if (!np) - return -ENODEV; + mcr |= MAC_MCR_TX_EN | MAC_MCR_RX_EN; + mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id)); +} - err = mtk_setup_hw_path(eth, mac->id, of_get_phy_mode(np)); - if (err) - goto err_phy; - - mac->ge_mode = 0; - switch (of_get_phy_mode(np)) { - case PHY_INTERFACE_MODE_TRGMII: - mac->trgmii = true; - 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_SGMII: - break; - case PHY_INTERFACE_MODE_MII: - case PHY_INTERFACE_MODE_GMII: - mac->ge_mode = 1; - break; - case PHY_INTERFACE_MODE_REVMII: - mac->ge_mode = 2; - break; - case PHY_INTERFACE_MODE_RMII: - if (!mac->id) - goto err_phy; - mac->ge_mode = 3; - break; - default: - goto err_phy; - } +static void mtk_validate(struct phylink_config *config, + unsigned long *supported, + struct phylink_link_state *state) +{ + struct mtk_mac *mac = container_of(config, struct mtk_mac, + phylink_config); + __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, }; - /* No MT7628/88 support for now */ - if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) { - /* put the gmac into the right mode */ - regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val); - val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, mac->id); - val |= SYSCFG0_GE_MODE(mac->ge_mode, mac->id); - regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val); + if (state->interface != PHY_INTERFACE_MODE_NA && + state->interface != PHY_INTERFACE_MODE_MII && + state->interface != PHY_INTERFACE_MODE_GMII && + !(MTK_HAS_CAPS(mac->hw->soc->caps, MTK_RGMII) && + phy_interface_mode_is_rgmii(state->interface)) && + !(MTK_HAS_CAPS(mac->hw->soc->caps, MTK_TRGMII) && + !mac->id && state->interface == PHY_INTERFACE_MODE_TRGMII)) { + linkmode_zero(supported); + return; } - /* couple phydev to net_device */ - if (mtk_phy_connect_node(eth, mac, np)) - goto err_phy; + phylink_set_port_modes(mask); + phylink_set(mask, Autoneg); - of_node_put(np); + 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); + phylink_set(mask, 1000baseX_Full); + } + } - return 0; + phylink_set(mask, Pause); + phylink_set(mask, Asym_Pause); -err_phy: - if (of_phy_is_fixed_link(mac->of_node)) - of_phy_deregister_fixed_link(mac->of_node); - of_node_put(np); - dev_err(eth->dev, "%s: invalid phy\n", __func__); - return -EINVAL; + linkmode_and(supported, supported, mask); + linkmode_and(state->advertising, state->advertising, mask); } +static const struct phylink_mac_ops mtk_phylink_ops = { + .validate = mtk_validate, + .mac_link_state = mtk_mac_link_state, + .mac_an_restart = mtk_mac_an_restart, + .mac_config = mtk_mac_config, + .mac_link_down = mtk_mac_link_down, + .mac_link_up = mtk_mac_link_up, +}; + static int mtk_mdio_init(struct mtk_eth *eth) { struct device_node *mii_np; @@ -2013,6 +2068,14 @@ static int mtk_open(struct net_device *dev) { struct mtk_mac *mac = netdev_priv(dev); struct mtk_eth *eth = mac->hw; + int err; + + err = phylink_of_phy_connect(mac->phylink, mac->of_node, 0); + if (err) { + netdev_err(dev, "%s: could not attach PHY: %d\n", __func__, + err); + return err; + } /* we run 2 netdevs on the same dma ring so we only bring it up once */ if (!refcount_read(ð->dma_refcnt)) { @@ -2030,7 +2093,7 @@ static int mtk_open(struct net_device *dev) else refcount_inc(ð->dma_refcnt); - phy_start(dev->phydev); + phylink_start(mac->phylink); netif_start_queue(dev); return 0; } @@ -2063,8 +2126,11 @@ static int mtk_stop(struct net_device *dev) struct mtk_mac *mac = netdev_priv(dev); struct mtk_eth *eth = mac->hw; + phylink_stop(mac->phylink); + netif_tx_disable(dev); - phy_stop(dev->phydev); + + phylink_disconnect_phy(mac->phylink); /* only shutdown DMA if this is the last user */ if (!refcount_dec_and_test(ð->dma_refcnt)) @@ -2159,15 +2225,6 @@ static int mtk_hw_init(struct mtk_eth *eth) ethsys_reset(eth, RSTCTRL_FE); ethsys_reset(eth, RSTCTRL_PPE); - regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val); - for (i = 0; i < MTK_MAC_COUNT; i++) { - if (!eth->mac[i]) - continue; - val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, eth->mac[i]->id); - val |= SYSCFG0_GE_MODE(eth->mac[i]->ge_mode, eth->mac[i]->id); - } - regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val); - if (eth->pctl) { /* Set GE2 driving and slew rate */ regmap_write(eth->pctl, GPIO_DRV_SEL10, 0xa00); @@ -2180,11 +2237,11 @@ static int mtk_hw_init(struct mtk_eth *eth) } /* Set linkdown as the default for each GMAC. Its own MCR would be set - * up with the more appropriate value when mtk_phy_link_adjust call is - * being invoked. + * up with the more appropriate value when mtk_mac_config call is being + * invoked. */ for (i = 0; i < MTK_MAC_COUNT; i++) - mtk_w32(eth, 0, MTK_MAC_MCR(i)); + mtk_w32(eth, MAC_MCR_FORCE_LINK_DOWN, MTK_MAC_MCR(i)); /* Indicates CDM to parse the MTK special tag from CPU * which also is working out for untag packets. @@ -2212,7 +2269,7 @@ static int mtk_hw_init(struct mtk_eth *eth) mtk_w32(eth, MTK_RX_DONE_INT, MTK_QDMA_INT_GRP2); mtk_w32(eth, 0x21021000, MTK_FE_INT_GRP); - for (i = 0; i < 2; i++) { + for (i = 0; i < MTK_MAC_COUNT; i++) { u32 val = mtk_r32(eth, MTK_GDMA_FWD_CFG(i)); /* setup the forward port to send frame to PDMA */ @@ -2264,7 +2321,7 @@ static int __init mtk_init(struct net_device *dev) dev->dev_addr); } - return mtk_phy_connect(dev); + return 0; } static void mtk_uninit(struct net_device *dev) @@ -2272,20 +2329,20 @@ static void mtk_uninit(struct net_device *dev) struct mtk_mac *mac = netdev_priv(dev); struct mtk_eth *eth = mac->hw; - phy_disconnect(dev->phydev); - if (of_phy_is_fixed_link(mac->of_node)) - of_phy_deregister_fixed_link(mac->of_node); + phylink_disconnect_phy(mac->phylink); mtk_tx_irq_disable(eth, ~0); mtk_rx_irq_disable(eth, ~0); } static int mtk_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) { + struct mtk_mac *mac = netdev_priv(dev); + switch (cmd) { case SIOCGMIIPHY: case SIOCGMIIREG: case SIOCSMIIREG: - return phy_mii_ioctl(dev->phydev, ifr, cmd); + return phylink_mii_ioctl(mac->phylink, ifr, cmd); default: break; } @@ -2326,16 +2383,6 @@ static void mtk_pending_work(struct work_struct *work) eth->dev->pins->default_state); mtk_hw_init(eth); - for (i = 0; i < MTK_MAC_COUNT; i++) { - if (!eth->mac[i] || - of_phy_is_fixed_link(eth->mac[i]->of_node)) - continue; - err = phy_init_hw(eth->netdev[i]->phydev); - if (err) - dev_err(eth->dev, "%s: PHY init failed.\n", - eth->netdev[i]->name); - } - /* restart DMA and enable IRQs */ for (i = 0; i < MTK_MAC_COUNT; i++) { if (!test_bit(i, &restart)) @@ -2398,9 +2445,7 @@ static int mtk_get_link_ksettings(struct net_device *ndev, if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state))) return -EBUSY; - phy_ethtool_ksettings_get(ndev->phydev, cmd); - - return 0; + return phylink_ethtool_ksettings_get(mac->phylink, cmd); } static int mtk_set_link_ksettings(struct net_device *ndev, @@ -2411,7 +2456,7 @@ static int mtk_set_link_ksettings(struct net_device *ndev, if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state))) return -EBUSY; - return phy_ethtool_ksettings_set(ndev->phydev, cmd); + return phylink_ethtool_ksettings_set(mac->phylink, cmd); } static void mtk_get_drvinfo(struct net_device *dev, @@ -2445,22 +2490,10 @@ static int mtk_nway_reset(struct net_device *dev) if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state))) return -EBUSY; - return genphy_restart_aneg(dev->phydev); -} + if (!mac->phylink) + return -ENOTSUPP; -static u32 mtk_get_link(struct net_device *dev) -{ - struct mtk_mac *mac = netdev_priv(dev); - int err; - - if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state))) - return -EBUSY; - - err = genphy_update_link(dev->phydev); - if (err) - return ethtool_op_get_link(dev); - - return dev->phydev->link; + return phylink_ethtool_nway_reset(mac->phylink); } static void mtk_get_strings(struct net_device *dev, u32 stringset, u8 *data) @@ -2580,7 +2613,7 @@ static const struct ethtool_ops mtk_ethtool_ops = { .get_msglevel = mtk_get_msglevel, .set_msglevel = mtk_set_msglevel, .nway_reset = mtk_nway_reset, - .get_link = mtk_get_link, + .get_link = ethtool_op_get_link, .get_strings = mtk_get_strings, .get_sset_count = mtk_get_sset_count, .get_ethtool_stats = mtk_get_ethtool_stats, @@ -2608,9 +2641,10 @@ static const struct net_device_ops mtk_netdev_ops = { static int mtk_add_mac(struct mtk_eth *eth, struct device_node *np) { - struct mtk_mac *mac; const __be32 *_id = of_get_property(np, "reg", NULL); - int id, err; + struct phylink *phylink; + int phy_mode, id, err; + struct mtk_mac *mac; if (!_id) { dev_err(eth->dev, "missing mac id\n"); @@ -2654,6 +2688,32 @@ static int mtk_add_mac(struct mtk_eth *eth, struct device_node *np) u64_stats_init(&mac->hw_stats->syncp); mac->hw_stats->reg_offset = id * MTK_STAT_OFFSET; + /* phylink create */ + phy_mode = of_get_phy_mode(np); + if (phy_mode < 0) { + dev_err(eth->dev, "incorrect phy-mode\n"); + err = -EINVAL; + goto free_netdev; + } + + /* mac config is not set */ + mac->interface = PHY_INTERFACE_MODE_NA; + mac->mode = MLO_AN_PHY; + mac->speed = SPEED_UNKNOWN; + + mac->phylink_config.dev = ð->netdev[id]->dev; + mac->phylink_config.type = PHYLINK_NETDEV; + + phylink = phylink_create(&mac->phylink_config, + of_fwnode_handle(mac->of_node), + phy_mode, &mtk_phylink_ops); + if (IS_ERR(phylink)) { + err = PTR_ERR(phylink); + goto free_netdev; + } + + mac->phylink = phylink; + SET_NETDEV_DEV(eth->netdev[id], eth->dev); eth->netdev[id]->watchdog_timeo = 5 * HZ; eth->netdev[id]->netdev_ops = &mtk_netdev_ops; @@ -2682,8 +2742,7 @@ static int mtk_probe(struct platform_device *pdev) { struct device_node *mac_np; struct mtk_eth *eth; - int err; - int i; + int err, i; eth = devm_kzalloc(&pdev->dev, sizeof(*eth), GFP_KERNEL); if (!eth) @@ -2869,6 +2928,7 @@ static int mtk_probe(struct platform_device *pdev) static int mtk_remove(struct platform_device *pdev) { struct mtk_eth *eth = platform_get_drvdata(pdev); + struct mtk_mac *mac; int i; /* stop all devices to make sure that dma is properly shut down */ @@ -2876,6 +2936,8 @@ static int mtk_remove(struct platform_device *pdev) if (!eth->netdev[i]) continue; mtk_stop(eth->netdev[i]); + mac = netdev_priv(eth->netdev[i]); + phylink_disconnect_phy(mac->phylink); } mtk_hw_deinit(eth); diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.h b/drivers/net/ethernet/mediatek/mtk_eth_soc.h index cc1466ae0926..7f5f541daad7 100644 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.h +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.h @@ -14,6 +14,7 @@ #include #include #include +#include #define MTK_QDMA_PAGE_SIZE 2048 #define MTK_MAX_RX_LENGTH 1536 @@ -330,12 +331,19 @@ #define MAC_MCR_SPEED_100 BIT(2) #define MAC_MCR_FORCE_DPX BIT(1) #define MAC_MCR_FORCE_LINK BIT(0) -#define MAC_MCR_FIXED_LINK (MAC_MCR_MAX_RX_1536 | MAC_MCR_IPG_CFG | \ - MAC_MCR_FORCE_MODE | MAC_MCR_TX_EN | \ - MAC_MCR_RX_EN | MAC_MCR_BACKOFF_EN | \ - MAC_MCR_BACKPR_EN | MAC_MCR_FORCE_RX_FC | \ - MAC_MCR_FORCE_TX_FC | MAC_MCR_SPEED_1000 | \ - MAC_MCR_FORCE_DPX | MAC_MCR_FORCE_LINK) +#define MAC_MCR_FORCE_LINK_DOWN (MAC_MCR_FORCE_MODE) + +/* Mac status registers */ +#define MTK_MAC_MSR(x) (0x10108 + (x * 0x100)) +#define MAC_MSR_EEE1G BIT(7) +#define MAC_MSR_EEE100M BIT(6) +#define MAC_MSR_RX_FC BIT(5) +#define MAC_MSR_TX_FC BIT(4) +#define MAC_MSR_SPEED_1000 BIT(3) +#define MAC_MSR_SPEED_100 BIT(2) +#define MAC_MSR_SPEED_MASK (MAC_MSR_SPEED_1000 | MAC_MSR_SPEED_100) +#define MAC_MSR_DPX BIT(1) +#define MAC_MSR_LINK BIT(0) /* TRGMII RXC control register */ #define TRGMII_RCK_CTRL 0x10300 @@ -858,22 +866,23 @@ struct mtk_eth { /* struct mtk_mac - the structure that holds the info about the MACs of the * SoC * @id: The number of the MAC - * @ge_mode: Interface mode kept for setup restoring + * @interface: Interface mode kept for detecting change in hw settings * @of_node: Our devicetree node * @hw: Backpointer to our main datastruture * @hw_stats: Packet statistics counter - * @trgmii Indicate if the MAC uses TRGMII connected to internal - switch */ struct mtk_mac { int id; - int ge_mode; + phy_interface_t interface; + unsigned int mode; + int speed; struct device_node *of_node; + struct phylink *phylink; + struct phylink_config phylink_config; struct mtk_eth *hw; struct mtk_hw_stats *hw_stats; __be32 hwlro_ip[MTK_MAX_LRO_IP_CNT]; int hwlro_ip_cnt; - bool trgmii; }; /* the struct describing the SoC. these are declared in the soc_xyz.c files */ -- 2.20.1 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=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham 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 0A2EDC3A59E for ; Wed, 21 Aug 2019 14:44:52 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id C1E1B206BA for ; Wed, 21 Aug 2019 14:44:51 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="khJ2fYt0"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="NR0LCnAa" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C1E1B206BA Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=vdorst.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=aWiUTNLaeM/isQmGmiqFxrOlb78m5ztSPaG/4SAjmEQ=; b=khJ2fYt0pZch/T getTtJHIQQ39Hxh3yBw314GkboN0jWW7GUh8QSH/GkpbrQbHRFuoRdE1Ive7J74urleE5SWP/JrAi Dj41PyxK6a65a8i/JO62vfIzjSMocTaew1Q7rH8QXv6uOfnIDcgh/8ILuqizS5GeTdR4fivlN4vQw FD+gRUGUzAec0vrr8W8MmUr1QdZNTKd04vBcPB0rWvU/8ClS/1GFbjZZKoYxqE91gYqGl29yTE3Ap 0WMsMhcxX4Q4yEr21JgRmne3KQ2Uj8T38RdugfihsVKF91urmq3QpY8Sv572lXPuqUoxgFHlVHB34 jRCSG+s/9+mVTy5AnfFQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1i0Rr1-0005Ev-3O; Wed, 21 Aug 2019 14:44:51 +0000 Received: from mx.0dd.nl ([2a04:52c0:101:921::25]) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1i0Rqj-0004yj-EQ; Wed, 21 Aug 2019 14:44:37 +0000 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 569725FC82; Wed, 21 Aug 2019 16:44:28 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="NR0LCnAa"; 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 EBF431D828CA; Wed, 21 Aug 2019 16:44:27 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com EBF431D828CA DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1566398668; bh=FUnehPWEvDCSZpwfMj6cIZO6tQX8OlCeuH+pkbv90RI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NR0LCnAagFEuCNsC07urBdaJxN/E70KnciwYlnxQgSx3gvjYc1droYBv16rujNytJ Wo06/JX7tNB+kZLl1Uy6oxn7rdj2KAmrWQBI5QVVmvybq0GUlnDG170DDMNH2QkHPM Qz7ugGAmuA7AsfQucbn8txYxvZIUwtM438JRA+t4/jjpdbkW971oVlfHPafDrTw5og FTudaTiKKoUrtHZ/ZZ3Z97NFtm7QpUk4PFpB8iKNA93bSmnxge31hF4P7OFCHZswG0 xuFP7AiLWuWSYDmlbTxCqIJU2L2hxQ5zyE4n7PASti8px+mY4gk+X65lqTS64oh8mQ sk0fSGnQSijlw== From: =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= To: John Crispin , Sean Wang , Nelson Chang , "David S . Miller" , Matthias Brugger Subject: [PATCH net-next v2 1/3] net: ethernet: mediatek: Add basic PHYLINK support Date: Wed, 21 Aug 2019 16:43:34 +0200 Message-Id: <20190821144336.9259-2-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190821144336.9259-1-opensource@vdorst.com> References: <20190821144336.9259-1-opensource@vdorst.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190821_074433_903148_0CDCB36B X-CRM114-Status: GOOD ( 22.91 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Frank Wunderlich , netdev@vger.kernel.org, linux-mips@vger.kernel.org, =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= , linux-mediatek@lists.infradead.org, Stefan Roese , linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhpcyBjb252ZXJ0IHRoZSBiYXNpY3MgdG8gUEhZTElOSyBBUEkuClNHTUlJIHN1cHBvcnQgaXMg bm90IGluIHRoaXMgcGF0Y2guCgpTaWduZWQtb2ZmLWJ5OiBSZW7DqSB2YW4gRG9yc3QgPG9wZW5z b3VyY2VAdmRvcnN0LmNvbT4KLS0KdjEtPnYyOgoqIEFsc28gcmVwb3J0IDEwMDBCYXNlLVggc3Vw cG9ydCBzdWdnZXN0ZWQgYnkgUnVzc2VsbCBLaW5nCiogUmV2ZXJzZSBjaHJpc3RtYXMgb24gbWFu eSBwbGFjZXMgc3VnZ2VzdGVkIGJ5IERhdmlkIE1pbGxlcgoqIFJlYmFzZSB0b28gcGlja3VwIHRo ZSBtdDc2eDggY2hhbmdlcy4KLS0tCiBkcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9LY29u ZmlnICAgICAgIHwgICAyICstCiBkcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRo X3NvYy5jIHwgNDIyICsrKysrKysrKysrLS0tLS0tLS0tCiBkcml2ZXJzL25ldC9ldGhlcm5ldC9t ZWRpYXRlay9tdGtfZXRoX3NvYy5oIHwgIDMxICstCiAzIGZpbGVzIGNoYW5nZWQsIDI2MyBpbnNl cnRpb25zKCspLCAxOTIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRo ZXJuZXQvbWVkaWF0ZWsvS2NvbmZpZyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL0tj b25maWcKaW5kZXggYjc2Y2YyZTFjOWRjLi40OTY4MzUyYmExODggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL0tjb25maWcKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJu ZXQvbWVkaWF0ZWsvS2NvbmZpZwpAQCAtOSw3ICs5LDcgQEAgaWYgTkVUX1ZFTkRPUl9NRURJQVRF SwogCiBjb25maWcgTkVUX01FRElBVEVLX1NPQwogCXRyaXN0YXRlICJNZWRpYVRlayBTb0MgR2ln YWJpdCBFdGhlcm5ldCBzdXBwb3J0IgotCXNlbGVjdCBQSFlMSUIKKwlzZWxlY3QgUEhZTElOSwog CS0tLWhlbHAtLS0KIAkgIFRoaXMgZHJpdmVyIHN1cHBvcnRzIHRoZSBnaWdhYml0IGV0aGVybmV0 IE1BQ3MgaW4gdGhlCiAJICBNZWRpYVRlayBTb0MgZmFtaWx5LgpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuYyBiL2RyaXZlcnMvbmV0L2V0aGVy bmV0L21lZGlhdGVrL210a19ldGhfc29jLmMKaW5kZXggOGRkYmI4ZGNmMDMyLi5lNDY3MTcyZjJj MjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29j LmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuYwpAQCAt MTgsNiArMTgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3RjcC5oPgogI2luY2x1ZGUgPGxpbnV4L2lu dGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvZGV2aW5mby5oPgorI2luY2x1ZGUg PGxpbnV4L3BoeWxpbmsuaD4KIAogI2luY2x1ZGUgIm10a19ldGhfc29jLmgiCiAKQEAgLTE4Niwx NjggKzE4NywyMjIgQEAgc3RhdGljIHZvaWQgbXRrX2dtYWMwX3JnbWlpX2FkanVzdChzdHJ1Y3Qg bXRrX2V0aCAqZXRoLCBpbnQgc3BlZWQpCiAJbXRrX3czMihldGgsIHZhbCwgVFJHTUlJX1RDS19D VFJMKTsKIH0KIAotc3RhdGljIHZvaWQgbXRrX3BoeV9saW5rX2FkanVzdChzdHJ1Y3QgbmV0X2Rl dmljZSAqZGV2KQorc3RhdGljIHZvaWQgbXRrX21hY19jb25maWcoc3RydWN0IHBoeWxpbmtfY29u ZmlnICpjb25maWcsIHVuc2lnbmVkIGludCBtb2RlLAorCQkJICAgY29uc3Qgc3RydWN0IHBoeWxp bmtfbGlua19zdGF0ZSAqc3RhdGUpCiB7Ci0Jc3RydWN0IG10a19tYWMgKm1hYyA9IG5ldGRldl9w cml2KGRldik7Ci0JdTE2IGxjbF9hZHYgPSAwLCBybXRfYWR2ID0gMDsKLQl1OCBmbG93Y3RybDsK LQl1MzIgbWNyID0gTUFDX01DUl9NQVhfUlhfMTUzNiB8IE1BQ19NQ1JfSVBHX0NGRyB8Ci0JCSAg TUFDX01DUl9GT1JDRV9NT0RFIHwgTUFDX01DUl9UWF9FTiB8Ci0JCSAgTUFDX01DUl9SWF9FTiB8 IE1BQ19NQ1JfQkFDS09GRl9FTiB8Ci0JCSAgTUFDX01DUl9CQUNLUFJfRU47CisJc3RydWN0IG10 a19tYWMgKm1hYyA9IGNvbnRhaW5lcl9vZihjb25maWcsIHN0cnVjdCBtdGtfbWFjLAorCQkJCQkg ICBwaHlsaW5rX2NvbmZpZyk7CisJc3RydWN0IG10a19ldGggKmV0aCA9IG1hYy0+aHc7CisJdTMy IG1jcl9jdXIsIG1jcl9uZXc7CisJaW50IHZhbCwgZ2VfbW9kZSA9IDA7CisKKwkvKiBNVDc2eDgg aGFzIG5vIGhhcmR3YXJlIHNldHRpbmdzIGJldHdlZW4gZm9yIHRoZSBNQUMgKi8KKwlpZiAoIU1U S19IQVNfQ0FQUyhldGgtPnNvYy0+Y2FwcywgTVRLX1NPQ19NVDc2MjgpICYmCisJICAgIG1hYy0+ aW50ZXJmYWNlICE9IHN0YXRlLT5pbnRlcmZhY2UpIHsKKwkJLyogU2V0dXAgc29jIHBpbiBmdW5j dGlvbnMgKi8KKwkJc3dpdGNoIChzdGF0ZS0+aW50ZXJmYWNlKSB7CisJCWNhc2UgUEhZX0lOVEVS RkFDRV9NT0RFX1RSR01JSToKKwkJCWlmIChtYWMtPmlkKQorCQkJCWdvdG8gZXJyX3BoeTsKKwkJ CWlmICghTVRLX0hBU19DQVBTKG1hYy0+aHctPnNvYy0+Y2FwcywKKwkJCQkJICBNVEtfR01BQzFf VFJHTUlJKSkKKwkJCQlnb3RvIGVycl9waHk7CisJCQkvKiBmYWxsIHRocm91Z2ggKi8KKwkJY2Fz ZSBQSFlfSU5URVJGQUNFX01PREVfR01JSToKKwkJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdN SUlfVFhJRDoKKwkJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdNSUlfUlhJRDoKKwkJY2FzZSBQ SFlfSU5URVJGQUNFX01PREVfUkdNSUlfSUQ6CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JH TUlJOgorCQkJYnJlYWs7CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX01JSToKKwkJCWdlX21v ZGUgPSAxOworCQkJYnJlYWs7CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JFVk1JSToKKwkJ CWdlX21vZGUgPSAyOworCQkJYnJlYWs7CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JNSUk6 CisJCQlpZiAobWFjLT5pZCkKKwkJCQlnb3RvIGVycl9waHk7CisJCQlnZV9tb2RlID0gMzsKKwkJ CWJyZWFrOworCQlkZWZhdWx0OgorCQkJZ290byBlcnJfcGh5OworCQl9CiAKLQlpZiAodW5saWtl bHkodGVzdF9iaXQoTVRLX1JFU0VUVElORywgJm1hYy0+aHctPnN0YXRlKSkpCi0JCXJldHVybjsK KwkJLyogU2V0dXAgY2xvY2sgZm9yIDFzdCBnbWFjICovCisJCWlmICghbWFjLT5pZCAmJgorCQkg ICAgTVRLX0hBU19DQVBTKG1hYy0+aHctPnNvYy0+Y2FwcywgTVRLX0dNQUMxX1RSR01JSSkpIHsK KwkJCWlmIChNVEtfSEFTX0NBUFMobWFjLT5ody0+c29jLT5jYXBzLAorCQkJCQkgTVRLX1RSR01J SV9NVDc2MjFfQ0xLKSkgeworCQkJCWlmIChtdDc2MjFfZ21hYzBfcmdtaWlfYWRqdXN0KG1hYy0+ aHcsCisJCQkJCQkJICAgICAgc3RhdGUtPmludGVyZmFjZSkpCisJCQkJCWdvdG8gZXJyX3BoeTsK KwkJCX0gZWxzZSB7CisJCQkJaWYgKHN0YXRlLT5pbnRlcmZhY2UgIT0KKwkJCQkgICAgUEhZX0lO VEVSRkFDRV9NT0RFX1RSR01JSSkKKwkJCQkJbXRrX2dtYWMwX3JnbWlpX2FkanVzdChtYWMtPmh3 LAorCQkJCQkJCSAgICAgICBzdGF0ZS0+c3BlZWQpOworCQkJfQorCQl9CisKKwkJLyogcHV0IHRo ZSBnbWFjIGludG8gdGhlIHJpZ2h0IG1vZGUgKi8KKwkJcmVnbWFwX3JlYWQoZXRoLT5ldGhzeXMs IEVUSFNZU19TWVNDRkcwLCAmdmFsKTsKKwkJdmFsICY9IH5TWVNDRkcwX0dFX01PREUoU1lTQ0ZH MF9HRV9NQVNLLCBtYWMtPmlkKTsKKwkJdmFsIHw9IFNZU0NGRzBfR0VfTU9ERShnZV9tb2RlLCBt YWMtPmlkKTsKKwkJcmVnbWFwX3dyaXRlKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgdmFs KTsKKworCQltYWMtPmludGVyZmFjZSA9IHN0YXRlLT5pbnRlcmZhY2U7CisJfQorCisJLyogU2V0 dXAgZ21hYyAqLworCW1jcl9jdXIgPSBtdGtfcjMyKG1hYy0+aHcsIE1US19NQUNfTUNSKG1hYy0+ aWQpKTsKKwltY3JfbmV3ID0gbWNyX2N1cjsKKwltY3JfbmV3ICY9IH4oTUFDX01DUl9TUEVFRF8x MDAgfCBNQUNfTUNSX1NQRUVEXzEwMDAgfAorCQkgICAgIE1BQ19NQ1JfRk9SQ0VfRFBYIHwgTUFD X01DUl9GT1JDRV9UWF9GQyB8CisJCSAgICAgTUFDX01DUl9GT1JDRV9SWF9GQyk7CisJbWNyX25l dyB8PSBNQUNfTUNSX01BWF9SWF8xNTM2IHwgTUFDX01DUl9JUEdfQ0ZHIHwgTUFDX01DUl9GT1JD RV9NT0RFIHwKKwkJICAgTUFDX01DUl9CQUNLT0ZGX0VOIHwgTUFDX01DUl9CQUNLUFJfRU4gfCBN QUNfTUNSX0ZPUkNFX0xJTks7CiAKLQlzd2l0Y2ggKGRldi0+cGh5ZGV2LT5zcGVlZCkgeworCXN3 aXRjaCAoc3RhdGUtPnNwZWVkKSB7CiAJY2FzZSBTUEVFRF8xMDAwOgotCQltY3IgfD0gTUFDX01D Ul9TUEVFRF8xMDAwOworCQltY3JfbmV3IHw9IE1BQ19NQ1JfU1BFRURfMTAwMDsKIAkJYnJlYWs7 CiAJY2FzZSBTUEVFRF8xMDA6Ci0JCW1jciB8PSBNQUNfTUNSX1NQRUVEXzEwMDsKKwkJbWNyX25l dyB8PSBNQUNfTUNSX1NQRUVEXzEwMDsKIAkJYnJlYWs7CiAJfQotCi0JaWYgKE1US19IQVNfQ0FQ UyhtYWMtPmh3LT5zb2MtPmNhcHMsIE1US19HTUFDMV9UUkdNSUkpICYmICFtYWMtPmlkKSB7Ci0J CWlmIChNVEtfSEFTX0NBUFMobWFjLT5ody0+c29jLT5jYXBzLCBNVEtfVFJHTUlJX01UNzYyMV9D TEspKSB7Ci0JCQlpZiAobXQ3NjIxX2dtYWMwX3JnbWlpX2FkanVzdChtYWMtPmh3LAotCQkJCQkJ ICAgICAgZGV2LT5waHlkZXYtPmludGVyZmFjZSkpCi0JCQkJcmV0dXJuOwotCQl9IGVsc2Ugewot CQkJaWYgKCFtYWMtPnRyZ21paSkKLQkJCQltdGtfZ21hYzBfcmdtaWlfYWRqdXN0KG1hYy0+aHcs Ci0JCQkJCQkgICAgICAgZGV2LT5waHlkZXYtPnNwZWVkKTsKLQkJfQorCWlmIChzdGF0ZS0+ZHVw bGV4ID09IERVUExFWF9GVUxMKSB7CisJCW1jcl9uZXcgfD0gTUFDX01DUl9GT1JDRV9EUFg7CisJ CWlmIChzdGF0ZS0+cGF1c2UgJiBNTE9fUEFVU0VfVFgpCisJCQltY3JfbmV3IHw9IE1BQ19NQ1Jf Rk9SQ0VfVFhfRkM7CisJCWlmIChzdGF0ZS0+cGF1c2UgJiBNTE9fUEFVU0VfUlgpCisJCQltY3Jf bmV3IHw9IE1BQ19NQ1JfRk9SQ0VfUlhfRkM7CiAJfQogCi0JaWYgKGRldi0+cGh5ZGV2LT5saW5r KQotCQltY3IgfD0gTUFDX01DUl9GT1JDRV9MSU5LOworCS8qIE9ubHkgdXBkYXRlIGNvbnRyb2wg cmVnaXN0ZXIgd2hlbiBuZWVkZWQhICovCisJaWYgKG1jcl9uZXcgIT0gbWNyX2N1cikKKwkJbXRr X3czMihtYWMtPmh3LCBtY3JfbmV3LCBNVEtfTUFDX01DUihtYWMtPmlkKSk7CiAKLQlpZiAoZGV2 LT5waHlkZXYtPmR1cGxleCkgewotCQltY3IgfD0gTUFDX01DUl9GT1JDRV9EUFg7CisJcmV0dXJu OwogCi0JCWlmIChkZXYtPnBoeWRldi0+cGF1c2UpCi0JCQlybXRfYWR2ID0gTFBBX1BBVVNFX0NB UDsKLQkJaWYgKGRldi0+cGh5ZGV2LT5hc3ltX3BhdXNlKQotCQkJcm10X2FkdiB8PSBMUEFfUEFV U0VfQVNZTTsKK2Vycl9waHk6CisJZGV2X2VycihldGgtPmRldiwgIiVzOiBHTUFDJWQgbW9kZSAl cyBub3Qgc3VwcG9ydGVkIVxuIiwgX19mdW5jX18sCisJCW1hYy0+aWQsIHBoeV9tb2RlcyhzdGF0 ZS0+aW50ZXJmYWNlKSk7Cit9CiAKLQkJbGNsX2FkdiA9IGxpbmttb2RlX2Fkdl90b19sY2xfYWR2 X3QoZGV2LT5waHlkZXYtPmFkdmVydGlzaW5nKTsKLQkJZmxvd2N0cmwgPSBtaWlfcmVzb2x2ZV9m bG93Y3RybF9mZHgobGNsX2Fkdiwgcm10X2Fkdik7CitzdGF0aWMgaW50IG10a19tYWNfbGlua19z dGF0ZShzdHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywKKwkJCSAgICAgIHN0cnVjdCBwaHls aW5rX2xpbmtfc3RhdGUgKnN0YXRlKQoreworCXN0cnVjdCBtdGtfbWFjICptYWMgPSBjb250YWlu ZXJfb2YoY29uZmlnLCBzdHJ1Y3QgbXRrX21hYywKKwkJCQkJICAgcGh5bGlua19jb25maWcpOwor CXUzMiBwbXNyID0gbXRrX3IzMihtYWMtPmh3LCBNVEtfTUFDX01TUihtYWMtPmlkKSk7CiAKLQkJ aWYgKGZsb3djdHJsICYgRkxPV19DVFJMX1RYKQotCQkJbWNyIHw9IE1BQ19NQ1JfRk9SQ0VfVFhf RkM7Ci0JCWlmIChmbG93Y3RybCAmIEZMT1dfQ1RSTF9SWCkKLQkJCW1jciB8PSBNQUNfTUNSX0ZP UkNFX1JYX0ZDOworCXN0YXRlLT5saW5rID0gKHBtc3IgJiBNQUNfTVNSX0xJTkspOworCXN0YXRl LT5kdXBsZXggPSAocG1zciAmIE1BQ19NU1JfRFBYKSA+PiAxOwogCi0JCW5ldGlmX2RiZyhtYWMt Pmh3LCBsaW5rLCBkZXYsICJyeCBwYXVzZSAlcywgdHggcGF1c2UgJXNcbiIsCi0JCQkgIGZsb3dj dHJsICYgRkxPV19DVFJMX1JYID8gImVuYWJsZWQiIDogImRpc2FibGVkIiwKLQkJCSAgZmxvd2N0 cmwgJiBGTE9XX0NUUkxfVFggPyAiZW5hYmxlZCIgOiAiZGlzYWJsZWQiKTsKKwlzd2l0Y2ggKHBt c3IgJiAoTUFDX01TUl9TUEVFRF8xMDAwIHwgTUFDX01TUl9TUEVFRF8xMDApKSB7CisJY2FzZSAw OgorCQlzdGF0ZS0+c3BlZWQgPSBTUEVFRF8xMDsKKwkJYnJlYWs7CisJY2FzZSBNQUNfTVNSX1NQ RUVEXzEwMDoKKwkJc3RhdGUtPnNwZWVkID0gU1BFRURfMTAwOworCQlicmVhazsKKwljYXNlIE1B Q19NU1JfU1BFRURfMTAwMDoKKwkJc3RhdGUtPnNwZWVkID0gU1BFRURfMTAwMDsKKwkJYnJlYWs7 CisJZGVmYXVsdDoKKwkJc3RhdGUtPnNwZWVkID0gU1BFRURfVU5LTk9XTjsKKwkJYnJlYWs7CiAJ fQogCi0JbXRrX3czMihtYWMtPmh3LCBtY3IsIE1US19NQUNfTUNSKG1hYy0+aWQpKTsKKwlzdGF0 ZS0+cGF1c2UgJj0gKE1MT19QQVVTRV9SWCB8IE1MT19QQVVTRV9UWCk7CisJaWYgKHBtc3IgJiBN QUNfTVNSX1JYX0ZDKQorCQlzdGF0ZS0+cGF1c2UgfD0gTUxPX1BBVVNFX1JYOworCWlmIChwbXNy ICYgTUFDX01TUl9UWF9GQykKKwkJc3RhdGUtPnBhdXNlIHw9IE1MT19QQVVTRV9UWDsKIAotCWlm ICghb2ZfcGh5X2lzX2ZpeGVkX2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJcGh5X3ByaW50X3N0YXR1 cyhkZXYtPnBoeWRldik7CisJcmV0dXJuIDE7CiB9CiAKLXN0YXRpYyBpbnQgbXRrX3BoeV9jb25u ZWN0X25vZGUoc3RydWN0IG10a19ldGggKmV0aCwgc3RydWN0IG10a19tYWMgKm1hYywKLQkJCQlz dHJ1Y3QgZGV2aWNlX25vZGUgKnBoeV9ub2RlKQorc3RhdGljIHZvaWQgbXRrX21hY19hbl9yZXN0 YXJ0KHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnKQogewotCXN0cnVjdCBwaHlfZGV2aWNl ICpwaHlkZXY7Ci0JaW50IHBoeV9tb2RlOwotCi0JcGh5X21vZGUgPSBvZl9nZXRfcGh5X21vZGUo cGh5X25vZGUpOwotCWlmIChwaHlfbW9kZSA8IDApIHsKLQkJZGV2X2VycihldGgtPmRldiwgImlu Y29ycmVjdCBwaHktbW9kZSAlZFxuIiwgcGh5X21vZGUpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9 Ci0KLQlwaHlkZXYgPSBvZl9waHlfY29ubmVjdChldGgtPm5ldGRldlttYWMtPmlkXSwgcGh5X25v ZGUsCi0JCQkJbXRrX3BoeV9saW5rX2FkanVzdCwgMCwgcGh5X21vZGUpOwotCWlmICghcGh5ZGV2 KSB7Ci0JCWRldl9lcnIoZXRoLT5kZXYsICJjb3VsZCBub3QgY29ubmVjdCB0byBQSFlcbiIpOwot CQlyZXR1cm4gLUVOT0RFVjsKLQl9CisJLyogRG8gbm90aGluZyAqLworfQogCi0JZGV2X2luZm8o ZXRoLT5kZXYsCi0JCSAiY29ubmVjdGVkIG1hYyAlZCB0byBQSFkgYXQgJXMgW3VpZD0lMDh4LCBk cml2ZXI9JXNdXG4iLAotCQkgbWFjLT5pZCwgcGh5ZGV2X25hbWUocGh5ZGV2KSwgcGh5ZGV2LT5w aHlfaWQsCi0JCSBwaHlkZXYtPmRydi0+bmFtZSk7CitzdGF0aWMgdm9pZCBtdGtfbWFjX2xpbmtf ZG93bihzdHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywgdW5zaWduZWQgaW50IG1vZGUsCisJ CQkgICAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlKQoreworCXN0cnVjdCBtdGtfbWFjICpt YWMgPSBjb250YWluZXJfb2YoY29uZmlnLCBzdHJ1Y3QgbXRrX21hYywKKwkJCQkJICAgcGh5bGlu a19jb25maWcpOwogCi0JcmV0dXJuIDA7CisJbXRrX3czMihtYWMtPmh3LCBNQUNfTUNSX0ZPUkNF X0xJTktfRE9XTiwgTVRLX01BQ19NQ1IobWFjLT5pZCkpOwogfQogCi1zdGF0aWMgaW50IG10a19w aHlfY29ubmVjdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQorc3RhdGljIHZvaWQgbXRrX21hY19s aW5rX3VwKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwK KwkJCSAgICBwaHlfaW50ZXJmYWNlX3QgaW50ZXJmYWNlLAorCQkJICAgIHN0cnVjdCBwaHlfZGV2 aWNlICpwaHkpCiB7Ci0Jc3RydWN0IG10a19tYWMgKm1hYyA9IG5ldGRldl9wcml2KGRldik7Ci0J c3RydWN0IG10a19ldGggKmV0aDsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wOwotCXUzMiB2YWw7 Ci0JaW50IGVycjsKKwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gY29udGFpbmVyX29mKGNvbmZpZywg c3RydWN0IG10a19tYWMsCisJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsKKwl1MzIgbWNyID0gbXRr X3IzMihtYWMtPmh3LCBNVEtfTUFDX01DUihtYWMtPmlkKSk7CiAKLQlldGggPSBtYWMtPmh3Owot CW5wID0gb2ZfcGFyc2VfcGhhbmRsZShtYWMtPm9mX25vZGUsICJwaHktaGFuZGxlIiwgMCk7Ci0J aWYgKCFucCAmJiBvZl9waHlfaXNfZml4ZWRfbGluayhtYWMtPm9mX25vZGUpKQotCQlpZiAoIW9m X3BoeV9yZWdpc3Rlcl9maXhlZF9saW5rKG1hYy0+b2Zfbm9kZSkpCi0JCQlucCA9IG9mX25vZGVf Z2V0KG1hYy0+b2Zfbm9kZSk7Ci0JaWYgKCFucCkKLQkJcmV0dXJuIC1FTk9ERVY7CisJbWNyIHw9 IE1BQ19NQ1JfVFhfRU4gfCBNQUNfTUNSX1JYX0VOOworCW10a193MzIobWFjLT5odywgbWNyLCBN VEtfTUFDX01DUihtYWMtPmlkKSk7Cit9CiAKLQllcnIgPSBtdGtfc2V0dXBfaHdfcGF0aChldGgs IG1hYy0+aWQsIG9mX2dldF9waHlfbW9kZShucCkpOwotCWlmIChlcnIpCi0JCWdvdG8gZXJyX3Bo eTsKLQotCW1hYy0+Z2VfbW9kZSA9IDA7Ci0Jc3dpdGNoIChvZl9nZXRfcGh5X21vZGUobnApKSB7 Ci0JY2FzZSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJOgotCQltYWMtPnRyZ21paSA9IHRydWU7 Ci0JY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdNSUlfVFhJRDoKLQljYXNlIFBIWV9JTlRFUkZB Q0VfTU9ERV9SR01JSV9SWElEOgotCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX0lEOgot CWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJOgotCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RF X1NHTUlJOgotCQlicmVhazsKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUk6Ci0JY2FzZSBQ SFlfSU5URVJGQUNFX01PREVfR01JSToKLQkJbWFjLT5nZV9tb2RlID0gMTsKLQkJYnJlYWs7Ci0J Y2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkVWTUlJOgotCQltYWMtPmdlX21vZGUgPSAyOwotCQli cmVhazsKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJOgotCQlpZiAoIW1hYy0+aWQpCi0J CQlnb3RvIGVycl9waHk7Ci0JCW1hYy0+Z2VfbW9kZSA9IDM7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6 Ci0JCWdvdG8gZXJyX3BoeTsKLQl9CitzdGF0aWMgdm9pZCBtdGtfdmFsaWRhdGUoc3RydWN0IHBo eWxpbmtfY29uZmlnICpjb25maWcsCisJCQkgdW5zaWduZWQgbG9uZyAqc3VwcG9ydGVkLAorCQkJ IHN0cnVjdCBwaHlsaW5rX2xpbmtfc3RhdGUgKnN0YXRlKQoreworCXN0cnVjdCBtdGtfbWFjICpt YWMgPSBjb250YWluZXJfb2YoY29uZmlnLCBzdHJ1Y3QgbXRrX21hYywKKwkJCQkJICAgcGh5bGlu a19jb25maWcpOworCV9fRVRIVE9PTF9ERUNMQVJFX0xJTktfTU9ERV9NQVNLKG1hc2spID0geyAw LCB9OwogCi0JLyogTm8gTVQ3NjI4Lzg4IHN1cHBvcnQgZm9yIG5vdyAqLwotCWlmICghTVRLX0hB U19DQVBTKGV0aC0+c29jLT5jYXBzLCBNVEtfU09DX01UNzYyOCkpIHsKLQkJLyogcHV0IHRoZSBn bWFjIGludG8gdGhlIHJpZ2h0IG1vZGUgKi8KLQkJcmVnbWFwX3JlYWQoZXRoLT5ldGhzeXMsIEVU SFNZU19TWVNDRkcwLCAmdmFsKTsKLQkJdmFsICY9IH5TWVNDRkcwX0dFX01PREUoU1lTQ0ZHMF9H RV9NQVNLLCBtYWMtPmlkKTsKLQkJdmFsIHw9IFNZU0NGRzBfR0VfTU9ERShtYWMtPmdlX21vZGUs IG1hYy0+aWQpOwotCQlyZWdtYXBfd3JpdGUoZXRoLT5ldGhzeXMsIEVUSFNZU19TWVNDRkcwLCB2 YWwpOworCWlmIChzdGF0ZS0+aW50ZXJmYWNlICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV9OQSAmJgor CSAgICBzdGF0ZS0+aW50ZXJmYWNlICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUkgJiYKKwkgICAg c3RhdGUtPmludGVyZmFjZSAhPSBQSFlfSU5URVJGQUNFX01PREVfR01JSSAmJgorCSAgICAhKE1U S19IQVNfQ0FQUyhtYWMtPmh3LT5zb2MtPmNhcHMsIE1US19SR01JSSkgJiYKKwkgICAgICBwaHlf aW50ZXJmYWNlX21vZGVfaXNfcmdtaWkoc3RhdGUtPmludGVyZmFjZSkpICYmCisJICAgICEoTVRL X0hBU19DQVBTKG1hYy0+aHctPnNvYy0+Y2FwcywgTVRLX1RSR01JSSkgJiYKKwkgICAgICAhbWFj LT5pZCAmJiBzdGF0ZS0+aW50ZXJmYWNlID09IFBIWV9JTlRFUkZBQ0VfTU9ERV9UUkdNSUkpKSB7 CisJCWxpbmttb2RlX3plcm8oc3VwcG9ydGVkKTsKKwkJcmV0dXJuOwogCX0KIAotCS8qIGNvdXBs ZSBwaHlkZXYgdG8gbmV0X2RldmljZSAqLwotCWlmIChtdGtfcGh5X2Nvbm5lY3Rfbm9kZShldGgs IG1hYywgbnApKQotCQlnb3RvIGVycl9waHk7CisJcGh5bGlua19zZXRfcG9ydF9tb2RlcyhtYXNr KTsKKwlwaHlsaW5rX3NldChtYXNrLCBBdXRvbmVnKTsKIAotCW9mX25vZGVfcHV0KG5wKTsKKwlp ZiAoc3RhdGUtPmludGVyZmFjZSA9PSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKSB7CisJCXBo eWxpbmtfc2V0KG1hc2ssIDEwMDBiYXNlVF9GdWxsKTsKKwl9IGVsc2UgeworCQlwaHlsaW5rX3Nl dChtYXNrLCAxMGJhc2VUX0hhbGYpOworCQlwaHlsaW5rX3NldChtYXNrLCAxMGJhc2VUX0Z1bGwp OworCQlwaHlsaW5rX3NldChtYXNrLCAxMDBiYXNlVF9IYWxmKTsKKwkJcGh5bGlua19zZXQobWFz aywgMTAwYmFzZVRfRnVsbCk7CisKKwkJaWYgKHN0YXRlLT5pbnRlcmZhY2UgIT0gUEhZX0lOVEVS RkFDRV9NT0RFX01JSSkgeworCQkJcGh5bGlua19zZXQobWFzaywgMTAwMGJhc2VUX0hhbGYpOwor CQkJcGh5bGlua19zZXQobWFzaywgMTAwMGJhc2VUX0Z1bGwpOworCQkJcGh5bGlua19zZXQobWFz aywgMTAwMGJhc2VYX0Z1bGwpOworCQl9CisJfQogCi0JcmV0dXJuIDA7CisJcGh5bGlua19zZXQo bWFzaywgUGF1c2UpOworCXBoeWxpbmtfc2V0KG1hc2ssIEFzeW1fUGF1c2UpOwogCi1lcnJfcGh5 OgotCWlmIChvZl9waHlfaXNfZml4ZWRfbGluayhtYWMtPm9mX25vZGUpKQotCQlvZl9waHlfZGVy ZWdpc3Rlcl9maXhlZF9saW5rKG1hYy0+b2Zfbm9kZSk7Ci0Jb2Zfbm9kZV9wdXQobnApOwotCWRl dl9lcnIoZXRoLT5kZXYsICIlczogaW52YWxpZCBwaHlcbiIsIF9fZnVuY19fKTsKLQlyZXR1cm4g LUVJTlZBTDsKKwlsaW5rbW9kZV9hbmQoc3VwcG9ydGVkLCBzdXBwb3J0ZWQsIG1hc2spOworCWxp bmttb2RlX2FuZChzdGF0ZS0+YWR2ZXJ0aXNpbmcsIHN0YXRlLT5hZHZlcnRpc2luZywgbWFzayk7 CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGh5bGlua19tYWNfb3BzIG10a19waHlsaW5rX29w cyA9IHsKKwkudmFsaWRhdGUgPSBtdGtfdmFsaWRhdGUsCisJLm1hY19saW5rX3N0YXRlID0gbXRr X21hY19saW5rX3N0YXRlLAorCS5tYWNfYW5fcmVzdGFydCA9IG10a19tYWNfYW5fcmVzdGFydCwK KwkubWFjX2NvbmZpZyA9IG10a19tYWNfY29uZmlnLAorCS5tYWNfbGlua19kb3duID0gbXRrX21h Y19saW5rX2Rvd24sCisJLm1hY19saW5rX3VwID0gbXRrX21hY19saW5rX3VwLAorfTsKKwogc3Rh dGljIGludCBtdGtfbWRpb19pbml0KHN0cnVjdCBtdGtfZXRoICpldGgpCiB7CiAJc3RydWN0IGRl dmljZV9ub2RlICptaWlfbnA7CkBAIC0yMDEzLDYgKzIwNjgsMTQgQEAgc3RhdGljIGludCBtdGtf b3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogewogCXN0cnVjdCBtdGtfbWFjICptYWMgPSBu ZXRkZXZfcHJpdihkZXYpOwogCXN0cnVjdCBtdGtfZXRoICpldGggPSBtYWMtPmh3OworCWludCBl cnI7CisKKwllcnIgPSBwaHlsaW5rX29mX3BoeV9jb25uZWN0KG1hYy0+cGh5bGluaywgbWFjLT5v Zl9ub2RlLCAwKTsKKwlpZiAoZXJyKSB7CisJCW5ldGRldl9lcnIoZGV2LCAiJXM6IGNvdWxkIG5v dCBhdHRhY2ggUEhZOiAlZFxuIiwgX19mdW5jX18sCisJCQkgICBlcnIpOworCQlyZXR1cm4gZXJy OworCX0KIAogCS8qIHdlIHJ1biAyIG5ldGRldnMgb24gdGhlIHNhbWUgZG1hIHJpbmcgc28gd2Ug b25seSBicmluZyBpdCB1cCBvbmNlICovCiAJaWYgKCFyZWZjb3VudF9yZWFkKCZldGgtPmRtYV9y ZWZjbnQpKSB7CkBAIC0yMDMwLDcgKzIwOTMsNyBAQCBzdGF0aWMgaW50IG10a19vcGVuKHN0cnVj dCBuZXRfZGV2aWNlICpkZXYpCiAJZWxzZQogCQlyZWZjb3VudF9pbmMoJmV0aC0+ZG1hX3JlZmNu dCk7CiAKLQlwaHlfc3RhcnQoZGV2LT5waHlkZXYpOworCXBoeWxpbmtfc3RhcnQobWFjLT5waHls aW5rKTsKIAluZXRpZl9zdGFydF9xdWV1ZShkZXYpOwogCXJldHVybiAwOwogfQpAQCAtMjA2Myw4 ICsyMTI2LDExIEBAIHN0YXRpYyBpbnQgbXRrX3N0b3Aoc3RydWN0IG5ldF9kZXZpY2UgKmRldikK IAlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAlzdHJ1Y3QgbXRrX2V0 aCAqZXRoID0gbWFjLT5odzsKIAorCXBoeWxpbmtfc3RvcChtYWMtPnBoeWxpbmspOworCiAJbmV0 aWZfdHhfZGlzYWJsZShkZXYpOwotCXBoeV9zdG9wKGRldi0+cGh5ZGV2KTsKKworCXBoeWxpbmtf ZGlzY29ubmVjdF9waHkobWFjLT5waHlsaW5rKTsKIAogCS8qIG9ubHkgc2h1dGRvd24gRE1BIGlm IHRoaXMgaXMgdGhlIGxhc3QgdXNlciAqLwogCWlmICghcmVmY291bnRfZGVjX2FuZF90ZXN0KCZl dGgtPmRtYV9yZWZjbnQpKQpAQCAtMjE1OSwxNSArMjIyNSw2IEBAIHN0YXRpYyBpbnQgbXRrX2h3 X2luaXQoc3RydWN0IG10a19ldGggKmV0aCkKIAlldGhzeXNfcmVzZXQoZXRoLCBSU1RDVFJMX0ZF KTsKIAlldGhzeXNfcmVzZXQoZXRoLCBSU1RDVFJMX1BQRSk7CiAKLQlyZWdtYXBfcmVhZChldGgt PmV0aHN5cywgRVRIU1lTX1NZU0NGRzAsICZ2YWwpOwotCWZvciAoaSA9IDA7IGkgPCBNVEtfTUFD X0NPVU5UOyBpKyspIHsKLQkJaWYgKCFldGgtPm1hY1tpXSkKLQkJCWNvbnRpbnVlOwotCQl2YWwg Jj0gflNZU0NGRzBfR0VfTU9ERShTWVNDRkcwX0dFX01BU0ssIGV0aC0+bWFjW2ldLT5pZCk7Ci0J CXZhbCB8PSBTWVNDRkcwX0dFX01PREUoZXRoLT5tYWNbaV0tPmdlX21vZGUsIGV0aC0+bWFjW2ld LT5pZCk7Ci0JfQotCXJlZ21hcF93cml0ZShldGgtPmV0aHN5cywgRVRIU1lTX1NZU0NGRzAsIHZh bCk7Ci0KIAlpZiAoZXRoLT5wY3RsKSB7CiAJCS8qIFNldCBHRTIgZHJpdmluZyBhbmQgc2xldyBy YXRlICovCiAJCXJlZ21hcF93cml0ZShldGgtPnBjdGwsIEdQSU9fRFJWX1NFTDEwLCAweGEwMCk7 CkBAIC0yMTgwLDExICsyMjM3LDExIEBAIHN0YXRpYyBpbnQgbXRrX2h3X2luaXQoc3RydWN0IG10 a19ldGggKmV0aCkKIAl9CiAKIAkvKiBTZXQgbGlua2Rvd24gYXMgdGhlIGRlZmF1bHQgZm9yIGVh Y2ggR01BQy4gSXRzIG93biBNQ1Igd291bGQgYmUgc2V0Ci0JICogdXAgd2l0aCB0aGUgbW9yZSBh cHByb3ByaWF0ZSB2YWx1ZSB3aGVuIG10a19waHlfbGlua19hZGp1c3QgY2FsbCBpcwotCSAqIGJl aW5nIGludm9rZWQuCisJICogdXAgd2l0aCB0aGUgbW9yZSBhcHByb3ByaWF0ZSB2YWx1ZSB3aGVu IG10a19tYWNfY29uZmlnIGNhbGwgaXMgYmVpbmcKKwkgKiBpbnZva2VkLgogCSAqLwogCWZvciAo aSA9IDA7IGkgPCBNVEtfTUFDX0NPVU5UOyBpKyspCi0JCW10a193MzIoZXRoLCAwLCBNVEtfTUFD X01DUihpKSk7CisJCW10a193MzIoZXRoLCBNQUNfTUNSX0ZPUkNFX0xJTktfRE9XTiwgTVRLX01B Q19NQ1IoaSkpOwogCiAJLyogSW5kaWNhdGVzIENETSB0byBwYXJzZSB0aGUgTVRLIHNwZWNpYWwg dGFnIGZyb20gQ1BVCiAJICogd2hpY2ggYWxzbyBpcyB3b3JraW5nIG91dCBmb3IgdW50YWcgcGFj a2V0cy4KQEAgLTIyMTIsNyArMjI2OSw3IEBAIHN0YXRpYyBpbnQgbXRrX2h3X2luaXQoc3RydWN0 IG10a19ldGggKmV0aCkKIAltdGtfdzMyKGV0aCwgTVRLX1JYX0RPTkVfSU5ULCBNVEtfUURNQV9J TlRfR1JQMik7CiAJbXRrX3czMihldGgsIDB4MjEwMjEwMDAsIE1US19GRV9JTlRfR1JQKTsKIAot CWZvciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19DT1VO VDsgaSsrKSB7CiAJCXUzMiB2YWwgPSBtdGtfcjMyKGV0aCwgTVRLX0dETUFfRldEX0NGRyhpKSk7 CiAKIAkJLyogc2V0dXAgdGhlIGZvcndhcmQgcG9ydCB0byBzZW5kIGZyYW1lIHRvIFBETUEgKi8K QEAgLTIyNjQsNyArMjMyMSw3IEBAIHN0YXRpYyBpbnQgX19pbml0IG10a19pbml0KHN0cnVjdCBu ZXRfZGV2aWNlICpkZXYpCiAJCQlkZXYtPmRldl9hZGRyKTsKIAl9CiAKLQlyZXR1cm4gbXRrX3Bo eV9jb25uZWN0KGRldik7CisJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyB2b2lkIG10a191bmluaXQo c3RydWN0IG5ldF9kZXZpY2UgKmRldikKQEAgLTIyNzIsMjAgKzIzMjksMjAgQEAgc3RhdGljIHZv aWQgbXRrX3VuaW5pdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCXN0cnVjdCBtdGtfbWFjICpt YWMgPSBuZXRkZXZfcHJpdihkZXYpOwogCXN0cnVjdCBtdGtfZXRoICpldGggPSBtYWMtPmh3Owog Ci0JcGh5X2Rpc2Nvbm5lY3QoZGV2LT5waHlkZXYpOwotCWlmIChvZl9waHlfaXNfZml4ZWRfbGlu ayhtYWMtPm9mX25vZGUpKQotCQlvZl9waHlfZGVyZWdpc3Rlcl9maXhlZF9saW5rKG1hYy0+b2Zf bm9kZSk7CisJcGh5bGlua19kaXNjb25uZWN0X3BoeShtYWMtPnBoeWxpbmspOwogCW10a190eF9p cnFfZGlzYWJsZShldGgsIH4wKTsKIAltdGtfcnhfaXJxX2Rpc2FibGUoZXRoLCB+MCk7CiB9CiAK IHN0YXRpYyBpbnQgbXRrX2RvX2lvY3RsKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBp ZnJlcSAqaWZyLCBpbnQgY21kKQogeworCXN0cnVjdCBtdGtfbWFjICptYWMgPSBuZXRkZXZfcHJp dihkZXYpOworCiAJc3dpdGNoIChjbWQpIHsKIAljYXNlIFNJT0NHTUlJUEhZOgogCWNhc2UgU0lP Q0dNSUlSRUc6CiAJY2FzZSBTSU9DU01JSVJFRzoKLQkJcmV0dXJuIHBoeV9taWlfaW9jdGwoZGV2 LT5waHlkZXYsIGlmciwgY21kKTsKKwkJcmV0dXJuIHBoeWxpbmtfbWlpX2lvY3RsKG1hYy0+cGh5 bGluaywgaWZyLCBjbWQpOwogCWRlZmF1bHQ6CiAJCWJyZWFrOwogCX0KQEAgLTIzMjYsMTYgKzIz ODMsNiBAQCBzdGF0aWMgdm9pZCBtdGtfcGVuZGluZ193b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAq d29yaykKIAkJCQkgICAgIGV0aC0+ZGV2LT5waW5zLT5kZWZhdWx0X3N0YXRlKTsKIAltdGtfaHdf aW5pdChldGgpOwogCi0JZm9yIChpID0gMDsgaSA8IE1US19NQUNfQ09VTlQ7IGkrKykgewotCQlp ZiAoIWV0aC0+bWFjW2ldIHx8Ci0JCSAgICBvZl9waHlfaXNfZml4ZWRfbGluayhldGgtPm1hY1tp XS0+b2Zfbm9kZSkpCi0JCQljb250aW51ZTsKLQkJZXJyID0gcGh5X2luaXRfaHcoZXRoLT5uZXRk ZXZbaV0tPnBoeWRldik7Ci0JCWlmIChlcnIpCi0JCQlkZXZfZXJyKGV0aC0+ZGV2LCAiJXM6IFBI WSBpbml0IGZhaWxlZC5cbiIsCi0JCQkJZXRoLT5uZXRkZXZbaV0tPm5hbWUpOwotCX0KLQogCS8q IHJlc3RhcnQgRE1BIGFuZCBlbmFibGUgSVJRcyAqLwogCWZvciAoaSA9IDA7IGkgPCBNVEtfTUFD X0NPVU5UOyBpKyspIHsKIAkJaWYgKCF0ZXN0X2JpdChpLCAmcmVzdGFydCkpCkBAIC0yMzk4LDkg KzI0NDUsNyBAQCBzdGF0aWMgaW50IG10a19nZXRfbGlua19rc2V0dGluZ3Moc3RydWN0IG5ldF9k ZXZpY2UgKm5kZXYsCiAJaWYgKHVubGlrZWx5KHRlc3RfYml0KE1US19SRVNFVFRJTkcsICZtYWMt Pmh3LT5zdGF0ZSkpKQogCQlyZXR1cm4gLUVCVVNZOwogCi0JcGh5X2V0aHRvb2xfa3NldHRpbmdz X2dldChuZGV2LT5waHlkZXYsIGNtZCk7Ci0KLQlyZXR1cm4gMDsKKwlyZXR1cm4gcGh5bGlua19l dGh0b29sX2tzZXR0aW5nc19nZXQobWFjLT5waHlsaW5rLCBjbWQpOwogfQogCiBzdGF0aWMgaW50 IG10a19zZXRfbGlua19rc2V0dGluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsCkBAIC0yNDEx LDcgKzI0NTYsNyBAQCBzdGF0aWMgaW50IG10a19zZXRfbGlua19rc2V0dGluZ3Moc3RydWN0IG5l dF9kZXZpY2UgKm5kZXYsCiAJaWYgKHVubGlrZWx5KHRlc3RfYml0KE1US19SRVNFVFRJTkcsICZt YWMtPmh3LT5zdGF0ZSkpKQogCQlyZXR1cm4gLUVCVVNZOwogCi0JcmV0dXJuIHBoeV9ldGh0b29s X2tzZXR0aW5nc19zZXQobmRldi0+cGh5ZGV2LCBjbWQpOworCXJldHVybiBwaHlsaW5rX2V0aHRv b2xfa3NldHRpbmdzX3NldChtYWMtPnBoeWxpbmssIGNtZCk7CiB9CiAKIHN0YXRpYyB2b2lkIG10 a19nZXRfZHJ2aW5mbyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LApAQCAtMjQ0NSwyMiArMjQ5MCwx MCBAQCBzdGF0aWMgaW50IG10a19ud2F5X3Jlc2V0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiAJ aWYgKHVubGlrZWx5KHRlc3RfYml0KE1US19SRVNFVFRJTkcsICZtYWMtPmh3LT5zdGF0ZSkpKQog CQlyZXR1cm4gLUVCVVNZOwogCi0JcmV0dXJuIGdlbnBoeV9yZXN0YXJ0X2FuZWcoZGV2LT5waHlk ZXYpOwotfQorCWlmICghbWFjLT5waHlsaW5rKQorCQlyZXR1cm4gLUVOT1RTVVBQOwogCi1zdGF0 aWMgdTMyIG10a19nZXRfbGluayhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQotewotCXN0cnVjdCBt dGtfbWFjICptYWMgPSBuZXRkZXZfcHJpdihkZXYpOwotCWludCBlcnI7Ci0KLQlpZiAodW5saWtl bHkodGVzdF9iaXQoTVRLX1JFU0VUVElORywgJm1hYy0+aHctPnN0YXRlKSkpCi0JCXJldHVybiAt RUJVU1k7Ci0KLQllcnIgPSBnZW5waHlfdXBkYXRlX2xpbmsoZGV2LT5waHlkZXYpOwotCWlmIChl cnIpCi0JCXJldHVybiBldGh0b29sX29wX2dldF9saW5rKGRldik7Ci0KLQlyZXR1cm4gZGV2LT5w aHlkZXYtPmxpbms7CisJcmV0dXJuIHBoeWxpbmtfZXRodG9vbF9ud2F5X3Jlc2V0KG1hYy0+cGh5 bGluayk7CiB9CiAKIHN0YXRpYyB2b2lkIG10a19nZXRfc3RyaW5ncyhzdHJ1Y3QgbmV0X2Rldmlj ZSAqZGV2LCB1MzIgc3RyaW5nc2V0LCB1OCAqZGF0YSkKQEAgLTI1ODAsNyArMjYxMyw3IEBAIHN0 YXRpYyBjb25zdCBzdHJ1Y3QgZXRodG9vbF9vcHMgbXRrX2V0aHRvb2xfb3BzID0gewogCS5nZXRf bXNnbGV2ZWwJCT0gbXRrX2dldF9tc2dsZXZlbCwKIAkuc2V0X21zZ2xldmVsCQk9IG10a19zZXRf bXNnbGV2ZWwsCiAJLm53YXlfcmVzZXQJCT0gbXRrX253YXlfcmVzZXQsCi0JLmdldF9saW5rCQk9 IG10a19nZXRfbGluaywKKwkuZ2V0X2xpbmsJCT0gZXRodG9vbF9vcF9nZXRfbGluaywKIAkuZ2V0 X3N0cmluZ3MJCT0gbXRrX2dldF9zdHJpbmdzLAogCS5nZXRfc3NldF9jb3VudAkJPSBtdGtfZ2V0 X3NzZXRfY291bnQsCiAJLmdldF9ldGh0b29sX3N0YXRzCT0gbXRrX2dldF9ldGh0b29sX3N0YXRz LApAQCAtMjYwOCw5ICsyNjQxLDEwIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbmV0X2RldmljZV9v cHMgbXRrX25ldGRldl9vcHMgPSB7CiAKIHN0YXRpYyBpbnQgbXRrX2FkZF9tYWMoc3RydWN0IG10 a19ldGggKmV0aCwgc3RydWN0IGRldmljZV9ub2RlICpucCkKIHsKLQlzdHJ1Y3QgbXRrX21hYyAq bWFjOwogCWNvbnN0IF9fYmUzMiAqX2lkID0gb2ZfZ2V0X3Byb3BlcnR5KG5wLCAicmVnIiwgTlVM TCk7Ci0JaW50IGlkLCBlcnI7CisJc3RydWN0IHBoeWxpbmsgKnBoeWxpbms7CisJaW50IHBoeV9t b2RlLCBpZCwgZXJyOworCXN0cnVjdCBtdGtfbWFjICptYWM7CiAKIAlpZiAoIV9pZCkgewogCQlk ZXZfZXJyKGV0aC0+ZGV2LCAibWlzc2luZyBtYWMgaWRcbiIpOwpAQCAtMjY1NCw2ICsyNjg4LDMy IEBAIHN0YXRpYyBpbnQgbXRrX2FkZF9tYWMoc3RydWN0IG10a19ldGggKmV0aCwgc3RydWN0IGRl dmljZV9ub2RlICpucCkKIAl1NjRfc3RhdHNfaW5pdCgmbWFjLT5od19zdGF0cy0+c3luY3ApOwog CW1hYy0+aHdfc3RhdHMtPnJlZ19vZmZzZXQgPSBpZCAqIE1US19TVEFUX09GRlNFVDsKIAorCS8q IHBoeWxpbmsgY3JlYXRlICovCisJcGh5X21vZGUgPSBvZl9nZXRfcGh5X21vZGUobnApOworCWlm IChwaHlfbW9kZSA8IDApIHsKKwkJZGV2X2VycihldGgtPmRldiwgImluY29ycmVjdCBwaHktbW9k ZVxuIik7CisJCWVyciA9IC1FSU5WQUw7CisJCWdvdG8gZnJlZV9uZXRkZXY7CisJfQorCisJLyog bWFjIGNvbmZpZyBpcyBub3Qgc2V0ICovCisJbWFjLT5pbnRlcmZhY2UgPSBQSFlfSU5URVJGQUNF X01PREVfTkE7CisJbWFjLT5tb2RlID0gTUxPX0FOX1BIWTsKKwltYWMtPnNwZWVkID0gU1BFRURf VU5LTk9XTjsKKworCW1hYy0+cGh5bGlua19jb25maWcuZGV2ID0gJmV0aC0+bmV0ZGV2W2lkXS0+ ZGV2OworCW1hYy0+cGh5bGlua19jb25maWcudHlwZSA9IFBIWUxJTktfTkVUREVWOworCisJcGh5 bGluayA9IHBoeWxpbmtfY3JlYXRlKCZtYWMtPnBoeWxpbmtfY29uZmlnLAorCQkJCSBvZl9md25v ZGVfaGFuZGxlKG1hYy0+b2Zfbm9kZSksCisJCQkJIHBoeV9tb2RlLCAmbXRrX3BoeWxpbmtfb3Bz KTsKKwlpZiAoSVNfRVJSKHBoeWxpbmspKSB7CisJCWVyciA9IFBUUl9FUlIocGh5bGluayk7CisJ CWdvdG8gZnJlZV9uZXRkZXY7CisJfQorCisJbWFjLT5waHlsaW5rID0gcGh5bGluazsKKwogCVNF VF9ORVRERVZfREVWKGV0aC0+bmV0ZGV2W2lkXSwgZXRoLT5kZXYpOwogCWV0aC0+bmV0ZGV2W2lk XS0+d2F0Y2hkb2dfdGltZW8gPSA1ICogSFo7CiAJZXRoLT5uZXRkZXZbaWRdLT5uZXRkZXZfb3Bz ID0gJm10a19uZXRkZXZfb3BzOwpAQCAtMjY4Miw4ICsyNzQyLDcgQEAgc3RhdGljIGludCBtdGtf cHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgZGV2aWNlX25v ZGUgKm1hY19ucDsKIAlzdHJ1Y3QgbXRrX2V0aCAqZXRoOwotCWludCBlcnI7Ci0JaW50IGk7CisJ aW50IGVyciwgaTsKIAogCWV0aCA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmV0 aCksIEdGUF9LRVJORUwpOwogCWlmICghZXRoKQpAQCAtMjg2OSw2ICsyOTI4LDcgQEAgc3RhdGlj IGludCBtdGtfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHN0YXRpYyBpbnQg bXRrX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBtdGtf ZXRoICpldGggPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlzdHJ1Y3QgbXRrX21hYyAq bWFjOwogCWludCBpOwogCiAJLyogc3RvcCBhbGwgZGV2aWNlcyB0byBtYWtlIHN1cmUgdGhhdCBk bWEgaXMgcHJvcGVybHkgc2h1dCBkb3duICovCkBAIC0yODc2LDYgKzI5MzYsOCBAQCBzdGF0aWMg aW50IG10a19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJaWYgKCFldGgt Pm5ldGRldltpXSkKIAkJCWNvbnRpbnVlOwogCQltdGtfc3RvcChldGgtPm5ldGRldltpXSk7CisJ CW1hYyA9IG5ldGRldl9wcml2KGV0aC0+bmV0ZGV2W2ldKTsKKwkJcGh5bGlua19kaXNjb25uZWN0 X3BoeShtYWMtPnBoeWxpbmspOwogCX0KIAogCW10a19od19kZWluaXQoZXRoKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmggYi9kcml2ZXJz L25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5oCmluZGV4IGNjMTQ2NmFlMDkyNi4u N2Y1ZjU0MWRhYWQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9t dGtfZXRoX3NvYy5oCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhf c29jLmgKQEAgLTE0LDYgKzE0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9vZl9uZXQuaD4KICNpbmNs dWRlIDxsaW51eC91NjRfc3RhdHNfc3luYy5oPgogI2luY2x1ZGUgPGxpbnV4L3JlZmNvdW50Lmg+ CisjaW5jbHVkZSA8bGludXgvcGh5bGluay5oPgogCiAjZGVmaW5lIE1US19RRE1BX1BBR0VfU0la RQkyMDQ4CiAjZGVmaW5lCU1US19NQVhfUlhfTEVOR1RICTE1MzYKQEAgLTMzMCwxMiArMzMxLDE5 IEBACiAjZGVmaW5lIE1BQ19NQ1JfU1BFRURfMTAwCUJJVCgyKQogI2RlZmluZSBNQUNfTUNSX0ZP UkNFX0RQWAlCSVQoMSkKICNkZWZpbmUgTUFDX01DUl9GT1JDRV9MSU5LCUJJVCgwKQotI2RlZmlu ZSBNQUNfTUNSX0ZJWEVEX0xJTksJKE1BQ19NQ1JfTUFYX1JYXzE1MzYgfCBNQUNfTUNSX0lQR19D RkcgfCBcCi0JCQkJIE1BQ19NQ1JfRk9SQ0VfTU9ERSB8IE1BQ19NQ1JfVFhfRU4gfCBcCi0JCQkJ IE1BQ19NQ1JfUlhfRU4gfCBNQUNfTUNSX0JBQ0tPRkZfRU4gfCBcCi0JCQkJIE1BQ19NQ1JfQkFD S1BSX0VOIHwgTUFDX01DUl9GT1JDRV9SWF9GQyB8IFwKLQkJCQkgTUFDX01DUl9GT1JDRV9UWF9G QyB8IE1BQ19NQ1JfU1BFRURfMTAwMCB8IFwKLQkJCQkgTUFDX01DUl9GT1JDRV9EUFggfCBNQUNf TUNSX0ZPUkNFX0xJTkspCisjZGVmaW5lIE1BQ19NQ1JfRk9SQ0VfTElOS19ET1dOCShNQUNfTUNS X0ZPUkNFX01PREUpCisKKy8qIE1hYyBzdGF0dXMgcmVnaXN0ZXJzICovCisjZGVmaW5lIE1US19N QUNfTVNSKHgpCQkoMHgxMDEwOCArICh4ICogMHgxMDApKQorI2RlZmluZSBNQUNfTVNSX0VFRTFH CQlCSVQoNykKKyNkZWZpbmUgTUFDX01TUl9FRUUxMDBNCQlCSVQoNikKKyNkZWZpbmUgTUFDX01T Ul9SWF9GQwkJQklUKDUpCisjZGVmaW5lIE1BQ19NU1JfVFhfRkMJCUJJVCg0KQorI2RlZmluZSBN QUNfTVNSX1NQRUVEXzEwMDAJQklUKDMpCisjZGVmaW5lIE1BQ19NU1JfU1BFRURfMTAwCUJJVCgy KQorI2RlZmluZSBNQUNfTVNSX1NQRUVEX01BU0sJKE1BQ19NU1JfU1BFRURfMTAwMCB8IE1BQ19N U1JfU1BFRURfMTAwKQorI2RlZmluZSBNQUNfTVNSX0RQWAkJQklUKDEpCisjZGVmaW5lIE1BQ19N U1JfTElOSwkJQklUKDApCiAKIC8qIFRSR01JSSBSWEMgY29udHJvbCByZWdpc3RlciAqLwogI2Rl ZmluZSBUUkdNSUlfUkNLX0NUUkwJCTB4MTAzMDAKQEAgLTg1OCwyMiArODY2LDIzIEBAIHN0cnVj dCBtdGtfZXRoIHsKIC8qIHN0cnVjdCBtdGtfbWFjIC0JdGhlIHN0cnVjdHVyZSB0aGF0IGhvbGRz IHRoZSBpbmZvIGFib3V0IHRoZSBNQUNzIG9mIHRoZQogICoJCQlTb0MKICAqIEBpZDoJCQlUaGUg bnVtYmVyIG9mIHRoZSBNQUMKLSAqIEBnZV9tb2RlOiAgICAgICAgICAgIEludGVyZmFjZSBtb2Rl IGtlcHQgZm9yIHNldHVwIHJlc3RvcmluZworICogQGludGVyZmFjZToJCUludGVyZmFjZSBtb2Rl IGtlcHQgZm9yIGRldGVjdGluZyBjaGFuZ2UgaW4gaHcgc2V0dGluZ3MKICAqIEBvZl9ub2RlOgkJ T3VyIGRldmljZXRyZWUgbm9kZQogICogQGh3OgkJCUJhY2twb2ludGVyIHRvIG91ciBtYWluIGRh dGFzdHJ1dHVyZQogICogQGh3X3N0YXRzOgkJUGFja2V0IHN0YXRpc3RpY3MgY291bnRlcgotICog QHRyZ21paQkJSW5kaWNhdGUgaWYgdGhlIE1BQyB1c2VzIFRSR01JSSBjb25uZWN0ZWQgdG8gaW50 ZXJuYWwKLQkJCXN3aXRjaAogICovCiBzdHJ1Y3QgbXRrX21hYyB7CiAJaW50CQkJCWlkOwotCWlu dAkJCQlnZV9tb2RlOworCXBoeV9pbnRlcmZhY2VfdAkJCWludGVyZmFjZTsKKwl1bnNpZ25lZCBp bnQJCQltb2RlOworCWludAkJCQlzcGVlZDsKIAlzdHJ1Y3QgZGV2aWNlX25vZGUJCSpvZl9ub2Rl OworCXN0cnVjdCBwaHlsaW5rCQkJKnBoeWxpbms7CisJc3RydWN0IHBoeWxpbmtfY29uZmlnCQlw aHlsaW5rX2NvbmZpZzsKIAlzdHJ1Y3QgbXRrX2V0aAkJCSpodzsKIAlzdHJ1Y3QgbXRrX2h3X3N0 YXRzCQkqaHdfc3RhdHM7CiAJX19iZTMyCQkJCWh3bHJvX2lwW01US19NQVhfTFJPX0lQX0NOVF07 CiAJaW50CQkJCWh3bHJvX2lwX2NudDsKLQlib29sCQkJCXRyZ21paTsKIH07CiAKIC8qIHRoZSBz dHJ1Y3QgZGVzY3JpYmluZyB0aGUgU29DLiB0aGVzZSBhcmUgZGVjbGFyZWQgaW4gdGhlIHNvY194 eXouYyBmaWxlcyAqLwotLSAKMi4yMC4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJt LWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21h aWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=