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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 61CFAC48BC2 for ; Fri, 25 Jun 2021 06:55:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 39B1B61423 for ; Fri, 25 Jun 2021 06:55:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229759AbhFYG56 (ORCPT ); Fri, 25 Jun 2021 02:57:58 -0400 Received: from regular1.263xmail.com ([211.150.70.203]:38882 "EHLO regular1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229448AbhFYG5y (ORCPT ); Fri, 25 Jun 2021 02:57:54 -0400 Received: from localhost (unknown [192.168.167.13]) by regular1.263xmail.com (Postfix) with ESMTP id D0C1A8DC; Fri, 25 Jun 2021 14:55:22 +0800 (CST) X-MAIL-GRAY: 0 X-MAIL-DELIVERY: 1 X-ADDR-CHECKED4: 1 X-SKE-CHECKED: 1 X-ABS-CHECKED: 1 X-ANTISPAM-LEVEL: 2 Received: from xxm-vm.localdomain (unknown [58.22.7.114]) by smtp.263.net (postfix) whith ESMTP id P30156T139874253620992S1624604118052833_; Fri, 25 Jun 2021 14:55:21 +0800 (CST) X-IP-DOMAINF: 1 X-UNIQUE-TAG: <25abb18687147f0a6a8bbc0f2da15c2e> X-RL-SENDER: xxm@rock-chips.com X-SENDER: xxm@rock-chips.com X-LOGIN-NAME: xxm@rock-chips.com X-FST-TO: bhelgaas@google.com X-RCPT-COUNT: 12 X-SENDER-IP: 58.22.7.114 X-ATTACHMENT-NUM: 0 X-System-Flag: 0 From: Simon Xue To: Bjorn Helgaas , Lorenzo Pieralisi Cc: linux-pci@vger.kernel.org, linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, robh+dt@kernel.org, Johan Jonker , Heiko Stuebner , Simon Xue , Peter Geis , Kever Yang , Shawn Lin Subject: [PATCH v11] PCI: rockchip-dwc: Add Rockchip RK356X host controller driver Date: Fri, 25 Jun 2021 14:55:11 +0800 Message-Id: <20210625065511.1096935-1-xxm@rock-chips.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Add a driver for the DesignWare-based PCIe controller found on RK356X. The existing pcie-rockchip-host driver is only used for the Rockchip-designed IP found on RK3399. Tested-by: Peter Geis Reviewed-by: Kever Yang Signed-off-by: Simon Xue Signed-off-by: Shawn Lin --- drivers/pci/controller/dwc/Kconfig | 11 + drivers/pci/controller/dwc/Makefile | 1 + drivers/pci/controller/dwc/pcie-dw-rockchip.c | 276 ++++++++++++++++++ 3 files changed, 288 insertions(+) create mode 100644 drivers/pci/controller/dwc/pcie-dw-rockchip.c diff --git a/drivers/pci/controller/dwc/Kconfig b/drivers/pci/controller/dwc/Kconfig index 423d35872ce4..60d3dde9ca39 100644 --- a/drivers/pci/controller/dwc/Kconfig +++ b/drivers/pci/controller/dwc/Kconfig @@ -214,6 +214,17 @@ config PCIE_ARTPEC6_EP Enables support for the PCIe controller in the ARTPEC-6 SoC to work in endpoint mode. This uses the DesignWare core. +config PCIE_ROCKCHIP_DW_HOST + bool "Rockchip DesignWare PCIe controller" + select PCIE_DW + select PCIE_DW_HOST + depends on PCI_MSI_IRQ_DOMAIN + depends on ARCH_ROCKCHIP || COMPILE_TEST + depends on OF + help + Enables support for the DesignWare PCIe controller in the + Rockchip SoC except RK3399. + config PCIE_INTEL_GW bool "Intel Gateway PCIe host controller support" depends on OF && (X86 || COMPILE_TEST) diff --git a/drivers/pci/controller/dwc/Makefile b/drivers/pci/controller/dwc/Makefile index 9e6ce0dc2f53..3710e91471f7 100644 --- a/drivers/pci/controller/dwc/Makefile +++ b/drivers/pci/controller/dwc/Makefile @@ -14,6 +14,7 @@ obj-$(CONFIG_PCI_LAYERSCAPE_EP) += pci-layerscape-ep.o obj-$(CONFIG_PCIE_QCOM) += pcie-qcom.o obj-$(CONFIG_PCIE_ARMADA_8K) += pcie-armada8k.o obj-$(CONFIG_PCIE_ARTPEC6) += pcie-artpec6.o +obj-$(CONFIG_PCIE_ROCKCHIP_DW_HOST) += pcie-dw-rockchip.o obj-$(CONFIG_PCIE_INTEL_GW) += pcie-intel-gw.o obj-$(CONFIG_PCIE_KIRIN) += pcie-kirin.o obj-$(CONFIG_PCIE_HISI_STB) += pcie-histb.o diff --git a/drivers/pci/controller/dwc/pcie-dw-rockchip.c b/drivers/pci/controller/dwc/pcie-dw-rockchip.c new file mode 100644 index 000000000000..20cef2e06f66 --- /dev/null +++ b/drivers/pci/controller/dwc/pcie-dw-rockchip.c @@ -0,0 +1,276 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * PCIe host controller driver for Rockchip SoCs. + * + * Copyright (C) 2021 Rockchip Electronics Co., Ltd. + * http://www.rock-chips.com + * + * Author: Simon Xue + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "pcie-designware.h" + +/* + * The upper 16 bits of PCIE_CLIENT_CONFIG are a write + * mask for the lower 16 bits. + */ +#define HIWORD_UPDATE(mask, val) (((mask) << 16) | (val)) +#define HIWORD_UPDATE_BIT(val) HIWORD_UPDATE(val, val) + +#define to_rockchip_pcie(x) dev_get_drvdata((x)->dev) + +#define PCIE_CLIENT_RC_MODE HIWORD_UPDATE_BIT(0x40) +#define PCIE_CLIENT_ENABLE_LTSSM HIWORD_UPDATE_BIT(0xc) +#define PCIE_SMLH_LINKUP BIT(16) +#define PCIE_RDLH_LINKUP BIT(17) +#define PCIE_LINKUP (PCIE_SMLH_LINKUP | PCIE_RDLH_LINKUP) +#define PCIE_L0S_ENTRY 0x11 +#define PCIE_CLIENT_GENERAL_CONTROL 0x0 +#define PCIE_CLIENT_GENERAL_DEBUG 0x104 +#define PCIE_CLIENT_HOT_RESET_CTRL 0x180 +#define PCIE_CLIENT_LTSSM_STATUS 0x300 +#define PCIE_LTSSM_ENABLE_ENHANCE BIT(4) +#define PCIE_LTSSM_STATUS_MASK GENMASK(5, 0) + +struct rockchip_pcie { + struct dw_pcie pci; + void __iomem *apb_base; + struct phy *phy; + struct clk_bulk_data *clks; + unsigned int clk_cnt; + struct reset_control *rst; + struct gpio_desc *rst_gpio; + struct regulator *vpcie3v3; +}; + +static int rockchip_pcie_readl_apb(struct rockchip_pcie *rockchip, + u32 reg) +{ + return readl_relaxed(rockchip->apb_base + reg); +} + +static void rockchip_pcie_writel_apb(struct rockchip_pcie *rockchip, + u32 val, u32 reg) +{ + writel_relaxed(val, rockchip->apb_base + reg); +} + +static void rockchip_pcie_enable_ltssm(struct rockchip_pcie *rockchip) +{ + rockchip_pcie_writel_apb(rockchip, PCIE_CLIENT_ENABLE_LTSSM, + PCIE_CLIENT_GENERAL_CONTROL); +} + +static int rockchip_pcie_link_up(struct dw_pcie *pci) +{ + struct rockchip_pcie *rockchip = to_rockchip_pcie(pci); + u32 val = rockchip_pcie_readl_apb(rockchip, PCIE_CLIENT_LTSSM_STATUS); + + if ((val & PCIE_LINKUP) == PCIE_LINKUP && + (val & PCIE_LTSSM_STATUS_MASK) == PCIE_L0S_ENTRY) + return 1; + + return 0; +} + +static int rockchip_pcie_start_link(struct dw_pcie *pci) +{ + struct rockchip_pcie *rockchip = to_rockchip_pcie(pci); + + /* Reset device */ + gpiod_set_value_cansleep(rockchip->rst_gpio, 0); + + rockchip_pcie_enable_ltssm(rockchip); + + /* + * PCIe requires the refclk to be stable for 100µs prior to releasing + * PERST. See table 2-4 in section 2.6.2 AC Specifications of the PCI + * Express Card Electromechanical Specification, 1.1. However, we don't + * know if the refclk is coming from RC's PHY or external OSC. If it's + * from RC, so enabling LTSSM is the just right place to release #PERST. + * We need more extra time as before, rather than setting just + * 100us as we don't know how long should the device need to reset. + */ + msleep(100); + gpiod_set_value_cansleep(rockchip->rst_gpio, 1); + + return 0; +} + +static int rockchip_pcie_host_init(struct pcie_port *pp) +{ + struct dw_pcie *pci = to_dw_pcie_from_pp(pp); + struct rockchip_pcie *rockchip = to_rockchip_pcie(pci); + u32 val = HIWORD_UPDATE_BIT(PCIE_LTSSM_ENABLE_ENHANCE); + + /* LTSSM enable control mode */ + rockchip_pcie_writel_apb(rockchip, val, PCIE_CLIENT_HOT_RESET_CTRL); + + rockchip_pcie_writel_apb(rockchip, PCIE_CLIENT_RC_MODE, + PCIE_CLIENT_GENERAL_CONTROL); + + return 0; +} + +static const struct dw_pcie_host_ops rockchip_pcie_host_ops = { + .host_init = rockchip_pcie_host_init, +}; + +static int rockchip_pcie_clk_init(struct rockchip_pcie *rockchip) +{ + struct device *dev = rockchip->pci.dev; + int ret; + + ret = devm_clk_bulk_get_all(dev, &rockchip->clks); + if (ret < 0) + return ret; + + rockchip->clk_cnt = ret; + + return clk_bulk_prepare_enable(rockchip->clk_cnt, rockchip->clks); +} + +static int rockchip_pcie_resource_get(struct platform_device *pdev, + struct rockchip_pcie *rockchip) +{ + rockchip->apb_base = devm_platform_ioremap_resource_byname(pdev, "apb"); + if (IS_ERR(rockchip->apb_base)) + return PTR_ERR(rockchip->apb_base); + + rockchip->rst_gpio = devm_gpiod_get_optional(&pdev->dev, "reset", + GPIOD_OUT_HIGH); + if (IS_ERR(rockchip->rst_gpio)) + return PTR_ERR(rockchip->rst_gpio); + + return 0; +} + +static int rockchip_pcie_phy_init(struct rockchip_pcie *rockchip) +{ + struct device *dev = rockchip->pci.dev; + int ret; + + rockchip->phy = devm_phy_get(dev, "pcie-phy"); + if (IS_ERR(rockchip->phy)) + return dev_err_probe(dev, PTR_ERR(rockchip->phy), + "missing PHY\n"); + + ret = phy_init(rockchip->phy); + if (ret < 0) + return ret; + + ret = phy_power_on(rockchip->phy); + if (ret) + phy_exit(rockchip->phy); + + return ret; +} + +static void rockchip_pcie_phy_deinit(struct rockchip_pcie *rockchip) +{ + phy_exit(rockchip->phy); + phy_power_off(rockchip->phy); +} + +static int rockchip_pcie_reset_control_release(struct rockchip_pcie *rockchip) +{ + struct device *dev = rockchip->pci.dev; + + rockchip->rst = devm_reset_control_array_get_exclusive(dev); + if (IS_ERR(rockchip->rst)) + return dev_err_probe(dev, PTR_ERR(rockchip->rst), + "failed to get reset lines\n"); + + return reset_control_deassert(rockchip->rst); +} + +static const struct dw_pcie_ops dw_pcie_ops = { + .link_up = rockchip_pcie_link_up, + .start_link = rockchip_pcie_start_link, +}; + +static int rockchip_pcie_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct rockchip_pcie *rockchip; + struct pcie_port *pp; + int ret; + + rockchip = devm_kzalloc(dev, sizeof(*rockchip), GFP_KERNEL); + if (!rockchip) + return -ENOMEM; + + platform_set_drvdata(pdev, rockchip); + + rockchip->pci.dev = dev; + rockchip->pci.ops = &dw_pcie_ops; + + pp = &rockchip->pci.pp; + pp->ops = &rockchip_pcie_host_ops; + + ret = rockchip_pcie_resource_get(pdev, rockchip); + if (ret) + return ret; + + /* DON'T MOVE ME: must be enable before PHY init */ + rockchip->vpcie3v3 = devm_regulator_get_optional(dev, "vpcie3v3"); + if (IS_ERR(rockchip->vpcie3v3)) + if (PTR_ERR(rockchip->vpcie3v3) != -ENODEV) + return dev_err_probe(dev, PTR_ERR(rockchip->vpcie3v3), + "failed to get vpcie3v3 regulator\n"); + + ret = regulator_enable(rockchip->vpcie3v3); + if (ret) { + dev_err(dev, "failed to enable vpcie3v3 regulator\n"); + return ret; + } + + ret = rockchip_pcie_phy_init(rockchip); + if (ret) + goto disable_regulator; + + ret = rockchip_pcie_reset_control_release(rockchip); + if (ret) + goto deinit_phy; + + ret = rockchip_pcie_clk_init(rockchip); + if (ret) + goto deinit_phy; + + ret = dw_pcie_host_init(pp); + if (!ret) + return 0; + + clk_bulk_disable_unprepare(rockchip->clk_cnt, rockchip->clks); +deinit_phy: + rockchip_pcie_phy_deinit(rockchip); +disable_regulator: + regulator_disable(rockchip->vpcie3v3); + + return ret; +} + +static const struct of_device_id rockchip_pcie_of_match[] = { + { .compatible = "rockchip,rk3568-pcie", }, + {}, +}; + +static struct platform_driver rockchip_pcie_driver = { + .driver = { + .name = "rockchip-dw-pcie", + .of_match_table = rockchip_pcie_of_match, + .suppress_bind_attrs = true, + }, + .probe = rockchip_pcie_probe, +}; +builtin_platform_driver(rockchip_pcie_driver); -- 2.25.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=-17.1 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,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 43252C2B9F4 for ; Fri, 25 Jun 2021 06:55:46 +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 B18E7613F3 for ; Fri, 25 Jun 2021 06:55:45 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B18E7613F3 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=rock-chips.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-rockchip-bounces+linux-rockchip=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.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:Message-Id:Date:Subject:Cc :To:From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References: List-Owner; bh=GnMqGQfrmUBO755akUBMFaqTL1POSEp4nI13ddEFV54=; b=DW7Y+Mlp6Uq8HP 1oH1x3u5qMKrglERiOPdLofkaHaTZ2UnkcWdh/7jVEp0xTlfuel/UDSb0+9cBWJTW6Py0k4ko6f8F i3I9Ug2TfcuFjgH4C8SA6L9DulCjeYT3seQlkPMTisE4q0Wb2XZetLMPAQTUDiSL1pF9OP0LKR19m UNVM4n/Hkj+FqczpNeSS/18zMFrV80h56clUmaYTm+MH4mLFqYIg5NwOxeeOBpA89KwMpPyXepUGm 0/zzUpgHpD3OcOt/ZCyjIgbjjxHHOV6MxzlJdMRWENmHTEo1INAkXDYcXv7+rjn1nfzWZ+3kxsr4h usQEIixDknbUywcjh2Xg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1lwfkT-00HUMx-Vw; Fri, 25 Jun 2021 06:55:34 +0000 Received: from regular1.263xmail.com ([211.150.70.203]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1lwfkQ-00HUMM-A3 for linux-rockchip@lists.infradead.org; Fri, 25 Jun 2021 06:55:33 +0000 Received: from localhost (unknown [192.168.167.13]) by regular1.263xmail.com (Postfix) with ESMTP id D0C1A8DC; Fri, 25 Jun 2021 14:55:22 +0800 (CST) X-MAIL-GRAY: 0 X-MAIL-DELIVERY: 1 X-ADDR-CHECKED4: 1 X-SKE-CHECKED: 1 X-ABS-CHECKED: 1 X-ANTISPAM-LEVEL: 2 Received: from xxm-vm.localdomain (unknown [58.22.7.114]) by smtp.263.net (postfix) whith ESMTP id P30156T139874253620992S1624604118052833_; Fri, 25 Jun 2021 14:55:21 +0800 (CST) X-IP-DOMAINF: 1 X-UNIQUE-TAG: <25abb18687147f0a6a8bbc0f2da15c2e> X-RL-SENDER: xxm@rock-chips.com X-SENDER: xxm@rock-chips.com X-LOGIN-NAME: xxm@rock-chips.com X-FST-TO: bhelgaas@google.com X-RCPT-COUNT: 12 X-SENDER-IP: 58.22.7.114 X-ATTACHMENT-NUM: 0 X-System-Flag: 0 From: Simon Xue To: Bjorn Helgaas , Lorenzo Pieralisi Cc: linux-pci@vger.kernel.org, linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, robh+dt@kernel.org, Johan Jonker , Heiko Stuebner , Simon Xue , Peter Geis , Kever Yang , Shawn Lin Subject: [PATCH v11] PCI: rockchip-dwc: Add Rockchip RK356X host controller driver Date: Fri, 25 Jun 2021 14:55:11 +0800 Message-Id: <20210625065511.1096935-1-xxm@rock-chips.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210624_235530_735971_AFDF386A X-CRM114-Status: GOOD ( 26.41 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org QWRkIGEgZHJpdmVyIGZvciB0aGUgRGVzaWduV2FyZS1iYXNlZCBQQ0llIGNvbnRyb2xsZXIgZm91 bmQgb24KUkszNTZYLiBUaGUgZXhpc3RpbmcgcGNpZS1yb2NrY2hpcC1ob3N0IGRyaXZlciBpcyBv bmx5IHVzZWQgZm9yCnRoZSBSb2NrY2hpcC1kZXNpZ25lZCBJUCBmb3VuZCBvbiBSSzMzOTkuCgpU ZXN0ZWQtYnk6IFBldGVyIEdlaXMgPHBnd2lwZW91dEBnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBL ZXZlciBZYW5nIDxrZXZlci55YW5nQHJvY2stY2hpcHMuY29tPgpTaWduZWQtb2ZmLWJ5OiBTaW1v biBYdWUgPHh4bUByb2NrLWNoaXBzLmNvbT4KU2lnbmVkLW9mZi1ieTogU2hhd24gTGluIDxzaGF3 bi5saW5Acm9jay1jaGlwcy5jb20+Ci0tLQogZHJpdmVycy9wY2kvY29udHJvbGxlci9kd2MvS2Nv bmZpZyAgICAgICAgICAgIHwgIDExICsKIGRyaXZlcnMvcGNpL2NvbnRyb2xsZXIvZHdjL01ha2Vm aWxlICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3BjaS9jb250cm9sbGVyL2R3Yy9wY2llLWR3 LXJvY2tjaGlwLmMgfCAyNzYgKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDI4 OCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9wY2kvY29udHJvbGxl ci9kd2MvcGNpZS1kdy1yb2NrY2hpcC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvY29udHJv bGxlci9kd2MvS2NvbmZpZyBiL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvZHdjL0tjb25maWcKaW5k ZXggNDIzZDM1ODcyY2U0Li42MGQzZGRlOWNhMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2Nv bnRyb2xsZXIvZHdjL0tjb25maWcKKysrIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9kd2MvS2Nv bmZpZwpAQCAtMjE0LDYgKzIxNCwxNyBAQCBjb25maWcgUENJRV9BUlRQRUM2X0VQCiAJICBFbmFi bGVzIHN1cHBvcnQgZm9yIHRoZSBQQ0llIGNvbnRyb2xsZXIgaW4gdGhlIEFSVFBFQy02IFNvQyB0 byB3b3JrIGluCiAJICBlbmRwb2ludCBtb2RlLiBUaGlzIHVzZXMgdGhlIERlc2lnbldhcmUgY29y ZS4KIAorY29uZmlnIFBDSUVfUk9DS0NISVBfRFdfSE9TVAorCWJvb2wgIlJvY2tjaGlwIERlc2ln bldhcmUgUENJZSBjb250cm9sbGVyIgorCXNlbGVjdCBQQ0lFX0RXCisJc2VsZWN0IFBDSUVfRFdf SE9TVAorCWRlcGVuZHMgb24gUENJX01TSV9JUlFfRE9NQUlOCisJZGVwZW5kcyBvbiBBUkNIX1JP Q0tDSElQIHx8IENPTVBJTEVfVEVTVAorCWRlcGVuZHMgb24gT0YKKwloZWxwCisJICBFbmFibGVz IHN1cHBvcnQgZm9yIHRoZSBEZXNpZ25XYXJlIFBDSWUgY29udHJvbGxlciBpbiB0aGUKKwkgIFJv Y2tjaGlwIFNvQyBleGNlcHQgUkszMzk5LgorCiBjb25maWcgUENJRV9JTlRFTF9HVwogCWJvb2wg IkludGVsIEdhdGV3YXkgUENJZSBob3N0IGNvbnRyb2xsZXIgc3VwcG9ydCIKIAlkZXBlbmRzIG9u IE9GICYmIChYODYgfHwgQ09NUElMRV9URVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvY29u dHJvbGxlci9kd2MvTWFrZWZpbGUgYi9kcml2ZXJzL3BjaS9jb250cm9sbGVyL2R3Yy9NYWtlZmls ZQppbmRleCA5ZTZjZTBkYzJmNTMuLjM3MTBlOTE0NzFmNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9w Y2kvY29udHJvbGxlci9kd2MvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9k d2MvTWFrZWZpbGUKQEAgLTE0LDYgKzE0LDcgQEAgb2JqLSQoQ09ORklHX1BDSV9MQVlFUlNDQVBF X0VQKSArPSBwY2ktbGF5ZXJzY2FwZS1lcC5vCiBvYmotJChDT05GSUdfUENJRV9RQ09NKSArPSBw Y2llLXFjb20ubwogb2JqLSQoQ09ORklHX1BDSUVfQVJNQURBXzhLKSArPSBwY2llLWFybWFkYThr Lm8KIG9iai0kKENPTkZJR19QQ0lFX0FSVFBFQzYpICs9IHBjaWUtYXJ0cGVjNi5vCitvYmotJChD T05GSUdfUENJRV9ST0NLQ0hJUF9EV19IT1NUKSArPSBwY2llLWR3LXJvY2tjaGlwLm8KIG9iai0k KENPTkZJR19QQ0lFX0lOVEVMX0dXKSArPSBwY2llLWludGVsLWd3Lm8KIG9iai0kKENPTkZJR19Q Q0lFX0tJUklOKSArPSBwY2llLWtpcmluLm8KIG9iai0kKENPTkZJR19QQ0lFX0hJU0lfU1RCKSAr PSBwY2llLWhpc3RiLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvZHdjL3Bj aWUtZHctcm9ja2NoaXAuYyBiL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvZHdjL3BjaWUtZHctcm9j a2NoaXAuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjIwY2VmMmUw NmY2NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvZHdjL3BjaWUt ZHctcm9ja2NoaXAuYwpAQCAtMCwwICsxLDI3NiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAKKy8qCisgKiBQQ0llIGhvc3QgY29udHJvbGxlciBkcml2ZXIgZm9yIFJvY2tj aGlwIFNvQ3MuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDIxIFJvY2tjaGlwIEVsZWN0cm9uaWNz IENvLiwgTHRkLgorICoJCWh0dHA6Ly93d3cucm9jay1jaGlwcy5jb20KKyAqCisgKiBBdXRob3I6 IFNpbW9uIFh1ZSA8eHhtQHJvY2stY2hpcHMuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9j bGsuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvL2NvbnN1bWVyLmg+CisjaW5jbHVkZSA8bGludXgv bWZkL3N5c2Nvbi5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4 L29mX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BoeS9waHkuaD4KKyNpbmNsdWRlIDxsaW51 eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKyNpbmNsdWRl IDxsaW51eC9yZXNldC5oPgorCisjaW5jbHVkZSAicGNpZS1kZXNpZ253YXJlLmgiCisKKy8qCisg KiBUaGUgdXBwZXIgMTYgYml0cyBvZiBQQ0lFX0NMSUVOVF9DT05GSUcgYXJlIGEgd3JpdGUKKyAq IG1hc2sgZm9yIHRoZSBsb3dlciAxNiBiaXRzLgorICovCisjZGVmaW5lIEhJV09SRF9VUERBVEUo bWFzaywgdmFsKSAoKChtYXNrKSA8PCAxNikgfCAodmFsKSkKKyNkZWZpbmUgSElXT1JEX1VQREFU RV9CSVQodmFsKQlISVdPUkRfVVBEQVRFKHZhbCwgdmFsKQorCisjZGVmaW5lIHRvX3JvY2tjaGlw X3BjaWUoeCkgZGV2X2dldF9kcnZkYXRhKCh4KS0+ZGV2KQorCisjZGVmaW5lIFBDSUVfQ0xJRU5U X1JDX01PREUJCUhJV09SRF9VUERBVEVfQklUKDB4NDApCisjZGVmaW5lIFBDSUVfQ0xJRU5UX0VO QUJMRV9MVFNTTQlISVdPUkRfVVBEQVRFX0JJVCgweGMpCisjZGVmaW5lIFBDSUVfU01MSF9MSU5L VVAJCUJJVCgxNikKKyNkZWZpbmUgUENJRV9SRExIX0xJTktVUAkJQklUKDE3KQorI2RlZmluZSBQ Q0lFX0xJTktVUAkJCShQQ0lFX1NNTEhfTElOS1VQIHwgUENJRV9SRExIX0xJTktVUCkKKyNkZWZp bmUgUENJRV9MMFNfRU5UUlkJCQkweDExCisjZGVmaW5lIFBDSUVfQ0xJRU5UX0dFTkVSQUxfQ09O VFJPTAkweDAKKyNkZWZpbmUgUENJRV9DTElFTlRfR0VORVJBTF9ERUJVRwkweDEwNAorI2RlZmlu ZSBQQ0lFX0NMSUVOVF9IT1RfUkVTRVRfQ1RSTCAgICAgIDB4MTgwCisjZGVmaW5lIFBDSUVfQ0xJ RU5UX0xUU1NNX1NUQVRVUwkweDMwMAorI2RlZmluZSBQQ0lFX0xUU1NNX0VOQUJMRV9FTkhBTkNF ICAgICAgIEJJVCg0KQorI2RlZmluZSBQQ0lFX0xUU1NNX1NUQVRVU19NQVNLCQlHRU5NQVNLKDUs IDApCisKK3N0cnVjdCByb2NrY2hpcF9wY2llIHsKKwlzdHJ1Y3QgZHdfcGNpZQkJCXBjaTsKKwl2 b2lkIF9faW9tZW0JCQkqYXBiX2Jhc2U7CisJc3RydWN0IHBoeQkJCSpwaHk7CisJc3RydWN0IGNs a19idWxrX2RhdGEJCSpjbGtzOworCXVuc2lnbmVkIGludAkJCWNsa19jbnQ7CisJc3RydWN0IHJl c2V0X2NvbnRyb2wJCSpyc3Q7CisJc3RydWN0IGdwaW9fZGVzYwkJKnJzdF9ncGlvOworCXN0cnVj dCByZWd1bGF0b3IgICAgICAgICAgICAgICAgKnZwY2llM3YzOworfTsKKworc3RhdGljIGludCBy b2NrY2hpcF9wY2llX3JlYWRsX2FwYihzdHJ1Y3Qgcm9ja2NoaXBfcGNpZSAqcm9ja2NoaXAsCisJ CQkJCSAgICAgdTMyIHJlZykKK3sKKwlyZXR1cm4gcmVhZGxfcmVsYXhlZChyb2NrY2hpcC0+YXBi X2Jhc2UgKyByZWcpOworfQorCitzdGF0aWMgdm9pZCByb2NrY2hpcF9wY2llX3dyaXRlbF9hcGIo c3RydWN0IHJvY2tjaGlwX3BjaWUgKnJvY2tjaGlwLAorCQkJCQkJdTMyIHZhbCwgdTMyIHJlZykK K3sKKwl3cml0ZWxfcmVsYXhlZCh2YWwsIHJvY2tjaGlwLT5hcGJfYmFzZSArIHJlZyk7Cit9CisK K3N0YXRpYyB2b2lkIHJvY2tjaGlwX3BjaWVfZW5hYmxlX2x0c3NtKHN0cnVjdCByb2NrY2hpcF9w Y2llICpyb2NrY2hpcCkKK3sKKwlyb2NrY2hpcF9wY2llX3dyaXRlbF9hcGIocm9ja2NoaXAsIFBD SUVfQ0xJRU5UX0VOQUJMRV9MVFNTTSwKKwkJCQkgUENJRV9DTElFTlRfR0VORVJBTF9DT05UUk9M KTsKK30KKworc3RhdGljIGludCByb2NrY2hpcF9wY2llX2xpbmtfdXAoc3RydWN0IGR3X3BjaWUg KnBjaSkKK3sKKwlzdHJ1Y3Qgcm9ja2NoaXBfcGNpZSAqcm9ja2NoaXAgPSB0b19yb2NrY2hpcF9w Y2llKHBjaSk7CisJdTMyIHZhbCA9IHJvY2tjaGlwX3BjaWVfcmVhZGxfYXBiKHJvY2tjaGlwLCBQ Q0lFX0NMSUVOVF9MVFNTTV9TVEFUVVMpOworCisJaWYgKCh2YWwgJiBQQ0lFX0xJTktVUCkgPT0g UENJRV9MSU5LVVAgJiYKKwkgICAgKHZhbCAmIFBDSUVfTFRTU01fU1RBVFVTX01BU0spID09IFBD SUVfTDBTX0VOVFJZKQorCQlyZXR1cm4gMTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50 IHJvY2tjaGlwX3BjaWVfc3RhcnRfbGluayhzdHJ1Y3QgZHdfcGNpZSAqcGNpKQoreworCXN0cnVj dCByb2NrY2hpcF9wY2llICpyb2NrY2hpcCA9IHRvX3JvY2tjaGlwX3BjaWUocGNpKTsKKworCS8q IFJlc2V0IGRldmljZSAqLworCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChyb2NrY2hpcC0+cnN0 X2dwaW8sIDApOworCisJcm9ja2NoaXBfcGNpZV9lbmFibGVfbHRzc20ocm9ja2NoaXApOworCisJ LyoKKwkgKiBQQ0llIHJlcXVpcmVzIHRoZSByZWZjbGsgdG8gYmUgc3RhYmxlIGZvciAxMDDCtXMg cHJpb3IgdG8gcmVsZWFzaW5nCisJICogUEVSU1QuIFNlZSB0YWJsZSAyLTQgaW4gc2VjdGlvbiAy LjYuMiBBQyBTcGVjaWZpY2F0aW9ucyBvZiB0aGUgUENJCisJICogRXhwcmVzcyBDYXJkIEVsZWN0 cm9tZWNoYW5pY2FsIFNwZWNpZmljYXRpb24sIDEuMS4gSG93ZXZlciwgd2UgZG9uJ3QKKwkgKiBr bm93IGlmIHRoZSByZWZjbGsgaXMgY29taW5nIGZyb20gUkMncyBQSFkgb3IgZXh0ZXJuYWwgT1ND LiBJZiBpdCdzCisJICogZnJvbSBSQywgc28gZW5hYmxpbmcgTFRTU00gaXMgdGhlIGp1c3Qgcmln aHQgcGxhY2UgdG8gcmVsZWFzZSAjUEVSU1QuCisJICogV2UgbmVlZCBtb3JlIGV4dHJhIHRpbWUg YXMgYmVmb3JlLCByYXRoZXIgdGhhbiBzZXR0aW5nIGp1c3QKKwkgKiAxMDB1cyBhcyB3ZSBkb24n dCBrbm93IGhvdyBsb25nIHNob3VsZCB0aGUgZGV2aWNlIG5lZWQgdG8gcmVzZXQuCisJICovCisJ bXNsZWVwKDEwMCk7CisJZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKHJvY2tjaGlwLT5yc3RfZ3Bp bywgMSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCByb2NrY2hpcF9wY2llX2hvc3Rf aW5pdChzdHJ1Y3QgcGNpZV9wb3J0ICpwcCkKK3sKKwlzdHJ1Y3QgZHdfcGNpZSAqcGNpID0gdG9f ZHdfcGNpZV9mcm9tX3BwKHBwKTsKKwlzdHJ1Y3Qgcm9ja2NoaXBfcGNpZSAqcm9ja2NoaXAgPSB0 b19yb2NrY2hpcF9wY2llKHBjaSk7CisJdTMyIHZhbCA9IEhJV09SRF9VUERBVEVfQklUKFBDSUVf TFRTU01fRU5BQkxFX0VOSEFOQ0UpOworCisJLyogTFRTU00gZW5hYmxlIGNvbnRyb2wgbW9kZSAq LworCXJvY2tjaGlwX3BjaWVfd3JpdGVsX2FwYihyb2NrY2hpcCwgdmFsLCBQQ0lFX0NMSUVOVF9I T1RfUkVTRVRfQ1RSTCk7CisKKwlyb2NrY2hpcF9wY2llX3dyaXRlbF9hcGIocm9ja2NoaXAsIFBD SUVfQ0xJRU5UX1JDX01PREUsCisJCQkJIFBDSUVfQ0xJRU5UX0dFTkVSQUxfQ09OVFJPTCk7CisK KwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkd19wY2llX2hvc3Rfb3BzIHJv Y2tjaGlwX3BjaWVfaG9zdF9vcHMgPSB7CisJLmhvc3RfaW5pdCA9IHJvY2tjaGlwX3BjaWVfaG9z dF9pbml0LAorfTsKKworc3RhdGljIGludCByb2NrY2hpcF9wY2llX2Nsa19pbml0KHN0cnVjdCBy b2NrY2hpcF9wY2llICpyb2NrY2hpcCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSByb2NrY2hp cC0+cGNpLmRldjsKKwlpbnQgcmV0OworCisJcmV0ID0gZGV2bV9jbGtfYnVsa19nZXRfYWxsKGRl diwgJnJvY2tjaGlwLT5jbGtzKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXJv Y2tjaGlwLT5jbGtfY250ID0gcmV0OworCisJcmV0dXJuIGNsa19idWxrX3ByZXBhcmVfZW5hYmxl KHJvY2tjaGlwLT5jbGtfY250LCByb2NrY2hpcC0+Y2xrcyk7Cit9CisKK3N0YXRpYyBpbnQgcm9j a2NoaXBfcGNpZV9yZXNvdXJjZV9nZXQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKKwkJ CQkgICAgICBzdHJ1Y3Qgcm9ja2NoaXBfcGNpZSAqcm9ja2NoaXApCit7CisJcm9ja2NoaXAtPmFw Yl9iYXNlID0gZGV2bV9wbGF0Zm9ybV9pb3JlbWFwX3Jlc291cmNlX2J5bmFtZShwZGV2LCAiYXBi Iik7CisJaWYgKElTX0VSUihyb2NrY2hpcC0+YXBiX2Jhc2UpKQorCQlyZXR1cm4gUFRSX0VSUihy b2NrY2hpcC0+YXBiX2Jhc2UpOworCisJcm9ja2NoaXAtPnJzdF9ncGlvID0gZGV2bV9ncGlvZF9n ZXRfb3B0aW9uYWwoJnBkZXYtPmRldiwgInJlc2V0IiwKKwkJCQkJCSAgICAgR1BJT0RfT1VUX0hJ R0gpOworCWlmIChJU19FUlIocm9ja2NoaXAtPnJzdF9ncGlvKSkKKwkJcmV0dXJuIFBUUl9FUlIo cm9ja2NoaXAtPnJzdF9ncGlvKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHJvY2tj aGlwX3BjaWVfcGh5X2luaXQoc3RydWN0IHJvY2tjaGlwX3BjaWUgKnJvY2tjaGlwKQoreworCXN0 cnVjdCBkZXZpY2UgKmRldiA9IHJvY2tjaGlwLT5wY2kuZGV2OworCWludCByZXQ7CisKKwlyb2Nr Y2hpcC0+cGh5ID0gZGV2bV9waHlfZ2V0KGRldiwgInBjaWUtcGh5Iik7CisJaWYgKElTX0VSUihy b2NrY2hpcC0+cGh5KSkKKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCBQVFJfRVJSKHJvY2tj aGlwLT5waHkpLAorCQkJCSAgICAgIm1pc3NpbmcgUEhZXG4iKTsKKworCXJldCA9IHBoeV9pbml0 KHJvY2tjaGlwLT5waHkpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJcmV0ID0g cGh5X3Bvd2VyX29uKHJvY2tjaGlwLT5waHkpOworCWlmIChyZXQpCisJCXBoeV9leGl0KHJvY2tj aGlwLT5waHkpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgcm9ja2NoaXBfcGNp ZV9waHlfZGVpbml0KHN0cnVjdCByb2NrY2hpcF9wY2llICpyb2NrY2hpcCkKK3sKKwlwaHlfZXhp dChyb2NrY2hpcC0+cGh5KTsKKwlwaHlfcG93ZXJfb2ZmKHJvY2tjaGlwLT5waHkpOworfQorCitz dGF0aWMgaW50IHJvY2tjaGlwX3BjaWVfcmVzZXRfY29udHJvbF9yZWxlYXNlKHN0cnVjdCByb2Nr Y2hpcF9wY2llICpyb2NrY2hpcCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSByb2NrY2hpcC0+ cGNpLmRldjsKKworCXJvY2tjaGlwLT5yc3QgPSBkZXZtX3Jlc2V0X2NvbnRyb2xfYXJyYXlfZ2V0 X2V4Y2x1c2l2ZShkZXYpOworCWlmIChJU19FUlIocm9ja2NoaXAtPnJzdCkpCisJCXJldHVybiBk ZXZfZXJyX3Byb2JlKGRldiwgUFRSX0VSUihyb2NrY2hpcC0+cnN0KSwKKwkJCQkgICAgICJmYWls ZWQgdG8gZ2V0IHJlc2V0IGxpbmVzXG4iKTsKKworCXJldHVybiByZXNldF9jb250cm9sX2RlYXNz ZXJ0KHJvY2tjaGlwLT5yc3QpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGR3X3BjaWVfb3Bz IGR3X3BjaWVfb3BzID0geworCS5saW5rX3VwID0gcm9ja2NoaXBfcGNpZV9saW5rX3VwLAorCS5z dGFydF9saW5rID0gcm9ja2NoaXBfcGNpZV9zdGFydF9saW5rLAorfTsKKworc3RhdGljIGludCBy b2NrY2hpcF9wY2llX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3Ry dWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3Qgcm9ja2NoaXBfcGNpZSAqcm9j a2NoaXA7CisJc3RydWN0IHBjaWVfcG9ydCAqcHA7CisJaW50IHJldDsKKworCXJvY2tjaGlwID0g ZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpyb2NrY2hpcCksIEdGUF9LRVJORUwpOworCWlmICgh cm9ja2NoaXApCisJCXJldHVybiAtRU5PTUVNOworCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRl diwgcm9ja2NoaXApOworCisJcm9ja2NoaXAtPnBjaS5kZXYgPSBkZXY7CisJcm9ja2NoaXAtPnBj aS5vcHMgPSAmZHdfcGNpZV9vcHM7CisKKwlwcCA9ICZyb2NrY2hpcC0+cGNpLnBwOworCXBwLT5v cHMgPSAmcm9ja2NoaXBfcGNpZV9ob3N0X29wczsKKworCXJldCA9IHJvY2tjaGlwX3BjaWVfcmVz b3VyY2VfZ2V0KHBkZXYsIHJvY2tjaGlwKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJ LyogRE9OJ1QgTU9WRSBNRTogbXVzdCBiZSBlbmFibGUgYmVmb3JlIFBIWSBpbml0ICovCisJcm9j a2NoaXAtPnZwY2llM3YzID0gZGV2bV9yZWd1bGF0b3JfZ2V0X29wdGlvbmFsKGRldiwgInZwY2ll M3YzIik7CisJaWYgKElTX0VSUihyb2NrY2hpcC0+dnBjaWUzdjMpKQorCQlpZiAoUFRSX0VSUihy b2NrY2hpcC0+dnBjaWUzdjMpICE9IC1FTk9ERVYpCisJCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShk ZXYsIFBUUl9FUlIocm9ja2NoaXAtPnZwY2llM3YzKSwKKwkJCQkJImZhaWxlZCB0byBnZXQgdnBj aWUzdjMgcmVndWxhdG9yXG4iKTsKKworCXJldCA9IHJlZ3VsYXRvcl9lbmFibGUocm9ja2NoaXAt PnZwY2llM3YzKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGVuYWJs ZSB2cGNpZTN2MyByZWd1bGF0b3JcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCXJldCA9IHJv Y2tjaGlwX3BjaWVfcGh5X2luaXQocm9ja2NoaXApOworCWlmIChyZXQpCisJCWdvdG8gZGlzYWJs ZV9yZWd1bGF0b3I7CisKKwlyZXQgPSByb2NrY2hpcF9wY2llX3Jlc2V0X2NvbnRyb2xfcmVsZWFz ZShyb2NrY2hpcCk7CisJaWYgKHJldCkKKwkJZ290byBkZWluaXRfcGh5OworCisJcmV0ID0gcm9j a2NoaXBfcGNpZV9jbGtfaW5pdChyb2NrY2hpcCk7CisJaWYgKHJldCkKKwkJZ290byBkZWluaXRf cGh5OworCisJcmV0ID0gZHdfcGNpZV9ob3N0X2luaXQocHApOworCWlmICghcmV0KQorCQlyZXR1 cm4gMDsKKworCWNsa19idWxrX2Rpc2FibGVfdW5wcmVwYXJlKHJvY2tjaGlwLT5jbGtfY250LCBy b2NrY2hpcC0+Y2xrcyk7CitkZWluaXRfcGh5OgorCXJvY2tjaGlwX3BjaWVfcGh5X2RlaW5pdChy b2NrY2hpcCk7CitkaXNhYmxlX3JlZ3VsYXRvcjoKKwlyZWd1bGF0b3JfZGlzYWJsZShyb2NrY2hp cC0+dnBjaWUzdjMpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBv Zl9kZXZpY2VfaWQgcm9ja2NoaXBfcGNpZV9vZl9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUg PSAicm9ja2NoaXAscmszNTY4LXBjaWUiLCB9LAorCXt9LAorfTsKKworc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kcml2ZXIgcm9ja2NoaXBfcGNpZV9kcml2ZXIgPSB7CisJLmRyaXZlciA9IHsKKwkJ Lm5hbWUJPSAicm9ja2NoaXAtZHctcGNpZSIsCisJCS5vZl9tYXRjaF90YWJsZSA9IHJvY2tjaGlw X3BjaWVfb2ZfbWF0Y2gsCisJCS5zdXBwcmVzc19iaW5kX2F0dHJzID0gdHJ1ZSwKKwl9LAorCS5w cm9iZSA9IHJvY2tjaGlwX3BjaWVfcHJvYmUsCit9OworYnVpbHRpbl9wbGF0Zm9ybV9kcml2ZXIo cm9ja2NoaXBfcGNpZV9kcml2ZXIpOwotLSAKMi4yNS4xCgoKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1yb2NrY2hpcCBtYWlsaW5nIGxpc3QK TGludXgtcm9ja2NoaXBAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFk Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJvY2tjaGlwCg==