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=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 44439C3A5A3 for ; Fri, 23 Aug 2019 13:45:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 05E8322CE3 for ; Fri, 23 Aug 2019 13:45:51 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="bG+EfB5r" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2405716AbfHWNpo (ORCPT ); Fri, 23 Aug 2019 09:45:44 -0400 Received: from mx.0dd.nl ([5.2.79.48]:33130 "EHLO mx.0dd.nl" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2405717AbfHWNpn (ORCPT ); Fri, 23 Aug 2019 09:45:43 -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 D5CBE5FA7F; Fri, 23 Aug 2019 15:45:39 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key; secure) header.d=vdorst.com header.i=@vdorst.com header.b="bG+EfB5r"; 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 8BF861D89682; Fri, 23 Aug 2019 15:45:39 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com 8BF861D89682 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1566567939; bh=/552+791KCxvkIMeMhHUmXy9wroe2azQdRTvkqXg2Qo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bG+EfB5r2v5HRIIMLgpIQaqpCMEVOeFige/mvVPI3d55SDX1D7/CdXHWs4BgueDKS qlk58fYRffFRpfex5AoKPGNEGREWcT+cbkeCpjP8OGWIjazU4rdHJsF2r+NSbvmVQH NNZBYcFv+TPSV7NsEffjyFvXOl0QQpAJiGb3BxdqIf+bzn1sDraa/54kTTymkQBLWT cqf2ehq+hu+ZA8G6RTJMbySv/SpLKOxd0JEWZtHgYWsmQuQ8AdotvUaQVODvTF96Ho n/CROyTEYi34Zh7OZ8gZfAt0zEQTIuIpNTlketZwXQ5IJHS3fF5RnEcL78AYMhC2Is BoY1FS6REnCUA== 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, Russell King , Frank Wunderlich , Stefan Roese , =?UTF-8?q?Ren=C3=A9=20van=20Dorst?= Subject: [PATCH net-next v3 1/3] net: ethernet: mediatek: Add basic PHYLINK support Date: Fri, 23 Aug 2019 15:45:14 +0200 Message-Id: <20190823134516.27559-2-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190823134516.27559-1-opensource@vdorst.com> References: <20190823134516.27559-1-opensource@vdorst.com> 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 This convert the basics to PHYLINK API. SGMII support is not in this patch. Signed-off-by: RenĂ© van Dorst -- v2->v3: * Make link_down() similar as link_up() suggested by Russell King 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 | 424 +++++++++++--------- drivers/net/ethernet/mediatek/mtk_eth_soc.h | 31 +- 3 files changed, 265 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..a04baad6337c 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,224 @@ 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); + } + } - switch (dev->phydev->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 (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); + u32 mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id)); - return 0; + mcr &= (MAC_MCR_TX_EN | MAC_MCR_RX_EN); + mtk_w32(mac->hw, mcr, 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 +2070,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 +2095,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 +2128,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 +2227,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 +2239,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 +2271,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 +2323,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 +2331,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 +2385,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 +2447,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 +2458,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 +2492,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 +2615,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 +2643,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 +2690,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 +2744,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 +2930,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 +2938,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,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 DFC34C3A5A2 for ; Fri, 23 Aug 2019 13:46:31 +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 AAC0722CE3 for ; Fri, 23 Aug 2019 13:46:31 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="QUO6n41x"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="bG+EfB5r" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AAC0722CE3 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=6qMRhJsfDJzT56jKSNR6OL+lf3gJtuzLfsAG9DWb7jY=; b=QUO6n41x0ioVsl q2jypqrB/HJJOY2K4W2eLB6GwPW4Nzz8jIvUkfYYXLqz7PmV2s2BCqZF4U0ut3tOuGooT3xNFk+jQ wrwZAxYnh1so1DI5EgnEYTwDxsgPoloqHUetQlz2C7RSq80vMqTuD306dorIva8QW5r9KZ65F2ZP9 gtbmg2ARrm8NOUQR6pF1eBdWPNucAEaqTVnUJoZjddRw6Kp901nzm0hAx79Yq5zexDMycgrapl3Nu 0kKm8pB4yrHM92OPGytR1SwoE/K5YZKl/t+KrCWcXAjeiDCI0+mqHZJPvbK9awzMsPFxh0VOCqTEV ni2ah1tr45FfkQD7WwKg==; 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 1i19tf-0004Xv-5v; Fri, 23 Aug 2019 13:46:31 +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 1i19ss-0003Tr-Nr; Fri, 23 Aug 2019 13:45:47 +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 D5CBE5FA7F; Fri, 23 Aug 2019 15:45:39 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key; secure) header.d=vdorst.com header.i=@vdorst.com header.b="bG+EfB5r"; 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 8BF861D89682; Fri, 23 Aug 2019 15:45:39 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com 8BF861D89682 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1566567939; bh=/552+791KCxvkIMeMhHUmXy9wroe2azQdRTvkqXg2Qo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bG+EfB5r2v5HRIIMLgpIQaqpCMEVOeFige/mvVPI3d55SDX1D7/CdXHWs4BgueDKS qlk58fYRffFRpfex5AoKPGNEGREWcT+cbkeCpjP8OGWIjazU4rdHJsF2r+NSbvmVQH NNZBYcFv+TPSV7NsEffjyFvXOl0QQpAJiGb3BxdqIf+bzn1sDraa/54kTTymkQBLWT cqf2ehq+hu+ZA8G6RTJMbySv/SpLKOxd0JEWZtHgYWsmQuQ8AdotvUaQVODvTF96Ho n/CROyTEYi34Zh7OZ8gZfAt0zEQTIuIpNTlketZwXQ5IJHS3fF5RnEcL78AYMhC2Is BoY1FS6REnCUA== 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 v3 1/3] net: ethernet: mediatek: Add basic PHYLINK support Date: Fri, 23 Aug 2019 15:45:14 +0200 Message-Id: <20190823134516.27559-2-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190823134516.27559-1-opensource@vdorst.com> References: <20190823134516.27559-1-opensource@vdorst.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190823_064543_265742_7B8C3D4D X-CRM114-Status: GOOD ( 22.39 ) 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, Russell King , =?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 b3VyY2VAdmRvcnN0LmNvbT4KLS0KdjItPnYzOgoqIE1ha2UgbGlua19kb3duKCkgc2ltaWxhciBh cyBsaW5rX3VwKCkgc3VnZ2VzdGVkIGJ5IFJ1c3NlbGwgS2luZwp2MS0+djI6CiogQWxzbyByZXBv cnQgMTAwMEJhc2UtWCBzdXBwb3J0IHN1Z2dlc3RlZCBieSBSdXNzZWxsIEtpbmcKKiBSZXZlcnNl IGNocmlzdG1hcyBvbiBtYW55IHBsYWNlcyBzdWdnZXN0ZWQgYnkgRGF2aWQgTWlsbGVyCiogUmVi YXNlIHRvbyBwaWNrdXAgdGhlIG10NzZ4OCBjaGFuZ2VzLgotLS0KIGRyaXZlcnMvbmV0L2V0aGVy bmV0L21lZGlhdGVrL0tjb25maWcgICAgICAgfCAgIDIgKy0KIGRyaXZlcnMvbmV0L2V0aGVybmV0 L21lZGlhdGVrL210a19ldGhfc29jLmMgfCA0MjQgKysrKysrKysrKystLS0tLS0tLS0KIGRyaXZl cnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmggfCAgMzEgKy0KIDMgZmlsZXMg Y2hhbmdlZCwgMjY1IGluc2VydGlvbnMoKyksIDE5MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9LY29uZmlnIGIvZHJpdmVycy9uZXQvZXRo ZXJuZXQvbWVkaWF0ZWsvS2NvbmZpZwppbmRleCBiNzZjZjJlMWM5ZGMuLjQ5NjgzNTJiYTE4OCAx MDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvS2NvbmZpZworKysgYi9k cml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9LY29uZmlnCkBAIC05LDcgKzksNyBAQCBpZiBO RVRfVkVORE9SX01FRElBVEVLCiAKIGNvbmZpZyBORVRfTUVESUFURUtfU09DCiAJdHJpc3RhdGUg Ik1lZGlhVGVrIFNvQyBHaWdhYml0IEV0aGVybmV0IHN1cHBvcnQiCi0Jc2VsZWN0IFBIWUxJQgor CXNlbGVjdCBQSFlMSU5LCiAJLS0taGVscC0tLQogCSAgVGhpcyBkcml2ZXIgc3VwcG9ydHMgdGhl IGdpZ2FiaXQgZXRoZXJuZXQgTUFDcyBpbiB0aGUKIAkgIE1lZGlhVGVrIFNvQyBmYW1pbHkuCmRp ZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5jIGIv ZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuYwppbmRleCA4ZGRiYjhk Y2YwMzIuLmEwNGJhYWQ2MzM3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVk aWF0ZWsvbXRrX2V0aF9zb2MuYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9t dGtfZXRoX3NvYy5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8bGludXgvdGNwLmg+CiAj aW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvcGluY3RybC9kZXZp bmZvLmg+CisjaW5jbHVkZSA8bGludXgvcGh5bGluay5oPgogCiAjaW5jbHVkZSAibXRrX2V0aF9z b2MuaCIKIApAQCAtMTg2LDE2OCArMTg3LDIyNCBAQCBzdGF0aWMgdm9pZCBtdGtfZ21hYzBfcmdt aWlfYWRqdXN0KHN0cnVjdCBtdGtfZXRoICpldGgsIGludCBzcGVlZCkKIAltdGtfdzMyKGV0aCwg dmFsLCBUUkdNSUlfVENLX0NUUkwpOwogfQogCi1zdGF0aWMgdm9pZCBtdGtfcGh5X2xpbmtfYWRq dXN0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCitzdGF0aWMgdm9pZCBtdGtfbWFjX2NvbmZpZyhz dHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZywgdW5zaWduZWQgaW50IG1vZGUsCisJCQkgICBj b25zdCBzdHJ1Y3QgcGh5bGlua19saW5rX3N0YXRlICpzdGF0ZSkKIHsKLQlzdHJ1Y3QgbXRrX21h YyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsKLQl1MTYgbGNsX2FkdiA9IDAsIHJtdF9hZHYgPSAw OwotCXU4IGZsb3djdHJsOwotCXUzMiBtY3IgPSBNQUNfTUNSX01BWF9SWF8xNTM2IHwgTUFDX01D Ul9JUEdfQ0ZHIHwKLQkJICBNQUNfTUNSX0ZPUkNFX01PREUgfCBNQUNfTUNSX1RYX0VOIHwKLQkJ ICBNQUNfTUNSX1JYX0VOIHwgTUFDX01DUl9CQUNLT0ZGX0VOIHwKLQkJICBNQUNfTUNSX0JBQ0tQ Ul9FTjsKKwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gY29udGFpbmVyX29mKGNvbmZpZywgc3RydWN0 IG10a19tYWMsCisJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsKKwlzdHJ1Y3QgbXRrX2V0aCAqZXRo ID0gbWFjLT5odzsKKwl1MzIgbWNyX2N1ciwgbWNyX25ldzsKKwlpbnQgdmFsLCBnZV9tb2RlID0g MDsKKworCS8qIE1UNzZ4OCBoYXMgbm8gaGFyZHdhcmUgc2V0dGluZ3MgYmV0d2VlbiBmb3IgdGhl IE1BQyAqLworCWlmICghTVRLX0hBU19DQVBTKGV0aC0+c29jLT5jYXBzLCBNVEtfU09DX01UNzYy OCkgJiYKKwkgICAgbWFjLT5pbnRlcmZhY2UgIT0gc3RhdGUtPmludGVyZmFjZSkgeworCQkvKiBT ZXR1cCBzb2MgcGluIGZ1bmN0aW9ucyAqLworCQlzd2l0Y2ggKHN0YXRlLT5pbnRlcmZhY2UpIHsK KwkJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJOgorCQkJaWYgKG1hYy0+aWQpCisJCQkJ Z290byBlcnJfcGh5OworCQkJaWYgKCFNVEtfSEFTX0NBUFMobWFjLT5ody0+c29jLT5jYXBzLAor CQkJCQkgIE1US19HTUFDMV9UUkdNSUkpKQorCQkJCWdvdG8gZXJyX3BoeTsKKwkJCS8qIGZhbGwg dGhyb3VnaCAqLworCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9HTUlJOgorCQljYXNlIFBIWV9J TlRFUkZBQ0VfTU9ERV9SR01JSV9UWElEOgorCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01J SV9SWElEOgorCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9JRDoKKwkJY2FzZSBQSFlf SU5URVJGQUNFX01PREVfUkdNSUk6CisJCQlicmVhazsKKwkJY2FzZSBQSFlfSU5URVJGQUNFX01P REVfTUlJOgorCQkJZ2VfbW9kZSA9IDE7CisJCQlicmVhazsKKwkJY2FzZSBQSFlfSU5URVJGQUNF X01PREVfUkVWTUlJOgorCQkJZ2VfbW9kZSA9IDI7CisJCQlicmVhazsKKwkJY2FzZSBQSFlfSU5U RVJGQUNFX01PREVfUk1JSToKKwkJCWlmIChtYWMtPmlkKQorCQkJCWdvdG8gZXJyX3BoeTsKKwkJ CWdlX21vZGUgPSAzOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlnb3RvIGVycl9waHk7CisJ CX0KIAotCWlmICh1bmxpa2VseSh0ZXN0X2JpdChNVEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3Rh dGUpKSkKLQkJcmV0dXJuOworCQkvKiBTZXR1cCBjbG9jayBmb3IgMXN0IGdtYWMgKi8KKwkJaWYg KCFtYWMtPmlkICYmCisJCSAgICBNVEtfSEFTX0NBUFMobWFjLT5ody0+c29jLT5jYXBzLCBNVEtf R01BQzFfVFJHTUlJKSkgeworCQkJaWYgKE1US19IQVNfQ0FQUyhtYWMtPmh3LT5zb2MtPmNhcHMs CisJCQkJCSBNVEtfVFJHTUlJX01UNzYyMV9DTEspKSB7CisJCQkJaWYgKG10NzYyMV9nbWFjMF9y Z21paV9hZGp1c3QobWFjLT5odywKKwkJCQkJCQkgICAgICBzdGF0ZS0+aW50ZXJmYWNlKSkKKwkJ CQkJZ290byBlcnJfcGh5OworCQkJfSBlbHNlIHsKKwkJCQlpZiAoc3RhdGUtPmludGVyZmFjZSAh PQorCQkJCSAgICBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKQorCQkJCQltdGtfZ21hYzBfcmdt aWlfYWRqdXN0KG1hYy0+aHcsCisJCQkJCQkJICAgICAgIHN0YXRlLT5zcGVlZCk7CisJCQl9CisJ CX0KIAotCXN3aXRjaCAoZGV2LT5waHlkZXYtPnNwZWVkKSB7CisJCS8qIHB1dCB0aGUgZ21hYyBp bnRvIHRoZSByaWdodCBtb2RlICovCisJCXJlZ21hcF9yZWFkKGV0aC0+ZXRoc3lzLCBFVEhTWVNf U1lTQ0ZHMCwgJnZhbCk7CisJCXZhbCAmPSB+U1lTQ0ZHMF9HRV9NT0RFKFNZU0NGRzBfR0VfTUFT SywgbWFjLT5pZCk7CisJCXZhbCB8PSBTWVNDRkcwX0dFX01PREUoZ2VfbW9kZSwgbWFjLT5pZCk7 CisJCXJlZ21hcF93cml0ZShldGgtPmV0aHN5cywgRVRIU1lTX1NZU0NGRzAsIHZhbCk7CisKKwkJ bWFjLT5pbnRlcmZhY2UgPSBzdGF0ZS0+aW50ZXJmYWNlOworCX0KKworCS8qIFNldHVwIGdtYWMg Ki8KKwltY3JfY3VyID0gbXRrX3IzMihtYWMtPmh3LCBNVEtfTUFDX01DUihtYWMtPmlkKSk7CisJ bWNyX25ldyA9IG1jcl9jdXI7CisJbWNyX25ldyAmPSB+KE1BQ19NQ1JfU1BFRURfMTAwIHwgTUFD X01DUl9TUEVFRF8xMDAwIHwKKwkJICAgICBNQUNfTUNSX0ZPUkNFX0RQWCB8IE1BQ19NQ1JfRk9S Q0VfVFhfRkMgfAorCQkgICAgIE1BQ19NQ1JfRk9SQ0VfUlhfRkMpOworCW1jcl9uZXcgfD0gTUFD X01DUl9NQVhfUlhfMTUzNiB8IE1BQ19NQ1JfSVBHX0NGRyB8IE1BQ19NQ1JfRk9SQ0VfTU9ERSB8 CisJCSAgIE1BQ19NQ1JfQkFDS09GRl9FTiB8IE1BQ19NQ1JfQkFDS1BSX0VOIHwgTUFDX01DUl9G T1JDRV9MSU5LOworCisJc3dpdGNoIChzdGF0ZS0+c3BlZWQpIHsKIAljYXNlIFNQRUVEXzEwMDA6 Ci0JCW1jciB8PSBNQUNfTUNSX1NQRUVEXzEwMDA7CisJCW1jcl9uZXcgfD0gTUFDX01DUl9TUEVF RF8xMDAwOwogCQlicmVhazsKIAljYXNlIFNQRUVEXzEwMDoKLQkJbWNyIHw9IE1BQ19NQ1JfU1BF RURfMTAwOworCQltY3JfbmV3IHw9IE1BQ19NQ1JfU1BFRURfMTAwOwogCQlicmVhazsKIAl9Ci0K LQlpZiAoTVRLX0hBU19DQVBTKG1hYy0+aHctPnNvYy0+Y2FwcywgTVRLX0dNQUMxX1RSR01JSSkg JiYgIW1hYy0+aWQpIHsKLQkJaWYgKE1US19IQVNfQ0FQUyhtYWMtPmh3LT5zb2MtPmNhcHMsIE1U S19UUkdNSUlfTVQ3NjIxX0NMSykpIHsKLQkJCWlmIChtdDc2MjFfZ21hYzBfcmdtaWlfYWRqdXN0 KG1hYy0+aHcsCi0JCQkJCQkgICAgICBkZXYtPnBoeWRldi0+aW50ZXJmYWNlKSkKLQkJCQlyZXR1 cm47Ci0JCX0gZWxzZSB7Ci0JCQlpZiAoIW1hYy0+dHJnbWlpKQotCQkJCW10a19nbWFjMF9yZ21p aV9hZGp1c3QobWFjLT5odywKLQkJCQkJCSAgICAgICBkZXYtPnBoeWRldi0+c3BlZWQpOwotCQl9 CisJaWYgKHN0YXRlLT5kdXBsZXggPT0gRFVQTEVYX0ZVTEwpIHsKKwkJbWNyX25ldyB8PSBNQUNf TUNSX0ZPUkNFX0RQWDsKKwkJaWYgKHN0YXRlLT5wYXVzZSAmIE1MT19QQVVTRV9UWCkKKwkJCW1j cl9uZXcgfD0gTUFDX01DUl9GT1JDRV9UWF9GQzsKKwkJaWYgKHN0YXRlLT5wYXVzZSAmIE1MT19Q QVVTRV9SWCkKKwkJCW1jcl9uZXcgfD0gTUFDX01DUl9GT1JDRV9SWF9GQzsKIAl9CiAKLQlpZiAo ZGV2LT5waHlkZXYtPmxpbmspCi0JCW1jciB8PSBNQUNfTUNSX0ZPUkNFX0xJTks7CisJLyogT25s eSB1cGRhdGUgY29udHJvbCByZWdpc3RlciB3aGVuIG5lZWRlZCEgKi8KKwlpZiAobWNyX25ldyAh PSBtY3JfY3VyKQorCQltdGtfdzMyKG1hYy0+aHcsIG1jcl9uZXcsIE1US19NQUNfTUNSKG1hYy0+ aWQpKTsKIAotCWlmIChkZXYtPnBoeWRldi0+ZHVwbGV4KSB7Ci0JCW1jciB8PSBNQUNfTUNSX0ZP UkNFX0RQWDsKKwlyZXR1cm47CiAKLQkJaWYgKGRldi0+cGh5ZGV2LT5wYXVzZSkKLQkJCXJtdF9h ZHYgPSBMUEFfUEFVU0VfQ0FQOwotCQlpZiAoZGV2LT5waHlkZXYtPmFzeW1fcGF1c2UpCi0JCQly bXRfYWR2IHw9IExQQV9QQVVTRV9BU1lNOworZXJyX3BoeToKKwlkZXZfZXJyKGV0aC0+ZGV2LCAi JXM6IEdNQUMlZCBtb2RlICVzIG5vdCBzdXBwb3J0ZWQhXG4iLCBfX2Z1bmNfXywKKwkJbWFjLT5p ZCwgcGh5X21vZGVzKHN0YXRlLT5pbnRlcmZhY2UpKTsKK30KIAotCQlsY2xfYWR2ID0gbGlua21v ZGVfYWR2X3RvX2xjbF9hZHZfdChkZXYtPnBoeWRldi0+YWR2ZXJ0aXNpbmcpOwotCQlmbG93Y3Ry bCA9IG1paV9yZXNvbHZlX2Zsb3djdHJsX2ZkeChsY2xfYWR2LCBybXRfYWR2KTsKK3N0YXRpYyBp bnQgbXRrX21hY19saW5rX3N0YXRlKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLAorCQkJ ICAgICAgc3RydWN0IHBoeWxpbmtfbGlua19zdGF0ZSAqc3RhdGUpCit7CisJc3RydWN0IG10a19t YWMgKm1hYyA9IGNvbnRhaW5lcl9vZihjb25maWcsIHN0cnVjdCBtdGtfbWFjLAorCQkJCQkgICBw aHlsaW5rX2NvbmZpZyk7CisJdTMyIHBtc3IgPSBtdGtfcjMyKG1hYy0+aHcsIE1US19NQUNfTVNS KG1hYy0+aWQpKTsKIAotCQlpZiAoZmxvd2N0cmwgJiBGTE9XX0NUUkxfVFgpCi0JCQltY3IgfD0g TUFDX01DUl9GT1JDRV9UWF9GQzsKLQkJaWYgKGZsb3djdHJsICYgRkxPV19DVFJMX1JYKQotCQkJ bWNyIHw9IE1BQ19NQ1JfRk9SQ0VfUlhfRkM7CisJc3RhdGUtPmxpbmsgPSAocG1zciAmIE1BQ19N U1JfTElOSyk7CisJc3RhdGUtPmR1cGxleCA9IChwbXNyICYgTUFDX01TUl9EUFgpID4+IDE7CiAK LQkJbmV0aWZfZGJnKG1hYy0+aHcsIGxpbmssIGRldiwgInJ4IHBhdXNlICVzLCB0eCBwYXVzZSAl c1xuIiwKLQkJCSAgZmxvd2N0cmwgJiBGTE9XX0NUUkxfUlggPyAiZW5hYmxlZCIgOiAiZGlzYWJs ZWQiLAotCQkJICBmbG93Y3RybCAmIEZMT1dfQ1RSTF9UWCA/ICJlbmFibGVkIiA6ICJkaXNhYmxl ZCIpOworCXN3aXRjaCAocG1zciAmIChNQUNfTVNSX1NQRUVEXzEwMDAgfCBNQUNfTVNSX1NQRUVE XzEwMCkpIHsKKwljYXNlIDA6CisJCXN0YXRlLT5zcGVlZCA9IFNQRUVEXzEwOworCQlicmVhazsK KwljYXNlIE1BQ19NU1JfU1BFRURfMTAwOgorCQlzdGF0ZS0+c3BlZWQgPSBTUEVFRF8xMDA7CisJ CWJyZWFrOworCWNhc2UgTUFDX01TUl9TUEVFRF8xMDAwOgorCQlzdGF0ZS0+c3BlZWQgPSBTUEVF RF8xMDAwOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlzdGF0ZS0+c3BlZWQgPSBTUEVFRF9VTktO T1dOOworCQlicmVhazsKIAl9CiAKLQltdGtfdzMyKG1hYy0+aHcsIG1jciwgTVRLX01BQ19NQ1Io bWFjLT5pZCkpOworCXN0YXRlLT5wYXVzZSAmPSAoTUxPX1BBVVNFX1JYIHwgTUxPX1BBVVNFX1RY KTsKKwlpZiAocG1zciAmIE1BQ19NU1JfUlhfRkMpCisJCXN0YXRlLT5wYXVzZSB8PSBNTE9fUEFV U0VfUlg7CisJaWYgKHBtc3IgJiBNQUNfTVNSX1RYX0ZDKQorCQlzdGF0ZS0+cGF1c2UgfD0gTUxP X1BBVVNFX1RYOwogCi0JaWYgKCFvZl9waHlfaXNfZml4ZWRfbGluayhtYWMtPm9mX25vZGUpKQot CQlwaHlfcHJpbnRfc3RhdHVzKGRldi0+cGh5ZGV2KTsKKwlyZXR1cm4gMTsKIH0KIAotc3RhdGlj IGludCBtdGtfcGh5X2Nvbm5lY3Rfbm9kZShzdHJ1Y3QgbXRrX2V0aCAqZXRoLCBzdHJ1Y3QgbXRr X21hYyAqbWFjLAotCQkJCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcGh5X25vZGUpCitzdGF0aWMgdm9p ZCBtdGtfbWFjX2FuX3Jlc3RhcnQoc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcpCiB7Ci0J c3RydWN0IHBoeV9kZXZpY2UgKnBoeWRldjsKLQlpbnQgcGh5X21vZGU7Ci0KLQlwaHlfbW9kZSA9 IG9mX2dldF9waHlfbW9kZShwaHlfbm9kZSk7Ci0JaWYgKHBoeV9tb2RlIDwgMCkgewotCQlkZXZf ZXJyKGV0aC0+ZGV2LCAiaW5jb3JyZWN0IHBoeS1tb2RlICVkXG4iLCBwaHlfbW9kZSk7Ci0JCXJl dHVybiAtRUlOVkFMOwotCX0KLQotCXBoeWRldiA9IG9mX3BoeV9jb25uZWN0KGV0aC0+bmV0ZGV2 W21hYy0+aWRdLCBwaHlfbm9kZSwKLQkJCQltdGtfcGh5X2xpbmtfYWRqdXN0LCAwLCBwaHlfbW9k ZSk7Ci0JaWYgKCFwaHlkZXYpIHsKLQkJZGV2X2VycihldGgtPmRldiwgImNvdWxkIG5vdCBjb25u ZWN0IHRvIFBIWVxuIik7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KKwkvKiBEbyBub3RoaW5nICov Cit9CiAKLQlkZXZfaW5mbyhldGgtPmRldiwKLQkJICJjb25uZWN0ZWQgbWFjICVkIHRvIFBIWSBh dCAlcyBbdWlkPSUwOHgsIGRyaXZlcj0lc11cbiIsCi0JCSBtYWMtPmlkLCBwaHlkZXZfbmFtZShw aHlkZXYpLCBwaHlkZXYtPnBoeV9pZCwKLQkJIHBoeWRldi0+ZHJ2LT5uYW1lKTsKK3N0YXRpYyB2 b2lkIG10a19tYWNfbGlua19kb3duKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNp Z25lZCBpbnQgbW9kZSwKKwkJCSAgICAgIHBoeV9pbnRlcmZhY2VfdCBpbnRlcmZhY2UpCit7CisJ c3RydWN0IG10a19tYWMgKm1hYyA9IGNvbnRhaW5lcl9vZihjb25maWcsIHN0cnVjdCBtdGtfbWFj LAorCQkJCQkgICBwaHlsaW5rX2NvbmZpZyk7CisJdTMyIG1jciA9IG10a19yMzIobWFjLT5odywg TVRLX01BQ19NQ1IobWFjLT5pZCkpOwogCi0JcmV0dXJuIDA7CisJbWNyICY9IChNQUNfTUNSX1RY X0VOIHwgTUFDX01DUl9SWF9FTik7CisJbXRrX3czMihtYWMtPmh3LCBtY3IsIE1US19NQUNfTUNS KG1hYy0+aWQpKTsKIH0KIAotc3RhdGljIGludCBtdGtfcGh5X2Nvbm5lY3Qoc3RydWN0IG5ldF9k ZXZpY2UgKmRldikKK3N0YXRpYyB2b2lkIG10a19tYWNfbGlua191cChzdHJ1Y3QgcGh5bGlua19j b25maWcgKmNvbmZpZywgdW5zaWduZWQgaW50IG1vZGUsCisJCQkgICAgcGh5X2ludGVyZmFjZV90 IGludGVyZmFjZSwKKwkJCSAgICBzdHJ1Y3QgcGh5X2RldmljZSAqcGh5KQogewotCXN0cnVjdCBt dGtfbWFjICptYWMgPSBuZXRkZXZfcHJpdihkZXYpOwotCXN0cnVjdCBtdGtfZXRoICpldGg7Ci0J c3RydWN0IGRldmljZV9ub2RlICpucDsKLQl1MzIgdmFsOwotCWludCBlcnI7CisJc3RydWN0IG10 a19tYWMgKm1hYyA9IGNvbnRhaW5lcl9vZihjb25maWcsIHN0cnVjdCBtdGtfbWFjLAorCQkJCQkg ICBwaHlsaW5rX2NvbmZpZyk7CisJdTMyIG1jciA9IG10a19yMzIobWFjLT5odywgTVRLX01BQ19N Q1IobWFjLT5pZCkpOwogCi0JZXRoID0gbWFjLT5odzsKLQlucCA9IG9mX3BhcnNlX3BoYW5kbGUo bWFjLT5vZl9ub2RlLCAicGh5LWhhbmRsZSIsIDApOwotCWlmICghbnAgJiYgb2ZfcGh5X2lzX2Zp eGVkX2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJaWYgKCFvZl9waHlfcmVnaXN0ZXJfZml4ZWRfbGlu ayhtYWMtPm9mX25vZGUpKQotCQkJbnAgPSBvZl9ub2RlX2dldChtYWMtPm9mX25vZGUpOwotCWlm ICghbnApCi0JCXJldHVybiAtRU5PREVWOworCW1jciB8PSBNQUNfTUNSX1RYX0VOIHwgTUFDX01D Ul9SWF9FTjsKKwltdGtfdzMyKG1hYy0+aHcsIG1jciwgTVRLX01BQ19NQ1IobWFjLT5pZCkpOwor fQogCi0JZXJyID0gbXRrX3NldHVwX2h3X3BhdGgoZXRoLCBtYWMtPmlkLCBvZl9nZXRfcGh5X21v ZGUobnApKTsKLQlpZiAoZXJyKQotCQlnb3RvIGVycl9waHk7Ci0KLQltYWMtPmdlX21vZGUgPSAw OwotCXN3aXRjaCAob2ZfZ2V0X3BoeV9tb2RlKG5wKSkgewotCWNhc2UgUEhZX0lOVEVSRkFDRV9N T0RFX1RSR01JSToKLQkJbWFjLT50cmdtaWkgPSB0cnVlOwotCWNhc2UgUEhZX0lOVEVSRkFDRV9N T0RFX1JHTUlJX1RYSUQ6Ci0JY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdNSUlfUlhJRDoKLQlj YXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9JRDoKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9E RV9SR01JSToKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9TR01JSToKLQkJYnJlYWs7Ci0JY2Fz ZSBQSFlfSU5URVJGQUNFX01PREVfTUlJOgotCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX0dNSUk6 Ci0JCW1hYy0+Z2VfbW9kZSA9IDE7Ci0JCWJyZWFrOwotCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RF X1JFVk1JSToKLQkJbWFjLT5nZV9tb2RlID0gMjsKLQkJYnJlYWs7Ci0JY2FzZSBQSFlfSU5URVJG QUNFX01PREVfUk1JSToKLQkJaWYgKCFtYWMtPmlkKQotCQkJZ290byBlcnJfcGh5OwotCQltYWMt PmdlX21vZGUgPSAzOwotCQlicmVhazsKLQlkZWZhdWx0OgotCQlnb3RvIGVycl9waHk7Ci0JfQor c3RhdGljIHZvaWQgbXRrX3ZhbGlkYXRlKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLAor CQkJIHVuc2lnbmVkIGxvbmcgKnN1cHBvcnRlZCwKKwkJCSBzdHJ1Y3QgcGh5bGlua19saW5rX3N0 YXRlICpzdGF0ZSkKK3sKKwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gY29udGFpbmVyX29mKGNvbmZp Zywgc3RydWN0IG10a19tYWMsCisJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsKKwlfX0VUSFRPT0xf REVDTEFSRV9MSU5LX01PREVfTUFTSyhtYXNrKSA9IHsgMCwgfTsKIAotCS8qIE5vIE1UNzYyOC84 OCBzdXBwb3J0IGZvciBub3cgKi8KLQlpZiAoIU1US19IQVNfQ0FQUyhldGgtPnNvYy0+Y2Fwcywg TVRLX1NPQ19NVDc2MjgpKSB7Ci0JCS8qIHB1dCB0aGUgZ21hYyBpbnRvIHRoZSByaWdodCBtb2Rl ICovCi0JCXJlZ21hcF9yZWFkKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgJnZhbCk7Ci0J CXZhbCAmPSB+U1lTQ0ZHMF9HRV9NT0RFKFNZU0NGRzBfR0VfTUFTSywgbWFjLT5pZCk7Ci0JCXZh bCB8PSBTWVNDRkcwX0dFX01PREUobWFjLT5nZV9tb2RlLCBtYWMtPmlkKTsKLQkJcmVnbWFwX3dy aXRlKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgdmFsKTsKKwlpZiAoc3RhdGUtPmludGVy ZmFjZSAhPSBQSFlfSU5URVJGQUNFX01PREVfTkEgJiYKKwkgICAgc3RhdGUtPmludGVyZmFjZSAh PSBQSFlfSU5URVJGQUNFX01PREVfTUlJICYmCisJICAgIHN0YXRlLT5pbnRlcmZhY2UgIT0gUEhZ X0lOVEVSRkFDRV9NT0RFX0dNSUkgJiYKKwkgICAgIShNVEtfSEFTX0NBUFMobWFjLT5ody0+c29j LT5jYXBzLCBNVEtfUkdNSUkpICYmCisJICAgICAgcGh5X2ludGVyZmFjZV9tb2RlX2lzX3JnbWlp KHN0YXRlLT5pbnRlcmZhY2UpKSAmJgorCSAgICAhKE1US19IQVNfQ0FQUyhtYWMtPmh3LT5zb2Mt PmNhcHMsIE1US19UUkdNSUkpICYmCisJICAgICAgIW1hYy0+aWQgJiYgc3RhdGUtPmludGVyZmFj ZSA9PSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKSkgeworCQlsaW5rbW9kZV96ZXJvKHN1cHBv cnRlZCk7CisJCXJldHVybjsKIAl9CiAKLQkvKiBjb3VwbGUgcGh5ZGV2IHRvIG5ldF9kZXZpY2Ug Ki8KLQlpZiAobXRrX3BoeV9jb25uZWN0X25vZGUoZXRoLCBtYWMsIG5wKSkKLQkJZ290byBlcnJf cGh5OworCXBoeWxpbmtfc2V0X3BvcnRfbW9kZXMobWFzayk7CisJcGh5bGlua19zZXQobWFzaywg QXV0b25lZyk7CiAKLQlvZl9ub2RlX3B1dChucCk7CisJaWYgKHN0YXRlLT5pbnRlcmZhY2UgPT0g UEhZX0lOVEVSRkFDRV9NT0RFX1RSR01JSSkgeworCQlwaHlsaW5rX3NldChtYXNrLCAxMDAwYmFz ZVRfRnVsbCk7CisJfSBlbHNlIHsKKwkJcGh5bGlua19zZXQobWFzaywgMTBiYXNlVF9IYWxmKTsK KwkJcGh5bGlua19zZXQobWFzaywgMTBiYXNlVF9GdWxsKTsKKwkJcGh5bGlua19zZXQobWFzaywg MTAwYmFzZVRfSGFsZik7CisJCXBoeWxpbmtfc2V0KG1hc2ssIDEwMGJhc2VUX0Z1bGwpOworCisJ CWlmIChzdGF0ZS0+aW50ZXJmYWNlICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUkpIHsKKwkJCXBo eWxpbmtfc2V0KG1hc2ssIDEwMDBiYXNlVF9IYWxmKTsKKwkJCXBoeWxpbmtfc2V0KG1hc2ssIDEw MDBiYXNlVF9GdWxsKTsKKwkJCXBoeWxpbmtfc2V0KG1hc2ssIDEwMDBiYXNlWF9GdWxsKTsKKwkJ fQorCX0KIAotCXJldHVybiAwOworCXBoeWxpbmtfc2V0KG1hc2ssIFBhdXNlKTsKKwlwaHlsaW5r X3NldChtYXNrLCBBc3ltX1BhdXNlKTsKIAotZXJyX3BoeToKLQlpZiAob2ZfcGh5X2lzX2ZpeGVk X2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJb2ZfcGh5X2RlcmVnaXN0ZXJfZml4ZWRfbGluayhtYWMt Pm9mX25vZGUpOwotCW9mX25vZGVfcHV0KG5wKTsKLQlkZXZfZXJyKGV0aC0+ZGV2LCAiJXM6IGlu dmFsaWQgcGh5XG4iLCBfX2Z1bmNfXyk7Ci0JcmV0dXJuIC1FSU5WQUw7CisJbGlua21vZGVfYW5k KHN1cHBvcnRlZCwgc3VwcG9ydGVkLCBtYXNrKTsKKwlsaW5rbW9kZV9hbmQoc3RhdGUtPmFkdmVy dGlzaW5nLCBzdGF0ZS0+YWR2ZXJ0aXNpbmcsIG1hc2spOwogfQogCitzdGF0aWMgY29uc3Qgc3Ry dWN0IHBoeWxpbmtfbWFjX29wcyBtdGtfcGh5bGlua19vcHMgPSB7CisJLnZhbGlkYXRlID0gbXRr X3ZhbGlkYXRlLAorCS5tYWNfbGlua19zdGF0ZSA9IG10a19tYWNfbGlua19zdGF0ZSwKKwkubWFj X2FuX3Jlc3RhcnQgPSBtdGtfbWFjX2FuX3Jlc3RhcnQsCisJLm1hY19jb25maWcgPSBtdGtfbWFj X2NvbmZpZywKKwkubWFjX2xpbmtfZG93biA9IG10a19tYWNfbGlua19kb3duLAorCS5tYWNfbGlu a191cCA9IG10a19tYWNfbGlua191cCwKK307CisKIHN0YXRpYyBpbnQgbXRrX21kaW9faW5pdChz dHJ1Y3QgbXRrX2V0aCAqZXRoKQogewogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbWlpX25wOwpAQCAt MjAxMyw2ICsyMDcwLDE0IEBAIHN0YXRpYyBpbnQgbXRrX29wZW4oc3RydWN0IG5ldF9kZXZpY2Ug KmRldikKIHsKIAlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAlzdHJ1 Y3QgbXRrX2V0aCAqZXRoID0gbWFjLT5odzsKKwlpbnQgZXJyOworCisJZXJyID0gcGh5bGlua19v Zl9waHlfY29ubmVjdChtYWMtPnBoeWxpbmssIG1hYy0+b2Zfbm9kZSwgMCk7CisJaWYgKGVycikg eworCQluZXRkZXZfZXJyKGRldiwgIiVzOiBjb3VsZCBub3QgYXR0YWNoIFBIWTogJWRcbiIsIF9f ZnVuY19fLAorCQkJICAgZXJyKTsKKwkJcmV0dXJuIGVycjsKKwl9CiAKIAkvKiB3ZSBydW4gMiBu ZXRkZXZzIG9uIHRoZSBzYW1lIGRtYSByaW5nIHNvIHdlIG9ubHkgYnJpbmcgaXQgdXAgb25jZSAq LwogCWlmICghcmVmY291bnRfcmVhZCgmZXRoLT5kbWFfcmVmY250KSkgewpAQCAtMjAzMCw3ICsy MDk1LDcgQEAgc3RhdGljIGludCBtdGtfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCWVs c2UKIAkJcmVmY291bnRfaW5jKCZldGgtPmRtYV9yZWZjbnQpOwogCi0JcGh5X3N0YXJ0KGRldi0+ cGh5ZGV2KTsKKwlwaHlsaW5rX3N0YXJ0KG1hYy0+cGh5bGluayk7CiAJbmV0aWZfc3RhcnRfcXVl dWUoZGV2KTsKIAlyZXR1cm4gMDsKIH0KQEAgLTIwNjMsOCArMjEyOCwxMSBAQCBzdGF0aWMgaW50 IG10a19zdG9wKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiAJc3RydWN0IG10a19tYWMgKm1hYyA9 IG5ldGRldl9wcml2KGRldik7CiAJc3RydWN0IG10a19ldGggKmV0aCA9IG1hYy0+aHc7CiAKKwlw aHlsaW5rX3N0b3AobWFjLT5waHlsaW5rKTsKKwogCW5ldGlmX3R4X2Rpc2FibGUoZGV2KTsKLQlw aHlfc3RvcChkZXYtPnBoeWRldik7CisKKwlwaHlsaW5rX2Rpc2Nvbm5lY3RfcGh5KG1hYy0+cGh5 bGluayk7CiAKIAkvKiBvbmx5IHNodXRkb3duIERNQSBpZiB0aGlzIGlzIHRoZSBsYXN0IHVzZXIg Ki8KIAlpZiAoIXJlZmNvdW50X2RlY19hbmRfdGVzdCgmZXRoLT5kbWFfcmVmY250KSkKQEAgLTIx NTksMTUgKzIyMjcsNiBAQCBzdGF0aWMgaW50IG10a19od19pbml0KHN0cnVjdCBtdGtfZXRoICpl dGgpCiAJZXRoc3lzX3Jlc2V0KGV0aCwgUlNUQ1RSTF9GRSk7CiAJZXRoc3lzX3Jlc2V0KGV0aCwg UlNUQ1RSTF9QUEUpOwogCi0JcmVnbWFwX3JlYWQoZXRoLT5ldGhzeXMsIEVUSFNZU19TWVNDRkcw LCAmdmFsKTsKLQlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19DT1VOVDsgaSsrKSB7Ci0JCWlmICgh ZXRoLT5tYWNbaV0pCi0JCQljb250aW51ZTsKLQkJdmFsICY9IH5TWVNDRkcwX0dFX01PREUoU1lT Q0ZHMF9HRV9NQVNLLCBldGgtPm1hY1tpXS0+aWQpOwotCQl2YWwgfD0gU1lTQ0ZHMF9HRV9NT0RF KGV0aC0+bWFjW2ldLT5nZV9tb2RlLCBldGgtPm1hY1tpXS0+aWQpOwotCX0KLQlyZWdtYXBfd3Jp dGUoZXRoLT5ldGhzeXMsIEVUSFNZU19TWVNDRkcwLCB2YWwpOwotCiAJaWYgKGV0aC0+cGN0bCkg ewogCQkvKiBTZXQgR0UyIGRyaXZpbmcgYW5kIHNsZXcgcmF0ZSAqLwogCQlyZWdtYXBfd3JpdGUo ZXRoLT5wY3RsLCBHUElPX0RSVl9TRUwxMCwgMHhhMDApOwpAQCAtMjE4MCwxMSArMjIzOSwxMSBA QCBzdGF0aWMgaW50IG10a19od19pbml0KHN0cnVjdCBtdGtfZXRoICpldGgpCiAJfQogCiAJLyog U2V0IGxpbmtkb3duIGFzIHRoZSBkZWZhdWx0IGZvciBlYWNoIEdNQUMuIEl0cyBvd24gTUNSIHdv dWxkIGJlIHNldAotCSAqIHVwIHdpdGggdGhlIG1vcmUgYXBwcm9wcmlhdGUgdmFsdWUgd2hlbiBt dGtfcGh5X2xpbmtfYWRqdXN0IGNhbGwgaXMKLQkgKiBiZWluZyBpbnZva2VkLgorCSAqIHVwIHdp dGggdGhlIG1vcmUgYXBwcm9wcmlhdGUgdmFsdWUgd2hlbiBtdGtfbWFjX2NvbmZpZyBjYWxsIGlz IGJlaW5nCisJICogaW52b2tlZC4KIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19DT1VO VDsgaSsrKQotCQltdGtfdzMyKGV0aCwgMCwgTVRLX01BQ19NQ1IoaSkpOworCQltdGtfdzMyKGV0 aCwgTUFDX01DUl9GT1JDRV9MSU5LX0RPV04sIE1US19NQUNfTUNSKGkpKTsKIAogCS8qIEluZGlj YXRlcyBDRE0gdG8gcGFyc2UgdGhlIE1USyBzcGVjaWFsIHRhZyBmcm9tIENQVQogCSAqIHdoaWNo IGFsc28gaXMgd29ya2luZyBvdXQgZm9yIHVudGFnIHBhY2tldHMuCkBAIC0yMjEyLDcgKzIyNzEs NyBAQCBzdGF0aWMgaW50IG10a19od19pbml0KHN0cnVjdCBtdGtfZXRoICpldGgpCiAJbXRrX3cz MihldGgsIE1US19SWF9ET05FX0lOVCwgTVRLX1FETUFfSU5UX0dSUDIpOwogCW10a193MzIoZXRo LCAweDIxMDIxMDAwLCBNVEtfRkVfSU5UX0dSUCk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgMjsgaSsr KSB7CisJZm9yIChpID0gMDsgaSA8IE1US19NQUNfQ09VTlQ7IGkrKykgewogCQl1MzIgdmFsID0g bXRrX3IzMihldGgsIE1US19HRE1BX0ZXRF9DRkcoaSkpOwogCiAJCS8qIHNldHVwIHRoZSBmb3J3 YXJkIHBvcnQgdG8gc2VuZCBmcmFtZSB0byBQRE1BICovCkBAIC0yMjY0LDcgKzIzMjMsNyBAQCBz dGF0aWMgaW50IF9faW5pdCBtdGtfaW5pdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCQkJZGV2 LT5kZXZfYWRkcik7CiAJfQogCi0JcmV0dXJuIG10a19waHlfY29ubmVjdChkZXYpOworCXJldHVy biAwOwogfQogCiBzdGF0aWMgdm9pZCBtdGtfdW5pbml0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYp CkBAIC0yMjcyLDIwICsyMzMxLDIwIEBAIHN0YXRpYyB2b2lkIG10a191bmluaXQoc3RydWN0IG5l dF9kZXZpY2UgKmRldikKIAlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsK IAlzdHJ1Y3QgbXRrX2V0aCAqZXRoID0gbWFjLT5odzsKIAotCXBoeV9kaXNjb25uZWN0KGRldi0+ cGh5ZGV2KTsKLQlpZiAob2ZfcGh5X2lzX2ZpeGVkX2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJb2Zf cGh5X2RlcmVnaXN0ZXJfZml4ZWRfbGluayhtYWMtPm9mX25vZGUpOworCXBoeWxpbmtfZGlzY29u bmVjdF9waHkobWFjLT5waHlsaW5rKTsKIAltdGtfdHhfaXJxX2Rpc2FibGUoZXRoLCB+MCk7CiAJ bXRrX3J4X2lycV9kaXNhYmxlKGV0aCwgfjApOwogfQogCiBzdGF0aWMgaW50IG10a19kb19pb2N0 bChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKmlmciwgaW50IGNtZCkKIHsK KwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwogCXN3aXRjaCAoY21k KSB7CiAJY2FzZSBTSU9DR01JSVBIWToKIAljYXNlIFNJT0NHTUlJUkVHOgogCWNhc2UgU0lPQ1NN SUlSRUc6Ci0JCXJldHVybiBwaHlfbWlpX2lvY3RsKGRldi0+cGh5ZGV2LCBpZnIsIGNtZCk7CisJ CXJldHVybiBwaHlsaW5rX21paV9pb2N0bChtYWMtPnBoeWxpbmssIGlmciwgY21kKTsKIAlkZWZh dWx0OgogCQlicmVhazsKIAl9CkBAIC0yMzI2LDE2ICsyMzg1LDYgQEAgc3RhdGljIHZvaWQgbXRr X3BlbmRpbmdfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJCQkJICAgICBldGgtPmRl di0+cGlucy0+ZGVmYXVsdF9zdGF0ZSk7CiAJbXRrX2h3X2luaXQoZXRoKTsKIAotCWZvciAoaSA9 IDA7IGkgPCBNVEtfTUFDX0NPVU5UOyBpKyspIHsKLQkJaWYgKCFldGgtPm1hY1tpXSB8fAotCQkg ICAgb2ZfcGh5X2lzX2ZpeGVkX2xpbmsoZXRoLT5tYWNbaV0tPm9mX25vZGUpKQotCQkJY29udGlu dWU7Ci0JCWVyciA9IHBoeV9pbml0X2h3KGV0aC0+bmV0ZGV2W2ldLT5waHlkZXYpOwotCQlpZiAo ZXJyKQotCQkJZGV2X2VycihldGgtPmRldiwgIiVzOiBQSFkgaW5pdCBmYWlsZWQuXG4iLAotCQkJ CWV0aC0+bmV0ZGV2W2ldLT5uYW1lKTsKLQl9Ci0KIAkvKiByZXN0YXJ0IERNQSBhbmQgZW5hYmxl IElSUXMgKi8KIAlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19DT1VOVDsgaSsrKSB7CiAJCWlmICgh dGVzdF9iaXQoaSwgJnJlc3RhcnQpKQpAQCAtMjM5OCw5ICsyNDQ3LDcgQEAgc3RhdGljIGludCBt dGtfZ2V0X2xpbmtfa3NldHRpbmdzKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LAogCWlmICh1bmxp a2VseSh0ZXN0X2JpdChNVEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3RhdGUpKSkKIAkJcmV0dXJu IC1FQlVTWTsKIAotCXBoeV9ldGh0b29sX2tzZXR0aW5nc19nZXQobmRldi0+cGh5ZGV2LCBjbWQp OwotCi0JcmV0dXJuIDA7CisJcmV0dXJuIHBoeWxpbmtfZXRodG9vbF9rc2V0dGluZ3NfZ2V0KG1h Yy0+cGh5bGluaywgY21kKTsKIH0KIAogc3RhdGljIGludCBtdGtfc2V0X2xpbmtfa3NldHRpbmdz KHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LApAQCAtMjQxMSw3ICsyNDU4LDcgQEAgc3RhdGljIGlu dCBtdGtfc2V0X2xpbmtfa3NldHRpbmdzKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LAogCWlmICh1 bmxpa2VseSh0ZXN0X2JpdChNVEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3RhdGUpKSkKIAkJcmV0 dXJuIC1FQlVTWTsKIAotCXJldHVybiBwaHlfZXRodG9vbF9rc2V0dGluZ3Nfc2V0KG5kZXYtPnBo eWRldiwgY21kKTsKKwlyZXR1cm4gcGh5bGlua19ldGh0b29sX2tzZXR0aW5nc19zZXQobWFjLT5w aHlsaW5rLCBjbWQpOwogfQogCiBzdGF0aWMgdm9pZCBtdGtfZ2V0X2RydmluZm8oc3RydWN0IG5l dF9kZXZpY2UgKmRldiwKQEAgLTI0NDUsMjIgKzI0OTIsMTAgQEAgc3RhdGljIGludCBtdGtfbndh eV9yZXNldChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCWlmICh1bmxpa2VseSh0ZXN0X2JpdChN VEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3RhdGUpKSkKIAkJcmV0dXJuIC1FQlVTWTsKIAotCXJl dHVybiBnZW5waHlfcmVzdGFydF9hbmVnKGRldi0+cGh5ZGV2KTsKLX0KKwlpZiAoIW1hYy0+cGh5 bGluaykKKwkJcmV0dXJuIC1FTk9UU1VQUDsKIAotc3RhdGljIHUzMiBtdGtfZ2V0X2xpbmsoc3Ry dWN0IG5ldF9kZXZpY2UgKmRldikKLXsKLQlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3By aXYoZGV2KTsKLQlpbnQgZXJyOwotCi0JaWYgKHVubGlrZWx5KHRlc3RfYml0KE1US19SRVNFVFRJ TkcsICZtYWMtPmh3LT5zdGF0ZSkpKQotCQlyZXR1cm4gLUVCVVNZOwotCi0JZXJyID0gZ2VucGh5 X3VwZGF0ZV9saW5rKGRldi0+cGh5ZGV2KTsKLQlpZiAoZXJyKQotCQlyZXR1cm4gZXRodG9vbF9v cF9nZXRfbGluayhkZXYpOwotCi0JcmV0dXJuIGRldi0+cGh5ZGV2LT5saW5rOworCXJldHVybiBw aHlsaW5rX2V0aHRvb2xfbndheV9yZXNldChtYWMtPnBoeWxpbmspOwogfQogCiBzdGF0aWMgdm9p ZCBtdGtfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTMyIHN0cmluZ3NldCwg dTggKmRhdGEpCkBAIC0yNTgwLDcgKzI2MTUsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGV0aHRv b2xfb3BzIG10a19ldGh0b29sX29wcyA9IHsKIAkuZ2V0X21zZ2xldmVsCQk9IG10a19nZXRfbXNn bGV2ZWwsCiAJLnNldF9tc2dsZXZlbAkJPSBtdGtfc2V0X21zZ2xldmVsLAogCS5ud2F5X3Jlc2V0 CQk9IG10a19ud2F5X3Jlc2V0LAotCS5nZXRfbGluawkJPSBtdGtfZ2V0X2xpbmssCisJLmdldF9s aW5rCQk9IGV0aHRvb2xfb3BfZ2V0X2xpbmssCiAJLmdldF9zdHJpbmdzCQk9IG10a19nZXRfc3Ry aW5ncywKIAkuZ2V0X3NzZXRfY291bnQJCT0gbXRrX2dldF9zc2V0X2NvdW50LAogCS5nZXRfZXRo dG9vbF9zdGF0cwk9IG10a19nZXRfZXRodG9vbF9zdGF0cywKQEAgLTI2MDgsOSArMjY0MywxMCBA QCBzdGF0aWMgY29uc3Qgc3RydWN0IG5ldF9kZXZpY2Vfb3BzIG10a19uZXRkZXZfb3BzID0gewog CiBzdGF0aWMgaW50IG10a19hZGRfbWFjKHN0cnVjdCBtdGtfZXRoICpldGgsIHN0cnVjdCBkZXZp Y2Vfbm9kZSAqbnApCiB7Ci0Jc3RydWN0IG10a19tYWMgKm1hYzsKIAljb25zdCBfX2JlMzIgKl9p ZCA9IG9mX2dldF9wcm9wZXJ0eShucCwgInJlZyIsIE5VTEwpOwotCWludCBpZCwgZXJyOworCXN0 cnVjdCBwaHlsaW5rICpwaHlsaW5rOworCWludCBwaHlfbW9kZSwgaWQsIGVycjsKKwlzdHJ1Y3Qg bXRrX21hYyAqbWFjOwogCiAJaWYgKCFfaWQpIHsKIAkJZGV2X2VycihldGgtPmRldiwgIm1pc3Np bmcgbWFjIGlkXG4iKTsKQEAgLTI2NTQsNiArMjY5MCwzMiBAQCBzdGF0aWMgaW50IG10a19hZGRf bWFjKHN0cnVjdCBtdGtfZXRoICpldGgsIHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApCiAJdTY0X3N0 YXRzX2luaXQoJm1hYy0+aHdfc3RhdHMtPnN5bmNwKTsKIAltYWMtPmh3X3N0YXRzLT5yZWdfb2Zm c2V0ID0gaWQgKiBNVEtfU1RBVF9PRkZTRVQ7CiAKKwkvKiBwaHlsaW5rIGNyZWF0ZSAqLworCXBo eV9tb2RlID0gb2ZfZ2V0X3BoeV9tb2RlKG5wKTsKKwlpZiAocGh5X21vZGUgPCAwKSB7CisJCWRl dl9lcnIoZXRoLT5kZXYsICJpbmNvcnJlY3QgcGh5LW1vZGVcbiIpOworCQllcnIgPSAtRUlOVkFM OworCQlnb3RvIGZyZWVfbmV0ZGV2OworCX0KKworCS8qIG1hYyBjb25maWcgaXMgbm90IHNldCAq LworCW1hYy0+aW50ZXJmYWNlID0gUEhZX0lOVEVSRkFDRV9NT0RFX05BOworCW1hYy0+bW9kZSA9 IE1MT19BTl9QSFk7CisJbWFjLT5zcGVlZCA9IFNQRUVEX1VOS05PV047CisKKwltYWMtPnBoeWxp bmtfY29uZmlnLmRldiA9ICZldGgtPm5ldGRldltpZF0tPmRldjsKKwltYWMtPnBoeWxpbmtfY29u ZmlnLnR5cGUgPSBQSFlMSU5LX05FVERFVjsKKworCXBoeWxpbmsgPSBwaHlsaW5rX2NyZWF0ZSgm bWFjLT5waHlsaW5rX2NvbmZpZywKKwkJCQkgb2ZfZndub2RlX2hhbmRsZShtYWMtPm9mX25vZGUp LAorCQkJCSBwaHlfbW9kZSwgJm10a19waHlsaW5rX29wcyk7CisJaWYgKElTX0VSUihwaHlsaW5r KSkgeworCQllcnIgPSBQVFJfRVJSKHBoeWxpbmspOworCQlnb3RvIGZyZWVfbmV0ZGV2OworCX0K KworCW1hYy0+cGh5bGluayA9IHBoeWxpbms7CisKIAlTRVRfTkVUREVWX0RFVihldGgtPm5ldGRl dltpZF0sIGV0aC0+ZGV2KTsKIAlldGgtPm5ldGRldltpZF0tPndhdGNoZG9nX3RpbWVvID0gNSAq IEhaOwogCWV0aC0+bmV0ZGV2W2lkXS0+bmV0ZGV2X29wcyA9ICZtdGtfbmV0ZGV2X29wczsKQEAg LTI2ODIsOCArMjc0NCw3IEBAIHN0YXRpYyBpbnQgbXRrX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IGRldmljZV9ub2RlICptYWNfbnA7CiAJc3RydWN0IG10 a19ldGggKmV0aDsKLQlpbnQgZXJyOwotCWludCBpOworCWludCBlcnIsIGk7CiAKIAlldGggPSBk ZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpldGgpLCBHRlBfS0VSTkVMKTsKIAlpZiAo IWV0aCkKQEAgLTI4NjksNiArMjkzMCw3IEBAIHN0YXRpYyBpbnQgbXRrX3Byb2JlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiBzdGF0aWMgaW50IG10a19yZW1vdmUoc3RydWN0IHBsYXRm b3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgbXRrX2V0aCAqZXRoID0gcGxhdGZvcm1fZ2V0 X2RydmRhdGEocGRldik7CisJc3RydWN0IG10a19tYWMgKm1hYzsKIAlpbnQgaTsKIAogCS8qIHN0 b3AgYWxsIGRldmljZXMgdG8gbWFrZSBzdXJlIHRoYXQgZG1hIGlzIHByb3Blcmx5IHNodXQgZG93 biAqLwpAQCAtMjg3Niw2ICsyOTM4LDggQEAgc3RhdGljIGludCBtdGtfcmVtb3ZlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJCWlmICghZXRoLT5uZXRkZXZbaV0pCiAJCQljb250aW51 ZTsKIAkJbXRrX3N0b3AoZXRoLT5uZXRkZXZbaV0pOworCQltYWMgPSBuZXRkZXZfcHJpdihldGgt Pm5ldGRldltpXSk7CisJCXBoeWxpbmtfZGlzY29ubmVjdF9waHkobWFjLT5waHlsaW5rKTsKIAl9 CiAKIAltdGtfaHdfZGVpbml0KGV0aCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5l dC9tZWRpYXRlay9tdGtfZXRoX3NvYy5oIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsv bXRrX2V0aF9zb2MuaAppbmRleCBjYzE0NjZhZTA5MjYuLjdmNWY1NDFkYWFkNyAxMDA2NDQKLS0t IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuaAorKysgYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5oCkBAIC0xNCw2ICsxNCw3IEBA CiAjaW5jbHVkZSA8bGludXgvb2ZfbmV0Lmg+CiAjaW5jbHVkZSA8bGludXgvdTY0X3N0YXRzX3N5 bmMuaD4KICNpbmNsdWRlIDxsaW51eC9yZWZjb3VudC5oPgorI2luY2x1ZGUgPGxpbnV4L3BoeWxp bmsuaD4KIAogI2RlZmluZSBNVEtfUURNQV9QQUdFX1NJWkUJMjA0OAogI2RlZmluZQlNVEtfTUFY X1JYX0xFTkdUSAkxNTM2CkBAIC0zMzAsMTIgKzMzMSwxOSBAQAogI2RlZmluZSBNQUNfTUNSX1NQ RUVEXzEwMAlCSVQoMikKICNkZWZpbmUgTUFDX01DUl9GT1JDRV9EUFgJQklUKDEpCiAjZGVmaW5l IE1BQ19NQ1JfRk9SQ0VfTElOSwlCSVQoMCkKLSNkZWZpbmUgTUFDX01DUl9GSVhFRF9MSU5LCShN QUNfTUNSX01BWF9SWF8xNTM2IHwgTUFDX01DUl9JUEdfQ0ZHIHwgXAotCQkJCSBNQUNfTUNSX0ZP UkNFX01PREUgfCBNQUNfTUNSX1RYX0VOIHwgXAotCQkJCSBNQUNfTUNSX1JYX0VOIHwgTUFDX01D Ul9CQUNLT0ZGX0VOIHwgXAotCQkJCSBNQUNfTUNSX0JBQ0tQUl9FTiB8IE1BQ19NQ1JfRk9SQ0Vf UlhfRkMgfCBcCi0JCQkJIE1BQ19NQ1JfRk9SQ0VfVFhfRkMgfCBNQUNfTUNSX1NQRUVEXzEwMDAg fCBcCi0JCQkJIE1BQ19NQ1JfRk9SQ0VfRFBYIHwgTUFDX01DUl9GT1JDRV9MSU5LKQorI2RlZmlu ZSBNQUNfTUNSX0ZPUkNFX0xJTktfRE9XTgkoTUFDX01DUl9GT1JDRV9NT0RFKQorCisvKiBNYWMg c3RhdHVzIHJlZ2lzdGVycyAqLworI2RlZmluZSBNVEtfTUFDX01TUih4KQkJKDB4MTAxMDggKyAo eCAqIDB4MTAwKSkKKyNkZWZpbmUgTUFDX01TUl9FRUUxRwkJQklUKDcpCisjZGVmaW5lIE1BQ19N U1JfRUVFMTAwTQkJQklUKDYpCisjZGVmaW5lIE1BQ19NU1JfUlhfRkMJCUJJVCg1KQorI2RlZmlu ZSBNQUNfTVNSX1RYX0ZDCQlCSVQoNCkKKyNkZWZpbmUgTUFDX01TUl9TUEVFRF8xMDAwCUJJVCgz KQorI2RlZmluZSBNQUNfTVNSX1NQRUVEXzEwMAlCSVQoMikKKyNkZWZpbmUgTUFDX01TUl9TUEVF RF9NQVNLCShNQUNfTVNSX1NQRUVEXzEwMDAgfCBNQUNfTVNSX1NQRUVEXzEwMCkKKyNkZWZpbmUg TUFDX01TUl9EUFgJCUJJVCgxKQorI2RlZmluZSBNQUNfTVNSX0xJTksJCUJJVCgwKQogCiAvKiBU UkdNSUkgUlhDIGNvbnRyb2wgcmVnaXN0ZXIgKi8KICNkZWZpbmUgVFJHTUlJX1JDS19DVFJMCQkw eDEwMzAwCkBAIC04NTgsMjIgKzg2NiwyMyBAQCBzdHJ1Y3QgbXRrX2V0aCB7CiAvKiBzdHJ1Y3Qg bXRrX21hYyAtCXRoZSBzdHJ1Y3R1cmUgdGhhdCBob2xkcyB0aGUgaW5mbyBhYm91dCB0aGUgTUFD cyBvZiB0aGUKICAqCQkJU29DCiAgKiBAaWQ6CQkJVGhlIG51bWJlciBvZiB0aGUgTUFDCi0gKiBA Z2VfbW9kZTogICAgICAgICAgICBJbnRlcmZhY2UgbW9kZSBrZXB0IGZvciBzZXR1cCByZXN0b3Jp bmcKKyAqIEBpbnRlcmZhY2U6CQlJbnRlcmZhY2UgbW9kZSBrZXB0IGZvciBkZXRlY3RpbmcgY2hh bmdlIGluIGh3IHNldHRpbmdzCiAgKiBAb2Zfbm9kZToJCU91ciBkZXZpY2V0cmVlIG5vZGUKICAq IEBodzoJCQlCYWNrcG9pbnRlciB0byBvdXIgbWFpbiBkYXRhc3RydXR1cmUKICAqIEBod19zdGF0 czoJCVBhY2tldCBzdGF0aXN0aWNzIGNvdW50ZXIKLSAqIEB0cmdtaWkJCUluZGljYXRlIGlmIHRo ZSBNQUMgdXNlcyBUUkdNSUkgY29ubmVjdGVkIHRvIGludGVybmFsCi0JCQlzd2l0Y2gKICAqLwog c3RydWN0IG10a19tYWMgewogCWludAkJCQlpZDsKLQlpbnQJCQkJZ2VfbW9kZTsKKwlwaHlfaW50 ZXJmYWNlX3QJCQlpbnRlcmZhY2U7CisJdW5zaWduZWQgaW50CQkJbW9kZTsKKwlpbnQJCQkJc3Bl ZWQ7CiAJc3RydWN0IGRldmljZV9ub2RlCQkqb2Zfbm9kZTsKKwlzdHJ1Y3QgcGh5bGluawkJCSpw aHlsaW5rOworCXN0cnVjdCBwaHlsaW5rX2NvbmZpZwkJcGh5bGlua19jb25maWc7CiAJc3RydWN0 IG10a19ldGgJCQkqaHc7CiAJc3RydWN0IG10a19od19zdGF0cwkJKmh3X3N0YXRzOwogCV9fYmUz MgkJCQlod2xyb19pcFtNVEtfTUFYX0xST19JUF9DTlRdOwogCWludAkJCQlod2xyb19pcF9jbnQ7 Ci0JYm9vbAkJCQl0cmdtaWk7CiB9OwogCiAvKiB0aGUgc3RydWN0IGRlc2NyaWJpbmcgdGhlIFNv Qy4gdGhlc2UgYXJlIGRlY2xhcmVkIGluIHRoZSBzb2NfeHl6LmMgZmlsZXMgKi8KLS0gCjIuMjAu MQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFk Lm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFy bS1rZXJuZWwK