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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 65DB7C6FA82 for ; Tue, 27 Sep 2022 14:19:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231703AbiI0OTp (ORCPT ); Tue, 27 Sep 2022 10:19:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53282 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232022AbiI0OTm (ORCPT ); Tue, 27 Sep 2022 10:19:42 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 148614B4B5 for ; Tue, 27 Sep 2022 07:19:36 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id A749C619EF for ; Tue, 27 Sep 2022 14:19:35 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 72F8CC433B5; Tue, 27 Sep 2022 14:19:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1664288375; bh=vMseaGF7YcKRjNhEJUiDiek5OZEHpO6bmBoVzrBANUo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=QKPycydpKppRHX1GZUWHh0MNyunc2MuOvAfkpbAgOFNf0//D4tYx8PIc9v6zHfgC2 GGGmc8ZVrLhfBitjIR69iP4YluSTfQ5sP1A4om8RF4izHhAyv7eyutL3b+te+1GrO3 7pg9NKZCDbONp0rrcHxHG9EekEiAgrqNhncV4S4I3W77CSOKy5oSWh3ED+YkYJyFmE vAdI3rDBxVQvZvR9co/AOq4p0wIMroJFhLKR+zTT1OQ0Rt2xnO0rzgFkFt4t9/OA/I rmyJ1gk8LVXSjpqEKuWCjbnk2xUx43xun4/q2kXp35RU5OYXJr5sDiF1J0YyaqPL1k H4jDoDGRUJzWA== From: =?UTF-8?q?Marek=20Beh=C3=BAn?= To: Lorenzo Pieralisi Cc: Bjorn Helgaas , Gregory CLEMENT , pali@kernel.org, =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, =?UTF-8?q?Marek=20Beh=C3=BAn?= Subject: [PATCH v2 02/10] PCI: aardvark: Add support for DLLSC and hotplug interrupt Date: Tue, 27 Sep 2022 16:19:18 +0200 Message-Id: <20220927141926.8895-3-kabel@kernel.org> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220927141926.8895-1-kabel@kernel.org> References: <20220927141926.8895-1-kabel@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org From: Pali Rohár Add support for Data Link Layer State Change in the emulated slot registers and hotplug interrupt via the emulated root bridge. DLLSC is needed by the pciehp driver, which handles hotplug, but also link state change events. AFAIK no Aardvark devices support hotplug, but link state change events are required for graceful driver unbinding in case of a link down event. So with this change we achieve graceful driver unbind for example when WiFi card PCIe link goes down (we've seen this with ath10k and mt76 WiFi cards). Before the WiFi driver started spitting out errors, or even taking the whole system down. Link down state change can be implemented because Aardvark supports Link Down event interrupt. After the link goes down, it can come up again (if the WiFi card can recover or if reset pin is used to reset the card). Because of this we need to be able to recognize link up event. Since AFAIK Aardvark does not have interrupt for link up event, the best thing we can do is simulate it - whenever we read the link state and find it is up, and have cached value saying it is down, we trigger the link up event. We read link state in the advk_pcie_link_up() function, which is called for example whenever the configuration space is read (i.e. when writing 1 to /sys/bus/pci/rescan). We add the triggering of Hot-Plug Interrupt from this function. Although not ideal, it is better than nothing. Since advk_pcie_link_up() is not called from an interrupt handler, we cannot call generic_handle_domain_irq() from it directly. So instead we schedule the triggering via an IRQSAFE timer as soon as possible: at jiffies + 1. This ensures that generic_handle_domain_irq() is called from within a safe context. (Note that the timer is not a periodic timer - we do not call the handler every jiffy. We just schedule the calling once, at the next jiffy.) (We haven't been able to find any documentation for a Link Up interrupt on Aardvark, but it is possible there is one, in some undocumented register. If we manage to find this information, this can be rewritten.) Signed-off-by: Pali Rohár Signed-off-by: Marek Behún --- Changes since batch 6 v1: - more explanation in commit message Changes since batch 5: - changed commit message (add paragraph about why the change is needed) - select hotplug and pcieportbus in Kconfig --- drivers/pci/controller/Kconfig | 3 + drivers/pci/controller/pci-aardvark.c | 101 ++++++++++++++++++++++++-- 2 files changed, 99 insertions(+), 5 deletions(-) diff --git a/drivers/pci/controller/Kconfig b/drivers/pci/controller/Kconfig index d1c5fcf00a8a..5e8a84f5c654 100644 --- a/drivers/pci/controller/Kconfig +++ b/drivers/pci/controller/Kconfig @@ -21,6 +21,9 @@ config PCI_AARDVARK depends on OF depends on PCI_MSI_IRQ_DOMAIN select PCI_BRIDGE_EMUL + select PCIEPORTBUS + select HOTPLUG_PCI + select HOTPLUG_PCI_PCIE help Add support for Aardvark 64bit PCIe Host Controller. This controller is part of the South Bridge of the Marvel Armada diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c index 966c8b48bd96..31da28ebc5d1 100644 --- a/drivers/pci/controller/pci-aardvark.c +++ b/drivers/pci/controller/pci-aardvark.c @@ -25,6 +25,7 @@ #include #include #include +#include #include "../pci.h" #include "../pci-bridge-emul.h" @@ -100,6 +101,7 @@ #define PCIE_MSG_PM_PME_MASK BIT(7) #define PCIE_ISR0_MASK_REG (CONTROL_BASE_ADDR + 0x44) #define PCIE_ISR0_MSI_INT_PENDING BIT(24) +#define PCIE_ISR0_LINK_DOWN BIT(1) #define PCIE_ISR0_CORR_ERR BIT(11) #define PCIE_ISR0_NFAT_ERR BIT(12) #define PCIE_ISR0_FAT_ERR BIT(13) @@ -284,6 +286,8 @@ struct advk_pcie { DECLARE_BITMAP(msi_used, MSI_IRQ_NUM); struct mutex msi_used_lock; int link_gen; + bool link_was_up; + struct timer_list link_irq_timer; struct pci_bridge_emul bridge; struct gpio_desc *reset_gpio; struct phy *phy; @@ -313,7 +317,24 @@ static inline bool advk_pcie_link_up(struct advk_pcie *pcie) { /* check if LTSSM is in normal operation - some L* state */ u8 ltssm_state = advk_pcie_ltssm_state(pcie); - return ltssm_state >= LTSSM_L0 && ltssm_state < LTSSM_DISABLED; + bool link_is_up; + u16 slotsta; + + link_is_up = ltssm_state >= LTSSM_L0 && ltssm_state < LTSSM_DISABLED; + + if (link_is_up && !pcie->link_was_up) { + dev_info(&pcie->pdev->dev, "link up\n"); + + pcie->link_was_up = true; + + slotsta = le16_to_cpu(pcie->bridge.pcie_conf.slotsta); + slotsta |= PCI_EXP_SLTSTA_DLLSC; + pcie->bridge.pcie_conf.slotsta = cpu_to_le16(slotsta); + + mod_timer(&pcie->link_irq_timer, jiffies + 1); + } + + return link_is_up; } static inline bool advk_pcie_link_active(struct advk_pcie *pcie) @@ -442,8 +463,6 @@ static void advk_pcie_train_link(struct advk_pcie *pcie) ret = advk_pcie_wait_for_link(pcie); if (ret < 0) dev_err(dev, "link never came up\n"); - else - dev_info(dev, "link up\n"); } /* @@ -592,6 +611,11 @@ static void advk_pcie_setup_hw(struct advk_pcie *pcie) reg &= ~PCIE_ISR0_MSI_INT_PENDING; advk_writel(pcie, reg, PCIE_ISR0_MASK_REG); + /* Unmask Link Down interrupt */ + reg = advk_readl(pcie, PCIE_ISR0_MASK_REG); + reg &= ~PCIE_ISR0_LINK_DOWN; + advk_writel(pcie, reg, PCIE_ISR0_MASK_REG); + /* Unmask PME interrupt for processing of PME requester */ reg = advk_readl(pcie, PCIE_ISR0_MASK_REG); reg &= ~PCIE_MSG_PM_PME_MASK; @@ -918,6 +942,14 @@ advk_pci_bridge_emul_pcie_conf_write(struct pci_bridge_emul *bridge, advk_pcie_wait_for_retrain(pcie); break; + case PCI_EXP_SLTCTL: { + u16 slotctl = le16_to_cpu(bridge->pcie_conf.slotctl); + /* Only emulation of HPIE and DLLSCE bits is provided */ + slotctl &= PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_DLLSCE; + bridge->pcie_conf.slotctl = cpu_to_le16(slotctl); + break; + } + case PCI_EXP_RTCTL: { u16 rootctl = le16_to_cpu(bridge->pcie_conf.rootctl); /* Only emulation of PMEIE and CRSSVE bits is provided */ @@ -1035,6 +1067,7 @@ static const struct pci_bridge_emul_ops advk_pci_bridge_emul_ops = { static int advk_sw_pci_bridge_init(struct advk_pcie *pcie) { struct pci_bridge_emul *bridge = &pcie->bridge; + u32 slotcap; bridge->conf.vendor = cpu_to_le16(advk_readl(pcie, PCIE_CORE_DEV_ID_REG) & 0xffff); @@ -1061,6 +1094,13 @@ static int advk_sw_pci_bridge_init(struct advk_pcie *pcie) bridge->pcie_conf.cap = cpu_to_le16(2 | PCI_EXP_FLAGS_SLOT); /* + * Mark bridge as Hot Plug Capable since this is the way how to enable + * delivering of Data Link Layer State Change interrupts. + * + * Set No Command Completed Support because bridge does not support + * Command Completed Interrupt. Every command is executed immediately + * without any delay. + * * Set Presence Detect State bit permanently since there is no support * for unplugging the card nor detecting whether it is plugged. (If a * platform exists in the future that supports it, via a GPIO for @@ -1070,8 +1110,9 @@ static int advk_sw_pci_bridge_init(struct advk_pcie *pcie) * value is reserved for ports within the same silicon as Root Port * which is not our case. */ - bridge->pcie_conf.slotcap = cpu_to_le32(FIELD_PREP(PCI_EXP_SLTCAP_PSN, - 1)); + slotcap = PCI_EXP_SLTCAP_NCCS | PCI_EXP_SLTCAP_HPC | + FIELD_PREP(PCI_EXP_SLTCAP_PSN, 1); + bridge->pcie_conf.slotcap = cpu_to_le32(slotcap); bridge->pcie_conf.slotsta = cpu_to_le16(PCI_EXP_SLTSTA_PDS); /* Indicates supports for Completion Retry Status */ @@ -1568,6 +1609,24 @@ static void advk_pcie_remove_rp_irq_domain(struct advk_pcie *pcie) irq_domain_remove(pcie->rp_irq_domain); } +static void advk_pcie_link_irq_handler(struct timer_list *timer) +{ + struct advk_pcie *pcie = from_timer(pcie, timer, link_irq_timer); + u16 slotctl; + + slotctl = le16_to_cpu(pcie->bridge.pcie_conf.slotctl); + if (!(slotctl & PCI_EXP_SLTCTL_DLLSCE) || + !(slotctl & PCI_EXP_SLTCTL_HPIE)) + return; + + /* + * Aardvark HW returns zero for PCI_EXP_FLAGS_IRQ, so use PCIe + * interrupt 0 + */ + if (generic_handle_domain_irq(pcie->rp_irq_domain, 0) == -EINVAL) + dev_err_ratelimited(&pcie->pdev->dev, "unhandled HP IRQ\n"); +} + static void advk_pcie_handle_pme(struct advk_pcie *pcie) { u32 requester = advk_readl(pcie, PCIE_MSG_LOG_REG) >> 16; @@ -1619,6 +1678,7 @@ static void advk_pcie_handle_int(struct advk_pcie *pcie) { u32 isr0_val, isr0_mask, isr0_status; u32 isr1_val, isr1_mask, isr1_status; + u16 slotsta; int i; isr0_val = advk_readl(pcie, PCIE_ISR0_REG); @@ -1645,6 +1705,26 @@ static void advk_pcie_handle_int(struct advk_pcie *pcie) dev_err_ratelimited(&pcie->pdev->dev, "unhandled ERR IRQ\n"); } + /* Process Link Down interrupt as HP IRQ */ + if (isr0_status & PCIE_ISR0_LINK_DOWN) { + advk_writel(pcie, PCIE_ISR0_LINK_DOWN, PCIE_ISR0_REG); + + dev_info(&pcie->pdev->dev, "link down\n"); + + pcie->link_was_up = false; + + slotsta = le16_to_cpu(pcie->bridge.pcie_conf.slotsta); + slotsta |= PCI_EXP_SLTSTA_DLLSC; + pcie->bridge.pcie_conf.slotsta = cpu_to_le16(slotsta); + + /* + * Deactivate timer and call advk_pcie_link_irq_handler() + * function directly as we are in the interrupt context. + */ + del_timer_sync(&pcie->link_irq_timer); + advk_pcie_link_irq_handler(&pcie->link_irq_timer); + } + /* Process MSI interrupts */ if (isr0_status & PCIE_ISR0_MSI_INT_PENDING) advk_pcie_handle_msi(pcie); @@ -1881,6 +1961,14 @@ static int advk_pcie_probe(struct platform_device *pdev) if (ret) return ret; + /* + * generic_handle_domain_irq() expects local IRQs to be disabled since + * normally it is called from interrupt context, so use TIMER_IRQSAFE + * flag for this link_irq_timer. + */ + timer_setup(&pcie->link_irq_timer, advk_pcie_link_irq_handler, + TIMER_IRQSAFE); + advk_pcie_setup_hw(pcie); ret = advk_sw_pci_bridge_init(pcie); @@ -1969,6 +2057,9 @@ static int advk_pcie_remove(struct platform_device *pdev) advk_pcie_remove_msi_irq_domain(pcie); advk_pcie_remove_irq_domain(pcie); + /* Deactivate link event timer */ + del_timer_sync(&pcie->link_irq_timer); + /* Free config space for emulated root bridge */ pci_bridge_emul_cleanup(&pcie->bridge); -- 2.35.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 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 160F4C54EE9 for ; Tue, 27 Sep 2022 14:21:09 +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:MIME-Version:References:In-Reply-To: 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: List-Owner; bh=unX4EDpgv8K7ZlxSSOJi0/TlPkwDD5sQX7/9lH4vi8I=; b=vSMHPdbFnts9Bf pYn0i2mGZ9hQAQ2tRYSi7Sge0T131K73bbDTGuu5890tnKofK9xy99z2Cxppk8QY2lOgAnHbRXtgS kbCzaQpZGdWyRgAUib/dYxyCaoNtZI3cBr48X4D4aX/AXc7ewUOFxnxKmeVKZ2gCA+5X5bAG3e1MY lp6XfKl79A2Deo+yB+jVvGH6V9h//x/t5dG+wZ9KrGY9Vjk1Cww+LHI1/Bsd0HJ5PEsjH4JUJZgYK VFItUwvF0x91Yqc62X1uEQdQxZHY6C00CJg4pBvXyij8v053lgqcLU02nO0scJZ6ft4ujXdWC3Nse n4nN98UEkDcDrE7y7sdA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1odBRE-00BB8g-WA; Tue, 27 Sep 2022 14:19:57 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1odBQt-00BB0J-MD for linux-arm-kernel@lists.infradead.org; Tue, 27 Sep 2022 14:19:37 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 465D7619F2; Tue, 27 Sep 2022 14:19:35 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 72F8CC433B5; Tue, 27 Sep 2022 14:19:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1664288375; bh=vMseaGF7YcKRjNhEJUiDiek5OZEHpO6bmBoVzrBANUo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=QKPycydpKppRHX1GZUWHh0MNyunc2MuOvAfkpbAgOFNf0//D4tYx8PIc9v6zHfgC2 GGGmc8ZVrLhfBitjIR69iP4YluSTfQ5sP1A4om8RF4izHhAyv7eyutL3b+te+1GrO3 7pg9NKZCDbONp0rrcHxHG9EekEiAgrqNhncV4S4I3W77CSOKy5oSWh3ED+YkYJyFmE vAdI3rDBxVQvZvR9co/AOq4p0wIMroJFhLKR+zTT1OQ0Rt2xnO0rzgFkFt4t9/OA/I rmyJ1gk8LVXSjpqEKuWCjbnk2xUx43xun4/q2kXp35RU5OYXJr5sDiF1J0YyaqPL1k H4jDoDGRUJzWA== From: =?UTF-8?q?Marek=20Beh=C3=BAn?= To: Lorenzo Pieralisi Cc: Bjorn Helgaas , Gregory CLEMENT , pali@kernel.org, =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, =?UTF-8?q?Marek=20Beh=C3=BAn?= Subject: [PATCH v2 02/10] PCI: aardvark: Add support for DLLSC and hotplug interrupt Date: Tue, 27 Sep 2022 16:19:18 +0200 Message-Id: <20220927141926.8895-3-kabel@kernel.org> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220927141926.8895-1-kabel@kernel.org> References: <20220927141926.8895-1-kabel@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220927_071935_833464_C04A014B X-CRM114-Status: GOOD ( 35.13 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org RnJvbTogUGFsaSBSb2jDoXIgPHBhbGlAa2VybmVsLm9yZz4KCkFkZCBzdXBwb3J0IGZvciBEYXRh IExpbmsgTGF5ZXIgU3RhdGUgQ2hhbmdlIGluIHRoZSBlbXVsYXRlZCBzbG90CnJlZ2lzdGVycyBh bmQgaG90cGx1ZyBpbnRlcnJ1cHQgdmlhIHRoZSBlbXVsYXRlZCByb290IGJyaWRnZS4KCkRMTFND IGlzIG5lZWRlZCBieSB0aGUgcGNpZWhwIGRyaXZlciwgd2hpY2ggaGFuZGxlcyBob3RwbHVnLCBi dXQgYWxzbwpsaW5rIHN0YXRlIGNoYW5nZSBldmVudHMuIEFGQUlLIG5vIEFhcmR2YXJrIGRldmlj ZXMgc3VwcG9ydCBob3RwbHVnLApidXQgbGluayBzdGF0ZSBjaGFuZ2UgZXZlbnRzIGFyZSByZXF1 aXJlZCBmb3IgZ3JhY2VmdWwgZHJpdmVyCnVuYmluZGluZyBpbiBjYXNlIG9mIGEgbGluayBkb3du IGV2ZW50LgoKU28gd2l0aCB0aGlzIGNoYW5nZSB3ZSBhY2hpZXZlIGdyYWNlZnVsIGRyaXZlciB1 bmJpbmQgZm9yIGV4YW1wbGUKd2hlbiBXaUZpIGNhcmQgUENJZSBsaW5rIGdvZXMgZG93biAod2Un dmUgc2VlbiB0aGlzIHdpdGggYXRoMTBrIGFuZAptdDc2IFdpRmkgY2FyZHMpLiBCZWZvcmUgdGhl IFdpRmkgZHJpdmVyIHN0YXJ0ZWQgc3BpdHRpbmcgb3V0IGVycm9ycywKb3IgZXZlbiB0YWtpbmcg dGhlIHdob2xlIHN5c3RlbSBkb3duLgoKTGluayBkb3duIHN0YXRlIGNoYW5nZSBjYW4gYmUgaW1w bGVtZW50ZWQgYmVjYXVzZSBBYXJkdmFyayBzdXBwb3J0cwpMaW5rIERvd24gZXZlbnQgaW50ZXJy dXB0LgoKQWZ0ZXIgdGhlIGxpbmsgZ29lcyBkb3duLCBpdCBjYW4gY29tZSB1cCBhZ2FpbiAoaWYg dGhlIFdpRmkgY2FyZCBjYW4KcmVjb3ZlciBvciBpZiByZXNldCBwaW4gaXMgdXNlZCB0byByZXNl dCB0aGUgY2FyZCkuIEJlY2F1c2Ugb2YgdGhpcwp3ZSBuZWVkIHRvIGJlIGFibGUgdG8gcmVjb2du aXplIGxpbmsgdXAgZXZlbnQuIFNpbmNlIEFGQUlLIEFhcmR2YXJrCmRvZXMgbm90IGhhdmUgaW50 ZXJydXB0IGZvciBsaW5rIHVwIGV2ZW50LCB0aGUgYmVzdCB0aGluZyB3ZSBjYW4gZG8KaXMgc2lt dWxhdGUgaXQgLSB3aGVuZXZlciB3ZSByZWFkIHRoZSBsaW5rIHN0YXRlIGFuZCBmaW5kIGl0IGlz IHVwLAphbmQgaGF2ZSBjYWNoZWQgdmFsdWUgc2F5aW5nIGl0IGlzIGRvd24sIHdlIHRyaWdnZXIg dGhlIGxpbmsgdXAKZXZlbnQuIFdlIHJlYWQgbGluayBzdGF0ZSBpbiB0aGUgYWR2a19wY2llX2xp bmtfdXAoKSBmdW5jdGlvbiwgd2hpY2gKaXMgY2FsbGVkIGZvciBleGFtcGxlIHdoZW5ldmVyIHRo ZSBjb25maWd1cmF0aW9uIHNwYWNlIGlzIHJlYWQgKGkuZS4Kd2hlbiB3cml0aW5nIDEgdG8gL3N5 cy9idXMvcGNpL3Jlc2NhbikuIFdlIGFkZCB0aGUgdHJpZ2dlcmluZyBvZgpIb3QtUGx1ZyBJbnRl cnJ1cHQgZnJvbSB0aGlzIGZ1bmN0aW9uLiBBbHRob3VnaCBub3QgaWRlYWwsIGl0IGlzCmJldHRl ciB0aGFuIG5vdGhpbmcuCgpTaW5jZSBhZHZrX3BjaWVfbGlua191cCgpIGlzIG5vdCBjYWxsZWQg ZnJvbSBhbiBpbnRlcnJ1cHQgaGFuZGxlciwgd2UKY2Fubm90IGNhbGwgZ2VuZXJpY19oYW5kbGVf ZG9tYWluX2lycSgpIGZyb20gaXQgZGlyZWN0bHkuIFNvIGluc3RlYWQKd2Ugc2NoZWR1bGUgdGhl IHRyaWdnZXJpbmcgdmlhIGFuIElSUVNBRkUgdGltZXIgYXMgc29vbiBhcyBwb3NzaWJsZToKYXQg amlmZmllcyArIDEuIFRoaXMgZW5zdXJlcyB0aGF0IGdlbmVyaWNfaGFuZGxlX2RvbWFpbl9pcnEo KSBpcwpjYWxsZWQgZnJvbSB3aXRoaW4gYSBzYWZlIGNvbnRleHQuIChOb3RlIHRoYXQgdGhlIHRp bWVyIGlzIG5vdCBhCnBlcmlvZGljIHRpbWVyIC0gd2UgZG8gbm90IGNhbGwgdGhlIGhhbmRsZXIg ZXZlcnkgamlmZnkuIFdlIGp1c3QKc2NoZWR1bGUgdGhlIGNhbGxpbmcgb25jZSwgYXQgdGhlIG5l eHQgamlmZnkuKQoKKFdlIGhhdmVuJ3QgYmVlbiBhYmxlIHRvIGZpbmQgYW55IGRvY3VtZW50YXRp b24gZm9yIGEgTGluayBVcAogaW50ZXJydXB0IG9uIEFhcmR2YXJrLCBidXQgaXQgaXMgcG9zc2li bGUgdGhlcmUgaXMgb25lLCBpbiBzb21lCiB1bmRvY3VtZW50ZWQgcmVnaXN0ZXIuIElmIHdlIG1h bmFnZSB0byBmaW5kIHRoaXMgaW5mb3JtYXRpb24sIHRoaXMKIGNhbiBiZSByZXdyaXR0ZW4uKQoK U2lnbmVkLW9mZi1ieTogUGFsaSBSb2jDoXIgPHBhbGlAa2VybmVsLm9yZz4KU2lnbmVkLW9mZi1i eTogTWFyZWsgQmVow7puIDxrYWJlbEBrZXJuZWwub3JnPgotLS0KQ2hhbmdlcyBzaW5jZSBiYXRj aCA2IHYxOgotIG1vcmUgZXhwbGFuYXRpb24gaW4gY29tbWl0IG1lc3NhZ2UKQ2hhbmdlcyBzaW5j ZSBiYXRjaCA1OgotIGNoYW5nZWQgY29tbWl0IG1lc3NhZ2UgKGFkZCBwYXJhZ3JhcGggYWJvdXQg d2h5IHRoZSBjaGFuZ2UgaXMgbmVlZGVkKQotIHNlbGVjdCBob3RwbHVnIGFuZCBwY2llcG9ydGJ1 cyBpbiBLY29uZmlnCi0tLQogZHJpdmVycy9wY2kvY29udHJvbGxlci9LY29uZmlnICAgICAgICB8 ICAgMyArCiBkcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1hYXJkdmFyay5jIHwgMTAxICsrKysr KysrKysrKysrKysrKysrKysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDk5IGluc2VydGlvbnMoKyks IDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvY29udHJvbGxlci9LY29u ZmlnIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9LY29uZmlnCmluZGV4IGQxYzVmY2YwMGE4YS4u NWU4YTg0ZjVjNjU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9jb250cm9sbGVyL0tjb25maWcK KysrIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9LY29uZmlnCkBAIC0yMSw2ICsyMSw5IEBAIGNv bmZpZyBQQ0lfQUFSRFZBUksKIAlkZXBlbmRzIG9uIE9GCiAJZGVwZW5kcyBvbiBQQ0lfTVNJX0lS UV9ET01BSU4KIAlzZWxlY3QgUENJX0JSSURHRV9FTVVMCisJc2VsZWN0IFBDSUVQT1JUQlVTCisJ c2VsZWN0IEhPVFBMVUdfUENJCisJc2VsZWN0IEhPVFBMVUdfUENJX1BDSUUKIAloZWxwCiAJIEFk ZCBzdXBwb3J0IGZvciBBYXJkdmFyayA2NGJpdCBQQ0llIEhvc3QgQ29udHJvbGxlci4gVGhpcwog CSBjb250cm9sbGVyIGlzIHBhcnQgb2YgdGhlIFNvdXRoIEJyaWRnZSBvZiB0aGUgTWFydmVsIEFy bWFkYQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktYWFyZHZhcmsuYyBi L2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLWFhcmR2YXJrLmMKaW5kZXggOTY2YzhiNDhiZDk2 Li4zMWRhMjhlYmM1ZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLWFh cmR2YXJrLmMKKysrIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktYWFyZHZhcmsuYwpAQCAt MjUsNiArMjUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KICNpbmNsdWRlIDxs aW51eC9vZl9ncGlvLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfcGNpLmg+CisjaW5jbHVkZSA8bGlu dXgvdGltZXIuaD4KIAogI2luY2x1ZGUgIi4uL3BjaS5oIgogI2luY2x1ZGUgIi4uL3BjaS1icmlk Z2UtZW11bC5oIgpAQCAtMTAwLDYgKzEwMSw3IEBACiAjZGVmaW5lIFBDSUVfTVNHX1BNX1BNRV9N QVNLCQkJQklUKDcpCiAjZGVmaW5lIFBDSUVfSVNSMF9NQVNLX1JFRwkJCShDT05UUk9MX0JBU0Vf QUREUiArIDB4NDQpCiAjZGVmaW5lICAgICBQQ0lFX0lTUjBfTVNJX0lOVF9QRU5ESU5HCQlCSVQo MjQpCisjZGVmaW5lICAgICBQQ0lFX0lTUjBfTElOS19ET1dOCQkJQklUKDEpCiAjZGVmaW5lICAg ICBQQ0lFX0lTUjBfQ09SUl9FUlIJCQlCSVQoMTEpCiAjZGVmaW5lICAgICBQQ0lFX0lTUjBfTkZB VF9FUlIJCQlCSVQoMTIpCiAjZGVmaW5lICAgICBQQ0lFX0lTUjBfRkFUX0VSUgkJCUJJVCgxMykK QEAgLTI4NCw2ICsyODYsOCBAQCBzdHJ1Y3QgYWR2a19wY2llIHsKIAlERUNMQVJFX0JJVE1BUCht c2lfdXNlZCwgTVNJX0lSUV9OVU0pOwogCXN0cnVjdCBtdXRleCBtc2lfdXNlZF9sb2NrOwogCWlu dCBsaW5rX2dlbjsKKwlib29sIGxpbmtfd2FzX3VwOworCXN0cnVjdCB0aW1lcl9saXN0IGxpbmtf aXJxX3RpbWVyOwogCXN0cnVjdCBwY2lfYnJpZGdlX2VtdWwgYnJpZGdlOwogCXN0cnVjdCBncGlv X2Rlc2MgKnJlc2V0X2dwaW87CiAJc3RydWN0IHBoeSAqcGh5OwpAQCAtMzEzLDcgKzMxNywyNCBA QCBzdGF0aWMgaW5saW5lIGJvb2wgYWR2a19wY2llX2xpbmtfdXAoc3RydWN0IGFkdmtfcGNpZSAq cGNpZSkKIHsKIAkvKiBjaGVjayBpZiBMVFNTTSBpcyBpbiBub3JtYWwgb3BlcmF0aW9uIC0gc29t ZSBMKiBzdGF0ZSAqLwogCXU4IGx0c3NtX3N0YXRlID0gYWR2a19wY2llX2x0c3NtX3N0YXRlKHBj aWUpOwotCXJldHVybiBsdHNzbV9zdGF0ZSA+PSBMVFNTTV9MMCAmJiBsdHNzbV9zdGF0ZSA8IExU U1NNX0RJU0FCTEVEOworCWJvb2wgbGlua19pc191cDsKKwl1MTYgc2xvdHN0YTsKKworCWxpbmtf aXNfdXAgPSBsdHNzbV9zdGF0ZSA+PSBMVFNTTV9MMCAmJiBsdHNzbV9zdGF0ZSA8IExUU1NNX0RJ U0FCTEVEOworCisJaWYgKGxpbmtfaXNfdXAgJiYgIXBjaWUtPmxpbmtfd2FzX3VwKSB7CisJCWRl dl9pbmZvKCZwY2llLT5wZGV2LT5kZXYsICJsaW5rIHVwXG4iKTsKKworCQlwY2llLT5saW5rX3dh c191cCA9IHRydWU7CisKKwkJc2xvdHN0YSA9IGxlMTZfdG9fY3B1KHBjaWUtPmJyaWRnZS5wY2ll X2NvbmYuc2xvdHN0YSk7CisJCXNsb3RzdGEgfD0gUENJX0VYUF9TTFRTVEFfRExMU0M7CisJCXBj aWUtPmJyaWRnZS5wY2llX2NvbmYuc2xvdHN0YSA9IGNwdV90b19sZTE2KHNsb3RzdGEpOworCisJ CW1vZF90aW1lcigmcGNpZS0+bGlua19pcnFfdGltZXIsIGppZmZpZXMgKyAxKTsKKwl9CisKKwly ZXR1cm4gbGlua19pc191cDsKIH0KIAogc3RhdGljIGlubGluZSBib29sIGFkdmtfcGNpZV9saW5r X2FjdGl2ZShzdHJ1Y3QgYWR2a19wY2llICpwY2llKQpAQCAtNDQyLDggKzQ2Myw2IEBAIHN0YXRp YyB2b2lkIGFkdmtfcGNpZV90cmFpbl9saW5rKHN0cnVjdCBhZHZrX3BjaWUgKnBjaWUpCiAJcmV0 ID0gYWR2a19wY2llX3dhaXRfZm9yX2xpbmsocGNpZSk7CiAJaWYgKHJldCA8IDApCiAJCWRldl9l cnIoZGV2LCAibGluayBuZXZlciBjYW1lIHVwXG4iKTsKLQllbHNlCi0JCWRldl9pbmZvKGRldiwg ImxpbmsgdXBcbiIpOwogfQogCiAvKgpAQCAtNTkyLDYgKzYxMSwxMSBAQCBzdGF0aWMgdm9pZCBh ZHZrX3BjaWVfc2V0dXBfaHcoc3RydWN0IGFkdmtfcGNpZSAqcGNpZSkKIAlyZWcgJj0gflBDSUVf SVNSMF9NU0lfSU5UX1BFTkRJTkc7CiAJYWR2a193cml0ZWwocGNpZSwgcmVnLCBQQ0lFX0lTUjBf TUFTS19SRUcpOwogCisJLyogVW5tYXNrIExpbmsgRG93biBpbnRlcnJ1cHQgKi8KKwlyZWcgPSBh ZHZrX3JlYWRsKHBjaWUsIFBDSUVfSVNSMF9NQVNLX1JFRyk7CisJcmVnICY9IH5QQ0lFX0lTUjBf TElOS19ET1dOOworCWFkdmtfd3JpdGVsKHBjaWUsIHJlZywgUENJRV9JU1IwX01BU0tfUkVHKTsK KwogCS8qIFVubWFzayBQTUUgaW50ZXJydXB0IGZvciBwcm9jZXNzaW5nIG9mIFBNRSByZXF1ZXN0 ZXIgKi8KIAlyZWcgPSBhZHZrX3JlYWRsKHBjaWUsIFBDSUVfSVNSMF9NQVNLX1JFRyk7CiAJcmVn ICY9IH5QQ0lFX01TR19QTV9QTUVfTUFTSzsKQEAgLTkxOCw2ICs5NDIsMTQgQEAgYWR2a19wY2lf YnJpZGdlX2VtdWxfcGNpZV9jb25mX3dyaXRlKHN0cnVjdCBwY2lfYnJpZGdlX2VtdWwgKmJyaWRn ZSwKIAkJCWFkdmtfcGNpZV93YWl0X2Zvcl9yZXRyYWluKHBjaWUpOwogCQlicmVhazsKIAorCWNh c2UgUENJX0VYUF9TTFRDVEw6IHsKKwkJdTE2IHNsb3RjdGwgPSBsZTE2X3RvX2NwdShicmlkZ2Ut PnBjaWVfY29uZi5zbG90Y3RsKTsKKwkJLyogT25seSBlbXVsYXRpb24gb2YgSFBJRSBhbmQgRExM U0NFIGJpdHMgaXMgcHJvdmlkZWQgKi8KKwkJc2xvdGN0bCAmPSBQQ0lfRVhQX1NMVENUTF9IUElF IHwgUENJX0VYUF9TTFRDVExfRExMU0NFOworCQlicmlkZ2UtPnBjaWVfY29uZi5zbG90Y3RsID0g Y3B1X3RvX2xlMTYoc2xvdGN0bCk7CisJCWJyZWFrOworCX0KKwogCWNhc2UgUENJX0VYUF9SVENU TDogewogCQl1MTYgcm9vdGN0bCA9IGxlMTZfdG9fY3B1KGJyaWRnZS0+cGNpZV9jb25mLnJvb3Rj dGwpOwogCQkvKiBPbmx5IGVtdWxhdGlvbiBvZiBQTUVJRSBhbmQgQ1JTU1ZFIGJpdHMgaXMgcHJv dmlkZWQgKi8KQEAgLTEwMzUsNiArMTA2Nyw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcGNpX2Jy aWRnZV9lbXVsX29wcyBhZHZrX3BjaV9icmlkZ2VfZW11bF9vcHMgPSB7CiBzdGF0aWMgaW50IGFk dmtfc3dfcGNpX2JyaWRnZV9pbml0KHN0cnVjdCBhZHZrX3BjaWUgKnBjaWUpCiB7CiAJc3RydWN0 IHBjaV9icmlkZ2VfZW11bCAqYnJpZGdlID0gJnBjaWUtPmJyaWRnZTsKKwl1MzIgc2xvdGNhcDsK IAogCWJyaWRnZS0+Y29uZi52ZW5kb3IgPQogCQljcHVfdG9fbGUxNihhZHZrX3JlYWRsKHBjaWUs IFBDSUVfQ09SRV9ERVZfSURfUkVHKSAmIDB4ZmZmZik7CkBAIC0xMDYxLDYgKzEwOTQsMTMgQEAg c3RhdGljIGludCBhZHZrX3N3X3BjaV9icmlkZ2VfaW5pdChzdHJ1Y3QgYWR2a19wY2llICpwY2ll KQogCWJyaWRnZS0+cGNpZV9jb25mLmNhcCA9IGNwdV90b19sZTE2KDIgfCBQQ0lfRVhQX0ZMQUdT X1NMT1QpOwogCiAJLyoKKwkgKiBNYXJrIGJyaWRnZSBhcyBIb3QgUGx1ZyBDYXBhYmxlIHNpbmNl IHRoaXMgaXMgdGhlIHdheSBob3cgdG8gZW5hYmxlCisJICogZGVsaXZlcmluZyBvZiBEYXRhIExp bmsgTGF5ZXIgU3RhdGUgQ2hhbmdlIGludGVycnVwdHMuCisJICoKKwkgKiBTZXQgTm8gQ29tbWFu ZCBDb21wbGV0ZWQgU3VwcG9ydCBiZWNhdXNlIGJyaWRnZSBkb2VzIG5vdCBzdXBwb3J0CisJICog Q29tbWFuZCBDb21wbGV0ZWQgSW50ZXJydXB0LiBFdmVyeSBjb21tYW5kIGlzIGV4ZWN1dGVkIGlt bWVkaWF0ZWx5CisJICogd2l0aG91dCBhbnkgZGVsYXkuCisJICoKIAkgKiBTZXQgUHJlc2VuY2Ug RGV0ZWN0IFN0YXRlIGJpdCBwZXJtYW5lbnRseSBzaW5jZSB0aGVyZSBpcyBubyBzdXBwb3J0CiAJ ICogZm9yIHVucGx1Z2dpbmcgdGhlIGNhcmQgbm9yIGRldGVjdGluZyB3aGV0aGVyIGl0IGlzIHBs dWdnZWQuIChJZiBhCiAJICogcGxhdGZvcm0gZXhpc3RzIGluIHRoZSBmdXR1cmUgdGhhdCBzdXBw b3J0cyBpdCwgdmlhIGEgR1BJTyBmb3IKQEAgLTEwNzAsOCArMTExMCw5IEBAIHN0YXRpYyBpbnQg YWR2a19zd19wY2lfYnJpZGdlX2luaXQoc3RydWN0IGFkdmtfcGNpZSAqcGNpZSkKIAkgKiB2YWx1 ZSBpcyByZXNlcnZlZCBmb3IgcG9ydHMgd2l0aGluIHRoZSBzYW1lIHNpbGljb24gYXMgUm9vdCBQ b3J0CiAJICogd2hpY2ggaXMgbm90IG91ciBjYXNlLgogCSAqLwotCWJyaWRnZS0+cGNpZV9jb25m LnNsb3RjYXAgPSBjcHVfdG9fbGUzMihGSUVMRF9QUkVQKFBDSV9FWFBfU0xUQ0FQX1BTTiwKLQkJ CQkJCQkgICAxKSk7CisJc2xvdGNhcCA9IFBDSV9FWFBfU0xUQ0FQX05DQ1MgfCBQQ0lfRVhQX1NM VENBUF9IUEMgfAorCQkgIEZJRUxEX1BSRVAoUENJX0VYUF9TTFRDQVBfUFNOLCAxKTsKKwlicmlk Z2UtPnBjaWVfY29uZi5zbG90Y2FwID0gY3B1X3RvX2xlMzIoc2xvdGNhcCk7CiAJYnJpZGdlLT5w Y2llX2NvbmYuc2xvdHN0YSA9IGNwdV90b19sZTE2KFBDSV9FWFBfU0xUU1RBX1BEUyk7CiAKIAkv KiBJbmRpY2F0ZXMgc3VwcG9ydHMgZm9yIENvbXBsZXRpb24gUmV0cnkgU3RhdHVzICovCkBAIC0x NTY4LDYgKzE2MDksMjQgQEAgc3RhdGljIHZvaWQgYWR2a19wY2llX3JlbW92ZV9ycF9pcnFfZG9t YWluKHN0cnVjdCBhZHZrX3BjaWUgKnBjaWUpCiAJaXJxX2RvbWFpbl9yZW1vdmUocGNpZS0+cnBf aXJxX2RvbWFpbik7CiB9CiAKK3N0YXRpYyB2b2lkIGFkdmtfcGNpZV9saW5rX2lycV9oYW5kbGVy KHN0cnVjdCB0aW1lcl9saXN0ICp0aW1lcikKK3sKKwlzdHJ1Y3QgYWR2a19wY2llICpwY2llID0g ZnJvbV90aW1lcihwY2llLCB0aW1lciwgbGlua19pcnFfdGltZXIpOworCXUxNiBzbG90Y3RsOwor CisJc2xvdGN0bCA9IGxlMTZfdG9fY3B1KHBjaWUtPmJyaWRnZS5wY2llX2NvbmYuc2xvdGN0bCk7 CisJaWYgKCEoc2xvdGN0bCAmIFBDSV9FWFBfU0xUQ1RMX0RMTFNDRSkgfHwKKwkgICAgIShzbG90 Y3RsICYgUENJX0VYUF9TTFRDVExfSFBJRSkpCisJCXJldHVybjsKKworCS8qCisJICogQWFyZHZh cmsgSFcgcmV0dXJucyB6ZXJvIGZvciBQQ0lfRVhQX0ZMQUdTX0lSUSwgc28gdXNlIFBDSWUKKwkg KiBpbnRlcnJ1cHQgMAorCSAqLworCWlmIChnZW5lcmljX2hhbmRsZV9kb21haW5faXJxKHBjaWUt PnJwX2lycV9kb21haW4sIDApID09IC1FSU5WQUwpCisJCWRldl9lcnJfcmF0ZWxpbWl0ZWQoJnBj aWUtPnBkZXYtPmRldiwgInVuaGFuZGxlZCBIUCBJUlFcbiIpOworfQorCiBzdGF0aWMgdm9pZCBh ZHZrX3BjaWVfaGFuZGxlX3BtZShzdHJ1Y3QgYWR2a19wY2llICpwY2llKQogewogCXUzMiByZXF1 ZXN0ZXIgPSBhZHZrX3JlYWRsKHBjaWUsIFBDSUVfTVNHX0xPR19SRUcpID4+IDE2OwpAQCAtMTYx OSw2ICsxNjc4LDcgQEAgc3RhdGljIHZvaWQgYWR2a19wY2llX2hhbmRsZV9pbnQoc3RydWN0IGFk dmtfcGNpZSAqcGNpZSkKIHsKIAl1MzIgaXNyMF92YWwsIGlzcjBfbWFzaywgaXNyMF9zdGF0dXM7 CiAJdTMyIGlzcjFfdmFsLCBpc3IxX21hc2ssIGlzcjFfc3RhdHVzOworCXUxNiBzbG90c3RhOwog CWludCBpOwogCiAJaXNyMF92YWwgPSBhZHZrX3JlYWRsKHBjaWUsIFBDSUVfSVNSMF9SRUcpOwpA QCAtMTY0NSw2ICsxNzA1LDI2IEBAIHN0YXRpYyB2b2lkIGFkdmtfcGNpZV9oYW5kbGVfaW50KHN0 cnVjdCBhZHZrX3BjaWUgKnBjaWUpCiAJCQlkZXZfZXJyX3JhdGVsaW1pdGVkKCZwY2llLT5wZGV2 LT5kZXYsICJ1bmhhbmRsZWQgRVJSIElSUVxuIik7CiAJfQogCisJLyogUHJvY2VzcyBMaW5rIERv d24gaW50ZXJydXB0IGFzIEhQIElSUSAqLworCWlmIChpc3IwX3N0YXR1cyAmIFBDSUVfSVNSMF9M SU5LX0RPV04pIHsKKwkJYWR2a193cml0ZWwocGNpZSwgUENJRV9JU1IwX0xJTktfRE9XTiwgUENJ RV9JU1IwX1JFRyk7CisKKwkJZGV2X2luZm8oJnBjaWUtPnBkZXYtPmRldiwgImxpbmsgZG93blxu Iik7CisKKwkJcGNpZS0+bGlua193YXNfdXAgPSBmYWxzZTsKKworCQlzbG90c3RhID0gbGUxNl90 b19jcHUocGNpZS0+YnJpZGdlLnBjaWVfY29uZi5zbG90c3RhKTsKKwkJc2xvdHN0YSB8PSBQQ0lf RVhQX1NMVFNUQV9ETExTQzsKKwkJcGNpZS0+YnJpZGdlLnBjaWVfY29uZi5zbG90c3RhID0gY3B1 X3RvX2xlMTYoc2xvdHN0YSk7CisKKwkJLyoKKwkJICogRGVhY3RpdmF0ZSB0aW1lciBhbmQgY2Fs bCBhZHZrX3BjaWVfbGlua19pcnFfaGFuZGxlcigpCisJCSAqIGZ1bmN0aW9uIGRpcmVjdGx5IGFz IHdlIGFyZSBpbiB0aGUgaW50ZXJydXB0IGNvbnRleHQuCisJCSAqLworCQlkZWxfdGltZXJfc3lu YygmcGNpZS0+bGlua19pcnFfdGltZXIpOworCQlhZHZrX3BjaWVfbGlua19pcnFfaGFuZGxlcigm cGNpZS0+bGlua19pcnFfdGltZXIpOworCX0KKwogCS8qIFByb2Nlc3MgTVNJIGludGVycnVwdHMg Ki8KIAlpZiAoaXNyMF9zdGF0dXMgJiBQQ0lFX0lTUjBfTVNJX0lOVF9QRU5ESU5HKQogCQlhZHZr X3BjaWVfaGFuZGxlX21zaShwY2llKTsKQEAgLTE4ODEsNiArMTk2MSwxNCBAQCBzdGF0aWMgaW50 IGFkdmtfcGNpZV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChyZXQp CiAJCXJldHVybiByZXQ7CiAKKwkvKgorCSAqIGdlbmVyaWNfaGFuZGxlX2RvbWFpbl9pcnEoKSBl eHBlY3RzIGxvY2FsIElSUXMgdG8gYmUgZGlzYWJsZWQgc2luY2UKKwkgKiBub3JtYWxseSBpdCBp cyBjYWxsZWQgZnJvbSBpbnRlcnJ1cHQgY29udGV4dCwgc28gdXNlIFRJTUVSX0lSUVNBRkUKKwkg KiBmbGFnIGZvciB0aGlzIGxpbmtfaXJxX3RpbWVyLgorCSAqLworCXRpbWVyX3NldHVwKCZwY2ll LT5saW5rX2lycV90aW1lciwgYWR2a19wY2llX2xpbmtfaXJxX2hhbmRsZXIsCisJCSAgICBUSU1F Ul9JUlFTQUZFKTsKKwogCWFkdmtfcGNpZV9zZXR1cF9odyhwY2llKTsKIAogCXJldCA9IGFkdmtf c3dfcGNpX2JyaWRnZV9pbml0KHBjaWUpOwpAQCAtMTk2OSw2ICsyMDU3LDkgQEAgc3RhdGljIGlu dCBhZHZrX3BjaWVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJYWR2a19w Y2llX3JlbW92ZV9tc2lfaXJxX2RvbWFpbihwY2llKTsKIAlhZHZrX3BjaWVfcmVtb3ZlX2lycV9k b21haW4ocGNpZSk7CiAKKwkvKiBEZWFjdGl2YXRlIGxpbmsgZXZlbnQgdGltZXIgKi8KKwlkZWxf dGltZXJfc3luYygmcGNpZS0+bGlua19pcnFfdGltZXIpOworCiAJLyogRnJlZSBjb25maWcgc3Bh Y2UgZm9yIGVtdWxhdGVkIHJvb3QgYnJpZGdlICovCiAJcGNpX2JyaWRnZV9lbXVsX2NsZWFudXAo JnBjaWUtPmJyaWRnZSk7CiAKLS0gCjIuMzUuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4 LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK