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=-19.7 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,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 BFE48C433B4 for ; Thu, 6 May 2021 15:32:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 969BC6147E for ; Thu, 6 May 2021 15:32:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235547AbhEFPds (ORCPT ); Thu, 6 May 2021 11:33:48 -0400 Received: from mail.kernel.org ([198.145.29.99]:45974 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235390AbhEFPdq (ORCPT ); Thu, 6 May 2021 11:33:46 -0400 Received: by mail.kernel.org (Postfix) with ESMTPSA id DC524613F2; Thu, 6 May 2021 15:32:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1620315168; bh=c7GGuyUtVyL1SLFfZcJF6dkFcBmF/f2vbvmIa4XMBGk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Uk752vva9+3aZbQc1d8zcNpDjPeI8l75tYIslNH6LmoLxAInnItGuzB4Em+wbZZ0/ H/WgaOS8wQgL3J01VyjMoLCvQK7mRJ1IfRNwVY1RL8yN1m8s1/pgtNIOSfa1WeM8KM sCcz3CGju/FSqut+gU+PJJJLNhbP77uY6nFpZQNpTJXnYMIOJ/dVFw4dy6TOQN2i7y EmcIx/4f1B0W8VMdXlphGnGNs44Dq7Vg5/LOgwiQ0Ar/puHsiMO4NWuYZ2gLgXZG8t M7SqWIZMEvhiYt0i7+QmmWva36zdPAxVZIJSUSGfRkWUtU7rE/RjTwk6KRqmv37NmV xu3AkBgCizWfg== Received: by pali.im (Postfix) id 14E4B11DA; Thu, 6 May 2021 17:32:46 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , Thomas Petazzoni , Rob Herring , Bjorn Helgaas Cc: Russell King , =?UTF-8?q?Marek=20Beh=C3=BAn?= , Remi Pommarel , Xogium , Tomasz Maciej Nowak , Marc Zyngier , linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH 07/42] PCI: aardvark: Fix link training Date: Thu, 6 May 2021 17:31:18 +0200 Message-Id: <20210506153153.30454-8-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210506153153.30454-1-pali@kernel.org> References: <20210506153153.30454-1-pali@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 Fix multiple link training issues in aardvark driver. The main reason of these issues was misunderstanding of what certain registers do, since their names and comments were misleading: before commit 96be36dbffac ("PCI: aardvark: Replace custom macros by standard linux/pci_regs.h macros"), the pci-aardvark.c driver used custom macros for accessing standard PCIe Root Bridge registers, and misleading comments did not help to understand what the code was really doing. After doing more tests and experiments I've come to the conclusion that the SPEED_GEN register in aardvark sets the PCIe revision / generation compliance and forces maximal link speed. Both GEN3 and GEN2 values set the read-only PCI_EXP_FLAGS_VERS bits (PCIe capabilities version of Root Bridge) to value 2, while GEN1 value sets PCI_EXP_FLAGS_VERS to 1, which matches with PCI Express specifications revision 3, 2 and 1, respectively. Changing SPEED_GEN also sets the read-only bits PCI_EXP_LNKCAP_SLS and PCI_EXP_LNKCAP2_SLS to corresponding speed. Note that PCI Express rev 1 specification does not define PCI_EXP_LNKCAP2 and PCI_EXP_LNKCTL2 registers and when SPEED_GEN is set to GEN1 (which also sets PCI_EXP_FLAGS_VERS set to 1), lspci cannot access PCI_EXP_LNKCAP2 and PCI_EXP_LNKCTL2 registers. Changing PCIe link speed can be done via PCI_EXP_LNKCTL2_TLS bits of PCI_EXP_LNKCTL2 register. Armada 3700 Functional Specifications says that the default value of PCI_EXP_LNKCTL2_TLS is based on SPEED_GEN value, but tests showed that the default value is always 8.0 GT/s, independently of speed set by SPEED_GEN. So after setting SPEED_GEN, we must also set value in PCI_EXP_LNKCTL2 register via PCI_EXP_LNKCTL2_TLS bits. Triggering PCI_EXP_LNKCTL_RL bit immediately after setting LINK_TRAINING_EN bit actually doesn't do anything. Tests have shown that a delay is needed after enabling LINK_TRAINING_EN bit. As triggering PCI_EXP_LNKCTL_RL currently does nothing, remove it. Commit 43fc679ced18 ("PCI: aardvark: Improve link training") introduced code which sets SPEED_GEN register based on negotiated link speed from PCI_EXP_LNKSTA_CLS bits of PCI_EXP_LNKSTA register. This code was added to fix detection of Compex WLE900VX (Atheros QCA9880) WiFi GEN1 PCIe cards, as otherwise these cards were "invisible" on PCIe bus (probably because they crashed). But apparently more people reported the same issues with these cards also with other PCIe controllers [1] and I was able to reproduce this issue also with other "noname" WiFi cards based on Atheros QCA9890 chip (with the same PCI vendor/device ids as Atheros QCA9880). So this is not an issue in aardvark but rather issue in Atheros QCA98xx chips. Also, this issue only exists if the kernel is compiled with PCIe ASPM support, and a generic workaround for this is to change PCIe Bridge to 2.5 GT/s link speed via PCI_EXP_LNKCTL2_TLS_2_5GT bits in PCI_EXP_LNKCTL2 register [2], before triggering PCI_EXP_LNKCTL_RL bit. This workaround also works when SPEED_GEN is set to value GEN2 (5 GT/s). So remove this hack completely in the aardvark driver and always set SPEED_GEN to value from 'max-link-speed' DT property. Fix for Atheros QCA98xx chips is handled separately by patch [2]. These two things (code for triggering PCI_EXP_LNKCTL_RL bit and changing SPEED_GEN value) also explain why commit 6964494582f5 ("PCI: aardvark: Train link immediately after enabling training") somehow fixed detection of those problematic Compex cards with Atheros chips: if triggering link retraining (via PCI_EXP_LNKCTL_RL bit) was done immediately after enabling link training (via LINK_TRAINING_EN), it did nothing. If there was a specific delay, aardvark HW already initialized PCIe link and therefore triggering link retraining caused the above issue. Compex cards triggered link down event and disappeared from the PCIe bus. Commit f4c7d053d7f7 ("PCI: aardvark: Wait for endpoint to be ready before training link") added 100ms sleep before calling 'Start link training' command and explained that it is a requirement of PCI Express specification. But the code after this 100ms sleep was not doing 'Start link training', rather it triggered PCI_EXP_LNKCTL_RL bit via PCIe Root Bridge to put link into Recovery state. The required delay after fundamental reset is already done in function advk_pcie_wait_for_link() which also check when PCIe link is up. So after removing the code which triggers PCI_EXP_LNKCTL_RL bit on PCIe Root Bridge, there is no need to wait 100ms again. Remove the extra msleep() call and update comment about the delay required by the PCI Express specification. According to Marvell Armada 3700 Functional Specifications, Link training should be enabled via aardvark register LINK_TRAINING_EN after selecting PCIe generation and x1 lane. There is no need to disable it prior resetting card via PERST# signal. This disabling code was introduced in commit 5169a9851daa ("PCI: aardvark: Issue PERST via GPIO") as a workaround for some Atheros cards. It turns out that this also is Atheros specific issue and affects any PCIe controller, not only aardvark. Moreover this Atheros issue was triggered by juggling with PCI_EXP_LNKCTL_RL, LINK_TRAINING_EN and SPEED_GEN bits interleaved with sleeps. Now, after removing triggering PCI_EXP_LNKCTL_RL, there is no need to explicitly disable LINK_TRAINING_EN bit. So remove this code too. The problematic Compex cards described in previous git commits are correctly detected in advk_pcie_train_link() function even after applying all these changes. Note that with this patch, and also prior this patch, some NVMe disks which support PCIe GEN3 with 8 GT/s speed are negotiated only at the lowest link speed 2.5 GT/s, independently of SPEED_GEN value. After manually triggering PCI_EXP_LNKCTL_RL bit (e.g. from userspace via setpci), these NVMe disks change link speed to 5 GT/s when SPEED_GEN was configured to GEN2. This issue first needs to be properly investigated. I will send a fix in the future. On the other hand, some other GEN2 PCIe cards with 5 GT/s speed are autonomously by HW autonegotiated at full 5 GT/s speed without need of any software interaction. Armada 3700 Functional Specifications describes the following steps for link training: set SPEED_GEN to GEN2, enable LINK_TRAINING_EN, poll until link training is complete, trigger PCI_EXP_LNKCTL_RL, poll until signal rate is 5 GT/s, poll until link training is complete, enable ASPM L0s. The requirement for triggering PCI_EXP_LNKCTL_RL can be explained by the need to achieve 5 GT/s speed (as changing link speed is done by throw to recovery state entered by PCI_EXP_LNKCTL_RL) or maybe as a part of enabling ASPM L0s (but in this case ASPM L0s should have been enabled prior PCI_EXP_LNKCTL_RL). It is unknown why the original pci-aardvark.c driver was triggering PCI_EXP_LNKCTL_RL bit before waiting for the link to be up. This does not align with neither PCIe base specifications nor with Armada 3700 Functional Specification. (Note that in older versions of aardvark, this bit was called incorrectly PCIE_CORE_LINK_TRAINING, so this may be the reason.) It is also unknown why Armada 3700 Functional Specification says that it is needed to trigger PCI_EXP_LNKCTL_RL for GEN2 mode, as according to PCIe base specification 5 GT/s speed negotiation is supposed to be entirely autonomous, even if initial speed is 2.5 GT/s. [1] - https://lore.kernel.org/linux-pci/87h7l8axqp.fsf@toke.dk/ [2] - https://lore.kernel.org/linux-pci/20210326124326.21163-1-pali@kernel.org/ Signed-off-by: Pali Rohár Reviewed-by: Marek Behún Cc: stable@vger.kernel.org # f4c7d053d7f7 ("PCI: aardvark: Wait for endpoint to be ready before training link") Cc: stable@vger.kernel.org # 6964494582f5 ("PCI: aardvark: Train link immediately after enabling training") Cc: stable@vger.kernel.org # 43fc679ced18 ("PCI: aardvark: Improve link training") Cc: stable@vger.kernel.org # 5169a9851daa ("PCI: aardvark: Issue PERST via GPIO") Cc: stable@vger.kernel.org # 96be36dbffac ("PCI: aardvark: Replace custom macros by standard linux/pci_regs.h macros") Cc: stable@vger.kernel.org # d0c6a3475b03 ("PCI: aardvark: Move PCIe reset card code to advk_pcie_train_link()") Cc: stable@vger.kernel.org # 1d1cd163d0de ("PCI: aardvark: Update comment about disabling link training") --- drivers/pci/controller/pci-aardvark.c | 117 ++++++++------------------ 1 file changed, 34 insertions(+), 83 deletions(-) diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c index e297ec9ec390..edeacd95297e 100644 --- a/drivers/pci/controller/pci-aardvark.c +++ b/drivers/pci/controller/pci-aardvark.c @@ -209,11 +209,6 @@ static inline u32 advk_readl(struct advk_pcie *pcie, u64 reg) return readl(pcie->base + reg); } -static inline u16 advk_read16(struct advk_pcie *pcie, u64 reg) -{ - return advk_readl(pcie, (reg & ~0x3)) >> ((reg & 0x3) * 8); -} - static int advk_pcie_link_up(struct advk_pcie *pcie) { u32 val, ltssm_state; @@ -251,23 +246,9 @@ static void advk_pcie_wait_for_retrain(struct advk_pcie *pcie) static void advk_pcie_issue_perst(struct advk_pcie *pcie) { - u32 reg; - if (!pcie->reset_gpio) return; - /* - * As required by PCI Express spec (PCI Express Base Specification, REV. - * 4.0 PCI Express, February 19 2014, 6.6.1 Conventional Reset) a delay - * for at least 100ms after de-asserting PERST# signal is needed before - * link training is enabled. So ensure that link training is disabled - * prior de-asserting PERST# signal to fulfill that PCI Express spec - * requirement. - */ - reg = advk_readl(pcie, PCIE_CORE_CTRL0_REG); - reg &= ~LINK_TRAINING_EN; - advk_writel(pcie, reg, PCIE_CORE_CTRL0_REG); - /* 10ms delay is needed for some cards */ dev_info(&pcie->pdev->dev, "issuing PERST via reset GPIO for 10ms\n"); gpiod_set_value_cansleep(pcie->reset_gpio, 1); @@ -275,53 +256,46 @@ static void advk_pcie_issue_perst(struct advk_pcie *pcie) gpiod_set_value_cansleep(pcie->reset_gpio, 0); } -static int advk_pcie_train_at_gen(struct advk_pcie *pcie, int gen) +static void advk_pcie_train_link(struct advk_pcie *pcie) { - int ret, neg_gen; + struct device *dev = &pcie->pdev->dev; u32 reg; + int ret; - /* Setup link speed */ + /* + * Setup PCIe rev / gen compliance based on device tree property + * 'max-link-speed' which also forces maximal link speed. + */ reg = advk_readl(pcie, PCIE_CORE_CTRL0_REG); reg &= ~PCIE_GEN_SEL_MSK; - if (gen == 3) + if (pcie->link_gen == 3) reg |= SPEED_GEN_3; - else if (gen == 2) + else if (pcie->link_gen == 2) reg |= SPEED_GEN_2; else reg |= SPEED_GEN_1; advk_writel(pcie, reg, PCIE_CORE_CTRL0_REG); /* - * Enable link training. This is not needed in every call to this - * function, just once suffices, but it does not break anything either. + * Set maximal link speed value also into PCIe Link Control 2 register. + * Armada 3700 Functional Specification says that default value is based + * on SPEED_GEN but tests showed that default value is always 8.0 GT/s. */ + reg = advk_readl(pcie, PCIE_CORE_PCIEXP_CAP + PCI_EXP_LNKCTL2); + reg &= ~PCI_EXP_LNKCTL2_TLS; + if (pcie->link_gen == 3) + reg |= PCI_EXP_LNKCTL2_TLS_8_0GT; + else if (pcie->link_gen == 2) + reg |= PCI_EXP_LNKCTL2_TLS_5_0GT; + else + reg |= PCI_EXP_LNKCTL2_TLS_2_5GT; + advk_writel(pcie, reg, PCIE_CORE_PCIEXP_CAP + PCI_EXP_LNKCTL2); + + /* Enable link training after selecting PCIe generation */ reg = advk_readl(pcie, PCIE_CORE_CTRL0_REG); reg |= LINK_TRAINING_EN; advk_writel(pcie, reg, PCIE_CORE_CTRL0_REG); - /* - * Start link training immediately after enabling it. - * This solves problems for some buggy cards. - */ - reg = advk_readl(pcie, PCIE_CORE_PCIEXP_CAP + PCI_EXP_LNKCTL); - reg |= PCI_EXP_LNKCTL_RL; - advk_writel(pcie, reg, PCIE_CORE_PCIEXP_CAP + PCI_EXP_LNKCTL); - - ret = advk_pcie_wait_for_link(pcie); - if (ret) - return ret; - - reg = advk_read16(pcie, PCIE_CORE_PCIEXP_CAP + PCI_EXP_LNKSTA); - neg_gen = reg & PCI_EXP_LNKSTA_CLS; - - return neg_gen; -} - -static void advk_pcie_train_link(struct advk_pcie *pcie) -{ - struct device *dev = &pcie->pdev->dev; - int neg_gen = -1, gen; - /* * Reset PCIe card via PERST# signal. Some cards are not detected * during link training when they are in some non-initial state. @@ -332,41 +306,18 @@ static void advk_pcie_train_link(struct advk_pcie *pcie) * PERST# signal could have been asserted by pinctrl subsystem before * probe() callback has been called or issued explicitly by reset gpio * function advk_pcie_issue_perst(), making the endpoint going into - * fundamental reset. As required by PCI Express spec a delay for at - * least 100ms after such a reset before link training is needed. - */ - msleep(PCI_PM_D3COLD_WAIT); - - /* - * Try link training at link gen specified by device tree property - * 'max-link-speed'. If this fails, iteratively train at lower gen. - */ - for (gen = pcie->link_gen; gen > 0; --gen) { - neg_gen = advk_pcie_train_at_gen(pcie, gen); - if (neg_gen > 0) - break; - } - - if (neg_gen < 0) - goto err; - - /* - * After successful training if negotiated gen is lower than requested, - * train again on negotiated gen. This solves some stability issues for - * some buggy gen1 cards. + * fundamental reset. As required by PCI Express spec (PCI Express + * Base Specification, REV. 4.0 PCI Express, February 19 2014, 6.6.1 + * Conventional Reset) a delay for at least 100ms after such a reset + * before sending a Configuration Request to the device is needed. + * So wait until PCIe link is up. Function advk_pcie_wait_for_link() + * waits for link at least 900ms. */ - if (neg_gen < gen) { - gen = neg_gen; - neg_gen = advk_pcie_train_at_gen(pcie, gen); - } - - if (neg_gen == gen) { - dev_info(dev, "link up at gen %i\n", gen); - return; - } - -err: - dev_err(dev, "link never came up\n"); + 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"); } static void advk_pcie_setup_hw(struct advk_pcie *pcie) -- 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=-17.7 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI, 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 A235EC433B4 for ; Thu, 6 May 2021 15:40:35 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (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 E47BB61040 for ; Thu, 6 May 2021 15:40:34 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E47BB61040 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+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=desiato.20200630; 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=imQLnkD6vIRaJk83PeaVAthJRvyIOJY6Vfkn6d3/qas=; b=Z890nE66/tAg8n2k8MGnoxoyu OGjDzgK9phySCt4liRKi1fN81Lx6DcpQR1K44i1RaOfVYWdCIRfIncjvly5DYPYXrT+ZN5uLQIToH R5Galq05chXO/FUechSc0XzjOCtFb32NjA6IoIzPWKDCeDKwO/NCBAuRPG3oHYMrhnv4SjuqKXqs8 kHEP1N2qHA0Eh7FdGU6/XSaHIu5A3raSEHe7gc5f7JxBiuCVN+nXC2J79xXPsufJPqP5nFxFjdYug 5Sv6T2nUBHWZ9kNEU4OaV1glRWeAd+CHBf35O+61oHj6a0127t8E+oTup3bpGsldIaXctuJ9iDYJl M436FH0KQ==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1leg5U-004c9X-Bc; Thu, 06 May 2021 15:38:52 +0000 Received: from bombadil.infradead.org ([2607:7c80:54:e::133]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lefzl-004a55-NZ for linux-arm-kernel@desiato.infradead.org; Thu, 06 May 2021 15:32:58 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc: To:From:Sender:Reply-To:Content-ID:Content-Description; bh=WLdA42zvI1m5O15q6+bksx80p4jAJwc4hmxqBpr09a0=; b=qh8jbxtfrrYG6bGFj9BWXj5h+V pZmn6YnODm7myvxW0p/sP39o2Ba9DZphd0Gl3YxAeCMF5CnJjwxj4DZj8ZPARYvcGbtt1PtiYsyRO VTs7mt6IEF+eHzTF2QIkWyCSNEI0HcnC7lJQppA6iAUQABnsE04jobnKEarKJm2teS/iM4ld05Fa+ /PXf5g8M+nwN3+EuJloQMCJ52Y6qYE4+B7hqzM6WH8+Zh+QAN4JetFrzQgtFQuezsjr9/XTtDaptf +uGBZryMMl6rL4XLkRYS+T/GmX3oeSJdaVBaKtSqBYKDwYIWCNYjgxO67MWbk0kKN8Bb4nq0Pj40C ihLccfXA==; Received: from mail.kernel.org ([198.145.29.99]) by bombadil.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lefzf-0069hj-Jk for linux-arm-kernel@lists.infradead.org; Thu, 06 May 2021 15:32:56 +0000 Received: by mail.kernel.org (Postfix) with ESMTPSA id DC524613F2; Thu, 6 May 2021 15:32:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1620315168; bh=c7GGuyUtVyL1SLFfZcJF6dkFcBmF/f2vbvmIa4XMBGk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Uk752vva9+3aZbQc1d8zcNpDjPeI8l75tYIslNH6LmoLxAInnItGuzB4Em+wbZZ0/ H/WgaOS8wQgL3J01VyjMoLCvQK7mRJ1IfRNwVY1RL8yN1m8s1/pgtNIOSfa1WeM8KM sCcz3CGju/FSqut+gU+PJJJLNhbP77uY6nFpZQNpTJXnYMIOJ/dVFw4dy6TOQN2i7y EmcIx/4f1B0W8VMdXlphGnGNs44Dq7Vg5/LOgwiQ0Ar/puHsiMO4NWuYZ2gLgXZG8t M7SqWIZMEvhiYt0i7+QmmWva36zdPAxVZIJSUSGfRkWUtU7rE/RjTwk6KRqmv37NmV xu3AkBgCizWfg== Received: by pali.im (Postfix) id 14E4B11DA; Thu, 6 May 2021 17:32:46 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , Thomas Petazzoni , Rob Herring , Bjorn Helgaas Cc: Russell King , =?UTF-8?q?Marek=20Beh=C3=BAn?= , Remi Pommarel , Xogium , Tomasz Maciej Nowak , Marc Zyngier , linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH 07/42] PCI: aardvark: Fix link training Date: Thu, 6 May 2021 17:31:18 +0200 Message-Id: <20210506153153.30454-8-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210506153153.30454-1-pali@kernel.org> References: <20210506153153.30454-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210506_083251_845618_7CA01E5A X-CRM114-Status: GOOD ( 38.37 ) 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 Rml4IG11bHRpcGxlIGxpbmsgdHJhaW5pbmcgaXNzdWVzIGluIGFhcmR2YXJrIGRyaXZlci4gVGhl IG1haW4gcmVhc29uIG9mCnRoZXNlIGlzc3VlcyB3YXMgbWlzdW5kZXJzdGFuZGluZyBvZiB3aGF0 IGNlcnRhaW4gcmVnaXN0ZXJzIGRvLCBzaW5jZSB0aGVpcgpuYW1lcyBhbmQgY29tbWVudHMgd2Vy ZSBtaXNsZWFkaW5nOiBiZWZvcmUgY29tbWl0IDk2YmUzNmRiZmZhYyAoIlBDSToKYWFyZHZhcms6 IFJlcGxhY2UgY3VzdG9tIG1hY3JvcyBieSBzdGFuZGFyZCBsaW51eC9wY2lfcmVncy5oIG1hY3Jv cyIpLCB0aGUKcGNpLWFhcmR2YXJrLmMgZHJpdmVyIHVzZWQgY3VzdG9tIG1hY3JvcyBmb3IgYWNj ZXNzaW5nIHN0YW5kYXJkIFBDSWUgUm9vdApCcmlkZ2UgcmVnaXN0ZXJzLCBhbmQgbWlzbGVhZGlu ZyBjb21tZW50cyBkaWQgbm90IGhlbHAgdG8gdW5kZXJzdGFuZCB3aGF0CnRoZSBjb2RlIHdhcyBy ZWFsbHkgZG9pbmcuCgpBZnRlciBkb2luZyBtb3JlIHRlc3RzIGFuZCBleHBlcmltZW50cyBJJ3Zl IGNvbWUgdG8gdGhlIGNvbmNsdXNpb24gdGhhdCB0aGUKU1BFRURfR0VOIHJlZ2lzdGVyIGluIGFh cmR2YXJrIHNldHMgdGhlIFBDSWUgcmV2aXNpb24gLyBnZW5lcmF0aW9uCmNvbXBsaWFuY2UgYW5k IGZvcmNlcyBtYXhpbWFsIGxpbmsgc3BlZWQuIEJvdGggR0VOMyBhbmQgR0VOMiB2YWx1ZXMgc2V0 IHRoZQpyZWFkLW9ubHkgUENJX0VYUF9GTEFHU19WRVJTIGJpdHMgKFBDSWUgY2FwYWJpbGl0aWVz IHZlcnNpb24gb2YgUm9vdApCcmlkZ2UpIHRvIHZhbHVlIDIsIHdoaWxlIEdFTjEgdmFsdWUgc2V0 cyBQQ0lfRVhQX0ZMQUdTX1ZFUlMgdG8gMSwgd2hpY2gKbWF0Y2hlcyB3aXRoIFBDSSBFeHByZXNz IHNwZWNpZmljYXRpb25zIHJldmlzaW9uIDMsIDIgYW5kIDEsIHJlc3BlY3RpdmVseS4KQ2hhbmdp bmcgU1BFRURfR0VOIGFsc28gc2V0cyB0aGUgcmVhZC1vbmx5IGJpdHMgUENJX0VYUF9MTktDQVBf U0xTIGFuZApQQ0lfRVhQX0xOS0NBUDJfU0xTIHRvIGNvcnJlc3BvbmRpbmcgc3BlZWQuCgpOb3Rl IHRoYXQgUENJIEV4cHJlc3MgcmV2IDEgc3BlY2lmaWNhdGlvbiBkb2VzIG5vdCBkZWZpbmUgUENJ X0VYUF9MTktDQVAyCmFuZCBQQ0lfRVhQX0xOS0NUTDIgcmVnaXN0ZXJzIGFuZCB3aGVuIFNQRUVE X0dFTiBpcyBzZXQgdG8gR0VOMSAod2hpY2ggYWxzbwpzZXRzIFBDSV9FWFBfRkxBR1NfVkVSUyBz ZXQgdG8gMSksIGxzcGNpIGNhbm5vdCBhY2Nlc3MgUENJX0VYUF9MTktDQVAyIGFuZApQQ0lfRVhQ X0xOS0NUTDIgcmVnaXN0ZXJzLgoKQ2hhbmdpbmcgUENJZSBsaW5rIHNwZWVkIGNhbiBiZSBkb25l IHZpYSBQQ0lfRVhQX0xOS0NUTDJfVExTIGJpdHMgb2YKUENJX0VYUF9MTktDVEwyIHJlZ2lzdGVy LiBBcm1hZGEgMzcwMCBGdW5jdGlvbmFsIFNwZWNpZmljYXRpb25zIHNheXMgdGhhdAp0aGUgZGVm YXVsdCB2YWx1ZSBvZiBQQ0lfRVhQX0xOS0NUTDJfVExTIGlzIGJhc2VkIG9uIFNQRUVEX0dFTiB2 YWx1ZSwgYnV0CnRlc3RzIHNob3dlZCB0aGF0IHRoZSBkZWZhdWx0IHZhbHVlIGlzIGFsd2F5cyA4 LjAgR1QvcywgaW5kZXBlbmRlbnRseSBvZgpzcGVlZCBzZXQgYnkgU1BFRURfR0VOLiBTbyBhZnRl ciBzZXR0aW5nIFNQRUVEX0dFTiwgd2UgbXVzdCBhbHNvIHNldCB2YWx1ZQppbiBQQ0lfRVhQX0xO S0NUTDIgcmVnaXN0ZXIgdmlhIFBDSV9FWFBfTE5LQ1RMMl9UTFMgYml0cy4KClRyaWdnZXJpbmcg UENJX0VYUF9MTktDVExfUkwgYml0IGltbWVkaWF0ZWx5IGFmdGVyIHNldHRpbmcgTElOS19UUkFJ TklOR19FTgpiaXQgYWN0dWFsbHkgZG9lc24ndCBkbyBhbnl0aGluZy4gVGVzdHMgaGF2ZSBzaG93 biB0aGF0IGEgZGVsYXkgaXMgbmVlZGVkCmFmdGVyIGVuYWJsaW5nIExJTktfVFJBSU5JTkdfRU4g Yml0LiBBcyB0cmlnZ2VyaW5nIFBDSV9FWFBfTE5LQ1RMX1JMCmN1cnJlbnRseSBkb2VzIG5vdGhp bmcsIHJlbW92ZSBpdC4KCkNvbW1pdCA0M2ZjNjc5Y2VkMTggKCJQQ0k6IGFhcmR2YXJrOiBJbXBy b3ZlIGxpbmsgdHJhaW5pbmciKSBpbnRyb2R1Y2VkCmNvZGUgd2hpY2ggc2V0cyBTUEVFRF9HRU4g cmVnaXN0ZXIgYmFzZWQgb24gbmVnb3RpYXRlZCBsaW5rIHNwZWVkIGZyb20KUENJX0VYUF9MTktT VEFfQ0xTIGJpdHMgb2YgUENJX0VYUF9MTktTVEEgcmVnaXN0ZXIuIFRoaXMgY29kZSB3YXMgYWRk ZWQgdG8KZml4IGRldGVjdGlvbiBvZiBDb21wZXggV0xFOTAwVlggKEF0aGVyb3MgUUNBOTg4MCkg V2lGaSBHRU4xIFBDSWUgY2FyZHMsIGFzCm90aGVyd2lzZSB0aGVzZSBjYXJkcyB3ZXJlICJpbnZp c2libGUiIG9uIFBDSWUgYnVzIChwcm9iYWJseSBiZWNhdXNlIHRoZXkKY3Jhc2hlZCkuIEJ1dCBh cHBhcmVudGx5IG1vcmUgcGVvcGxlIHJlcG9ydGVkIHRoZSBzYW1lIGlzc3VlcyB3aXRoIHRoZXNl CmNhcmRzIGFsc28gd2l0aCBvdGhlciBQQ0llIGNvbnRyb2xsZXJzIFsxXSBhbmQgSSB3YXMgYWJs ZSB0byByZXByb2R1Y2UgdGhpcwppc3N1ZSBhbHNvIHdpdGggb3RoZXIgIm5vbmFtZSIgV2lGaSBj YXJkcyBiYXNlZCBvbiBBdGhlcm9zIFFDQTk4OTAgY2hpcAood2l0aCB0aGUgc2FtZSBQQ0kgdmVu ZG9yL2RldmljZSBpZHMgYXMgQXRoZXJvcyBRQ0E5ODgwKS4gU28gdGhpcyBpcyBub3QgYW4KaXNz dWUgaW4gYWFyZHZhcmsgYnV0IHJhdGhlciBpc3N1ZSBpbiBBdGhlcm9zIFFDQTk4eHggY2hpcHMu IEFsc28sIHRoaXMKaXNzdWUgb25seSBleGlzdHMgaWYgdGhlIGtlcm5lbCBpcyBjb21waWxlZCB3 aXRoIFBDSWUgQVNQTSBzdXBwb3J0LCBhbmQgYQpnZW5lcmljIHdvcmthcm91bmQgZm9yIHRoaXMg aXMgdG8gY2hhbmdlIFBDSWUgQnJpZGdlIHRvIDIuNSBHVC9zIGxpbmsgc3BlZWQKdmlhIFBDSV9F WFBfTE5LQ1RMMl9UTFNfMl81R1QgYml0cyBpbiBQQ0lfRVhQX0xOS0NUTDIgcmVnaXN0ZXIgWzJd LCBiZWZvcmUKdHJpZ2dlcmluZyBQQ0lfRVhQX0xOS0NUTF9STCBiaXQuIFRoaXMgd29ya2Fyb3Vu ZCBhbHNvIHdvcmtzIHdoZW4gU1BFRURfR0VOCmlzIHNldCB0byB2YWx1ZSBHRU4yICg1IEdUL3Mp LiBTbyByZW1vdmUgdGhpcyBoYWNrIGNvbXBsZXRlbHkgaW4gdGhlCmFhcmR2YXJrIGRyaXZlciBh bmQgYWx3YXlzIHNldCBTUEVFRF9HRU4gdG8gdmFsdWUgZnJvbSAnbWF4LWxpbmstc3BlZWQnIERU CnByb3BlcnR5LiBGaXggZm9yIEF0aGVyb3MgUUNBOTh4eCBjaGlwcyBpcyBoYW5kbGVkIHNlcGFy YXRlbHkgYnkgcGF0Y2ggWzJdLgoKVGhlc2UgdHdvIHRoaW5ncyAoY29kZSBmb3IgdHJpZ2dlcmlu ZyBQQ0lfRVhQX0xOS0NUTF9STCBiaXQgYW5kIGNoYW5naW5nClNQRUVEX0dFTiB2YWx1ZSkgYWxz byBleHBsYWluIHdoeSBjb21taXQgNjk2NDQ5NDU4MmY1ICgiUENJOiBhYXJkdmFyazoKVHJhaW4g bGluayBpbW1lZGlhdGVseSBhZnRlciBlbmFibGluZyB0cmFpbmluZyIpIHNvbWVob3cgZml4ZWQg ZGV0ZWN0aW9uIG9mCnRob3NlIHByb2JsZW1hdGljIENvbXBleCBjYXJkcyB3aXRoIEF0aGVyb3Mg Y2hpcHM6IGlmIHRyaWdnZXJpbmcgbGluawpyZXRyYWluaW5nICh2aWEgUENJX0VYUF9MTktDVExf UkwgYml0KSB3YXMgZG9uZSBpbW1lZGlhdGVseSBhZnRlciBlbmFibGluZwpsaW5rIHRyYWluaW5n ICh2aWEgTElOS19UUkFJTklOR19FTiksIGl0IGRpZCBub3RoaW5nLiBJZiB0aGVyZSB3YXMgYQpz cGVjaWZpYyBkZWxheSwgYWFyZHZhcmsgSFcgYWxyZWFkeSBpbml0aWFsaXplZCBQQ0llIGxpbmsg YW5kIHRoZXJlZm9yZQp0cmlnZ2VyaW5nIGxpbmsgcmV0cmFpbmluZyBjYXVzZWQgdGhlIGFib3Zl IGlzc3VlLiBDb21wZXggY2FyZHMgdHJpZ2dlcmVkCmxpbmsgZG93biBldmVudCBhbmQgZGlzYXBw ZWFyZWQgZnJvbSB0aGUgUENJZSBidXMuCgpDb21taXQgZjRjN2QwNTNkN2Y3ICgiUENJOiBhYXJk dmFyazogV2FpdCBmb3IgZW5kcG9pbnQgdG8gYmUgcmVhZHkgYmVmb3JlCnRyYWluaW5nIGxpbmsi KSBhZGRlZCAxMDBtcyBzbGVlcCBiZWZvcmUgY2FsbGluZyAnU3RhcnQgbGluayB0cmFpbmluZycK Y29tbWFuZCBhbmQgZXhwbGFpbmVkIHRoYXQgaXQgaXMgYSByZXF1aXJlbWVudCBvZiBQQ0kgRXhw cmVzcwpzcGVjaWZpY2F0aW9uLiBCdXQgdGhlIGNvZGUgYWZ0ZXIgdGhpcyAxMDBtcyBzbGVlcCB3 YXMgbm90IGRvaW5nICdTdGFydApsaW5rIHRyYWluaW5nJywgcmF0aGVyIGl0IHRyaWdnZXJlZCBQ Q0lfRVhQX0xOS0NUTF9STCBiaXQgdmlhIFBDSWUgUm9vdApCcmlkZ2UgdG8gcHV0IGxpbmsgaW50 byBSZWNvdmVyeSBzdGF0ZS4KClRoZSByZXF1aXJlZCBkZWxheSBhZnRlciBmdW5kYW1lbnRhbCBy ZXNldCBpcyBhbHJlYWR5IGRvbmUgaW4gZnVuY3Rpb24KYWR2a19wY2llX3dhaXRfZm9yX2xpbmso KSB3aGljaCBhbHNvIGNoZWNrIHdoZW4gUENJZSBsaW5rIGlzIHVwLgoKU28gYWZ0ZXIgcmVtb3Zp bmcgdGhlIGNvZGUgd2hpY2ggdHJpZ2dlcnMgUENJX0VYUF9MTktDVExfUkwgYml0IG9uIFBDSWUK Um9vdCBCcmlkZ2UsIHRoZXJlIGlzIG5vIG5lZWQgdG8gd2FpdCAxMDBtcyBhZ2Fpbi4gUmVtb3Zl IHRoZSBleHRyYQptc2xlZXAoKSBjYWxsIGFuZCB1cGRhdGUgY29tbWVudCBhYm91dCB0aGUgZGVs YXkgcmVxdWlyZWQgYnkgdGhlIFBDSQpFeHByZXNzIHNwZWNpZmljYXRpb24uCgpBY2NvcmRpbmcg dG8gTWFydmVsbCBBcm1hZGEgMzcwMCBGdW5jdGlvbmFsIFNwZWNpZmljYXRpb25zLCBMaW5rIHRy YWluaW5nCnNob3VsZCBiZSBlbmFibGVkIHZpYSBhYXJkdmFyayByZWdpc3RlciBMSU5LX1RSQUlO SU5HX0VOIGFmdGVyIHNlbGVjdGluZwpQQ0llIGdlbmVyYXRpb24gYW5kIHgxIGxhbmUuIFRoZXJl IGlzIG5vIG5lZWQgdG8gZGlzYWJsZSBpdCBwcmlvciByZXNldHRpbmcKY2FyZCB2aWEgUEVSU1Qj IHNpZ25hbC4gVGhpcyBkaXNhYmxpbmcgY29kZSB3YXMgaW50cm9kdWNlZCBpbiBjb21taXQKNTE2 OWE5ODUxZGFhICgiUENJOiBhYXJkdmFyazogSXNzdWUgUEVSU1QgdmlhIEdQSU8iKSBhcyBhIHdv cmthcm91bmQgZm9yCnNvbWUgQXRoZXJvcyBjYXJkcy4gSXQgdHVybnMgb3V0IHRoYXQgdGhpcyBh bHNvIGlzIEF0aGVyb3Mgc3BlY2lmaWMgaXNzdWUKYW5kIGFmZmVjdHMgYW55IFBDSWUgY29udHJv bGxlciwgbm90IG9ubHkgYWFyZHZhcmsuIE1vcmVvdmVyIHRoaXMgQXRoZXJvcwppc3N1ZSB3YXMg dHJpZ2dlcmVkIGJ5IGp1Z2dsaW5nIHdpdGggUENJX0VYUF9MTktDVExfUkwsIExJTktfVFJBSU5J TkdfRU4KYW5kIFNQRUVEX0dFTiBiaXRzIGludGVybGVhdmVkIHdpdGggc2xlZXBzLiBOb3csIGFm dGVyIHJlbW92aW5nIHRyaWdnZXJpbmcKUENJX0VYUF9MTktDVExfUkwsIHRoZXJlIGlzIG5vIG5l ZWQgdG8gZXhwbGljaXRseSBkaXNhYmxlIExJTktfVFJBSU5JTkdfRU4KYml0LiBTbyByZW1vdmUg dGhpcyBjb2RlIHRvby4gVGhlIHByb2JsZW1hdGljIENvbXBleCBjYXJkcyBkZXNjcmliZWQgaW4K cHJldmlvdXMgZ2l0IGNvbW1pdHMgYXJlIGNvcnJlY3RseSBkZXRlY3RlZCBpbiBhZHZrX3BjaWVf dHJhaW5fbGluaygpCmZ1bmN0aW9uIGV2ZW4gYWZ0ZXIgYXBwbHlpbmcgYWxsIHRoZXNlIGNoYW5n ZXMuCgpOb3RlIHRoYXQgd2l0aCB0aGlzIHBhdGNoLCBhbmQgYWxzbyBwcmlvciB0aGlzIHBhdGNo LCBzb21lIE5WTWUgZGlza3Mgd2hpY2gKc3VwcG9ydCBQQ0llIEdFTjMgd2l0aCA4IEdUL3Mgc3Bl ZWQgYXJlIG5lZ290aWF0ZWQgb25seSBhdCB0aGUgbG93ZXN0IGxpbmsKc3BlZWQgMi41IEdUL3Ms IGluZGVwZW5kZW50bHkgb2YgU1BFRURfR0VOIHZhbHVlLiBBZnRlciBtYW51YWxseSB0cmlnZ2Vy aW5nClBDSV9FWFBfTE5LQ1RMX1JMIGJpdCAoZS5nLiBmcm9tIHVzZXJzcGFjZSB2aWEgc2V0cGNp KSwgdGhlc2UgTlZNZSBkaXNrcwpjaGFuZ2UgbGluayBzcGVlZCB0byA1IEdUL3Mgd2hlbiBTUEVF RF9HRU4gd2FzIGNvbmZpZ3VyZWQgdG8gR0VOMi4gVGhpcwppc3N1ZSBmaXJzdCBuZWVkcyB0byBi ZSBwcm9wZXJseSBpbnZlc3RpZ2F0ZWQuIEkgd2lsbCBzZW5kIGEgZml4IGluIHRoZQpmdXR1cmUu CgpPbiB0aGUgb3RoZXIgaGFuZCwgc29tZSBvdGhlciBHRU4yIFBDSWUgY2FyZHMgd2l0aCA1IEdU L3Mgc3BlZWQgYXJlCmF1dG9ub21vdXNseSBieSBIVyBhdXRvbmVnb3RpYXRlZCBhdCBmdWxsIDUg R1QvcyBzcGVlZCB3aXRob3V0IG5lZWQgb2YgYW55CnNvZnR3YXJlIGludGVyYWN0aW9uLgoKQXJt YWRhIDM3MDAgRnVuY3Rpb25hbCBTcGVjaWZpY2F0aW9ucyBkZXNjcmliZXMgdGhlIGZvbGxvd2lu ZyBzdGVwcyBmb3IKbGluayB0cmFpbmluZzogc2V0IFNQRUVEX0dFTiB0byBHRU4yLCBlbmFibGUg TElOS19UUkFJTklOR19FTiwgcG9sbCB1bnRpbApsaW5rIHRyYWluaW5nIGlzIGNvbXBsZXRlLCB0 cmlnZ2VyIFBDSV9FWFBfTE5LQ1RMX1JMLCBwb2xsIHVudGlsIHNpZ25hbApyYXRlIGlzIDUgR1Qv cywgcG9sbCB1bnRpbCBsaW5rIHRyYWluaW5nIGlzIGNvbXBsZXRlLCBlbmFibGUgQVNQTSBMMHMu CgpUaGUgcmVxdWlyZW1lbnQgZm9yIHRyaWdnZXJpbmcgUENJX0VYUF9MTktDVExfUkwgY2FuIGJl IGV4cGxhaW5lZCBieSB0aGUKbmVlZCB0byBhY2hpZXZlIDUgR1QvcyBzcGVlZCAoYXMgY2hhbmdp bmcgbGluayBzcGVlZCBpcyBkb25lIGJ5IHRocm93IHRvCnJlY292ZXJ5IHN0YXRlIGVudGVyZWQg YnkgUENJX0VYUF9MTktDVExfUkwpIG9yIG1heWJlIGFzIGEgcGFydCBvZiBlbmFibGluZwpBU1BN IEwwcyAoYnV0IGluIHRoaXMgY2FzZSBBU1BNIEwwcyBzaG91bGQgaGF2ZSBiZWVuIGVuYWJsZWQg cHJpb3IKUENJX0VYUF9MTktDVExfUkwpLgoKSXQgaXMgdW5rbm93biB3aHkgdGhlIG9yaWdpbmFs IHBjaS1hYXJkdmFyay5jIGRyaXZlciB3YXMgdHJpZ2dlcmluZwpQQ0lfRVhQX0xOS0NUTF9STCBi aXQgYmVmb3JlIHdhaXRpbmcgZm9yIHRoZSBsaW5rIHRvIGJlIHVwLiBUaGlzIGRvZXMgbm90CmFs aWduIHdpdGggbmVpdGhlciBQQ0llIGJhc2Ugc3BlY2lmaWNhdGlvbnMgbm9yIHdpdGggQXJtYWRh IDM3MDAgRnVuY3Rpb25hbApTcGVjaWZpY2F0aW9uLiAoTm90ZSB0aGF0IGluIG9sZGVyIHZlcnNp b25zIG9mIGFhcmR2YXJrLCB0aGlzIGJpdCB3YXMKY2FsbGVkIGluY29ycmVjdGx5IFBDSUVfQ09S RV9MSU5LX1RSQUlOSU5HLCBzbyB0aGlzIG1heSBiZSB0aGUgcmVhc29uLikKCkl0IGlzIGFsc28g dW5rbm93biB3aHkgQXJtYWRhIDM3MDAgRnVuY3Rpb25hbCBTcGVjaWZpY2F0aW9uIHNheXMgdGhh dCBpdCBpcwpuZWVkZWQgdG8gdHJpZ2dlciBQQ0lfRVhQX0xOS0NUTF9STCBmb3IgR0VOMiBtb2Rl LCBhcyBhY2NvcmRpbmcgdG8gUENJZQpiYXNlIHNwZWNpZmljYXRpb24gNSBHVC9zIHNwZWVkIG5l Z290aWF0aW9uIGlzIHN1cHBvc2VkIHRvIGJlIGVudGlyZWx5CmF1dG9ub21vdXMsIGV2ZW4gaWYg aW5pdGlhbCBzcGVlZCBpcyAyLjUgR1Qvcy4KClsxXSAtIGh0dHBzOi8vbG9yZS5rZXJuZWwub3Jn L2xpbnV4LXBjaS84N2g3bDhheHFwLmZzZkB0b2tlLmRrLwpbMl0gLSBodHRwczovL2xvcmUua2Vy bmVsLm9yZy9saW51eC1wY2kvMjAyMTAzMjYxMjQzMjYuMjExNjMtMS1wYWxpQGtlcm5lbC5vcmcv CgpTaWduZWQtb2ZmLWJ5OiBQYWxpIFJvaMOhciA8cGFsaUBrZXJuZWwub3JnPgpSZXZpZXdlZC1i eTogTWFyZWsgQmVow7puIDxrYWJlbEBrZXJuZWwub3JnPgpDYzogc3RhYmxlQHZnZXIua2VybmVs Lm9yZyAjIGY0YzdkMDUzZDdmNyAoIlBDSTogYWFyZHZhcms6IFdhaXQgZm9yIGVuZHBvaW50IHRv IGJlIHJlYWR5IGJlZm9yZSB0cmFpbmluZyBsaW5rIikKQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5v cmcgIyA2OTY0NDk0NTgyZjUgKCJQQ0k6IGFhcmR2YXJrOiBUcmFpbiBsaW5rIGltbWVkaWF0ZWx5 IGFmdGVyIGVuYWJsaW5nIHRyYWluaW5nIikKQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcgIyA0 M2ZjNjc5Y2VkMTggKCJQQ0k6IGFhcmR2YXJrOiBJbXByb3ZlIGxpbmsgdHJhaW5pbmciKQpDYzog c3RhYmxlQHZnZXIua2VybmVsLm9yZyAjIDUxNjlhOTg1MWRhYSAoIlBDSTogYWFyZHZhcms6IElz c3VlIFBFUlNUIHZpYSBHUElPIikKQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcgIyA5NmJlMzZk YmZmYWMgKCJQQ0k6IGFhcmR2YXJrOiBSZXBsYWNlIGN1c3RvbSBtYWNyb3MgYnkgc3RhbmRhcmQg bGludXgvcGNpX3JlZ3MuaCBtYWNyb3MiKQpDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZyAjIGQw YzZhMzQ3NWIwMyAoIlBDSTogYWFyZHZhcms6IE1vdmUgUENJZSByZXNldCBjYXJkIGNvZGUgdG8g YWR2a19wY2llX3RyYWluX2xpbmsoKSIpCkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnICMgMWQx Y2QxNjNkMGRlICgiUENJOiBhYXJkdmFyazogVXBkYXRlIGNvbW1lbnQgYWJvdXQgZGlzYWJsaW5n IGxpbmsgdHJhaW5pbmciKQotLS0KIGRyaXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLWFhcmR2YXJr LmMgfCAxMTcgKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAzNCBp bnNlcnRpb25zKCspLCA4MyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9j b250cm9sbGVyL3BjaS1hYXJkdmFyay5jIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktYWFy ZHZhcmsuYwppbmRleCBlMjk3ZWM5ZWMzOTAuLmVkZWFjZDk1Mjk3ZSAxMDA2NDQKLS0tIGEvZHJp dmVycy9wY2kvY29udHJvbGxlci9wY2ktYWFyZHZhcmsuYworKysgYi9kcml2ZXJzL3BjaS9jb250 cm9sbGVyL3BjaS1hYXJkdmFyay5jCkBAIC0yMDksMTEgKzIwOSw2IEBAIHN0YXRpYyBpbmxpbmUg dTMyIGFkdmtfcmVhZGwoc3RydWN0IGFkdmtfcGNpZSAqcGNpZSwgdTY0IHJlZykKIAlyZXR1cm4g cmVhZGwocGNpZS0+YmFzZSArIHJlZyk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdTE2IGFkdmtfcmVh ZDE2KHN0cnVjdCBhZHZrX3BjaWUgKnBjaWUsIHU2NCByZWcpCi17Ci0JcmV0dXJuIGFkdmtfcmVh ZGwocGNpZSwgKHJlZyAmIH4weDMpKSA+PiAoKHJlZyAmIDB4MykgKiA4KTsKLX0KLQogc3RhdGlj IGludCBhZHZrX3BjaWVfbGlua191cChzdHJ1Y3QgYWR2a19wY2llICpwY2llKQogewogCXUzMiB2 YWwsIGx0c3NtX3N0YXRlOwpAQCAtMjUxLDIzICsyNDYsOSBAQCBzdGF0aWMgdm9pZCBhZHZrX3Bj aWVfd2FpdF9mb3JfcmV0cmFpbihzdHJ1Y3QgYWR2a19wY2llICpwY2llKQogCiBzdGF0aWMgdm9p ZCBhZHZrX3BjaWVfaXNzdWVfcGVyc3Qoc3RydWN0IGFkdmtfcGNpZSAqcGNpZSkKIHsKLQl1MzIg cmVnOwotCiAJaWYgKCFwY2llLT5yZXNldF9ncGlvKQogCQlyZXR1cm47CiAKLQkvKgotCSAqIEFz IHJlcXVpcmVkIGJ5IFBDSSBFeHByZXNzIHNwZWMgKFBDSSBFeHByZXNzIEJhc2UgU3BlY2lmaWNh dGlvbiwgUkVWLgotCSAqIDQuMCBQQ0kgRXhwcmVzcywgRmVicnVhcnkgMTkgMjAxNCwgNi42LjEg Q29udmVudGlvbmFsIFJlc2V0KSBhIGRlbGF5Ci0JICogZm9yIGF0IGxlYXN0IDEwMG1zIGFmdGVy IGRlLWFzc2VydGluZyBQRVJTVCMgc2lnbmFsIGlzIG5lZWRlZCBiZWZvcmUKLQkgKiBsaW5rIHRy YWluaW5nIGlzIGVuYWJsZWQuIFNvIGVuc3VyZSB0aGF0IGxpbmsgdHJhaW5pbmcgaXMgZGlzYWJs ZWQKLQkgKiBwcmlvciBkZS1hc3NlcnRpbmcgUEVSU1QjIHNpZ25hbCB0byBmdWxmaWxsIHRoYXQg UENJIEV4cHJlc3Mgc3BlYwotCSAqIHJlcXVpcmVtZW50LgotCSAqLwotCXJlZyA9IGFkdmtfcmVh ZGwocGNpZSwgUENJRV9DT1JFX0NUUkwwX1JFRyk7Ci0JcmVnICY9IH5MSU5LX1RSQUlOSU5HX0VO OwotCWFkdmtfd3JpdGVsKHBjaWUsIHJlZywgUENJRV9DT1JFX0NUUkwwX1JFRyk7Ci0KIAkvKiAx MG1zIGRlbGF5IGlzIG5lZWRlZCBmb3Igc29tZSBjYXJkcyAqLwogCWRldl9pbmZvKCZwY2llLT5w ZGV2LT5kZXYsICJpc3N1aW5nIFBFUlNUIHZpYSByZXNldCBHUElPIGZvciAxMG1zXG4iKTsKIAln cGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAocGNpZS0+cmVzZXRfZ3BpbywgMSk7CkBAIC0yNzUsNTMg KzI1Niw0NiBAQCBzdGF0aWMgdm9pZCBhZHZrX3BjaWVfaXNzdWVfcGVyc3Qoc3RydWN0IGFkdmtf cGNpZSAqcGNpZSkKIAlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAocGNpZS0+cmVzZXRfZ3Bpbywg MCk7CiB9CiAKLXN0YXRpYyBpbnQgYWR2a19wY2llX3RyYWluX2F0X2dlbihzdHJ1Y3QgYWR2a19w Y2llICpwY2llLCBpbnQgZ2VuKQorc3RhdGljIHZvaWQgYWR2a19wY2llX3RyYWluX2xpbmsoc3Ry dWN0IGFkdmtfcGNpZSAqcGNpZSkKIHsKLQlpbnQgcmV0LCBuZWdfZ2VuOworCXN0cnVjdCBkZXZp Y2UgKmRldiA9ICZwY2llLT5wZGV2LT5kZXY7CiAJdTMyIHJlZzsKKwlpbnQgcmV0OwogCi0JLyog U2V0dXAgbGluayBzcGVlZCAqLworCS8qCisJICogU2V0dXAgUENJZSByZXYgLyBnZW4gY29tcGxp YW5jZSBiYXNlZCBvbiBkZXZpY2UgdHJlZSBwcm9wZXJ0eQorCSAqICdtYXgtbGluay1zcGVlZCcg d2hpY2ggYWxzbyBmb3JjZXMgbWF4aW1hbCBsaW5rIHNwZWVkLgorCSAqLwogCXJlZyA9IGFkdmtf cmVhZGwocGNpZSwgUENJRV9DT1JFX0NUUkwwX1JFRyk7CiAJcmVnICY9IH5QQ0lFX0dFTl9TRUxf TVNLOwotCWlmIChnZW4gPT0gMykKKwlpZiAocGNpZS0+bGlua19nZW4gPT0gMykKIAkJcmVnIHw9 IFNQRUVEX0dFTl8zOwotCWVsc2UgaWYgKGdlbiA9PSAyKQorCWVsc2UgaWYgKHBjaWUtPmxpbmtf Z2VuID09IDIpCiAJCXJlZyB8PSBTUEVFRF9HRU5fMjsKIAllbHNlCiAJCXJlZyB8PSBTUEVFRF9H RU5fMTsKIAlhZHZrX3dyaXRlbChwY2llLCByZWcsIFBDSUVfQ09SRV9DVFJMMF9SRUcpOwogCiAJ LyoKLQkgKiBFbmFibGUgbGluayB0cmFpbmluZy4gVGhpcyBpcyBub3QgbmVlZGVkIGluIGV2ZXJ5 IGNhbGwgdG8gdGhpcwotCSAqIGZ1bmN0aW9uLCBqdXN0IG9uY2Ugc3VmZmljZXMsIGJ1dCBpdCBk b2VzIG5vdCBicmVhayBhbnl0aGluZyBlaXRoZXIuCisJICogU2V0IG1heGltYWwgbGluayBzcGVl ZCB2YWx1ZSBhbHNvIGludG8gUENJZSBMaW5rIENvbnRyb2wgMiByZWdpc3Rlci4KKwkgKiBBcm1h ZGEgMzcwMCBGdW5jdGlvbmFsIFNwZWNpZmljYXRpb24gc2F5cyB0aGF0IGRlZmF1bHQgdmFsdWUg aXMgYmFzZWQKKwkgKiBvbiBTUEVFRF9HRU4gYnV0IHRlc3RzIHNob3dlZCB0aGF0IGRlZmF1bHQg dmFsdWUgaXMgYWx3YXlzIDguMCBHVC9zLgogCSAqLworCXJlZyA9IGFkdmtfcmVhZGwocGNpZSwg UENJRV9DT1JFX1BDSUVYUF9DQVAgKyBQQ0lfRVhQX0xOS0NUTDIpOworCXJlZyAmPSB+UENJX0VY UF9MTktDVEwyX1RMUzsKKwlpZiAocGNpZS0+bGlua19nZW4gPT0gMykKKwkJcmVnIHw9IFBDSV9F WFBfTE5LQ1RMMl9UTFNfOF8wR1Q7CisJZWxzZSBpZiAocGNpZS0+bGlua19nZW4gPT0gMikKKwkJ cmVnIHw9IFBDSV9FWFBfTE5LQ1RMMl9UTFNfNV8wR1Q7CisJZWxzZQorCQlyZWcgfD0gUENJX0VY UF9MTktDVEwyX1RMU18yXzVHVDsKKwlhZHZrX3dyaXRlbChwY2llLCByZWcsIFBDSUVfQ09SRV9Q Q0lFWFBfQ0FQICsgUENJX0VYUF9MTktDVEwyKTsKKworCS8qIEVuYWJsZSBsaW5rIHRyYWluaW5n IGFmdGVyIHNlbGVjdGluZyBQQ0llIGdlbmVyYXRpb24gKi8KIAlyZWcgPSBhZHZrX3JlYWRsKHBj aWUsIFBDSUVfQ09SRV9DVFJMMF9SRUcpOwogCXJlZyB8PSBMSU5LX1RSQUlOSU5HX0VOOwogCWFk dmtfd3JpdGVsKHBjaWUsIHJlZywgUENJRV9DT1JFX0NUUkwwX1JFRyk7CiAKLQkvKgotCSAqIFN0 YXJ0IGxpbmsgdHJhaW5pbmcgaW1tZWRpYXRlbHkgYWZ0ZXIgZW5hYmxpbmcgaXQuCi0JICogVGhp cyBzb2x2ZXMgcHJvYmxlbXMgZm9yIHNvbWUgYnVnZ3kgY2FyZHMuCi0JICovCi0JcmVnID0gYWR2 a19yZWFkbChwY2llLCBQQ0lFX0NPUkVfUENJRVhQX0NBUCArIFBDSV9FWFBfTE5LQ1RMKTsKLQly ZWcgfD0gUENJX0VYUF9MTktDVExfUkw7Ci0JYWR2a193cml0ZWwocGNpZSwgcmVnLCBQQ0lFX0NP UkVfUENJRVhQX0NBUCArIFBDSV9FWFBfTE5LQ1RMKTsKLQotCXJldCA9IGFkdmtfcGNpZV93YWl0 X2Zvcl9saW5rKHBjaWUpOwotCWlmIChyZXQpCi0JCXJldHVybiByZXQ7Ci0KLQlyZWcgPSBhZHZr X3JlYWQxNihwY2llLCBQQ0lFX0NPUkVfUENJRVhQX0NBUCArIFBDSV9FWFBfTE5LU1RBKTsKLQlu ZWdfZ2VuID0gcmVnICYgUENJX0VYUF9MTktTVEFfQ0xTOwotCi0JcmV0dXJuIG5lZ19nZW47Ci19 Ci0KLXN0YXRpYyB2b2lkIGFkdmtfcGNpZV90cmFpbl9saW5rKHN0cnVjdCBhZHZrX3BjaWUgKnBj aWUpCi17Ci0Jc3RydWN0IGRldmljZSAqZGV2ID0gJnBjaWUtPnBkZXYtPmRldjsKLQlpbnQgbmVn X2dlbiA9IC0xLCBnZW47Ci0KIAkvKgogCSAqIFJlc2V0IFBDSWUgY2FyZCB2aWEgUEVSU1QjIHNp Z25hbC4gU29tZSBjYXJkcyBhcmUgbm90IGRldGVjdGVkCiAJICogZHVyaW5nIGxpbmsgdHJhaW5p bmcgd2hlbiB0aGV5IGFyZSBpbiBzb21lIG5vbi1pbml0aWFsIHN0YXRlLgpAQCAtMzMyLDQxICsz MDYsMTggQEAgc3RhdGljIHZvaWQgYWR2a19wY2llX3RyYWluX2xpbmsoc3RydWN0IGFkdmtfcGNp ZSAqcGNpZSkKIAkgKiBQRVJTVCMgc2lnbmFsIGNvdWxkIGhhdmUgYmVlbiBhc3NlcnRlZCBieSBw aW5jdHJsIHN1YnN5c3RlbSBiZWZvcmUKIAkgKiBwcm9iZSgpIGNhbGxiYWNrIGhhcyBiZWVuIGNh bGxlZCBvciBpc3N1ZWQgZXhwbGljaXRseSBieSByZXNldCBncGlvCiAJICogZnVuY3Rpb24gYWR2 a19wY2llX2lzc3VlX3BlcnN0KCksIG1ha2luZyB0aGUgZW5kcG9pbnQgZ29pbmcgaW50bwotCSAq IGZ1bmRhbWVudGFsIHJlc2V0LiBBcyByZXF1aXJlZCBieSBQQ0kgRXhwcmVzcyBzcGVjIGEgZGVs YXkgZm9yIGF0Ci0JICogbGVhc3QgMTAwbXMgYWZ0ZXIgc3VjaCBhIHJlc2V0IGJlZm9yZSBsaW5r IHRyYWluaW5nIGlzIG5lZWRlZC4KLQkgKi8KLQltc2xlZXAoUENJX1BNX0QzQ09MRF9XQUlUKTsK LQotCS8qCi0JICogVHJ5IGxpbmsgdHJhaW5pbmcgYXQgbGluayBnZW4gc3BlY2lmaWVkIGJ5IGRl dmljZSB0cmVlIHByb3BlcnR5Ci0JICogJ21heC1saW5rLXNwZWVkJy4gSWYgdGhpcyBmYWlscywg aXRlcmF0aXZlbHkgdHJhaW4gYXQgbG93ZXIgZ2VuLgotCSAqLwotCWZvciAoZ2VuID0gcGNpZS0+ bGlua19nZW47IGdlbiA+IDA7IC0tZ2VuKSB7Ci0JCW5lZ19nZW4gPSBhZHZrX3BjaWVfdHJhaW5f YXRfZ2VuKHBjaWUsIGdlbik7Ci0JCWlmIChuZWdfZ2VuID4gMCkKLQkJCWJyZWFrOwotCX0KLQot CWlmIChuZWdfZ2VuIDwgMCkKLQkJZ290byBlcnI7Ci0KLQkvKgotCSAqIEFmdGVyIHN1Y2Nlc3Nm dWwgdHJhaW5pbmcgaWYgbmVnb3RpYXRlZCBnZW4gaXMgbG93ZXIgdGhhbiByZXF1ZXN0ZWQsCi0J ICogdHJhaW4gYWdhaW4gb24gbmVnb3RpYXRlZCBnZW4uIFRoaXMgc29sdmVzIHNvbWUgc3RhYmls aXR5IGlzc3VlcyBmb3IKLQkgKiBzb21lIGJ1Z2d5IGdlbjEgY2FyZHMuCisJICogZnVuZGFtZW50 YWwgcmVzZXQuIEFzIHJlcXVpcmVkIGJ5IFBDSSBFeHByZXNzIHNwZWMgKFBDSSBFeHByZXNzCisJ ICogQmFzZSBTcGVjaWZpY2F0aW9uLCBSRVYuIDQuMCBQQ0kgRXhwcmVzcywgRmVicnVhcnkgMTkg MjAxNCwgNi42LjEKKwkgKiBDb252ZW50aW9uYWwgUmVzZXQpIGEgZGVsYXkgZm9yIGF0IGxlYXN0 IDEwMG1zIGFmdGVyIHN1Y2ggYSByZXNldAorCSAqIGJlZm9yZSBzZW5kaW5nIGEgQ29uZmlndXJh dGlvbiBSZXF1ZXN0IHRvIHRoZSBkZXZpY2UgaXMgbmVlZGVkLgorCSAqIFNvIHdhaXQgdW50aWwg UENJZSBsaW5rIGlzIHVwLiBGdW5jdGlvbiBhZHZrX3BjaWVfd2FpdF9mb3JfbGluaygpCisJICog d2FpdHMgZm9yIGxpbmsgYXQgbGVhc3QgOTAwbXMuCiAJICovCi0JaWYgKG5lZ19nZW4gPCBnZW4p IHsKLQkJZ2VuID0gbmVnX2dlbjsKLQkJbmVnX2dlbiA9IGFkdmtfcGNpZV90cmFpbl9hdF9nZW4o cGNpZSwgZ2VuKTsKLQl9Ci0KLQlpZiAobmVnX2dlbiA9PSBnZW4pIHsKLQkJZGV2X2luZm8oZGV2 LCAibGluayB1cCBhdCBnZW4gJWlcbiIsIGdlbik7Ci0JCXJldHVybjsKLQl9Ci0KLWVycjoKLQlk ZXZfZXJyKGRldiwgImxpbmsgbmV2ZXIgY2FtZSB1cFxuIik7CisJcmV0ID0gYWR2a19wY2llX3dh aXRfZm9yX2xpbmsocGNpZSk7CisJaWYgKHJldCA8IDApCisJCWRldl9lcnIoZGV2LCAibGluayBu ZXZlciBjYW1lIHVwXG4iKTsKKwllbHNlCisJCWRldl9pbmZvKGRldiwgImxpbmsgdXBcbiIpOwog fQogCiBzdGF0aWMgdm9pZCBhZHZrX3BjaWVfc2V0dXBfaHcoc3RydWN0IGFkdmtfcGNpZSAqcGNp ZSkKLS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlz dHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LWFybS1rZXJuZWwK