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 E1E7CC3A5A3 for ; Sun, 25 Aug 2019 17:44:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9C856206DD for ; Sun, 25 Aug 2019 17:44:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="DOrS+L25" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728784AbfHYRoC (ORCPT ); Sun, 25 Aug 2019 13:44:02 -0400 Received: from mx.0dd.nl ([5.2.79.48]:38706 "EHLO mx.0dd.nl" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725971AbfHYRn6 (ORCPT ); Sun, 25 Aug 2019 13:43:58 -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 2AD125FC96; Sun, 25 Aug 2019 19:43:55 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="DOrS+L25"; 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 DA3491D8E164; Sun, 25 Aug 2019 19:43:54 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com DA3491D8E164 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1566755034; bh=Rt1Y5fT37HpNUGUqGr2s1G3C7KWN2yOcBRSfSurO1qQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=DOrS+L25dulP0v9c5f6czcWXbjeMhoG2lsHhFxiLAOiZsX53u7rBHOzir341aHXO1 8LTFWpm3fJQTXx+2Dix8CPGBJA4xghZo0COkrchdMVJ4fYcxn794+hOy/jnL/REkjA QGLMTchZ3lxew3VQsNUAkSqrR94Unmuk943fDec07BCXJ3IaXybECiSkOfeCA5xrVV NmRt6jBaYHer0kSLNnK91MlKiR4kQirG1PeSdsDghiZgYmFO3sQIQQ7dQodBF48y3F MnpdXOrI1C8qb8n2n9k1AQZhiALqPVw2/09VIJcyXp7qOlt5P3wxwQuwNC9T7Dxui+ y5CuIDceGlfhg== 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 v4 1/3] net: ethernet: mediatek: Add basic PHYLINK support Date: Sun, 25 Aug 2019 19:43:39 +0200 Message-Id: <20190825174341.20750-2-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190825174341.20750-1-opensource@vdorst.com> References: <20190825174341.20750-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 -- v3->v4: * In link_down() a ~ was missing before the (, RX and TX bits have to be cleared. Spotted by Russell King 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..7d2566dd4ce0 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,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 5A008C3A5A1 for ; Sun, 25 Aug 2019 17:45:02 +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 1C0AE206DD for ; Sun, 25 Aug 2019 17:45:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="KGtBaUq3"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="DOrS+L25" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1C0AE206DD 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=kKrwO3MZsyN4pyjHXx80FZKGIfteFz5oWdelrdAk5G4=; b=KGtBaUq38/oAUr 1TIwn1PSz6gxZf3ZLRw74V8uHYDmV5MFFMwv+wu99XJqFU7Y++rlbXJbx20tsfHWMtO3TiSDS0K7p uHggyxqLYFOBcaj12N21tP7+Bc8MOV/UmwY1/TioKOL3O1g5VE1Dn5GkjfltQR9/mPvNfXhyrs+X7 16h5Ir7brnOsyQdygTnRD00c4r+LvBgtNMk/8Fqp1n2aWExU9A0z/AIqE104Ncf/NI2BJXtEybUIi Y+o8evCamItg2ztW/s2n0mXpgD9i1XfsXNn7GwnoZtjRVmi5CHG2RuCBh8vByZaZ19lRykVHOtMG4 PHi23LYO7yI9xBCNxNFQ==; 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 1i1wZS-0007aC-0N; Sun, 25 Aug 2019 17:44:54 +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 1i1wYY-0006iI-3U; Sun, 25 Aug 2019 17:44:02 +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 2AD125FC96; Sun, 25 Aug 2019 19:43:55 +0200 (CEST) Authentication-Results: mx.0dd.nl; dkim=pass (2048-bit key) header.d=vdorst.com header.i=@vdorst.com header.b="DOrS+L25"; 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 DA3491D8E164; Sun, 25 Aug 2019 19:43:54 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 mail.vdorst.com DA3491D8E164 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=vdorst.com; s=default; t=1566755034; bh=Rt1Y5fT37HpNUGUqGr2s1G3C7KWN2yOcBRSfSurO1qQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=DOrS+L25dulP0v9c5f6czcWXbjeMhoG2lsHhFxiLAOiZsX53u7rBHOzir341aHXO1 8LTFWpm3fJQTXx+2Dix8CPGBJA4xghZo0COkrchdMVJ4fYcxn794+hOy/jnL/REkjA QGLMTchZ3lxew3VQsNUAkSqrR94Unmuk943fDec07BCXJ3IaXybECiSkOfeCA5xrVV NmRt6jBaYHer0kSLNnK91MlKiR4kQirG1PeSdsDghiZgYmFO3sQIQQ7dQodBF48y3F MnpdXOrI1C8qb8n2n9k1AQZhiALqPVw2/09VIJcyXp7qOlt5P3wxwQuwNC9T7Dxui+ y5CuIDceGlfhg== 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 v4 1/3] net: ethernet: mediatek: Add basic PHYLINK support Date: Sun, 25 Aug 2019 19:43:39 +0200 Message-Id: <20190825174341.20750-2-opensource@vdorst.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190825174341.20750-1-opensource@vdorst.com> References: <20190825174341.20750-1-opensource@vdorst.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190825_104358_570778_AC16D4DC X-CRM114-Status: GOOD ( 22.32 ) 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 b3VyY2VAdmRvcnN0LmNvbT4KLS0KdjMtPnY0OgoqIEluIGxpbmtfZG93bigpIGEgfiB3YXMgbWlz c2luZyBiZWZvcmUgdGhlICgsIFJYIGFuZCBUWCBiaXRzIGhhdmUgdG8gYmUKICBjbGVhcmVkLiBT cG90dGVkIGJ5IFJ1c3NlbGwgS2luZwp2Mi0+djM6CiogTWFrZSBsaW5rX2Rvd24oKSBzaW1pbGFy IGFzIGxpbmtfdXAoKSBzdWdnZXN0ZWQgYnkgUnVzc2VsbCBLaW5nCnYxLT52MjoKKiBBbHNvIHJl cG9ydCAxMDAwQmFzZS1YIHN1cHBvcnQgc3VnZ2VzdGVkIGJ5IFJ1c3NlbGwgS2luZwoqIFJldmVy c2UgY2hyaXN0bWFzIG9uIG1hbnkgcGxhY2VzIHN1Z2dlc3RlZCBieSBEYXZpZCBNaWxsZXIKKiBS ZWJhc2UgdG9vIHBpY2t1cCB0aGUgbXQ3Nng4IGNoYW5nZXMuCi0tLQogZHJpdmVycy9uZXQvZXRo ZXJuZXQvbWVkaWF0ZWsvS2NvbmZpZyAgICAgICB8ICAgMiArLQogZHJpdmVycy9uZXQvZXRoZXJu ZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuYyB8IDQyNCArKysrKysrKysrKy0tLS0tLS0tLQogZHJp dmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuaCB8ICAzMSArLQogMyBmaWxl cyBjaGFuZ2VkLCAyNjUgaW5zZXJ0aW9ucygrKSwgMTkyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL0tjb25maWcgYi9kcml2ZXJzL25ldC9l dGhlcm5ldC9tZWRpYXRlay9LY29uZmlnCmluZGV4IGI3NmNmMmUxYzlkYy4uNDk2ODM1MmJhMTg4 IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9LY29uZmlnCisrKyBi L2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL0tjb25maWcKQEAgLTksNyArOSw3IEBAIGlm IE5FVF9WRU5ET1JfTUVESUFURUsKIAogY29uZmlnIE5FVF9NRURJQVRFS19TT0MKIAl0cmlzdGF0 ZSAiTWVkaWFUZWsgU29DIEdpZ2FiaXQgRXRoZXJuZXQgc3VwcG9ydCIKLQlzZWxlY3QgUEhZTElC CisJc2VsZWN0IFBIWUxJTksKIAktLS1oZWxwLS0tCiAJICBUaGlzIGRyaXZlciBzdXBwb3J0cyB0 aGUgZ2lnYWJpdCBldGhlcm5ldCBNQUNzIGluIHRoZQogCSAgTWVkaWFUZWsgU29DIGZhbWlseS4K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVrL210a19ldGhfc29jLmMg Yi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5jCmluZGV4IDhkZGJi OGRjZjAzMi4uN2QyNTY2ZGQ0Y2UwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9t ZWRpYXRlay9tdGtfZXRoX3NvYy5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lZGlhdGVr L210a19ldGhfc29jLmMKQEAgLTE4LDYgKzE4LDcgQEAKICNpbmNsdWRlIDxsaW51eC90Y3AuaD4K ICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9waW5jdHJsL2Rl dmluZm8uaD4KKyNpbmNsdWRlIDxsaW51eC9waHlsaW5rLmg+CiAKICNpbmNsdWRlICJtdGtfZXRo X3NvYy5oIgogCkBAIC0xODYsMTY4ICsxODcsMjI0IEBAIHN0YXRpYyB2b2lkIG10a19nbWFjMF9y Z21paV9hZGp1c3Qoc3RydWN0IG10a19ldGggKmV0aCwgaW50IHNwZWVkKQogCW10a193MzIoZXRo LCB2YWwsIFRSR01JSV9UQ0tfQ1RSTCk7CiB9CiAKLXN0YXRpYyB2b2lkIG10a19waHlfbGlua19h ZGp1c3Qoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3N0YXRpYyB2b2lkIG10a19tYWNfY29uZmln KHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmlnLCB1bnNpZ25lZCBpbnQgbW9kZSwKKwkJCSAg IGNvbnN0IHN0cnVjdCBwaHlsaW5rX2xpbmtfc3RhdGUgKnN0YXRlKQogewotCXN0cnVjdCBtdGtf bWFjICptYWMgPSBuZXRkZXZfcHJpdihkZXYpOwotCXUxNiBsY2xfYWR2ID0gMCwgcm10X2FkdiA9 IDA7Ci0JdTggZmxvd2N0cmw7Ci0JdTMyIG1jciA9IE1BQ19NQ1JfTUFYX1JYXzE1MzYgfCBNQUNf TUNSX0lQR19DRkcgfAotCQkgIE1BQ19NQ1JfRk9SQ0VfTU9ERSB8IE1BQ19NQ1JfVFhfRU4gfAot CQkgIE1BQ19NQ1JfUlhfRU4gfCBNQUNfTUNSX0JBQ0tPRkZfRU4gfAotCQkgIE1BQ19NQ1JfQkFD S1BSX0VOOworCXN0cnVjdCBtdGtfbWFjICptYWMgPSBjb250YWluZXJfb2YoY29uZmlnLCBzdHJ1 Y3QgbXRrX21hYywKKwkJCQkJICAgcGh5bGlua19jb25maWcpOworCXN0cnVjdCBtdGtfZXRoICpl dGggPSBtYWMtPmh3OworCXUzMiBtY3JfY3VyLCBtY3JfbmV3OworCWludCB2YWwsIGdlX21vZGUg PSAwOworCisJLyogTVQ3Nng4IGhhcyBubyBoYXJkd2FyZSBzZXR0aW5ncyBiZXR3ZWVuIGZvciB0 aGUgTUFDICovCisJaWYgKCFNVEtfSEFTX0NBUFMoZXRoLT5zb2MtPmNhcHMsIE1US19TT0NfTVQ3 NjI4KSAmJgorCSAgICBtYWMtPmludGVyZmFjZSAhPSBzdGF0ZS0+aW50ZXJmYWNlKSB7CisJCS8q IFNldHVwIHNvYyBwaW4gZnVuY3Rpb25zICovCisJCXN3aXRjaCAoc3RhdGUtPmludGVyZmFjZSkg eworCQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9UUkdNSUk6CisJCQlpZiAobWFjLT5pZCkKKwkJ CQlnb3RvIGVycl9waHk7CisJCQlpZiAoIU1US19IQVNfQ0FQUyhtYWMtPmh3LT5zb2MtPmNhcHMs CisJCQkJCSAgTVRLX0dNQUMxX1RSR01JSSkpCisJCQkJZ290byBlcnJfcGh5OworCQkJLyogZmFs bCB0aHJvdWdoICovCisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX0dNSUk6CisJCWNhc2UgUEhZ X0lOVEVSRkFDRV9NT0RFX1JHTUlJX1RYSUQ6CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JH TUlJX1JYSUQ6CisJCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX0lEOgorCQljYXNlIFBI WV9JTlRFUkZBQ0VfTU9ERV9SR01JSToKKwkJCWJyZWFrOworCQljYXNlIFBIWV9JTlRFUkZBQ0Vf TU9ERV9NSUk6CisJCQlnZV9tb2RlID0gMTsKKwkJCWJyZWFrOworCQljYXNlIFBIWV9JTlRFUkZB Q0VfTU9ERV9SRVZNSUk6CisJCQlnZV9tb2RlID0gMjsKKwkJCWJyZWFrOworCQljYXNlIFBIWV9J TlRFUkZBQ0VfTU9ERV9STUlJOgorCQkJaWYgKG1hYy0+aWQpCisJCQkJZ290byBlcnJfcGh5Owor CQkJZ2VfbW9kZSA9IDM7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWdvdG8gZXJyX3BoeTsK KwkJfQogCi0JaWYgKHVubGlrZWx5KHRlc3RfYml0KE1US19SRVNFVFRJTkcsICZtYWMtPmh3LT5z dGF0ZSkpKQotCQlyZXR1cm47CisJCS8qIFNldHVwIGNsb2NrIGZvciAxc3QgZ21hYyAqLworCQlp ZiAoIW1hYy0+aWQgJiYKKwkJICAgIE1US19IQVNfQ0FQUyhtYWMtPmh3LT5zb2MtPmNhcHMsIE1U S19HTUFDMV9UUkdNSUkpKSB7CisJCQlpZiAoTVRLX0hBU19DQVBTKG1hYy0+aHctPnNvYy0+Y2Fw cywKKwkJCQkJIE1US19UUkdNSUlfTVQ3NjIxX0NMSykpIHsKKwkJCQlpZiAobXQ3NjIxX2dtYWMw X3JnbWlpX2FkanVzdChtYWMtPmh3LAorCQkJCQkJCSAgICAgIHN0YXRlLT5pbnRlcmZhY2UpKQor CQkJCQlnb3RvIGVycl9waHk7CisJCQl9IGVsc2UgeworCQkJCWlmIChzdGF0ZS0+aW50ZXJmYWNl ICE9CisJCQkJICAgIFBIWV9JTlRFUkZBQ0VfTU9ERV9UUkdNSUkpCisJCQkJCW10a19nbWFjMF9y Z21paV9hZGp1c3QobWFjLT5odywKKwkJCQkJCQkgICAgICAgc3RhdGUtPnNwZWVkKTsKKwkJCX0K KwkJfQogCi0Jc3dpdGNoIChkZXYtPnBoeWRldi0+c3BlZWQpIHsKKwkJLyogcHV0IHRoZSBnbWFj IGludG8gdGhlIHJpZ2h0IG1vZGUgKi8KKwkJcmVnbWFwX3JlYWQoZXRoLT5ldGhzeXMsIEVUSFNZ U19TWVNDRkcwLCAmdmFsKTsKKwkJdmFsICY9IH5TWVNDRkcwX0dFX01PREUoU1lTQ0ZHMF9HRV9N QVNLLCBtYWMtPmlkKTsKKwkJdmFsIHw9IFNZU0NGRzBfR0VfTU9ERShnZV9tb2RlLCBtYWMtPmlk KTsKKwkJcmVnbWFwX3dyaXRlKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgdmFsKTsKKwor CQltYWMtPmludGVyZmFjZSA9IHN0YXRlLT5pbnRlcmZhY2U7CisJfQorCisJLyogU2V0dXAgZ21h YyAqLworCW1jcl9jdXIgPSBtdGtfcjMyKG1hYy0+aHcsIE1US19NQUNfTUNSKG1hYy0+aWQpKTsK KwltY3JfbmV3ID0gbWNyX2N1cjsKKwltY3JfbmV3ICY9IH4oTUFDX01DUl9TUEVFRF8xMDAgfCBN QUNfTUNSX1NQRUVEXzEwMDAgfAorCQkgICAgIE1BQ19NQ1JfRk9SQ0VfRFBYIHwgTUFDX01DUl9G T1JDRV9UWF9GQyB8CisJCSAgICAgTUFDX01DUl9GT1JDRV9SWF9GQyk7CisJbWNyX25ldyB8PSBN QUNfTUNSX01BWF9SWF8xNTM2IHwgTUFDX01DUl9JUEdfQ0ZHIHwgTUFDX01DUl9GT1JDRV9NT0RF IHwKKwkJICAgTUFDX01DUl9CQUNLT0ZGX0VOIHwgTUFDX01DUl9CQUNLUFJfRU4gfCBNQUNfTUNS X0ZPUkNFX0xJTks7CisKKwlzd2l0Y2ggKHN0YXRlLT5zcGVlZCkgewogCWNhc2UgU1BFRURfMTAw MDoKLQkJbWNyIHw9IE1BQ19NQ1JfU1BFRURfMTAwMDsKKwkJbWNyX25ldyB8PSBNQUNfTUNSX1NQ RUVEXzEwMDA7CiAJCWJyZWFrOwogCWNhc2UgU1BFRURfMTAwOgotCQltY3IgfD0gTUFDX01DUl9T UEVFRF8xMDA7CisJCW1jcl9uZXcgfD0gTUFDX01DUl9TUEVFRF8xMDA7CiAJCWJyZWFrOwogCX0K LQotCWlmIChNVEtfSEFTX0NBUFMobWFjLT5ody0+c29jLT5jYXBzLCBNVEtfR01BQzFfVFJHTUlJ KSAmJiAhbWFjLT5pZCkgewotCQlpZiAoTVRLX0hBU19DQVBTKG1hYy0+aHctPnNvYy0+Y2Fwcywg TVRLX1RSR01JSV9NVDc2MjFfQ0xLKSkgewotCQkJaWYgKG10NzYyMV9nbWFjMF9yZ21paV9hZGp1 c3QobWFjLT5odywKLQkJCQkJCSAgICAgIGRldi0+cGh5ZGV2LT5pbnRlcmZhY2UpKQotCQkJCXJl dHVybjsKLQkJfSBlbHNlIHsKLQkJCWlmICghbWFjLT50cmdtaWkpCi0JCQkJbXRrX2dtYWMwX3Jn bWlpX2FkanVzdChtYWMtPmh3LAotCQkJCQkJICAgICAgIGRldi0+cGh5ZGV2LT5zcGVlZCk7Ci0J CX0KKwlpZiAoc3RhdGUtPmR1cGxleCA9PSBEVVBMRVhfRlVMTCkgeworCQltY3JfbmV3IHw9IE1B Q19NQ1JfRk9SQ0VfRFBYOworCQlpZiAoc3RhdGUtPnBhdXNlICYgTUxPX1BBVVNFX1RYKQorCQkJ bWNyX25ldyB8PSBNQUNfTUNSX0ZPUkNFX1RYX0ZDOworCQlpZiAoc3RhdGUtPnBhdXNlICYgTUxP X1BBVVNFX1JYKQorCQkJbWNyX25ldyB8PSBNQUNfTUNSX0ZPUkNFX1JYX0ZDOwogCX0KIAotCWlm IChkZXYtPnBoeWRldi0+bGluaykKLQkJbWNyIHw9IE1BQ19NQ1JfRk9SQ0VfTElOSzsKKwkvKiBP bmx5IHVwZGF0ZSBjb250cm9sIHJlZ2lzdGVyIHdoZW4gbmVlZGVkISAqLworCWlmIChtY3JfbmV3 ICE9IG1jcl9jdXIpCisJCW10a193MzIobWFjLT5odywgbWNyX25ldywgTVRLX01BQ19NQ1IobWFj LT5pZCkpOwogCi0JaWYgKGRldi0+cGh5ZGV2LT5kdXBsZXgpIHsKLQkJbWNyIHw9IE1BQ19NQ1Jf Rk9SQ0VfRFBYOworCXJldHVybjsKIAotCQlpZiAoZGV2LT5waHlkZXYtPnBhdXNlKQotCQkJcm10 X2FkdiA9IExQQV9QQVVTRV9DQVA7Ci0JCWlmIChkZXYtPnBoeWRldi0+YXN5bV9wYXVzZSkKLQkJ CXJtdF9hZHYgfD0gTFBBX1BBVVNFX0FTWU07CitlcnJfcGh5OgorCWRldl9lcnIoZXRoLT5kZXYs ICIlczogR01BQyVkIG1vZGUgJXMgbm90IHN1cHBvcnRlZCFcbiIsIF9fZnVuY19fLAorCQltYWMt PmlkLCBwaHlfbW9kZXMoc3RhdGUtPmludGVyZmFjZSkpOworfQogCi0JCWxjbF9hZHYgPSBsaW5r bW9kZV9hZHZfdG9fbGNsX2Fkdl90KGRldi0+cGh5ZGV2LT5hZHZlcnRpc2luZyk7Ci0JCWZsb3dj dHJsID0gbWlpX3Jlc29sdmVfZmxvd2N0cmxfZmR4KGxjbF9hZHYsIHJtdF9hZHYpOworc3RhdGlj IGludCBtdGtfbWFjX2xpbmtfc3RhdGUoc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsCisJ CQkgICAgICBzdHJ1Y3QgcGh5bGlua19saW5rX3N0YXRlICpzdGF0ZSkKK3sKKwlzdHJ1Y3QgbXRr X21hYyAqbWFjID0gY29udGFpbmVyX29mKGNvbmZpZywgc3RydWN0IG10a19tYWMsCisJCQkJCSAg IHBoeWxpbmtfY29uZmlnKTsKKwl1MzIgcG1zciA9IG10a19yMzIobWFjLT5odywgTVRLX01BQ19N U1IobWFjLT5pZCkpOwogCi0JCWlmIChmbG93Y3RybCAmIEZMT1dfQ1RSTF9UWCkKLQkJCW1jciB8 PSBNQUNfTUNSX0ZPUkNFX1RYX0ZDOwotCQlpZiAoZmxvd2N0cmwgJiBGTE9XX0NUUkxfUlgpCi0J CQltY3IgfD0gTUFDX01DUl9GT1JDRV9SWF9GQzsKKwlzdGF0ZS0+bGluayA9IChwbXNyICYgTUFD X01TUl9MSU5LKTsKKwlzdGF0ZS0+ZHVwbGV4ID0gKHBtc3IgJiBNQUNfTVNSX0RQWCkgPj4gMTsK IAotCQluZXRpZl9kYmcobWFjLT5odywgbGluaywgZGV2LCAicnggcGF1c2UgJXMsIHR4IHBhdXNl ICVzXG4iLAotCQkJICBmbG93Y3RybCAmIEZMT1dfQ1RSTF9SWCA/ICJlbmFibGVkIiA6ICJkaXNh YmxlZCIsCi0JCQkgIGZsb3djdHJsICYgRkxPV19DVFJMX1RYID8gImVuYWJsZWQiIDogImRpc2Fi bGVkIik7CisJc3dpdGNoIChwbXNyICYgKE1BQ19NU1JfU1BFRURfMTAwMCB8IE1BQ19NU1JfU1BF RURfMTAwKSkgeworCWNhc2UgMDoKKwkJc3RhdGUtPnNwZWVkID0gU1BFRURfMTA7CisJCWJyZWFr OworCWNhc2UgTUFDX01TUl9TUEVFRF8xMDA6CisJCXN0YXRlLT5zcGVlZCA9IFNQRUVEXzEwMDsK KwkJYnJlYWs7CisJY2FzZSBNQUNfTVNSX1NQRUVEXzEwMDA6CisJCXN0YXRlLT5zcGVlZCA9IFNQ RUVEXzEwMDA7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXN0YXRlLT5zcGVlZCA9IFNQRUVEX1VO S05PV047CisJCWJyZWFrOwogCX0KIAotCW10a193MzIobWFjLT5odywgbWNyLCBNVEtfTUFDX01D UihtYWMtPmlkKSk7CisJc3RhdGUtPnBhdXNlICY9IChNTE9fUEFVU0VfUlggfCBNTE9fUEFVU0Vf VFgpOworCWlmIChwbXNyICYgTUFDX01TUl9SWF9GQykKKwkJc3RhdGUtPnBhdXNlIHw9IE1MT19Q QVVTRV9SWDsKKwlpZiAocG1zciAmIE1BQ19NU1JfVFhfRkMpCisJCXN0YXRlLT5wYXVzZSB8PSBN TE9fUEFVU0VfVFg7CiAKLQlpZiAoIW9mX3BoeV9pc19maXhlZF9saW5rKG1hYy0+b2Zfbm9kZSkp Ci0JCXBoeV9wcmludF9zdGF0dXMoZGV2LT5waHlkZXYpOworCXJldHVybiAxOwogfQogCi1zdGF0 aWMgaW50IG10a19waHlfY29ubmVjdF9ub2RlKHN0cnVjdCBtdGtfZXRoICpldGgsIHN0cnVjdCBt dGtfbWFjICptYWMsCi0JCQkJc3RydWN0IGRldmljZV9ub2RlICpwaHlfbm9kZSkKK3N0YXRpYyB2 b2lkIG10a19tYWNfYW5fcmVzdGFydChzdHJ1Y3QgcGh5bGlua19jb25maWcgKmNvbmZpZykKIHsK LQlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ZGV2OwotCWludCBwaHlfbW9kZTsKLQotCXBoeV9tb2Rl ID0gb2ZfZ2V0X3BoeV9tb2RlKHBoeV9ub2RlKTsKLQlpZiAocGh5X21vZGUgPCAwKSB7Ci0JCWRl dl9lcnIoZXRoLT5kZXYsICJpbmNvcnJlY3QgcGh5LW1vZGUgJWRcbiIsIHBoeV9tb2RlKTsKLQkJ cmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JcGh5ZGV2ID0gb2ZfcGh5X2Nvbm5lY3QoZXRoLT5uZXRk ZXZbbWFjLT5pZF0sIHBoeV9ub2RlLAotCQkJCW10a19waHlfbGlua19hZGp1c3QsIDAsIHBoeV9t b2RlKTsKLQlpZiAoIXBoeWRldikgewotCQlkZXZfZXJyKGV0aC0+ZGV2LCAiY291bGQgbm90IGNv bm5lY3QgdG8gUEhZXG4iKTsKLQkJcmV0dXJuIC1FTk9ERVY7Ci0JfQorCS8qIERvIG5vdGhpbmcg Ki8KK30KIAotCWRldl9pbmZvKGV0aC0+ZGV2LAotCQkgImNvbm5lY3RlZCBtYWMgJWQgdG8gUEhZ IGF0ICVzIFt1aWQ9JTA4eCwgZHJpdmVyPSVzXVxuIiwKLQkJIG1hYy0+aWQsIHBoeWRldl9uYW1l KHBoeWRldiksIHBoeWRldi0+cGh5X2lkLAotCQkgcGh5ZGV2LT5kcnYtPm5hbWUpOworc3RhdGlj IHZvaWQgbXRrX21hY19saW5rX2Rvd24oc3RydWN0IHBoeWxpbmtfY29uZmlnICpjb25maWcsIHVu c2lnbmVkIGludCBtb2RlLAorCQkJICAgICAgcGh5X2ludGVyZmFjZV90IGludGVyZmFjZSkKK3sK KwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gY29udGFpbmVyX29mKGNvbmZpZywgc3RydWN0IG10a19t YWMsCisJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsKKwl1MzIgbWNyID0gbXRrX3IzMihtYWMtPmh3 LCBNVEtfTUFDX01DUihtYWMtPmlkKSk7CiAKLQlyZXR1cm4gMDsKKwltY3IgJj0gfihNQUNfTUNS X1RYX0VOIHwgTUFDX01DUl9SWF9FTik7CisJbXRrX3czMihtYWMtPmh3LCBtY3IsIE1US19NQUNf TUNSKG1hYy0+aWQpKTsKIH0KIAotc3RhdGljIGludCBtdGtfcGh5X2Nvbm5lY3Qoc3RydWN0IG5l dF9kZXZpY2UgKmRldikKK3N0YXRpYyB2b2lkIG10a19tYWNfbGlua191cChzdHJ1Y3QgcGh5bGlu a19jb25maWcgKmNvbmZpZywgdW5zaWduZWQgaW50IG1vZGUsCisJCQkgICAgcGh5X2ludGVyZmFj ZV90IGludGVyZmFjZSwKKwkJCSAgICBzdHJ1Y3QgcGh5X2RldmljZSAqcGh5KQogewotCXN0cnVj dCBtdGtfbWFjICptYWMgPSBuZXRkZXZfcHJpdihkZXYpOwotCXN0cnVjdCBtdGtfZXRoICpldGg7 Ci0Jc3RydWN0IGRldmljZV9ub2RlICpucDsKLQl1MzIgdmFsOwotCWludCBlcnI7CisJc3RydWN0 IG10a19tYWMgKm1hYyA9IGNvbnRhaW5lcl9vZihjb25maWcsIHN0cnVjdCBtdGtfbWFjLAorCQkJ CQkgICBwaHlsaW5rX2NvbmZpZyk7CisJdTMyIG1jciA9IG10a19yMzIobWFjLT5odywgTVRLX01B Q19NQ1IobWFjLT5pZCkpOwogCi0JZXRoID0gbWFjLT5odzsKLQlucCA9IG9mX3BhcnNlX3BoYW5k bGUobWFjLT5vZl9ub2RlLCAicGh5LWhhbmRsZSIsIDApOwotCWlmICghbnAgJiYgb2ZfcGh5X2lz X2ZpeGVkX2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJaWYgKCFvZl9waHlfcmVnaXN0ZXJfZml4ZWRf bGluayhtYWMtPm9mX25vZGUpKQotCQkJbnAgPSBvZl9ub2RlX2dldChtYWMtPm9mX25vZGUpOwot CWlmICghbnApCi0JCXJldHVybiAtRU5PREVWOworCW1jciB8PSBNQUNfTUNSX1RYX0VOIHwgTUFD X01DUl9SWF9FTjsKKwltdGtfdzMyKG1hYy0+aHcsIG1jciwgTVRLX01BQ19NQ1IobWFjLT5pZCkp OworfQogCi0JZXJyID0gbXRrX3NldHVwX2h3X3BhdGgoZXRoLCBtYWMtPmlkLCBvZl9nZXRfcGh5 X21vZGUobnApKTsKLQlpZiAoZXJyKQotCQlnb3RvIGVycl9waHk7Ci0KLQltYWMtPmdlX21vZGUg PSAwOwotCXN3aXRjaCAob2ZfZ2V0X3BoeV9tb2RlKG5wKSkgewotCWNhc2UgUEhZX0lOVEVSRkFD RV9NT0RFX1RSR01JSToKLQkJbWFjLT50cmdtaWkgPSB0cnVlOwotCWNhc2UgUEhZX0lOVEVSRkFD RV9NT0RFX1JHTUlJX1RYSUQ6Ci0JY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUkdNSUlfUlhJRDoK LQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9JRDoKLQljYXNlIFBIWV9JTlRFUkZBQ0Vf TU9ERV9SR01JSToKLQljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9TR01JSToKLQkJYnJlYWs7Ci0J Y2FzZSBQSFlfSU5URVJGQUNFX01PREVfTUlJOgotCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX0dN SUk6Ci0JCW1hYy0+Z2VfbW9kZSA9IDE7Ci0JCWJyZWFrOwotCWNhc2UgUEhZX0lOVEVSRkFDRV9N T0RFX1JFVk1JSToKLQkJbWFjLT5nZV9tb2RlID0gMjsKLQkJYnJlYWs7Ci0JY2FzZSBQSFlfSU5U RVJGQUNFX01PREVfUk1JSToKLQkJaWYgKCFtYWMtPmlkKQotCQkJZ290byBlcnJfcGh5OwotCQlt YWMtPmdlX21vZGUgPSAzOwotCQlicmVhazsKLQlkZWZhdWx0OgotCQlnb3RvIGVycl9waHk7Ci0J fQorc3RhdGljIHZvaWQgbXRrX3ZhbGlkYXRlKHN0cnVjdCBwaHlsaW5rX2NvbmZpZyAqY29uZmln LAorCQkJIHVuc2lnbmVkIGxvbmcgKnN1cHBvcnRlZCwKKwkJCSBzdHJ1Y3QgcGh5bGlua19saW5r X3N0YXRlICpzdGF0ZSkKK3sKKwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gY29udGFpbmVyX29mKGNv bmZpZywgc3RydWN0IG10a19tYWMsCisJCQkJCSAgIHBoeWxpbmtfY29uZmlnKTsKKwlfX0VUSFRP T0xfREVDTEFSRV9MSU5LX01PREVfTUFTSyhtYXNrKSA9IHsgMCwgfTsKIAotCS8qIE5vIE1UNzYy OC84OCBzdXBwb3J0IGZvciBub3cgKi8KLQlpZiAoIU1US19IQVNfQ0FQUyhldGgtPnNvYy0+Y2Fw cywgTVRLX1NPQ19NVDc2MjgpKSB7Ci0JCS8qIHB1dCB0aGUgZ21hYyBpbnRvIHRoZSByaWdodCBt b2RlICovCi0JCXJlZ21hcF9yZWFkKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgJnZhbCk7 Ci0JCXZhbCAmPSB+U1lTQ0ZHMF9HRV9NT0RFKFNZU0NGRzBfR0VfTUFTSywgbWFjLT5pZCk7Ci0J CXZhbCB8PSBTWVNDRkcwX0dFX01PREUobWFjLT5nZV9tb2RlLCBtYWMtPmlkKTsKLQkJcmVnbWFw X3dyaXRlKGV0aC0+ZXRoc3lzLCBFVEhTWVNfU1lTQ0ZHMCwgdmFsKTsKKwlpZiAoc3RhdGUtPmlu dGVyZmFjZSAhPSBQSFlfSU5URVJGQUNFX01PREVfTkEgJiYKKwkgICAgc3RhdGUtPmludGVyZmFj ZSAhPSBQSFlfSU5URVJGQUNFX01PREVfTUlJICYmCisJICAgIHN0YXRlLT5pbnRlcmZhY2UgIT0g UEhZX0lOVEVSRkFDRV9NT0RFX0dNSUkgJiYKKwkgICAgIShNVEtfSEFTX0NBUFMobWFjLT5ody0+ c29jLT5jYXBzLCBNVEtfUkdNSUkpICYmCisJICAgICAgcGh5X2ludGVyZmFjZV9tb2RlX2lzX3Jn bWlpKHN0YXRlLT5pbnRlcmZhY2UpKSAmJgorCSAgICAhKE1US19IQVNfQ0FQUyhtYWMtPmh3LT5z b2MtPmNhcHMsIE1US19UUkdNSUkpICYmCisJICAgICAgIW1hYy0+aWQgJiYgc3RhdGUtPmludGVy ZmFjZSA9PSBQSFlfSU5URVJGQUNFX01PREVfVFJHTUlJKSkgeworCQlsaW5rbW9kZV96ZXJvKHN1 cHBvcnRlZCk7CisJCXJldHVybjsKIAl9CiAKLQkvKiBjb3VwbGUgcGh5ZGV2IHRvIG5ldF9kZXZp Y2UgKi8KLQlpZiAobXRrX3BoeV9jb25uZWN0X25vZGUoZXRoLCBtYWMsIG5wKSkKLQkJZ290byBl cnJfcGh5OworCXBoeWxpbmtfc2V0X3BvcnRfbW9kZXMobWFzayk7CisJcGh5bGlua19zZXQobWFz aywgQXV0b25lZyk7CiAKLQlvZl9ub2RlX3B1dChucCk7CisJaWYgKHN0YXRlLT5pbnRlcmZhY2Ug PT0gUEhZX0lOVEVSRkFDRV9NT0RFX1RSR01JSSkgeworCQlwaHlsaW5rX3NldChtYXNrLCAxMDAw YmFzZVRfRnVsbCk7CisJfSBlbHNlIHsKKwkJcGh5bGlua19zZXQobWFzaywgMTBiYXNlVF9IYWxm KTsKKwkJcGh5bGlua19zZXQobWFzaywgMTBiYXNlVF9GdWxsKTsKKwkJcGh5bGlua19zZXQobWFz aywgMTAwYmFzZVRfSGFsZik7CisJCXBoeWxpbmtfc2V0KG1hc2ssIDEwMGJhc2VUX0Z1bGwpOwor CisJCWlmIChzdGF0ZS0+aW50ZXJmYWNlICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV9NSUkpIHsKKwkJ CXBoeWxpbmtfc2V0KG1hc2ssIDEwMDBiYXNlVF9IYWxmKTsKKwkJCXBoeWxpbmtfc2V0KG1hc2ss IDEwMDBiYXNlVF9GdWxsKTsKKwkJCXBoeWxpbmtfc2V0KG1hc2ssIDEwMDBiYXNlWF9GdWxsKTsK KwkJfQorCX0KIAotCXJldHVybiAwOworCXBoeWxpbmtfc2V0KG1hc2ssIFBhdXNlKTsKKwlwaHls aW5rX3NldChtYXNrLCBBc3ltX1BhdXNlKTsKIAotZXJyX3BoeToKLQlpZiAob2ZfcGh5X2lzX2Zp eGVkX2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJb2ZfcGh5X2RlcmVnaXN0ZXJfZml4ZWRfbGluayht YWMtPm9mX25vZGUpOwotCW9mX25vZGVfcHV0KG5wKTsKLQlkZXZfZXJyKGV0aC0+ZGV2LCAiJXM6 IGludmFsaWQgcGh5XG4iLCBfX2Z1bmNfXyk7Ci0JcmV0dXJuIC1FSU5WQUw7CisJbGlua21vZGVf YW5kKHN1cHBvcnRlZCwgc3VwcG9ydGVkLCBtYXNrKTsKKwlsaW5rbW9kZV9hbmQoc3RhdGUtPmFk dmVydGlzaW5nLCBzdGF0ZS0+YWR2ZXJ0aXNpbmcsIG1hc2spOwogfQogCitzdGF0aWMgY29uc3Qg c3RydWN0IHBoeWxpbmtfbWFjX29wcyBtdGtfcGh5bGlua19vcHMgPSB7CisJLnZhbGlkYXRlID0g bXRrX3ZhbGlkYXRlLAorCS5tYWNfbGlua19zdGF0ZSA9IG10a19tYWNfbGlua19zdGF0ZSwKKwku bWFjX2FuX3Jlc3RhcnQgPSBtdGtfbWFjX2FuX3Jlc3RhcnQsCisJLm1hY19jb25maWcgPSBtdGtf bWFjX2NvbmZpZywKKwkubWFjX2xpbmtfZG93biA9IG10a19tYWNfbGlua19kb3duLAorCS5tYWNf bGlua191cCA9IG10a19tYWNfbGlua191cCwKK307CisKIHN0YXRpYyBpbnQgbXRrX21kaW9faW5p dChzdHJ1Y3QgbXRrX2V0aCAqZXRoKQogewogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbWlpX25wOwpA QCAtMjAxMyw2ICsyMDcwLDE0IEBAIHN0YXRpYyBpbnQgbXRrX29wZW4oc3RydWN0IG5ldF9kZXZp Y2UgKmRldikKIHsKIAlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAlz dHJ1Y3QgbXRrX2V0aCAqZXRoID0gbWFjLT5odzsKKwlpbnQgZXJyOworCisJZXJyID0gcGh5bGlu a19vZl9waHlfY29ubmVjdChtYWMtPnBoeWxpbmssIG1hYy0+b2Zfbm9kZSwgMCk7CisJaWYgKGVy cikgeworCQluZXRkZXZfZXJyKGRldiwgIiVzOiBjb3VsZCBub3QgYXR0YWNoIFBIWTogJWRcbiIs IF9fZnVuY19fLAorCQkJICAgZXJyKTsKKwkJcmV0dXJuIGVycjsKKwl9CiAKIAkvKiB3ZSBydW4g MiBuZXRkZXZzIG9uIHRoZSBzYW1lIGRtYSByaW5nIHNvIHdlIG9ubHkgYnJpbmcgaXQgdXAgb25j ZSAqLwogCWlmICghcmVmY291bnRfcmVhZCgmZXRoLT5kbWFfcmVmY250KSkgewpAQCAtMjAzMCw3 ICsyMDk1LDcgQEAgc3RhdGljIGludCBtdGtfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQog CWVsc2UKIAkJcmVmY291bnRfaW5jKCZldGgtPmRtYV9yZWZjbnQpOwogCi0JcGh5X3N0YXJ0KGRl di0+cGh5ZGV2KTsKKwlwaHlsaW5rX3N0YXJ0KG1hYy0+cGh5bGluayk7CiAJbmV0aWZfc3RhcnRf cXVldWUoZGV2KTsKIAlyZXR1cm4gMDsKIH0KQEAgLTIwNjMsOCArMjEyOCwxMSBAQCBzdGF0aWMg aW50IG10a19zdG9wKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiAJc3RydWN0IG10a19tYWMgKm1h YyA9IG5ldGRldl9wcml2KGRldik7CiAJc3RydWN0IG10a19ldGggKmV0aCA9IG1hYy0+aHc7CiAK KwlwaHlsaW5rX3N0b3AobWFjLT5waHlsaW5rKTsKKwogCW5ldGlmX3R4X2Rpc2FibGUoZGV2KTsK LQlwaHlfc3RvcChkZXYtPnBoeWRldik7CisKKwlwaHlsaW5rX2Rpc2Nvbm5lY3RfcGh5KG1hYy0+ cGh5bGluayk7CiAKIAkvKiBvbmx5IHNodXRkb3duIERNQSBpZiB0aGlzIGlzIHRoZSBsYXN0IHVz ZXIgKi8KIAlpZiAoIXJlZmNvdW50X2RlY19hbmRfdGVzdCgmZXRoLT5kbWFfcmVmY250KSkKQEAg LTIxNTksMTUgKzIyMjcsNiBAQCBzdGF0aWMgaW50IG10a19od19pbml0KHN0cnVjdCBtdGtfZXRo ICpldGgpCiAJZXRoc3lzX3Jlc2V0KGV0aCwgUlNUQ1RSTF9GRSk7CiAJZXRoc3lzX3Jlc2V0KGV0 aCwgUlNUQ1RSTF9QUEUpOwogCi0JcmVnbWFwX3JlYWQoZXRoLT5ldGhzeXMsIEVUSFNZU19TWVND RkcwLCAmdmFsKTsKLQlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19DT1VOVDsgaSsrKSB7Ci0JCWlm ICghZXRoLT5tYWNbaV0pCi0JCQljb250aW51ZTsKLQkJdmFsICY9IH5TWVNDRkcwX0dFX01PREUo U1lTQ0ZHMF9HRV9NQVNLLCBldGgtPm1hY1tpXS0+aWQpOwotCQl2YWwgfD0gU1lTQ0ZHMF9HRV9N T0RFKGV0aC0+bWFjW2ldLT5nZV9tb2RlLCBldGgtPm1hY1tpXS0+aWQpOwotCX0KLQlyZWdtYXBf d3JpdGUoZXRoLT5ldGhzeXMsIEVUSFNZU19TWVNDRkcwLCB2YWwpOwotCiAJaWYgKGV0aC0+cGN0 bCkgewogCQkvKiBTZXQgR0UyIGRyaXZpbmcgYW5kIHNsZXcgcmF0ZSAqLwogCQlyZWdtYXBfd3Jp dGUoZXRoLT5wY3RsLCBHUElPX0RSVl9TRUwxMCwgMHhhMDApOwpAQCAtMjE4MCwxMSArMjIzOSwx MSBAQCBzdGF0aWMgaW50IG10a19od19pbml0KHN0cnVjdCBtdGtfZXRoICpldGgpCiAJfQogCiAJ LyogU2V0IGxpbmtkb3duIGFzIHRoZSBkZWZhdWx0IGZvciBlYWNoIEdNQUMuIEl0cyBvd24gTUNS IHdvdWxkIGJlIHNldAotCSAqIHVwIHdpdGggdGhlIG1vcmUgYXBwcm9wcmlhdGUgdmFsdWUgd2hl biBtdGtfcGh5X2xpbmtfYWRqdXN0IGNhbGwgaXMKLQkgKiBiZWluZyBpbnZva2VkLgorCSAqIHVw IHdpdGggdGhlIG1vcmUgYXBwcm9wcmlhdGUgdmFsdWUgd2hlbiBtdGtfbWFjX2NvbmZpZyBjYWxs IGlzIGJlaW5nCisJICogaW52b2tlZC4KIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19D T1VOVDsgaSsrKQotCQltdGtfdzMyKGV0aCwgMCwgTVRLX01BQ19NQ1IoaSkpOworCQltdGtfdzMy KGV0aCwgTUFDX01DUl9GT1JDRV9MSU5LX0RPV04sIE1US19NQUNfTUNSKGkpKTsKIAogCS8qIElu ZGljYXRlcyBDRE0gdG8gcGFyc2UgdGhlIE1USyBzcGVjaWFsIHRhZyBmcm9tIENQVQogCSAqIHdo aWNoIGFsc28gaXMgd29ya2luZyBvdXQgZm9yIHVudGFnIHBhY2tldHMuCkBAIC0yMjEyLDcgKzIy NzEsNyBAQCBzdGF0aWMgaW50IG10a19od19pbml0KHN0cnVjdCBtdGtfZXRoICpldGgpCiAJbXRr X3czMihldGgsIE1US19SWF9ET05FX0lOVCwgTVRLX1FETUFfSU5UX0dSUDIpOwogCW10a193MzIo ZXRoLCAweDIxMDIxMDAwLCBNVEtfRkVfSU5UX0dSUCk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgMjsg aSsrKSB7CisJZm9yIChpID0gMDsgaSA8IE1US19NQUNfQ09VTlQ7IGkrKykgewogCQl1MzIgdmFs ID0gbXRrX3IzMihldGgsIE1US19HRE1BX0ZXRF9DRkcoaSkpOwogCiAJCS8qIHNldHVwIHRoZSBm b3J3YXJkIHBvcnQgdG8gc2VuZCBmcmFtZSB0byBQRE1BICovCkBAIC0yMjY0LDcgKzIzMjMsNyBA QCBzdGF0aWMgaW50IF9faW5pdCBtdGtfaW5pdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCQkJ ZGV2LT5kZXZfYWRkcik7CiAJfQogCi0JcmV0dXJuIG10a19waHlfY29ubmVjdChkZXYpOworCXJl dHVybiAwOwogfQogCiBzdGF0aWMgdm9pZCBtdGtfdW5pbml0KHN0cnVjdCBuZXRfZGV2aWNlICpk ZXYpCkBAIC0yMjcyLDIwICsyMzMxLDIwIEBAIHN0YXRpYyB2b2lkIG10a191bmluaXQoc3RydWN0 IG5ldF9kZXZpY2UgKmRldikKIAlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2 KTsKIAlzdHJ1Y3QgbXRrX2V0aCAqZXRoID0gbWFjLT5odzsKIAotCXBoeV9kaXNjb25uZWN0KGRl di0+cGh5ZGV2KTsKLQlpZiAob2ZfcGh5X2lzX2ZpeGVkX2xpbmsobWFjLT5vZl9ub2RlKSkKLQkJ b2ZfcGh5X2RlcmVnaXN0ZXJfZml4ZWRfbGluayhtYWMtPm9mX25vZGUpOworCXBoeWxpbmtfZGlz Y29ubmVjdF9waHkobWFjLT5waHlsaW5rKTsKIAltdGtfdHhfaXJxX2Rpc2FibGUoZXRoLCB+MCk7 CiAJbXRrX3J4X2lycV9kaXNhYmxlKGV0aCwgfjApOwogfQogCiBzdGF0aWMgaW50IG10a19kb19p b2N0bChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKmlmciwgaW50IGNtZCkK IHsKKwlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwogCXN3aXRjaCAo Y21kKSB7CiAJY2FzZSBTSU9DR01JSVBIWToKIAljYXNlIFNJT0NHTUlJUkVHOgogCWNhc2UgU0lP Q1NNSUlSRUc6Ci0JCXJldHVybiBwaHlfbWlpX2lvY3RsKGRldi0+cGh5ZGV2LCBpZnIsIGNtZCk7 CisJCXJldHVybiBwaHlsaW5rX21paV9pb2N0bChtYWMtPnBoeWxpbmssIGlmciwgY21kKTsKIAlk ZWZhdWx0OgogCQlicmVhazsKIAl9CkBAIC0yMzI2LDE2ICsyMzg1LDYgQEAgc3RhdGljIHZvaWQg bXRrX3BlbmRpbmdfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJCQkJICAgICBldGgt PmRldi0+cGlucy0+ZGVmYXVsdF9zdGF0ZSk7CiAJbXRrX2h3X2luaXQoZXRoKTsKIAotCWZvciAo aSA9IDA7IGkgPCBNVEtfTUFDX0NPVU5UOyBpKyspIHsKLQkJaWYgKCFldGgtPm1hY1tpXSB8fAot CQkgICAgb2ZfcGh5X2lzX2ZpeGVkX2xpbmsoZXRoLT5tYWNbaV0tPm9mX25vZGUpKQotCQkJY29u dGludWU7Ci0JCWVyciA9IHBoeV9pbml0X2h3KGV0aC0+bmV0ZGV2W2ldLT5waHlkZXYpOwotCQlp ZiAoZXJyKQotCQkJZGV2X2VycihldGgtPmRldiwgIiVzOiBQSFkgaW5pdCBmYWlsZWQuXG4iLAot CQkJCWV0aC0+bmV0ZGV2W2ldLT5uYW1lKTsKLQl9Ci0KIAkvKiByZXN0YXJ0IERNQSBhbmQgZW5h YmxlIElSUXMgKi8KIAlmb3IgKGkgPSAwOyBpIDwgTVRLX01BQ19DT1VOVDsgaSsrKSB7CiAJCWlm ICghdGVzdF9iaXQoaSwgJnJlc3RhcnQpKQpAQCAtMjM5OCw5ICsyNDQ3LDcgQEAgc3RhdGljIGlu dCBtdGtfZ2V0X2xpbmtfa3NldHRpbmdzKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LAogCWlmICh1 bmxpa2VseSh0ZXN0X2JpdChNVEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3RhdGUpKSkKIAkJcmV0 dXJuIC1FQlVTWTsKIAotCXBoeV9ldGh0b29sX2tzZXR0aW5nc19nZXQobmRldi0+cGh5ZGV2LCBj bWQpOwotCi0JcmV0dXJuIDA7CisJcmV0dXJuIHBoeWxpbmtfZXRodG9vbF9rc2V0dGluZ3NfZ2V0 KG1hYy0+cGh5bGluaywgY21kKTsKIH0KIAogc3RhdGljIGludCBtdGtfc2V0X2xpbmtfa3NldHRp bmdzKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LApAQCAtMjQxMSw3ICsyNDU4LDcgQEAgc3RhdGlj IGludCBtdGtfc2V0X2xpbmtfa3NldHRpbmdzKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LAogCWlm ICh1bmxpa2VseSh0ZXN0X2JpdChNVEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3RhdGUpKSkKIAkJ cmV0dXJuIC1FQlVTWTsKIAotCXJldHVybiBwaHlfZXRodG9vbF9rc2V0dGluZ3Nfc2V0KG5kZXYt PnBoeWRldiwgY21kKTsKKwlyZXR1cm4gcGh5bGlua19ldGh0b29sX2tzZXR0aW5nc19zZXQobWFj LT5waHlsaW5rLCBjbWQpOwogfQogCiBzdGF0aWMgdm9pZCBtdGtfZ2V0X2RydmluZm8oc3RydWN0 IG5ldF9kZXZpY2UgKmRldiwKQEAgLTI0NDUsMjIgKzI0OTIsMTAgQEAgc3RhdGljIGludCBtdGtf bndheV9yZXNldChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCWlmICh1bmxpa2VseSh0ZXN0X2Jp dChNVEtfUkVTRVRUSU5HLCAmbWFjLT5ody0+c3RhdGUpKSkKIAkJcmV0dXJuIC1FQlVTWTsKIAot CXJldHVybiBnZW5waHlfcmVzdGFydF9hbmVnKGRldi0+cGh5ZGV2KTsKLX0KKwlpZiAoIW1hYy0+ cGh5bGluaykKKwkJcmV0dXJuIC1FTk9UU1VQUDsKIAotc3RhdGljIHUzMiBtdGtfZ2V0X2xpbmso c3RydWN0IG5ldF9kZXZpY2UgKmRldikKLXsKLQlzdHJ1Y3QgbXRrX21hYyAqbWFjID0gbmV0ZGV2 X3ByaXYoZGV2KTsKLQlpbnQgZXJyOwotCi0JaWYgKHVubGlrZWx5KHRlc3RfYml0KE1US19SRVNF VFRJTkcsICZtYWMtPmh3LT5zdGF0ZSkpKQotCQlyZXR1cm4gLUVCVVNZOwotCi0JZXJyID0gZ2Vu cGh5X3VwZGF0ZV9saW5rKGRldi0+cGh5ZGV2KTsKLQlpZiAoZXJyKQotCQlyZXR1cm4gZXRodG9v bF9vcF9nZXRfbGluayhkZXYpOwotCi0JcmV0dXJuIGRldi0+cGh5ZGV2LT5saW5rOworCXJldHVy biBwaHlsaW5rX2V0aHRvb2xfbndheV9yZXNldChtYWMtPnBoeWxpbmspOwogfQogCiBzdGF0aWMg dm9pZCBtdGtfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTMyIHN0cmluZ3Nl dCwgdTggKmRhdGEpCkBAIC0yNTgwLDcgKzI2MTUsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGV0 aHRvb2xfb3BzIG10a19ldGh0b29sX29wcyA9IHsKIAkuZ2V0X21zZ2xldmVsCQk9IG10a19nZXRf bXNnbGV2ZWwsCiAJLnNldF9tc2dsZXZlbAkJPSBtdGtfc2V0X21zZ2xldmVsLAogCS5ud2F5X3Jl c2V0CQk9IG10a19ud2F5X3Jlc2V0LAotCS5nZXRfbGluawkJPSBtdGtfZ2V0X2xpbmssCisJLmdl dF9saW5rCQk9IGV0aHRvb2xfb3BfZ2V0X2xpbmssCiAJLmdldF9zdHJpbmdzCQk9IG10a19nZXRf c3RyaW5ncywKIAkuZ2V0X3NzZXRfY291bnQJCT0gbXRrX2dldF9zc2V0X2NvdW50LAogCS5nZXRf ZXRodG9vbF9zdGF0cwk9IG10a19nZXRfZXRodG9vbF9zdGF0cywKQEAgLTI2MDgsOSArMjY0Mywx MCBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IG5ldF9kZXZpY2Vfb3BzIG10a19uZXRkZXZfb3BzID0g ewogCiBzdGF0aWMgaW50IG10a19hZGRfbWFjKHN0cnVjdCBtdGtfZXRoICpldGgsIHN0cnVjdCBk ZXZpY2Vfbm9kZSAqbnApCiB7Ci0Jc3RydWN0IG10a19tYWMgKm1hYzsKIAljb25zdCBfX2JlMzIg Kl9pZCA9IG9mX2dldF9wcm9wZXJ0eShucCwgInJlZyIsIE5VTEwpOwotCWludCBpZCwgZXJyOwor CXN0cnVjdCBwaHlsaW5rICpwaHlsaW5rOworCWludCBwaHlfbW9kZSwgaWQsIGVycjsKKwlzdHJ1 Y3QgbXRrX21hYyAqbWFjOwogCiAJaWYgKCFfaWQpIHsKIAkJZGV2X2VycihldGgtPmRldiwgIm1p c3NpbmcgbWFjIGlkXG4iKTsKQEAgLTI2NTQsNiArMjY5MCwzMiBAQCBzdGF0aWMgaW50IG10a19h ZGRfbWFjKHN0cnVjdCBtdGtfZXRoICpldGgsIHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApCiAJdTY0 X3N0YXRzX2luaXQoJm1hYy0+aHdfc3RhdHMtPnN5bmNwKTsKIAltYWMtPmh3X3N0YXRzLT5yZWdf b2Zmc2V0ID0gaWQgKiBNVEtfU1RBVF9PRkZTRVQ7CiAKKwkvKiBwaHlsaW5rIGNyZWF0ZSAqLwor CXBoeV9tb2RlID0gb2ZfZ2V0X3BoeV9tb2RlKG5wKTsKKwlpZiAocGh5X21vZGUgPCAwKSB7CisJ CWRldl9lcnIoZXRoLT5kZXYsICJpbmNvcnJlY3QgcGh5LW1vZGVcbiIpOworCQllcnIgPSAtRUlO VkFMOworCQlnb3RvIGZyZWVfbmV0ZGV2OworCX0KKworCS8qIG1hYyBjb25maWcgaXMgbm90IHNl dCAqLworCW1hYy0+aW50ZXJmYWNlID0gUEhZX0lOVEVSRkFDRV9NT0RFX05BOworCW1hYy0+bW9k ZSA9IE1MT19BTl9QSFk7CisJbWFjLT5zcGVlZCA9IFNQRUVEX1VOS05PV047CisKKwltYWMtPnBo eWxpbmtfY29uZmlnLmRldiA9ICZldGgtPm5ldGRldltpZF0tPmRldjsKKwltYWMtPnBoeWxpbmtf Y29uZmlnLnR5cGUgPSBQSFlMSU5LX05FVERFVjsKKworCXBoeWxpbmsgPSBwaHlsaW5rX2NyZWF0 ZSgmbWFjLT5waHlsaW5rX2NvbmZpZywKKwkJCQkgb2ZfZndub2RlX2hhbmRsZShtYWMtPm9mX25v ZGUpLAorCQkJCSBwaHlfbW9kZSwgJm10a19waHlsaW5rX29wcyk7CisJaWYgKElTX0VSUihwaHls aW5rKSkgeworCQllcnIgPSBQVFJfRVJSKHBoeWxpbmspOworCQlnb3RvIGZyZWVfbmV0ZGV2Owor CX0KKworCW1hYy0+cGh5bGluayA9IHBoeWxpbms7CisKIAlTRVRfTkVUREVWX0RFVihldGgtPm5l dGRldltpZF0sIGV0aC0+ZGV2KTsKIAlldGgtPm5ldGRldltpZF0tPndhdGNoZG9nX3RpbWVvID0g NSAqIEhaOwogCWV0aC0+bmV0ZGV2W2lkXS0+bmV0ZGV2X29wcyA9ICZtdGtfbmV0ZGV2X29wczsK QEAgLTI2ODIsOCArMjc0NCw3IEBAIHN0YXRpYyBpbnQgbXRrX3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IGRldmljZV9ub2RlICptYWNfbnA7CiAJc3RydWN0 IG10a19ldGggKmV0aDsKLQlpbnQgZXJyOwotCWludCBpOworCWludCBlcnIsIGk7CiAKIAlldGgg PSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpldGgpLCBHRlBfS0VSTkVMKTsKIAlp ZiAoIWV0aCkKQEAgLTI4NjksNiArMjkzMCw3IEBAIHN0YXRpYyBpbnQgbXRrX3Byb2JlKHN0cnVj dCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiBzdGF0aWMgaW50IG10a19yZW1vdmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgbXRrX2V0aCAqZXRoID0gcGxhdGZvcm1f Z2V0X2RydmRhdGEocGRldik7CisJc3RydWN0IG10a19tYWMgKm1hYzsKIAlpbnQgaTsKIAogCS8q IHN0b3AgYWxsIGRldmljZXMgdG8gbWFrZSBzdXJlIHRoYXQgZG1hIGlzIHByb3Blcmx5IHNodXQg ZG93biAqLwpAQCAtMjg3Niw2ICsyOTM4LDggQEAgc3RhdGljIGludCBtdGtfcmVtb3ZlKHN0cnVj dCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJCWlmICghZXRoLT5uZXRkZXZbaV0pCiAJCQljb250 aW51ZTsKIAkJbXRrX3N0b3AoZXRoLT5uZXRkZXZbaV0pOworCQltYWMgPSBuZXRkZXZfcHJpdihl dGgtPm5ldGRldltpXSk7CisJCXBoeWxpbmtfZGlzY29ubmVjdF9waHkobWFjLT5waHlsaW5rKTsK IAl9CiAKIAltdGtfaHdfZGVpbml0KGV0aCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhl cm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5oIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0 ZWsvbXRrX2V0aF9zb2MuaAppbmRleCBjYzE0NjZhZTA5MjYuLjdmNWY1NDFkYWFkNyAxMDA2NDQK LS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVkaWF0ZWsvbXRrX2V0aF9zb2MuaAorKysgYi9k cml2ZXJzL25ldC9ldGhlcm5ldC9tZWRpYXRlay9tdGtfZXRoX3NvYy5oCkBAIC0xNCw2ICsxNCw3 IEBACiAjaW5jbHVkZSA8bGludXgvb2ZfbmV0Lmg+CiAjaW5jbHVkZSA8bGludXgvdTY0X3N0YXRz X3N5bmMuaD4KICNpbmNsdWRlIDxsaW51eC9yZWZjb3VudC5oPgorI2luY2x1ZGUgPGxpbnV4L3Bo eWxpbmsuaD4KIAogI2RlZmluZSBNVEtfUURNQV9QQUdFX1NJWkUJMjA0OAogI2RlZmluZQlNVEtf TUFYX1JYX0xFTkdUSAkxNTM2CkBAIC0zMzAsMTIgKzMzMSwxOSBAQAogI2RlZmluZSBNQUNfTUNS X1NQRUVEXzEwMAlCSVQoMikKICNkZWZpbmUgTUFDX01DUl9GT1JDRV9EUFgJQklUKDEpCiAjZGVm aW5lIE1BQ19NQ1JfRk9SQ0VfTElOSwlCSVQoMCkKLSNkZWZpbmUgTUFDX01DUl9GSVhFRF9MSU5L CShNQUNfTUNSX01BWF9SWF8xNTM2IHwgTUFDX01DUl9JUEdfQ0ZHIHwgXAotCQkJCSBNQUNfTUNS X0ZPUkNFX01PREUgfCBNQUNfTUNSX1RYX0VOIHwgXAotCQkJCSBNQUNfTUNSX1JYX0VOIHwgTUFD X01DUl9CQUNLT0ZGX0VOIHwgXAotCQkJCSBNQUNfTUNSX0JBQ0tQUl9FTiB8IE1BQ19NQ1JfRk9S Q0VfUlhfRkMgfCBcCi0JCQkJIE1BQ19NQ1JfRk9SQ0VfVFhfRkMgfCBNQUNfTUNSX1NQRUVEXzEw MDAgfCBcCi0JCQkJIE1BQ19NQ1JfRk9SQ0VfRFBYIHwgTUFDX01DUl9GT1JDRV9MSU5LKQorI2Rl ZmluZSBNQUNfTUNSX0ZPUkNFX0xJTktfRE9XTgkoTUFDX01DUl9GT1JDRV9NT0RFKQorCisvKiBN YWMgc3RhdHVzIHJlZ2lzdGVycyAqLworI2RlZmluZSBNVEtfTUFDX01TUih4KQkJKDB4MTAxMDgg KyAoeCAqIDB4MTAwKSkKKyNkZWZpbmUgTUFDX01TUl9FRUUxRwkJQklUKDcpCisjZGVmaW5lIE1B Q19NU1JfRUVFMTAwTQkJQklUKDYpCisjZGVmaW5lIE1BQ19NU1JfUlhfRkMJCUJJVCg1KQorI2Rl ZmluZSBNQUNfTVNSX1RYX0ZDCQlCSVQoNCkKKyNkZWZpbmUgTUFDX01TUl9TUEVFRF8xMDAwCUJJ VCgzKQorI2RlZmluZSBNQUNfTVNSX1NQRUVEXzEwMAlCSVQoMikKKyNkZWZpbmUgTUFDX01TUl9T UEVFRF9NQVNLCShNQUNfTVNSX1NQRUVEXzEwMDAgfCBNQUNfTVNSX1NQRUVEXzEwMCkKKyNkZWZp bmUgTUFDX01TUl9EUFgJCUJJVCgxKQorI2RlZmluZSBNQUNfTVNSX0xJTksJCUJJVCgwKQogCiAv KiBUUkdNSUkgUlhDIGNvbnRyb2wgcmVnaXN0ZXIgKi8KICNkZWZpbmUgVFJHTUlJX1JDS19DVFJM CQkweDEwMzAwCkBAIC04NTgsMjIgKzg2NiwyMyBAQCBzdHJ1Y3QgbXRrX2V0aCB7CiAvKiBzdHJ1 Y3QgbXRrX21hYyAtCXRoZSBzdHJ1Y3R1cmUgdGhhdCBob2xkcyB0aGUgaW5mbyBhYm91dCB0aGUg TUFDcyBvZiB0aGUKICAqCQkJU29DCiAgKiBAaWQ6CQkJVGhlIG51bWJlciBvZiB0aGUgTUFDCi0g KiBAZ2VfbW9kZTogICAgICAgICAgICBJbnRlcmZhY2UgbW9kZSBrZXB0IGZvciBzZXR1cCByZXN0 b3JpbmcKKyAqIEBpbnRlcmZhY2U6CQlJbnRlcmZhY2UgbW9kZSBrZXB0IGZvciBkZXRlY3Rpbmcg Y2hhbmdlIGluIGh3IHNldHRpbmdzCiAgKiBAb2Zfbm9kZToJCU91ciBkZXZpY2V0cmVlIG5vZGUK ICAqIEBodzoJCQlCYWNrcG9pbnRlciB0byBvdXIgbWFpbiBkYXRhc3RydXR1cmUKICAqIEBod19z dGF0czoJCVBhY2tldCBzdGF0aXN0aWNzIGNvdW50ZXIKLSAqIEB0cmdtaWkJCUluZGljYXRlIGlm IHRoZSBNQUMgdXNlcyBUUkdNSUkgY29ubmVjdGVkIHRvIGludGVybmFsCi0JCQlzd2l0Y2gKICAq Lwogc3RydWN0IG10a19tYWMgewogCWludAkJCQlpZDsKLQlpbnQJCQkJZ2VfbW9kZTsKKwlwaHlf aW50ZXJmYWNlX3QJCQlpbnRlcmZhY2U7CisJdW5zaWduZWQgaW50CQkJbW9kZTsKKwlpbnQJCQkJ c3BlZWQ7CiAJc3RydWN0IGRldmljZV9ub2RlCQkqb2Zfbm9kZTsKKwlzdHJ1Y3QgcGh5bGluawkJ CSpwaHlsaW5rOworCXN0cnVjdCBwaHlsaW5rX2NvbmZpZwkJcGh5bGlua19jb25maWc7CiAJc3Ry dWN0IG10a19ldGgJCQkqaHc7CiAJc3RydWN0IG10a19od19zdGF0cwkJKmh3X3N0YXRzOwogCV9f YmUzMgkJCQlod2xyb19pcFtNVEtfTUFYX0xST19JUF9DTlRdOwogCWludAkJCQlod2xyb19pcF9j bnQ7Ci0JYm9vbAkJCQl0cmdtaWk7CiB9OwogCiAvKiB0aGUgc3RydWN0IGRlc2NyaWJpbmcgdGhl IFNvQy4gdGhlc2UgYXJlIGRlY2xhcmVkIGluIHRoZSBzb2NfeHl6LmMgZmlsZXMgKi8KLS0gCjIu MjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxp bnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFk ZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4 LWFybS1rZXJuZWwK