From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtpout-02.galae.net (smtpout-02.galae.net [185.246.84.56]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2D19A3A5E6D; Wed, 19 Nov 2025 15:51:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.246.84.56 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763567485; cv=none; b=TgkTd0GxsltR8Owp7ciDQC9jccQ4UcQwKDTXpclo+hKqAceogq/ntd9vVnFM0Z9PWJ1LZ51qPWG9amRMXWG4DFCSBFsatQdv+Vwsnxspk3cdK9LYpXupltK1LFusnbwTuTIRHZdBMy9WW44xvHNdPtYXE3jJxymw+xkW09F7rk4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763567485; c=relaxed/simple; bh=S63TG8xNOcQZcLoO4dkYed9u/K6wYYzrizL3nYPKntg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=sqXgnixrz+eRsu91oFjmarF/GpnYo2Pz8pwhahrwwcAE7vjfbIjoVIY+fndapBvGTqCqUHz3YLJHulRV4s5b+z3GdhY9PMr9AUDVgS7tnY549T0DeTYgJHRSv4ByTbvTG1HEYPKaDM6Eje2F2YbRIPbrQ6+VuLxj+tHMGPCCFdc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=ScKdkdOI; arc=none smtp.client-ip=185.246.84.56 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="ScKdkdOI" Received: from smtpout-01.galae.net (smtpout-01.galae.net [212.83.139.233]) by smtpout-02.galae.net (Postfix) with ESMTPS id 84D571A1BE8; Wed, 19 Nov 2025 15:51:21 +0000 (UTC) Received: from mail.galae.net (mail.galae.net [212.83.136.155]) by smtpout-01.galae.net (Postfix) with ESMTPS id 5335A60699; Wed, 19 Nov 2025 15:51:21 +0000 (UTC) Received: from [127.0.0.1] (localhost [127.0.0.1]) by localhost (Mailerdaemon) with ESMTPSA id C5F1210371A75; Wed, 19 Nov 2025 16:51:18 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=dkim; t=1763567480; h=from:subject:date:message-id:to:cc:mime-version:content-type: content-transfer-encoding:in-reply-to:references; bh=/eLWDd5hWvYbPca/EklNrX1O6zckyQobOuG2mMOxQ0U=; b=ScKdkdOIpvpIFnjPt99/MDoXY2bppPwPz2Nfuap7hL9X5okWSKHpg9GTUShQA4arzNpf5z 4jSbLrdSOjvvC5Pu4yXM/1ppVB60cwEuGEX3L6HNTdykcO5oV+MiLC3JnkVGW2S1gl+1+1 dXrT/PpP3QoFcPD5Nqs40RVOGyFSNLzjhJVjg35LQ25QDKcVF7dlmVjoUprJY926DAVhV1 8ABMoqHakKyZ2nT7Q7AMVwRZBaH6id0vPlGCYGy1KUhebMH3qVydlq3L6c1eFoV1ifp23e Wa/NlFEwKgZ9xZdPW+HkcR0cmDmPzUYcYyvERgktu8376mNuo3btk8XMJ90UMA== From: =?utf-8?q?Th=C3=A9o_Lebrun?= Date: Wed, 19 Nov 2025 16:51:10 +0100 Subject: [PATCH v3 2/7] phy: Add driver for EyeQ5 Ethernet PHY wrapper Precedence: bulk X-Mailing-List: linux-clk@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Message-Id: <20251119-macb-phy-v3-2-e9a7be186a33@bootlin.com> References: <20251119-macb-phy-v3-0-e9a7be186a33@bootlin.com> In-Reply-To: <20251119-macb-phy-v3-0-e9a7be186a33@bootlin.com> To: Vladimir Kondratiev , =?utf-8?q?Gr=C3=A9gory_Clement?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Vinod Koul , Kishon Vijay Abraham I , Michael Turquette , Stephen Boyd , Philipp Zabel , Thomas Bogendoerfer Cc: linux-mips@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, =?utf-8?q?Beno=C3=AEt_Monin?= , Maxime Chevallier , Tawfik Bayouk , Thomas Petazzoni , =?utf-8?q?Th=C3=A9o_Lebrun?= X-Mailer: b4 0.14.3 X-Last-TLS-Session-Version: TLSv1.3 EyeQ5 embeds a system-controller called OLB. It features many unrelated registers, and some of those are registers used to configure the integration of the RGMII/SGMII Cadence PHY used by MACB/GEM instances. Wrap in a neat generic PHY provider, exposing two PHYs with standard phy_init() / phy_set_mode() / phy_power_on() operations. Signed-off-by: Théo Lebrun --- MAINTAINERS | 1 + drivers/phy/Kconfig | 13 +++ drivers/phy/Makefile | 1 + drivers/phy/phy-eyeq5-eth.c | 254 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 269 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index b0223cfb2583..28c0b12dd125 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -17403,6 +17403,7 @@ F: arch/mips/boot/dts/mobileye/ F: arch/mips/configs/eyeq5_defconfig F: arch/mips/mobileye/board-epm5.its.S F: drivers/clk/clk-eyeq.c +F: drivers/phy/phy-eyeq5-eth.c F: drivers/pinctrl/pinctrl-eyeq5.c F: drivers/reset/reset-eyeq.c F: include/dt-bindings/clock/mobileye,eyeq5-clk.h diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig index 678dd0452f0a..1aa6eff12dbc 100644 --- a/drivers/phy/Kconfig +++ b/drivers/phy/Kconfig @@ -101,6 +101,19 @@ config PHY_NXP_PTN3222 schemes. It supports all three USB 2.0 data rates: Low Speed, Full Speed and High Speed. +config PHY_EYEQ5_ETH + tristate "Ethernet PHY Driver on EyeQ5" + depends on OF + depends on MACH_EYEQ5 || COMPILE_TEST + select AUXILIARY_BUS + select GENERIC_PHY + default MACH_EYEQ5 + help + Enable this to support the Ethernet PHY integrated on EyeQ5. + It supports both RGMII and SGMII. Registers are located in a + shared register region called OLB. If M is selected, the + module will be called phy-eyeq5-eth. + source "drivers/phy/allwinner/Kconfig" source "drivers/phy/amlogic/Kconfig" source "drivers/phy/broadcom/Kconfig" diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile index bfb27fb5a494..8289497ece55 100644 --- a/drivers/phy/Makefile +++ b/drivers/phy/Makefile @@ -13,6 +13,7 @@ obj-$(CONFIG_PHY_SNPS_EUSB2) += phy-snps-eusb2.o obj-$(CONFIG_USB_LGM_PHY) += phy-lgm-usb.o obj-$(CONFIG_PHY_AIROHA_PCIE) += phy-airoha-pcie.o obj-$(CONFIG_PHY_NXP_PTN3222) += phy-nxp-ptn3222.o +obj-$(CONFIG_PHY_EYEQ5_ETH) += phy-eyeq5-eth.o obj-y += allwinner/ \ amlogic/ \ broadcom/ \ diff --git a/drivers/phy/phy-eyeq5-eth.c b/drivers/phy/phy-eyeq5-eth.c new file mode 100644 index 000000000000..c901d1cce0c8 --- /dev/null +++ b/drivers/phy/phy-eyeq5-eth.c @@ -0,0 +1,254 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define EQ5_PHY_COUNT 2 + +#define EQ5_PHY0_GP 0x128 +#define EQ5_PHY1_GP 0x12c +#define EQ5_PHY0_SGMII 0x134 +#define EQ5_PHY1_SGMII 0x138 + +#define EQ5_GP_TX_SWRST_DIS BIT(0) // Tx SW reset +#define EQ5_GP_TX_M_CLKE BIT(1) // Tx M clock enable +#define EQ5_GP_SYS_SWRST_DIS BIT(2) // Sys SW reset +#define EQ5_GP_SYS_M_CLKE BIT(3) // Sys clock enable +#define EQ5_GP_SGMII_MODE BIT(4) // SGMII mode +#define EQ5_GP_RGMII_DRV GENMASK(8, 5) // RGMII drive strength + +#define EQ5_SGMII_PWR_EN BIT(0) +#define EQ5_SGMII_RST_DIS BIT(1) +#define EQ5_SGMII_PLL_EN BIT(2) +#define EQ5_SGMII_SIG_DET_SW BIT(3) +#define EQ5_SGMII_PWR_STATE BIT(4) +#define EQ5_SGMII_PLL_ACK BIT(18) +#define EQ5_SGMII_PWR_STATE_ACK GENMASK(24, 20) + +struct eq5_phy_inst { + struct eq5_phy_private *priv; + struct phy *phy; + void __iomem *gp, *sgmii; + phy_interface_t phy_interface; +}; + +struct eq5_phy_private { + struct device *dev; + struct eq5_phy_inst phys[EQ5_PHY_COUNT]; +}; + +static int eq5_phy_init(struct phy *phy) +{ + struct eq5_phy_inst *inst = phy_get_drvdata(phy); + struct eq5_phy_private *priv = inst->priv; + struct device *dev = priv->dev; + u32 reg; + + dev_dbg(dev, "phy_init(inst=%td)\n", inst - priv->phys); + + writel(0, inst->gp); + writel(0, inst->sgmii); + + udelay(5); + + reg = readl(inst->gp) | EQ5_GP_TX_SWRST_DIS | EQ5_GP_TX_M_CLKE | + EQ5_GP_SYS_SWRST_DIS | EQ5_GP_SYS_M_CLKE | + FIELD_PREP(EQ5_GP_RGMII_DRV, 0x9); + writel(reg, inst->gp); + + return 0; +} + +static int eq5_phy_exit(struct phy *phy) +{ + struct eq5_phy_inst *inst = phy_get_drvdata(phy); + struct eq5_phy_private *priv = inst->priv; + struct device *dev = priv->dev; + + dev_dbg(dev, "phy_exit(inst=%td)\n", inst - priv->phys); + + writel(0, inst->gp); + writel(0, inst->sgmii); + udelay(5); + + return 0; +} + +static int eq5_phy_set_mode(struct phy *phy, enum phy_mode mode, int submode) +{ + struct eq5_phy_inst *inst = phy_get_drvdata(phy); + struct eq5_phy_private *priv = inst->priv; + struct device *dev = priv->dev; + + dev_dbg(dev, "phy_set_mode(inst=%td, mode=%d, submode=%d)\n", + inst - priv->phys, mode, submode); + + if (mode != PHY_MODE_ETHERNET) + return -EOPNOTSUPP; + + if (!phy_interface_mode_is_rgmii(submode) && + submode != PHY_INTERFACE_MODE_SGMII) + return -EOPNOTSUPP; + + inst->phy_interface = submode; + return 0; +} + +static int eq5_phy_power_on(struct phy *phy) +{ + struct eq5_phy_inst *inst = phy_get_drvdata(phy); + struct eq5_phy_private *priv = inst->priv; + struct device *dev = priv->dev; + u32 reg; + + dev_dbg(dev, "phy_power_on(inst=%td)\n", inst - priv->phys); + + if (inst->phy_interface == PHY_INTERFACE_MODE_SGMII) { + writel(readl(inst->gp) | EQ5_GP_SGMII_MODE, inst->gp); + + reg = EQ5_SGMII_PWR_EN | EQ5_SGMII_RST_DIS | EQ5_SGMII_PLL_EN; + writel(reg, inst->sgmii); + + if (readl_poll_timeout(inst->sgmii, reg, + reg & EQ5_SGMII_PLL_ACK, 1, 100)) { + dev_err(dev, "PLL timeout\n"); + return -ETIMEDOUT; + } + + reg = readl(inst->sgmii); + reg |= EQ5_SGMII_PWR_STATE | EQ5_SGMII_SIG_DET_SW; + writel(reg, inst->sgmii); + } else { + writel(readl(inst->gp) & ~EQ5_GP_SGMII_MODE, inst->gp); + writel(0, inst->sgmii); + } + + return 0; +} + +static int eq5_phy_power_off(struct phy *phy) +{ + struct eq5_phy_inst *inst = phy_get_drvdata(phy); + struct eq5_phy_private *priv = inst->priv; + struct device *dev = priv->dev; + + dev_dbg(dev, "phy_power_off(inst=%td)\n", inst - priv->phys); + + writel(readl(inst->gp) & ~EQ5_GP_SGMII_MODE, inst->gp); + writel(0, inst->sgmii); + + return 0; +} + +static const struct phy_ops eq5_phy_ops = { + .init = eq5_phy_init, + .exit = eq5_phy_exit, + .set_mode = eq5_phy_set_mode, + .power_on = eq5_phy_power_on, + .power_off = eq5_phy_power_off, +}; + +static struct phy *eq5_phy_xlate(struct device *dev, + const struct of_phandle_args *args) +{ + struct eq5_phy_private *priv = dev_get_drvdata(dev); + + if (args->args_count != 1 || args->args[0] > 1) + return ERR_PTR(-EINVAL); + + return priv->phys[args->args[0]].phy; +} + +static int eq5_phy_probe_phy(struct eq5_phy_private *priv, unsigned int index, + void __iomem *base, unsigned int gp, + unsigned int sgmii) +{ + struct eq5_phy_inst *inst = &priv->phys[index]; + struct device *dev = priv->dev; + struct phy *phy; + + phy = devm_phy_create(dev, dev->of_node, &eq5_phy_ops); + if (IS_ERR(phy)) { + dev_err(dev, "failed to create PHY %u\n", index); + return PTR_ERR(phy); + } + + inst->priv = priv; + inst->phy = phy; + inst->gp = base + gp; + inst->sgmii = base + sgmii; + inst->phy_interface = PHY_INTERFACE_MODE_NA; + phy_set_drvdata(phy, inst); + + return 0; +} + +static int eq5_phy_probe(struct auxiliary_device *adev, + const struct auxiliary_device_id *id) +{ + struct device *dev = &adev->dev; + struct phy_provider *provider; + struct eq5_phy_private *priv; + void __iomem *base; + int ret; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->dev = dev; + dev_set_drvdata(dev, priv); + + base = (void __iomem *)dev_get_platdata(dev); + + ret = eq5_phy_probe_phy(priv, 0, base, EQ5_PHY0_GP, EQ5_PHY0_SGMII); + if (ret) + return ret; + + ret = eq5_phy_probe_phy(priv, 1, base, EQ5_PHY1_GP, EQ5_PHY1_SGMII); + if (ret) + return ret; + + provider = devm_of_phy_provider_register(dev, eq5_phy_xlate); + if (IS_ERR(provider)) { + dev_err(dev, "registering provider failed\n"); + return PTR_ERR(provider); + } + + return 0; +} + +static const struct auxiliary_device_id eq5_phy_id_table[] = { + { .name = "clk_eyeq.phy" }, + {} +}; +MODULE_DEVICE_TABLE(auxiliary, eq5_phy_id_table); + +static struct auxiliary_driver eq5_phy_driver = { + .probe = eq5_phy_probe, + .id_table = eq5_phy_id_table, +}; +module_auxiliary_driver(eq5_phy_driver); + +MODULE_DESCRIPTION("EyeQ5 Ethernet PHY driver"); +MODULE_AUTHOR("Théo Lebrun "); +MODULE_LICENSE("GPL"); -- 2.51.2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id D926ECF3943 for ; Wed, 19 Nov 2025 15:51:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References:Message-Id :MIME-Version:Subject:Date:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=t8y001Nj51SCbK13gDdgqe/4AmAAqJmFpUzn9XJwisc=; b=SkLYwje7/7S4UG 01Xu5C4M0dALZbFtysOyfzPNkqtyGhppWXax3vmSZ+Ia5f2mLHP+A7ZAJxP2yfSuHfoPKg/JS3oL3 ScRy6AQz3NNaPqjX2YDxR7Dv2qf3amfCIvm3QXrvY8gP70Q23VRhXEy+vxNiSUMObnafFbbWHJq6E 1TpIWqes0oy+9cSxEnYg+p970UNZbPWT+x7xGpzsf+hyixnQdWcmeh3vdHyJ76vHz1gWQ2182oXX3 /UY9aumr3ALmeheLwxYzc2w18WQx3tTa6ZjIjieePD7JM0Q7CD6rEMy6UT8wJcVnM+R2nz6wEZHbg G+TuImt9Zyxe4ASe5utQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1vLkSs-00000003ajB-2fd7; Wed, 19 Nov 2025 15:51:26 +0000 Received: from smtpout-02.galae.net ([185.246.84.56]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1vLkSq-00000003agm-0tdl for linux-phy@lists.infradead.org; Wed, 19 Nov 2025 15:51:25 +0000 Received: from smtpout-01.galae.net (smtpout-01.galae.net [212.83.139.233]) by smtpout-02.galae.net (Postfix) with ESMTPS id 84D571A1BE8; Wed, 19 Nov 2025 15:51:21 +0000 (UTC) Received: from mail.galae.net (mail.galae.net [212.83.136.155]) by smtpout-01.galae.net (Postfix) with ESMTPS id 5335A60699; Wed, 19 Nov 2025 15:51:21 +0000 (UTC) Received: from [127.0.0.1] (localhost [127.0.0.1]) by localhost (Mailerdaemon) with ESMTPSA id C5F1210371A75; Wed, 19 Nov 2025 16:51:18 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=dkim; t=1763567480; h=from:subject:date:message-id:to:cc:mime-version:content-type: content-transfer-encoding:in-reply-to:references; bh=/eLWDd5hWvYbPca/EklNrX1O6zckyQobOuG2mMOxQ0U=; b=ScKdkdOIpvpIFnjPt99/MDoXY2bppPwPz2Nfuap7hL9X5okWSKHpg9GTUShQA4arzNpf5z 4jSbLrdSOjvvC5Pu4yXM/1ppVB60cwEuGEX3L6HNTdykcO5oV+MiLC3JnkVGW2S1gl+1+1 dXrT/PpP3QoFcPD5Nqs40RVOGyFSNLzjhJVjg35LQ25QDKcVF7dlmVjoUprJY926DAVhV1 8ABMoqHakKyZ2nT7Q7AMVwRZBaH6id0vPlGCYGy1KUhebMH3qVydlq3L6c1eFoV1ifp23e Wa/NlFEwKgZ9xZdPW+HkcR0cmDmPzUYcYyvERgktu8376mNuo3btk8XMJ90UMA== From: =?utf-8?q?Th=C3=A9o_Lebrun?= Date: Wed, 19 Nov 2025 16:51:10 +0100 Subject: [PATCH v3 2/7] phy: Add driver for EyeQ5 Ethernet PHY wrapper MIME-Version: 1.0 Message-Id: <20251119-macb-phy-v3-2-e9a7be186a33@bootlin.com> References: <20251119-macb-phy-v3-0-e9a7be186a33@bootlin.com> In-Reply-To: <20251119-macb-phy-v3-0-e9a7be186a33@bootlin.com> To: Vladimir Kondratiev , =?utf-8?q?Gr=C3=A9gory_Clement?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Vinod Koul , Kishon Vijay Abraham I , Michael Turquette , Stephen Boyd , Philipp Zabel , Thomas Bogendoerfer Cc: linux-mips@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, =?utf-8?q?Beno=C3=AEt_Monin?= , Maxime Chevallier , Tawfik Bayouk , Thomas Petazzoni , =?utf-8?q?Th=C3=A9o_Lebrun?= X-Mailer: b4 0.14.3 X-Last-TLS-Session-Version: TLSv1.3 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20251119_075124_401607_6B74EE1E X-CRM114-Status: GOOD ( 19.13 ) X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org RXllUTUgZW1iZWRzIGEgc3lzdGVtLWNvbnRyb2xsZXIgY2FsbGVkIE9MQi4gSXQgZmVhdHVyZXMg bWFueSB1bnJlbGF0ZWQKcmVnaXN0ZXJzLCBhbmQgc29tZSBvZiB0aG9zZSBhcmUgcmVnaXN0ZXJz IHVzZWQgdG8gY29uZmlndXJlIHRoZQppbnRlZ3JhdGlvbiBvZiB0aGUgUkdNSUkvU0dNSUkgQ2Fk ZW5jZSBQSFkgdXNlZCBieSBNQUNCL0dFTSBpbnN0YW5jZXMuCgpXcmFwIGluIGEgbmVhdCBnZW5l cmljIFBIWSBwcm92aWRlciwgZXhwb3NpbmcgdHdvIFBIWXMgd2l0aCBzdGFuZGFyZApwaHlfaW5p dCgpIC8gcGh5X3NldF9tb2RlKCkgLyBwaHlfcG93ZXJfb24oKSBvcGVyYXRpb25zLgoKU2lnbmVk LW9mZi1ieTogVGjDqW8gTGVicnVuIDx0aGVvLmxlYnJ1bkBib290bGluLmNvbT4KLS0tCiBNQUlO VEFJTkVSUyAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9waHkvS2NvbmZpZyAgICAg ICAgIHwgIDEzICsrKwogZHJpdmVycy9waHkvTWFrZWZpbGUgICAgICAgIHwgICAxICsKIGRyaXZl cnMvcGh5L3BoeS1leWVxNS1ldGguYyB8IDI1NCArKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKwogNCBmaWxlcyBjaGFuZ2VkLCAyNjkgaW5zZXJ0aW9ucygrKQoKZGlm ZiAtLWdpdCBhL01BSU5UQUlORVJTIGIvTUFJTlRBSU5FUlMKaW5kZXggYjAyMjNjZmIyNTgzLi4y OGMwYjEyZGQxMjUgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBA IC0xNzQwMyw2ICsxNzQwMyw3IEBAIEY6CWFyY2gvbWlwcy9ib290L2R0cy9tb2JpbGV5ZS8KIEY6 CWFyY2gvbWlwcy9jb25maWdzL2V5ZXE1X2RlZmNvbmZpZwogRjoJYXJjaC9taXBzL21vYmlsZXll L2JvYXJkLWVwbTUuaXRzLlMKIEY6CWRyaXZlcnMvY2xrL2Nsay1leWVxLmMKK0Y6CWRyaXZlcnMv cGh5L3BoeS1leWVxNS1ldGguYwogRjoJZHJpdmVycy9waW5jdHJsL3BpbmN0cmwtZXllcTUuYwog RjoJZHJpdmVycy9yZXNldC9yZXNldC1leWVxLmMKIEY6CWluY2x1ZGUvZHQtYmluZGluZ3MvY2xv Y2svbW9iaWxleWUsZXllcTUtY2xrLmgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGh5L0tjb25maWcg Yi9kcml2ZXJzL3BoeS9LY29uZmlnCmluZGV4IDY3OGRkMDQ1MmYwYS4uMWFhNmVmZjEyZGJjIDEw MDY0NAotLS0gYS9kcml2ZXJzL3BoeS9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGh5L0tjb25maWcK QEAgLTEwMSw2ICsxMDEsMTkgQEAgY29uZmlnIFBIWV9OWFBfUFROMzIyMgogCSAgc2NoZW1lcy4g SXQgc3VwcG9ydHMgYWxsIHRocmVlIFVTQiAyLjAgZGF0YSByYXRlczogTG93IFNwZWVkLCBGdWxs CiAJICBTcGVlZCBhbmQgSGlnaCBTcGVlZC4KIAorY29uZmlnIFBIWV9FWUVRNV9FVEgKKwl0cmlz dGF0ZSAiRXRoZXJuZXQgUEhZIERyaXZlciBvbiBFeWVRNSIKKwlkZXBlbmRzIG9uIE9GCisJZGVw ZW5kcyBvbiBNQUNIX0VZRVE1IHx8IENPTVBJTEVfVEVTVAorCXNlbGVjdCBBVVhJTElBUllfQlVT CisJc2VsZWN0IEdFTkVSSUNfUEhZCisJZGVmYXVsdCBNQUNIX0VZRVE1CisJaGVscAorCSAgRW5h YmxlIHRoaXMgdG8gc3VwcG9ydCB0aGUgRXRoZXJuZXQgUEhZIGludGVncmF0ZWQgb24gRXllUTUu CisJICBJdCBzdXBwb3J0cyBib3RoIFJHTUlJIGFuZCBTR01JSS4gUmVnaXN0ZXJzIGFyZSBsb2Nh dGVkIGluIGEKKwkgIHNoYXJlZCByZWdpc3RlciByZWdpb24gY2FsbGVkIE9MQi4gSWYgTSBpcyBz ZWxlY3RlZCwgdGhlCisJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgcGh5LWV5ZXE1LWV0aC4KKwog c291cmNlICJkcml2ZXJzL3BoeS9hbGx3aW5uZXIvS2NvbmZpZyIKIHNvdXJjZSAiZHJpdmVycy9w aHkvYW1sb2dpYy9LY29uZmlnIgogc291cmNlICJkcml2ZXJzL3BoeS9icm9hZGNvbS9LY29uZmln IgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waHkvTWFrZWZpbGUgYi9kcml2ZXJzL3BoeS9NYWtlZmls ZQppbmRleCBiZmIyN2ZiNWE0OTQuLjgyODk0OTdlY2U1NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9w aHkvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9waHkvTWFrZWZpbGUKQEAgLTEzLDYgKzEzLDcgQEAg b2JqLSQoQ09ORklHX1BIWV9TTlBTX0VVU0IyKQkJKz0gcGh5LXNucHMtZXVzYjIubwogb2JqLSQo Q09ORklHX1VTQl9MR01fUEhZKQkJKz0gcGh5LWxnbS11c2Iubwogb2JqLSQoQ09ORklHX1BIWV9B SVJPSEFfUENJRSkJCSs9IHBoeS1haXJvaGEtcGNpZS5vCiBvYmotJChDT05GSUdfUEhZX05YUF9Q VE4zMjIyKQkJKz0gcGh5LW54cC1wdG4zMjIyLm8KK29iai0kKENPTkZJR19QSFlfRVlFUTVfRVRI KQkJKz0gcGh5LWV5ZXE1LWV0aC5vCiBvYmoteQkJCQkJKz0gYWxsd2lubmVyLwlcCiAJCQkJCSAg IGFtbG9naWMvCVwKIAkJCQkJICAgYnJvYWRjb20vCVwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGh5 L3BoeS1leWVxNS1ldGguYyBiL2RyaXZlcnMvcGh5L3BoeS1leWVxNS1ldGguYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmM5MDFkMWNjZTBjOAotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvcGh5L3BoeS1leWVxNS1ldGguYwpAQCAtMCwwICsxLDI1NCBAQAorLy8g U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQorCisjaW5jbHVkZSA8bGludXgv YXJyYXlfc2l6ZS5oPgorI2luY2x1ZGUgPGxpbnV4L2F1eGlsaWFyeV9idXMuaD4KKyNpbmNsdWRl IDxsaW51eC9iaXRmaWVsZC5oPgorI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KKyNpbmNsdWRlIDxs aW51eC9idWcuaD4KKyNpbmNsdWRlIDxsaW51eC9jbGVhbnVwLmg+CisjaW5jbHVkZSA8bGludXgv Y29udGFpbmVyX29mLmg+CisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CisjaW5jbHVkZSA8bGlu dXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0 Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4KKyNp bmNsdWRlIDxsaW51eC9sb2NrZGVwLmg+CisjaW5jbHVkZSA8bGludXgvbW9kX2RldmljZXRhYmxl Lmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2lu Y2x1ZGUgPGxpbnV4L3BoeS5oPgorI2luY2x1ZGUgPGxpbnV4L3BoeS9waHkuaD4KKyNpbmNsdWRl IDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2RlZmluZSBFUTVf UEhZX0NPVU5UCTIKKworI2RlZmluZSBFUTVfUEhZMF9HUAkweDEyOAorI2RlZmluZSBFUTVfUEhZ MV9HUAkweDEyYworI2RlZmluZSBFUTVfUEhZMF9TR01JSQkweDEzNAorI2RlZmluZSBFUTVfUEhZ MV9TR01JSQkweDEzOAorCisjZGVmaW5lIEVRNV9HUF9UWF9TV1JTVF9ESVMJQklUKDApCQkvLyBU eCBTVyByZXNldAorI2RlZmluZSBFUTVfR1BfVFhfTV9DTEtFCUJJVCgxKQkJLy8gVHggTSBjbG9j ayBlbmFibGUKKyNkZWZpbmUgRVE1X0dQX1NZU19TV1JTVF9ESVMJQklUKDIpCQkvLyBTeXMgU1cg cmVzZXQKKyNkZWZpbmUgRVE1X0dQX1NZU19NX0NMS0UJQklUKDMpCQkvLyBTeXMgY2xvY2sgZW5h YmxlCisjZGVmaW5lIEVRNV9HUF9TR01JSV9NT0RFCUJJVCg0KQkJLy8gU0dNSUkgbW9kZQorI2Rl ZmluZSBFUTVfR1BfUkdNSUlfRFJWCUdFTk1BU0soOCwgNSkJLy8gUkdNSUkgZHJpdmUgc3RyZW5n dGgKKworI2RlZmluZSBFUTVfU0dNSUlfUFdSX0VOCUJJVCgwKQorI2RlZmluZSBFUTVfU0dNSUlf UlNUX0RJUwlCSVQoMSkKKyNkZWZpbmUgRVE1X1NHTUlJX1BMTF9FTglCSVQoMikKKyNkZWZpbmUg RVE1X1NHTUlJX1NJR19ERVRfU1cJQklUKDMpCisjZGVmaW5lIEVRNV9TR01JSV9QV1JfU1RBVEUJ QklUKDQpCisjZGVmaW5lIEVRNV9TR01JSV9QTExfQUNLCUJJVCgxOCkKKyNkZWZpbmUgRVE1X1NH TUlJX1BXUl9TVEFURV9BQ0sJR0VOTUFTSygyNCwgMjApCisKK3N0cnVjdCBlcTVfcGh5X2luc3Qg eworCXN0cnVjdCBlcTVfcGh5X3ByaXZhdGUJKnByaXY7CisJc3RydWN0IHBoeQkJKnBoeTsKKwl2 b2lkIF9faW9tZW0JCSpncCwgKnNnbWlpOworCXBoeV9pbnRlcmZhY2VfdAkJcGh5X2ludGVyZmFj ZTsKK307CisKK3N0cnVjdCBlcTVfcGh5X3ByaXZhdGUgeworCXN0cnVjdCBkZXZpY2UJCSpkZXY7 CisJc3RydWN0IGVxNV9waHlfaW5zdAlwaHlzW0VRNV9QSFlfQ09VTlRdOworfTsKKworc3RhdGlj IGludCBlcTVfcGh5X2luaXQoc3RydWN0IHBoeSAqcGh5KQoreworCXN0cnVjdCBlcTVfcGh5X2lu c3QgKmluc3QgPSBwaHlfZ2V0X2RydmRhdGEocGh5KTsKKwlzdHJ1Y3QgZXE1X3BoeV9wcml2YXRl ICpwcml2ID0gaW5zdC0+cHJpdjsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBwcml2LT5kZXY7CisJ dTMyIHJlZzsKKworCWRldl9kYmcoZGV2LCAicGh5X2luaXQoaW5zdD0ldGQpXG4iLCBpbnN0IC0g cHJpdi0+cGh5cyk7CisKKwl3cml0ZWwoMCwgaW5zdC0+Z3ApOworCXdyaXRlbCgwLCBpbnN0LT5z Z21paSk7CisKKwl1ZGVsYXkoNSk7CisKKwlyZWcgPSByZWFkbChpbnN0LT5ncCkgfCBFUTVfR1Bf VFhfU1dSU1RfRElTIHwgRVE1X0dQX1RYX01fQ0xLRSB8CisJICAgICAgRVE1X0dQX1NZU19TV1JT VF9ESVMgfCBFUTVfR1BfU1lTX01fQ0xLRSB8CisJICAgICAgRklFTERfUFJFUChFUTVfR1BfUkdN SUlfRFJWLCAweDkpOworCXdyaXRlbChyZWcsIGluc3QtPmdwKTsKKworCXJldHVybiAwOworfQor CitzdGF0aWMgaW50IGVxNV9waHlfZXhpdChzdHJ1Y3QgcGh5ICpwaHkpCit7CisJc3RydWN0IGVx NV9waHlfaW5zdCAqaW5zdCA9IHBoeV9nZXRfZHJ2ZGF0YShwaHkpOworCXN0cnVjdCBlcTVfcGh5 X3ByaXZhdGUgKnByaXYgPSBpbnN0LT5wcml2OworCXN0cnVjdCBkZXZpY2UgKmRldiA9IHByaXYt PmRldjsKKworCWRldl9kYmcoZGV2LCAicGh5X2V4aXQoaW5zdD0ldGQpXG4iLCBpbnN0IC0gcHJp di0+cGh5cyk7CisKKwl3cml0ZWwoMCwgaW5zdC0+Z3ApOworCXdyaXRlbCgwLCBpbnN0LT5zZ21p aSk7CisJdWRlbGF5KDUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZXE1X3BoeV9z ZXRfbW9kZShzdHJ1Y3QgcGh5ICpwaHksIGVudW0gcGh5X21vZGUgbW9kZSwgaW50IHN1Ym1vZGUp Cit7CisJc3RydWN0IGVxNV9waHlfaW5zdCAqaW5zdCA9IHBoeV9nZXRfZHJ2ZGF0YShwaHkpOwor CXN0cnVjdCBlcTVfcGh5X3ByaXZhdGUgKnByaXYgPSBpbnN0LT5wcml2OworCXN0cnVjdCBkZXZp Y2UgKmRldiA9IHByaXYtPmRldjsKKworCWRldl9kYmcoZGV2LCAicGh5X3NldF9tb2RlKGluc3Q9 JXRkLCBtb2RlPSVkLCBzdWJtb2RlPSVkKVxuIiwKKwkJaW5zdCAtIHByaXYtPnBoeXMsIG1vZGUs IHN1Ym1vZGUpOworCisJaWYgKG1vZGUgIT0gUEhZX01PREVfRVRIRVJORVQpCisJCXJldHVybiAt RU9QTk9UU1VQUDsKKworCWlmICghcGh5X2ludGVyZmFjZV9tb2RlX2lzX3JnbWlpKHN1Ym1vZGUp ICYmCisJICAgIHN1Ym1vZGUgIT0gUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJKQorCQlyZXR1cm4g LUVPUE5PVFNVUFA7CisKKwlpbnN0LT5waHlfaW50ZXJmYWNlID0gc3VibW9kZTsKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGludCBlcTVfcGh5X3Bvd2VyX29uKHN0cnVjdCBwaHkgKnBoeSkKK3sK KwlzdHJ1Y3QgZXE1X3BoeV9pbnN0ICppbnN0ID0gcGh5X2dldF9kcnZkYXRhKHBoeSk7CisJc3Ry dWN0IGVxNV9waHlfcHJpdmF0ZSAqcHJpdiA9IGluc3QtPnByaXY7CisJc3RydWN0IGRldmljZSAq ZGV2ID0gcHJpdi0+ZGV2OworCXUzMiByZWc7CisKKwlkZXZfZGJnKGRldiwgInBoeV9wb3dlcl9v bihpbnN0PSV0ZClcbiIsIGluc3QgLSBwcml2LT5waHlzKTsKKworCWlmIChpbnN0LT5waHlfaW50 ZXJmYWNlID09IFBIWV9JTlRFUkZBQ0VfTU9ERV9TR01JSSkgeworCQl3cml0ZWwocmVhZGwoaW5z dC0+Z3ApIHwgRVE1X0dQX1NHTUlJX01PREUsIGluc3QtPmdwKTsKKworCQlyZWcgPSBFUTVfU0dN SUlfUFdSX0VOIHwgRVE1X1NHTUlJX1JTVF9ESVMgfCBFUTVfU0dNSUlfUExMX0VOOworCQl3cml0 ZWwocmVnLCBpbnN0LT5zZ21paSk7CisKKwkJaWYgKHJlYWRsX3BvbGxfdGltZW91dChpbnN0LT5z Z21paSwgcmVnLAorCQkJCSAgICAgICByZWcgJiBFUTVfU0dNSUlfUExMX0FDSywgMSwgMTAwKSkg eworCQkJZGV2X2VycihkZXYsICJQTEwgdGltZW91dFxuIik7CisJCQlyZXR1cm4gLUVUSU1FRE9V VDsKKwkJfQorCisJCXJlZyA9IHJlYWRsKGluc3QtPnNnbWlpKTsKKwkJcmVnIHw9IEVRNV9TR01J SV9QV1JfU1RBVEUgfCBFUTVfU0dNSUlfU0lHX0RFVF9TVzsKKwkJd3JpdGVsKHJlZywgaW5zdC0+ c2dtaWkpOworCX0gZWxzZSB7CisJCXdyaXRlbChyZWFkbChpbnN0LT5ncCkgJiB+RVE1X0dQX1NH TUlJX01PREUsIGluc3QtPmdwKTsKKwkJd3JpdGVsKDAsIGluc3QtPnNnbWlpKTsKKwl9CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGludCBlcTVfcGh5X3Bvd2VyX29mZihzdHJ1Y3QgcGh5ICpw aHkpCit7CisJc3RydWN0IGVxNV9waHlfaW5zdCAqaW5zdCA9IHBoeV9nZXRfZHJ2ZGF0YShwaHkp OworCXN0cnVjdCBlcTVfcGh5X3ByaXZhdGUgKnByaXYgPSBpbnN0LT5wcml2OworCXN0cnVjdCBk ZXZpY2UgKmRldiA9IHByaXYtPmRldjsKKworCWRldl9kYmcoZGV2LCAicGh5X3Bvd2VyX29mZihp bnN0PSV0ZClcbiIsIGluc3QgLSBwcml2LT5waHlzKTsKKworCXdyaXRlbChyZWFkbChpbnN0LT5n cCkgJiB+RVE1X0dQX1NHTUlJX01PREUsIGluc3QtPmdwKTsKKwl3cml0ZWwoMCwgaW5zdC0+c2dt aWkpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGh5X29wcyBlcTVf cGh5X29wcyA9IHsKKwkuaW5pdAkJPSBlcTVfcGh5X2luaXQsCisJLmV4aXQJCT0gZXE1X3BoeV9l eGl0LAorCS5zZXRfbW9kZQk9IGVxNV9waHlfc2V0X21vZGUsCisJLnBvd2VyX29uCT0gZXE1X3Bo eV9wb3dlcl9vbiwKKwkucG93ZXJfb2ZmCT0gZXE1X3BoeV9wb3dlcl9vZmYsCit9OworCitzdGF0 aWMgc3RydWN0IHBoeSAqZXE1X3BoeV94bGF0ZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJIGNv bnN0IHN0cnVjdCBvZl9waGFuZGxlX2FyZ3MgKmFyZ3MpCit7CisJc3RydWN0IGVxNV9waHlfcHJp dmF0ZSAqcHJpdiA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCisJaWYgKGFyZ3MtPmFyZ3NfY291 bnQgIT0gMSB8fCBhcmdzLT5hcmdzWzBdID4gMSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7 CisKKwlyZXR1cm4gcHJpdi0+cGh5c1thcmdzLT5hcmdzWzBdXS5waHk7Cit9CisKK3N0YXRpYyBp bnQgZXE1X3BoeV9wcm9iZV9waHkoc3RydWN0IGVxNV9waHlfcHJpdmF0ZSAqcHJpdiwgdW5zaWdu ZWQgaW50IGluZGV4LAorCQkJICAgICB2b2lkIF9faW9tZW0gKmJhc2UsIHVuc2lnbmVkIGludCBn cCwKKwkJCSAgICAgdW5zaWduZWQgaW50IHNnbWlpKQoreworCXN0cnVjdCBlcTVfcGh5X2luc3Qg Kmluc3QgPSAmcHJpdi0+cGh5c1tpbmRleF07CisJc3RydWN0IGRldmljZSAqZGV2ID0gcHJpdi0+ ZGV2OworCXN0cnVjdCBwaHkgKnBoeTsKKworCXBoeSA9IGRldm1fcGh5X2NyZWF0ZShkZXYsIGRl di0+b2Zfbm9kZSwgJmVxNV9waHlfb3BzKTsKKwlpZiAoSVNfRVJSKHBoeSkpIHsKKwkJZGV2X2Vy cihkZXYsICJmYWlsZWQgdG8gY3JlYXRlIFBIWSAldVxuIiwgaW5kZXgpOworCQlyZXR1cm4gUFRS X0VSUihwaHkpOworCX0KKworCWluc3QtPnByaXYgPSBwcml2OworCWluc3QtPnBoeSA9IHBoeTsK KwlpbnN0LT5ncCA9IGJhc2UgKyBncDsKKwlpbnN0LT5zZ21paSA9IGJhc2UgKyBzZ21paTsKKwlp bnN0LT5waHlfaW50ZXJmYWNlID0gUEhZX0lOVEVSRkFDRV9NT0RFX05BOworCXBoeV9zZXRfZHJ2 ZGF0YShwaHksIGluc3QpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZXE1X3BoeV9w cm9iZShzdHJ1Y3QgYXV4aWxpYXJ5X2RldmljZSAqYWRldiwKKwkJCSBjb25zdCBzdHJ1Y3QgYXV4 aWxpYXJ5X2RldmljZV9pZCAqaWQpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmFkZXYtPmRl djsKKwlzdHJ1Y3QgcGh5X3Byb3ZpZGVyICpwcm92aWRlcjsKKwlzdHJ1Y3QgZXE1X3BoeV9wcml2 YXRlICpwcml2OworCXZvaWQgX19pb21lbSAqYmFzZTsKKwlpbnQgcmV0OworCisJcHJpdiA9IGRl dm1fa3phbGxvYyhkZXYsIHNpemVvZigqcHJpdiksIEdGUF9LRVJORUwpOworCWlmICghcHJpdikK KwkJcmV0dXJuIC1FTk9NRU07CisKKwlwcml2LT5kZXYgPSBkZXY7CisJZGV2X3NldF9kcnZkYXRh KGRldiwgcHJpdik7CisKKwliYXNlID0gKHZvaWQgX19pb21lbSAqKWRldl9nZXRfcGxhdGRhdGEo ZGV2KTsKKworCXJldCA9IGVxNV9waHlfcHJvYmVfcGh5KHByaXYsIDAsIGJhc2UsIEVRNV9QSFkw X0dQLCBFUTVfUEhZMF9TR01JSSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9 IGVxNV9waHlfcHJvYmVfcGh5KHByaXYsIDEsIGJhc2UsIEVRNV9QSFkxX0dQLCBFUTVfUEhZMV9T R01JSSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXByb3ZpZGVyID0gZGV2bV9vZl9w aHlfcHJvdmlkZXJfcmVnaXN0ZXIoZGV2LCBlcTVfcGh5X3hsYXRlKTsKKwlpZiAoSVNfRVJSKHBy b3ZpZGVyKSkgeworCQlkZXZfZXJyKGRldiwgInJlZ2lzdGVyaW5nIHByb3ZpZGVyIGZhaWxlZFxu Iik7CisJCXJldHVybiBQVFJfRVJSKHByb3ZpZGVyKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGNvbnN0IHN0cnVjdCBhdXhpbGlhcnlfZGV2aWNlX2lkIGVxNV9waHlfaWRfdGFibGVb XSA9IHsKKwl7IC5uYW1lID0gImNsa19leWVxLnBoeSIgfSwKKwl7fQorfTsKK01PRFVMRV9ERVZJ Q0VfVEFCTEUoYXV4aWxpYXJ5LCBlcTVfcGh5X2lkX3RhYmxlKTsKKworc3RhdGljIHN0cnVjdCBh dXhpbGlhcnlfZHJpdmVyIGVxNV9waHlfZHJpdmVyID0geworCS5wcm9iZSA9IGVxNV9waHlfcHJv YmUsCisJLmlkX3RhYmxlID0gZXE1X3BoeV9pZF90YWJsZSwKK307Cittb2R1bGVfYXV4aWxpYXJ5 X2RyaXZlcihlcTVfcGh5X2RyaXZlcik7CisKK01PRFVMRV9ERVNDUklQVElPTigiRXllUTUgRXRo ZXJuZXQgUEhZIGRyaXZlciIpOworTU9EVUxFX0FVVEhPUigiVGjDqW8gTGVicnVuIDx0aGVvLmxl YnJ1bkBib290bGluLmNvbT4iKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKCi0tIAoyLjUxLjIK CgotLSAKbGludXgtcGh5IG1haWxpbmcgbGlzdApsaW51eC1waHlAbGlzdHMuaW5mcmFkZWFkLm9y ZwpodHRwczovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1waHkK