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 61513C4167B for ; Thu, 25 Nov 2021 12:48:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347925AbhKYMv5 (ORCPT ); Thu, 25 Nov 2021 07:51:57 -0500 Received: from mail.kernel.org ([198.145.29.99]:45588 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1354607AbhKYMvq (ORCPT ); Thu, 25 Nov 2021 07:51:46 -0500 Received: by mail.kernel.org (Postfix) with ESMTPSA id E5F1D6112E; Thu, 25 Nov 2021 12:46:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1637844402; bh=Mty959mLbQPgGqYK1YgoWBQXMBWeDHeOIHaBNRXQLDE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GZ8jAeCM1FvwWsjUuBg22F3rqTn5Gxri9xshTqL27+M4DZFIHFMqelcZo4gZzIB7k YRWlQcuuT9pTyetEgh+/jrN1DhhrNriQJ+FSS/eA+8enUxQGrTvOvT3WmgRszWIa/r IiwwScu5hGrGYuD0e+Yz1Di/hTXGBBaoDr3wV5P/9RWhE9qr4uJEDOyYj5nXIVf4IJ hyXUkgYY7TSYEdyIQ27zD4WOUV8b5jL/Lvey24mJ5AimP73nJXvzofRa3vtK1Q5H3a sFz4rKoY3CghoBHbHSpaWLXcUUC+cnE9BobMHgArFX0kVd6uiJVP2P+8C3bmCx32XR ALDcUhSAkkHeg== Received: by pali.im (Postfix) id A5A7867E; Thu, 25 Nov 2021 13:46:41 +0100 (CET) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Thomas Petazzoni , Lorenzo Pieralisi , Rob Herring , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , Bjorn Helgaas , =?UTF-8?q?Marek=20Beh=C3=BAn?= Cc: linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH 11/15] PCI: mvebu: Fix configuring secondary bus of PCIe Root Port via emulated bridge Date: Thu, 25 Nov 2021 13:46:01 +0100 Message-Id: <20211125124605.25915-12-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20211125124605.25915-1-pali@kernel.org> References: <20211125124605.25915-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 It looks like that mvebu PCIe controller has for each PCIe link fully independent PCIe host bridge and so every PCIe Root Port is isolated not only on its own bus but also isolated from each others. But in past device tree structure was defined to put all PCIe Root Ports (as PCI Bridge devices) into one root bus 0 and this bus is emulated by pci-mvebu.c driver. Probably reason for this decision was incorrect understanding of PCIe topology of these Armada SoCs and also reason of misunderstanding how is PCIe controller generating Type 0 and Type 1 config requests (it is fully different compared to other drivers). Probably incorrect setup leaded to very surprised things like having PCIe Root Port (PCI Bridge device, with even incorrect Device Class set to Memory Controller) and the PCIe device behind the Root Port on the same PCI bus, which obviously was needed to somehow hack (as these two devices cannot be in reality on the same bus). Properly set mvebu local bus number and mvebu local device number based on PCI Bridge secondary bus number configuration. Also correctly report configured secondary bus number in config space. And explain in driver comment why this setup is correct. Signed-off-by: Pali Rohár Fixes: 1f08673eef12 ("PCI: mvebu: Convert to PCI emulated bridge config space") Cc: stable@vger.kernel.org --- drivers/pci/controller/pci-mvebu.c | 98 +++++++++++++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-) diff --git a/drivers/pci/controller/pci-mvebu.c b/drivers/pci/controller/pci-mvebu.c index 4edce441901c..36fbdc4f0e06 100644 --- a/drivers/pci/controller/pci-mvebu.c +++ b/drivers/pci/controller/pci-mvebu.c @@ -127,6 +127,11 @@ static bool mvebu_pcie_link_up(struct mvebu_pcie_port *port) return !(mvebu_readl(port, PCIE_STAT_OFF) & PCIE_STAT_LINK_DOWN); } +static u8 mvebu_pcie_get_local_bus_nr(struct mvebu_pcie_port *port) +{ + return (mvebu_readl(port, PCIE_STAT_OFF) & PCIE_STAT_BUS) >> 8; +} + static void mvebu_pcie_set_local_bus_nr(struct mvebu_pcie_port *port, int nr) { u32 stat; @@ -490,6 +495,20 @@ mvebu_pci_bridge_emul_base_conf_read(struct pci_bridge_emul *bridge, *value = mvebu_readl(port, PCIE_CMD_OFF); break; + case PCI_PRIMARY_BUS: { + /* + * From the whole 32bit register we support reading from HW only + * secondary bus number which is mvebu local bus number. + * Other bits are retrieved only from emulated config buffer. + */ + __le32 *cfgspace = (__le32 *)&bridge->conf; + u32 val = le32_to_cpu(cfgspace[PCI_PRIMARY_BUS / 4]); + val &= ~0xff00; + val |= mvebu_pcie_get_local_bus_nr(port) << 8; + *value = val; + break; + } + default: return PCI_BRIDGE_EMUL_NOT_HANDLED; } @@ -594,7 +613,8 @@ mvebu_pci_bridge_emul_base_conf_write(struct pci_bridge_emul *bridge, break; case PCI_PRIMARY_BUS: - mvebu_pcie_set_local_bus_nr(port, conf->secondary_bus); + if (mask & 0xff00) + mvebu_pcie_set_local_bus_nr(port, conf->secondary_bus); break; default: @@ -1186,8 +1206,84 @@ static int mvebu_pcie_probe(struct platform_device *pdev) continue; } + /* + * PCIe topology exported by mvebu hw is quite complicated. In + * reality has something like N fully independent host bridges + * where each host bridge has one PCIe Root Port (which acts as + * PCI Bridge device). Each host bridge has its own independent + * internal registers, independent access to PCI config space, + * independent interrupt lines, independent window and memory + * access configuration. But additionally there is some kind of + * peer-to-peer support between PCIe devices behind different + * host bridges limited just to forwarding of memory and I/O + * transactions (forwarding of error messages and config cycles + * is not supported). So we could say there are N independent + * PCIe Root Complexes. + * + * For this kind of setup DT should have been structured into + * N independent PCIe controllers / host bridges. But instead + * structure in past was defined to put PCIe Root Ports of all + * host bridges into one bus zero, like in classic multi-port + * Root Complex setup with just one host bridge. + * + * This means that pci-mvebu.c driver provides "virtual" bus 0 + * on which registers all PCIe Root Ports (PCI Bridge devices) + * specified in DT by their BDF addresses and virtually routes + * PCI config access of each PCI bridge device to specific PCIe + * host bridge. + * + * Normally PCI Bridge should choose between Type 0 and Type 1 + * config requests based on primary and secondary bus numbers + * configured on the bridge itself. But because mvebu PCI Bridge + * does not have registers for primary and secondary bus numbers + * in its config space, it determinates type of config requests + * via its own custom way. + * + * There are two options how mvebu determinate type of config + * request. + * + * 1. If Secondary Bus Number Enable bit is not set or is not + * available (applies for pre-XP PCIe controllers) then Type 0 + * is used if target bus number equals Local Bus Number (bits + * [15:8] in register 0x1a04) and target device number differs + * from Local Device Number (bits [20:16] in register 0x1a04). + * Type 1 is used if target bus number differs from Local Bus + * Number. And when target bus number equals Local Bus Number + * and target device equals Local Device Number then request is + * routed to Local PCI Bridge (PCIe Root Port). + * + * 2. If Secondary Bus Number Enable bit is set (bit 7 in + * register 0x1a2c) then mvebu hw determinate type of config + * request like compliant PCI Bridge based on primary bus number + * which is configured via Local Bus Number (bits [15:8] in + * register 0x1a04) and secondary bus number which is configured + * via Secondary Bus Number (bits [7:0] in register 0x1a2c). + * Local PCI Bridge (PCIe Root Port) is available on primary bus + * as device with Local Device Number (bits [20:16] in register + * 0x1a04). + * + * Secondary Bus Number Enable bit is disabled by default and + * option 2. is not available on pre-XP PCIe controllers. Hence + * this driver always use option 1. + * + * Basically it means that primary and secondary buses shares + * one virtual number configured via Local Bus Number bits and + * Local Device Number bits determinates if accessing primary + * or secondary bus. Set Local Device Number to 1 and redirect + * all writes of PCI Bridge Secondary Bus Number register to + * Local Bus Number (bits [15:8] in register 0x1a04). + * + * So when accessing devices on buses behind secondary bus + * number it would work correctly. And also when accessing + * device 0 at secondary bus number via config space would be + * correctly routed to secondary bus. Due to issues described + * in mvebu_pcie_setup_hw(), PCI Bridges at primary bus (zero) + * are not accessed directly via PCI config space but rarher + * indirectly via kernel emulated PCI bridge driver. + */ mvebu_pcie_setup_hw(port); mvebu_pcie_set_local_dev_nr(port, 1); + mvebu_pcie_set_local_bus_nr(port, 0); } bridge->sysdata = 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 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 62DA1C433F5 for ; Thu, 25 Nov 2021 12:54:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id: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=oZmO8c5jKuJOmLYtpx7hduRDG3/puN0k83jfEdAdOOs=; b=UI9pDVvhJbhNX5 gm8tS4CNA2oy8P3at6z9QxLKveuc/x4CalGxeq5rRX6Jv08qCyz5TrgjjV4RmFpMyniui5tMdYwUH xWrcG3QENtY3ix5HDnBwQxskrPgNBIPBtfH7loYpxAUCGoydGyis2MG0CA25GrUZXddvIbCx9tfLN 4zFxPGgU1vBif253zUucZKTkRBbWSWXBMFmT3+hMX1B8P5vGERmr8E/iB8xdIHyH21sN5NbX1fU4o w4SkSin8hWbPfJJzB2H0PsRdgZUFquoa0sSL8uABCMRe332gL81B1soqHWkHLDEydcJJlOdDl58gh SDbgwFGny0N2kfygd8Yg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mqEEg-007VaQ-NX; Thu, 25 Nov 2021 12:52:22 +0000 Received: from mail.kernel.org ([198.145.29.99]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mqE9C-007SpG-Ce for linux-arm-kernel@lists.infradead.org; Thu, 25 Nov 2021 12:46:45 +0000 Received: by mail.kernel.org (Postfix) with ESMTPSA id E5F1D6112E; Thu, 25 Nov 2021 12:46:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1637844402; bh=Mty959mLbQPgGqYK1YgoWBQXMBWeDHeOIHaBNRXQLDE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GZ8jAeCM1FvwWsjUuBg22F3rqTn5Gxri9xshTqL27+M4DZFIHFMqelcZo4gZzIB7k YRWlQcuuT9pTyetEgh+/jrN1DhhrNriQJ+FSS/eA+8enUxQGrTvOvT3WmgRszWIa/r IiwwScu5hGrGYuD0e+Yz1Di/hTXGBBaoDr3wV5P/9RWhE9qr4uJEDOyYj5nXIVf4IJ hyXUkgYY7TSYEdyIQ27zD4WOUV8b5jL/Lvey24mJ5AimP73nJXvzofRa3vtK1Q5H3a sFz4rKoY3CghoBHbHSpaWLXcUUC+cnE9BobMHgArFX0kVd6uiJVP2P+8C3bmCx32XR ALDcUhSAkkHeg== Received: by pali.im (Postfix) id A5A7867E; Thu, 25 Nov 2021 13:46:41 +0100 (CET) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Thomas Petazzoni , Lorenzo Pieralisi , Rob Herring , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , Bjorn Helgaas , =?UTF-8?q?Marek=20Beh=C3=BAn?= Cc: linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH 11/15] PCI: mvebu: Fix configuring secondary bus of PCIe Root Port via emulated bridge Date: Thu, 25 Nov 2021 13:46:01 +0100 Message-Id: <20211125124605.25915-12-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20211125124605.25915-1-pali@kernel.org> References: <20211125124605.25915-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20211125_044642_584263_3FD72F1F X-CRM114-Status: GOOD ( 21.82 ) 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 SXQgbG9va3MgbGlrZSB0aGF0IG12ZWJ1IFBDSWUgY29udHJvbGxlciBoYXMgZm9yIGVhY2ggUENJ ZSBsaW5rIGZ1bGx5CmluZGVwZW5kZW50IFBDSWUgaG9zdCBicmlkZ2UgYW5kIHNvIGV2ZXJ5IFBD SWUgUm9vdCBQb3J0IGlzIGlzb2xhdGVkIG5vdApvbmx5IG9uIGl0cyBvd24gYnVzIGJ1dCBhbHNv IGlzb2xhdGVkIGZyb20gZWFjaCBvdGhlcnMuIEJ1dCBpbiBwYXN0IGRldmljZQp0cmVlIHN0cnVj dHVyZSB3YXMgZGVmaW5lZCB0byBwdXQgYWxsIFBDSWUgUm9vdCBQb3J0cyAoYXMgUENJIEJyaWRn ZQpkZXZpY2VzKSBpbnRvIG9uZSByb290IGJ1cyAwIGFuZCB0aGlzIGJ1cyBpcyBlbXVsYXRlZCBi eSBwY2ktbXZlYnUuYwpkcml2ZXIuCgpQcm9iYWJseSByZWFzb24gZm9yIHRoaXMgZGVjaXNpb24g d2FzIGluY29ycmVjdCB1bmRlcnN0YW5kaW5nIG9mIFBDSWUKdG9wb2xvZ3kgb2YgdGhlc2UgQXJt YWRhIFNvQ3MgYW5kIGFsc28gcmVhc29uIG9mIG1pc3VuZGVyc3RhbmRpbmcgaG93IGlzClBDSWUg Y29udHJvbGxlciBnZW5lcmF0aW5nIFR5cGUgMCBhbmQgVHlwZSAxIGNvbmZpZyByZXF1ZXN0cyAo aXQgaXMgZnVsbHkKZGlmZmVyZW50IGNvbXBhcmVkIHRvIG90aGVyIGRyaXZlcnMpLiBQcm9iYWJs eSBpbmNvcnJlY3Qgc2V0dXAgbGVhZGVkIHRvCnZlcnkgc3VycHJpc2VkIHRoaW5ncyBsaWtlIGhh dmluZyBQQ0llIFJvb3QgUG9ydCAoUENJIEJyaWRnZSBkZXZpY2UsIHdpdGgKZXZlbiBpbmNvcnJl Y3QgRGV2aWNlIENsYXNzIHNldCB0byBNZW1vcnkgQ29udHJvbGxlcikgYW5kIHRoZSBQQ0llIGRl dmljZQpiZWhpbmQgdGhlIFJvb3QgUG9ydCBvbiB0aGUgc2FtZSBQQ0kgYnVzLCB3aGljaCBvYnZp b3VzbHkgd2FzIG5lZWRlZCB0bwpzb21laG93IGhhY2sgKGFzIHRoZXNlIHR3byBkZXZpY2VzIGNh bm5vdCBiZSBpbiByZWFsaXR5IG9uIHRoZSBzYW1lIGJ1cykuCgpQcm9wZXJseSBzZXQgbXZlYnUg bG9jYWwgYnVzIG51bWJlciBhbmQgbXZlYnUgbG9jYWwgZGV2aWNlIG51bWJlciBiYXNlZCBvbgpQ Q0kgQnJpZGdlIHNlY29uZGFyeSBidXMgbnVtYmVyIGNvbmZpZ3VyYXRpb24uIEFsc28gY29ycmVj dGx5IHJlcG9ydApjb25maWd1cmVkIHNlY29uZGFyeSBidXMgbnVtYmVyIGluIGNvbmZpZyBzcGFj ZS4gQW5kIGV4cGxhaW4gaW4gZHJpdmVyCmNvbW1lbnQgd2h5IHRoaXMgc2V0dXAgaXMgY29ycmVj dC4KClNpZ25lZC1vZmYtYnk6IFBhbGkgUm9ow6FyIDxwYWxpQGtlcm5lbC5vcmc+CkZpeGVzOiAx ZjA4NjczZWVmMTIgKCJQQ0k6IG12ZWJ1OiBDb252ZXJ0IHRvIFBDSSBlbXVsYXRlZCBicmlkZ2Ug Y29uZmlnIHNwYWNlIikKQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcKLS0tCiBkcml2ZXJzL3Bj aS9jb250cm9sbGVyL3BjaS1tdmVidS5jIHwgOTggKysrKysrKysrKysrKysrKysrKysrKysrKysr KystCiAxIGZpbGUgY2hhbmdlZCwgOTcgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLW12ZWJ1LmMgYi9kcml2ZXJzL3Bj aS9jb250cm9sbGVyL3BjaS1tdmVidS5jCmluZGV4IDRlZGNlNDQxOTAxYy4uMzZmYmRjNGYwZTA2 IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jCisrKyBiL2Ry aXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLW12ZWJ1LmMKQEAgLTEyNyw2ICsxMjcsMTEgQEAgc3Rh dGljIGJvb2wgbXZlYnVfcGNpZV9saW5rX3VwKHN0cnVjdCBtdmVidV9wY2llX3BvcnQgKnBvcnQp CiAJcmV0dXJuICEobXZlYnVfcmVhZGwocG9ydCwgUENJRV9TVEFUX09GRikgJiBQQ0lFX1NUQVRf TElOS19ET1dOKTsKIH0KIAorc3RhdGljIHU4IG12ZWJ1X3BjaWVfZ2V0X2xvY2FsX2J1c19ucihz dHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0KQoreworCXJldHVybiAobXZlYnVfcmVhZGwocG9y dCwgUENJRV9TVEFUX09GRikgJiBQQ0lFX1NUQVRfQlVTKSA+PiA4OworfQorCiBzdGF0aWMgdm9p ZCBtdmVidV9wY2llX3NldF9sb2NhbF9idXNfbnIoc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9y dCwgaW50IG5yKQogewogCXUzMiBzdGF0OwpAQCAtNDkwLDYgKzQ5NSwyMCBAQCBtdmVidV9wY2lf YnJpZGdlX2VtdWxfYmFzZV9jb25mX3JlYWQoc3RydWN0IHBjaV9icmlkZ2VfZW11bCAqYnJpZGdl LAogCQkqdmFsdWUgPSBtdmVidV9yZWFkbChwb3J0LCBQQ0lFX0NNRF9PRkYpOwogCQlicmVhazsK IAorCWNhc2UgUENJX1BSSU1BUllfQlVTOiB7CisJCS8qCisJCSAqIEZyb20gdGhlIHdob2xlIDMy Yml0IHJlZ2lzdGVyIHdlIHN1cHBvcnQgcmVhZGluZyBmcm9tIEhXIG9ubHkKKwkJICogc2Vjb25k YXJ5IGJ1cyBudW1iZXIgd2hpY2ggaXMgbXZlYnUgbG9jYWwgYnVzIG51bWJlci4KKwkJICogT3Ro ZXIgYml0cyBhcmUgcmV0cmlldmVkIG9ubHkgZnJvbSBlbXVsYXRlZCBjb25maWcgYnVmZmVyLgor CQkgKi8KKwkJX19sZTMyICpjZmdzcGFjZSA9IChfX2xlMzIgKikmYnJpZGdlLT5jb25mOworCQl1 MzIgdmFsID0gbGUzMl90b19jcHUoY2Znc3BhY2VbUENJX1BSSU1BUllfQlVTIC8gNF0pOworCQl2 YWwgJj0gfjB4ZmYwMDsKKwkJdmFsIHw9IG12ZWJ1X3BjaWVfZ2V0X2xvY2FsX2J1c19ucihwb3J0 KSA8PCA4OworCQkqdmFsdWUgPSB2YWw7CisJCWJyZWFrOworCX0KKwogCWRlZmF1bHQ6CiAJCXJl dHVybiBQQ0lfQlJJREdFX0VNVUxfTk9UX0hBTkRMRUQ7CiAJfQpAQCAtNTk0LDcgKzYxMyw4IEBA IG12ZWJ1X3BjaV9icmlkZ2VfZW11bF9iYXNlX2NvbmZfd3JpdGUoc3RydWN0IHBjaV9icmlkZ2Vf ZW11bCAqYnJpZGdlLAogCQlicmVhazsKIAogCWNhc2UgUENJX1BSSU1BUllfQlVTOgotCQltdmVi dV9wY2llX3NldF9sb2NhbF9idXNfbnIocG9ydCwgY29uZi0+c2Vjb25kYXJ5X2J1cyk7CisJCWlm IChtYXNrICYgMHhmZjAwKQorCQkJbXZlYnVfcGNpZV9zZXRfbG9jYWxfYnVzX25yKHBvcnQsIGNv bmYtPnNlY29uZGFyeV9idXMpOwogCQlicmVhazsKIAogCWRlZmF1bHQ6CkBAIC0xMTg2LDggKzEy MDYsODQgQEAgc3RhdGljIGludCBtdmVidV9wY2llX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCiAJCQljb250aW51ZTsKIAkJfQogCisJCS8qCisJCSAqIFBDSWUgdG9wb2xvZ3kg ZXhwb3J0ZWQgYnkgbXZlYnUgaHcgaXMgcXVpdGUgY29tcGxpY2F0ZWQuIEluCisJCSAqIHJlYWxp dHkgaGFzIHNvbWV0aGluZyBsaWtlIE4gZnVsbHkgaW5kZXBlbmRlbnQgaG9zdCBicmlkZ2VzCisJ CSAqIHdoZXJlIGVhY2ggaG9zdCBicmlkZ2UgaGFzIG9uZSBQQ0llIFJvb3QgUG9ydCAod2hpY2gg YWN0cyBhcworCQkgKiBQQ0kgQnJpZGdlIGRldmljZSkuIEVhY2ggaG9zdCBicmlkZ2UgaGFzIGl0 cyBvd24gaW5kZXBlbmRlbnQKKwkJICogaW50ZXJuYWwgcmVnaXN0ZXJzLCBpbmRlcGVuZGVudCBh Y2Nlc3MgdG8gUENJIGNvbmZpZyBzcGFjZSwKKwkJICogaW5kZXBlbmRlbnQgaW50ZXJydXB0IGxp bmVzLCBpbmRlcGVuZGVudCB3aW5kb3cgYW5kIG1lbW9yeQorCQkgKiBhY2Nlc3MgY29uZmlndXJh dGlvbi4gQnV0IGFkZGl0aW9uYWxseSB0aGVyZSBpcyBzb21lIGtpbmQgb2YKKwkJICogcGVlci10 by1wZWVyIHN1cHBvcnQgYmV0d2VlbiBQQ0llIGRldmljZXMgYmVoaW5kIGRpZmZlcmVudAorCQkg KiBob3N0IGJyaWRnZXMgbGltaXRlZCBqdXN0IHRvIGZvcndhcmRpbmcgb2YgbWVtb3J5IGFuZCBJ L08KKwkJICogdHJhbnNhY3Rpb25zIChmb3J3YXJkaW5nIG9mIGVycm9yIG1lc3NhZ2VzIGFuZCBj b25maWcgY3ljbGVzCisJCSAqIGlzIG5vdCBzdXBwb3J0ZWQpLiBTbyB3ZSBjb3VsZCBzYXkgdGhl cmUgYXJlIE4gaW5kZXBlbmRlbnQKKwkJICogUENJZSBSb290IENvbXBsZXhlcy4KKwkJICoKKwkJ ICogRm9yIHRoaXMga2luZCBvZiBzZXR1cCBEVCBzaG91bGQgaGF2ZSBiZWVuIHN0cnVjdHVyZWQg aW50bworCQkgKiBOIGluZGVwZW5kZW50IFBDSWUgY29udHJvbGxlcnMgLyBob3N0IGJyaWRnZXMu IEJ1dCBpbnN0ZWFkCisJCSAqIHN0cnVjdHVyZSBpbiBwYXN0IHdhcyBkZWZpbmVkIHRvIHB1dCBQ Q0llIFJvb3QgUG9ydHMgb2YgYWxsCisJCSAqIGhvc3QgYnJpZGdlcyBpbnRvIG9uZSBidXMgemVy bywgbGlrZSBpbiBjbGFzc2ljIG11bHRpLXBvcnQKKwkJICogUm9vdCBDb21wbGV4IHNldHVwIHdp dGgganVzdCBvbmUgaG9zdCBicmlkZ2UuCisJCSAqCisJCSAqIFRoaXMgbWVhbnMgdGhhdCBwY2kt bXZlYnUuYyBkcml2ZXIgcHJvdmlkZXMgInZpcnR1YWwiIGJ1cyAwCisJCSAqIG9uIHdoaWNoIHJl Z2lzdGVycyBhbGwgUENJZSBSb290IFBvcnRzIChQQ0kgQnJpZGdlIGRldmljZXMpCisJCSAqIHNw ZWNpZmllZCBpbiBEVCBieSB0aGVpciBCREYgYWRkcmVzc2VzIGFuZCB2aXJ0dWFsbHkgcm91dGVz CisJCSAqIFBDSSBjb25maWcgYWNjZXNzIG9mIGVhY2ggUENJIGJyaWRnZSBkZXZpY2UgdG8gc3Bl Y2lmaWMgUENJZQorCQkgKiBob3N0IGJyaWRnZS4KKwkJICoKKwkJICogTm9ybWFsbHkgUENJIEJy aWRnZSBzaG91bGQgY2hvb3NlIGJldHdlZW4gVHlwZSAwIGFuZCBUeXBlIDEKKwkJICogY29uZmln IHJlcXVlc3RzIGJhc2VkIG9uIHByaW1hcnkgYW5kIHNlY29uZGFyeSBidXMgbnVtYmVycworCQkg KiBjb25maWd1cmVkIG9uIHRoZSBicmlkZ2UgaXRzZWxmLiBCdXQgYmVjYXVzZSBtdmVidSBQQ0kg QnJpZGdlCisJCSAqIGRvZXMgbm90IGhhdmUgcmVnaXN0ZXJzIGZvciBwcmltYXJ5IGFuZCBzZWNv bmRhcnkgYnVzIG51bWJlcnMKKwkJICogaW4gaXRzIGNvbmZpZyBzcGFjZSwgaXQgZGV0ZXJtaW5h dGVzIHR5cGUgb2YgY29uZmlnIHJlcXVlc3RzCisJCSAqIHZpYSBpdHMgb3duIGN1c3RvbSB3YXku CisJCSAqCisJCSAqIFRoZXJlIGFyZSB0d28gb3B0aW9ucyBob3cgbXZlYnUgZGV0ZXJtaW5hdGUg dHlwZSBvZiBjb25maWcKKwkJICogcmVxdWVzdC4KKwkJICoKKwkJICogMS4gSWYgU2Vjb25kYXJ5 IEJ1cyBOdW1iZXIgRW5hYmxlIGJpdCBpcyBub3Qgc2V0IG9yIGlzIG5vdAorCQkgKiBhdmFpbGFi bGUgKGFwcGxpZXMgZm9yIHByZS1YUCBQQ0llIGNvbnRyb2xsZXJzKSB0aGVuIFR5cGUgMAorCQkg KiBpcyB1c2VkIGlmIHRhcmdldCBidXMgbnVtYmVyIGVxdWFscyBMb2NhbCBCdXMgTnVtYmVyIChi aXRzCisJCSAqIFsxNTo4XSBpbiByZWdpc3RlciAweDFhMDQpIGFuZCB0YXJnZXQgZGV2aWNlIG51 bWJlciBkaWZmZXJzCisJCSAqIGZyb20gTG9jYWwgRGV2aWNlIE51bWJlciAoYml0cyBbMjA6MTZd IGluIHJlZ2lzdGVyIDB4MWEwNCkuCisJCSAqIFR5cGUgMSBpcyB1c2VkIGlmIHRhcmdldCBidXMg bnVtYmVyIGRpZmZlcnMgZnJvbSBMb2NhbCBCdXMKKwkJICogTnVtYmVyLiBBbmQgd2hlbiB0YXJn ZXQgYnVzIG51bWJlciBlcXVhbHMgTG9jYWwgQnVzIE51bWJlcgorCQkgKiBhbmQgdGFyZ2V0IGRl dmljZSBlcXVhbHMgTG9jYWwgRGV2aWNlIE51bWJlciB0aGVuIHJlcXVlc3QgaXMKKwkJICogcm91 dGVkIHRvIExvY2FsIFBDSSBCcmlkZ2UgKFBDSWUgUm9vdCBQb3J0KS4KKwkJICoKKwkJICogMi4g SWYgU2Vjb25kYXJ5IEJ1cyBOdW1iZXIgRW5hYmxlIGJpdCBpcyBzZXQgKGJpdCA3IGluCisJCSAq IHJlZ2lzdGVyIDB4MWEyYykgdGhlbiBtdmVidSBodyBkZXRlcm1pbmF0ZSB0eXBlIG9mIGNvbmZp ZworCQkgKiByZXF1ZXN0IGxpa2UgY29tcGxpYW50IFBDSSBCcmlkZ2UgYmFzZWQgb24gcHJpbWFy eSBidXMgbnVtYmVyCisJCSAqIHdoaWNoIGlzIGNvbmZpZ3VyZWQgdmlhIExvY2FsIEJ1cyBOdW1i ZXIgKGJpdHMgWzE1OjhdIGluCisJCSAqIHJlZ2lzdGVyIDB4MWEwNCkgYW5kIHNlY29uZGFyeSBi dXMgbnVtYmVyIHdoaWNoIGlzIGNvbmZpZ3VyZWQKKwkJICogdmlhIFNlY29uZGFyeSBCdXMgTnVt YmVyIChiaXRzIFs3OjBdIGluIHJlZ2lzdGVyIDB4MWEyYykuCisJCSAqIExvY2FsIFBDSSBCcmlk Z2UgKFBDSWUgUm9vdCBQb3J0KSBpcyBhdmFpbGFibGUgb24gcHJpbWFyeSBidXMKKwkJICogYXMg ZGV2aWNlIHdpdGggTG9jYWwgRGV2aWNlIE51bWJlciAoYml0cyBbMjA6MTZdIGluIHJlZ2lzdGVy CisJCSAqIDB4MWEwNCkuCisJCSAqCisJCSAqIFNlY29uZGFyeSBCdXMgTnVtYmVyIEVuYWJsZSBi aXQgaXMgZGlzYWJsZWQgYnkgZGVmYXVsdCBhbmQKKwkJICogb3B0aW9uIDIuIGlzIG5vdCBhdmFp bGFibGUgb24gcHJlLVhQIFBDSWUgY29udHJvbGxlcnMuIEhlbmNlCisJCSAqIHRoaXMgZHJpdmVy IGFsd2F5cyB1c2Ugb3B0aW9uIDEuCisJCSAqCisJCSAqIEJhc2ljYWxseSBpdCBtZWFucyB0aGF0 IHByaW1hcnkgYW5kIHNlY29uZGFyeSBidXNlcyBzaGFyZXMKKwkJICogb25lIHZpcnR1YWwgbnVt YmVyIGNvbmZpZ3VyZWQgdmlhIExvY2FsIEJ1cyBOdW1iZXIgYml0cyBhbmQKKwkJICogTG9jYWwg RGV2aWNlIE51bWJlciBiaXRzIGRldGVybWluYXRlcyBpZiBhY2Nlc3NpbmcgcHJpbWFyeQorCQkg KiBvciBzZWNvbmRhcnkgYnVzLiBTZXQgTG9jYWwgRGV2aWNlIE51bWJlciB0byAxIGFuZCByZWRp cmVjdAorCQkgKiBhbGwgd3JpdGVzIG9mIFBDSSBCcmlkZ2UgU2Vjb25kYXJ5IEJ1cyBOdW1iZXIg cmVnaXN0ZXIgdG8KKwkJICogTG9jYWwgQnVzIE51bWJlciAoYml0cyBbMTU6OF0gaW4gcmVnaXN0 ZXIgMHgxYTA0KS4KKwkJICoKKwkJICogU28gd2hlbiBhY2Nlc3NpbmcgZGV2aWNlcyBvbiBidXNl cyBiZWhpbmQgc2Vjb25kYXJ5IGJ1cworCQkgKiBudW1iZXIgaXQgd291bGQgd29yayBjb3JyZWN0 bHkuIEFuZCBhbHNvIHdoZW4gYWNjZXNzaW5nCisJCSAqIGRldmljZSAwIGF0IHNlY29uZGFyeSBi dXMgbnVtYmVyIHZpYSBjb25maWcgc3BhY2Ugd291bGQgYmUKKwkJICogY29ycmVjdGx5IHJvdXRl ZCB0byBzZWNvbmRhcnkgYnVzLiBEdWUgdG8gaXNzdWVzIGRlc2NyaWJlZAorCQkgKiBpbiBtdmVi dV9wY2llX3NldHVwX2h3KCksIFBDSSBCcmlkZ2VzIGF0IHByaW1hcnkgYnVzICh6ZXJvKQorCQkg KiBhcmUgbm90IGFjY2Vzc2VkIGRpcmVjdGx5IHZpYSBQQ0kgY29uZmlnIHNwYWNlIGJ1dCByYXJo ZXIKKwkJICogaW5kaXJlY3RseSB2aWEga2VybmVsIGVtdWxhdGVkIFBDSSBicmlkZ2UgZHJpdmVy LgorCQkgKi8KIAkJbXZlYnVfcGNpZV9zZXR1cF9odyhwb3J0KTsKIAkJbXZlYnVfcGNpZV9zZXRf bG9jYWxfZGV2X25yKHBvcnQsIDEpOworCQltdmVidV9wY2llX3NldF9sb2NhbF9idXNfbnIocG9y dCwgMCk7CiAJfQogCiAJYnJpZGdlLT5zeXNkYXRhID0gcGNpZTsKLS0gCjIuMjAuMQoKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJu ZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRw Oi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK