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 BBD4BC6FA8C for ; Mon, 5 Sep 2022 19:25:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231935AbiIETZY (ORCPT ); Mon, 5 Sep 2022 15:25:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42968 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231706AbiIETZU (ORCPT ); Mon, 5 Sep 2022 15:25:20 -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 B28001D31A; Mon, 5 Sep 2022 12:25:18 -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 2AAC76130A; Mon, 5 Sep 2022 19:25:18 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3D17AC433D6; Mon, 5 Sep 2022 19:25:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1662405917; bh=SXwJBeHNvftKq6M7GE7LYhPnEKUJ1AN/65rM+2MAXfo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=D7wL2NabC/FAYEcXLM1B+pgI+y4/G87OSlPn1LeDkV/FJNjA7IWN4VkbmiZW6/IzO 4LfaMfubGzhBe9FeB8lBQ2vrxN5+ZUbG0Bx09jlfXQRNjwRUfmzbVVA5MBeUvAiIxs q3pYe4QPdLD4HUK2eKf3dtLI4XL+sXTNcCwtf5hGTZHAm4yRNMcpLLwgyF+EbVQh9C rHR4qAlGe8dVa8cJmgIw0tp/g/hszQzkhy7bk5SHfo8OdF9VRqIemFCMQ8Lq1Gokol Z2GtP1mf3BbYaM27jUtlGubcgkeovErPHmEsvjRbbA3h+Vjb11hufAYcAg7ZS0spW/ 1YnoYXN0jQPtg== Received: by pali.im (Postfix) id EA6917D7; Mon, 5 Sep 2022 21:25:16 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Bjorn Helgaas , Lorenzo Pieralisi , Rob Herring , Krzysztof Kozlowski , Andrew Lunn , Sebastian Hesselbarth , Gregory Clement , Russell King , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , Thomas Petazzoni , Mauri Sandberg Cc: linux-pci@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v3 6/7] PCI: mvebu: Add support for Orion PCIe controller Date: Mon, 5 Sep 2022 21:23:09 +0200 Message-Id: <20220905192310.22786-7-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220905192310.22786-1-pali@kernel.org> References: <20220718202843.6766-1-maukka@ext.kapsi.fi> <20220905192310.22786-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 Orion PCIe controller has same register sets, same APIs, same functionality and also same bugs related to PCIe Root Ports as new PCIe controllers from Marvell found on Kirkwood, Dove or Armada products. So pci-mvebu.c should work fine with Orion PCIe controllers too. But Orion PCIe controller has additional bug - broken Marvell CF8/CFC registers which are used for config space access. This hardware bug is documented in Marvell Orion Functional Errata, linked from kernel docs https://www.kernel.org/doc/html/latest/arm/marvell.html. Document contains also official workaround, but that workaround does not work when CPU or other side of PCIe link is doing PCIe TLP operations. Because of race conditions that official workaround is unusable for kernel, any other multi-threaded systems and any PCIe card with bus mastering support. Instead Linux kernel for a long time implements different undocumented workaround (which does not have this issue) via platform code found in arch/arm/mach-orion5x/pci.c and arch/arm/plat-orion/pcie.c files. It maps PCIe config space directly into CPU physical address space via Marvell mbus driver and then kernel access directly mapped physical address of config space. The only disadvantage of this workaround is that it required additional 16 MB of physical address space and only standard PCI config space registers are accessible. Testing proved that via mbus the physical size can be of this special address range increased to 256 MB and then whole PCIe config space, including PCIe registers, is accessible. So the only disadvantage is requirement of free 256 MB in physical address space. So for Orion support in pci-mvebu.c driver, this change reimplements arch-specific mapping of config space with existing mbus driver and kernel function pci_remap_cfgspace() which simplify physical space mappings. Therefore pci-mvebu.c driver does not have to relay on static virtual MMU mappings like old arch-specific code. Like with any address ranges settings and configurations, this Orion code reads physical config space address range from device tree files. There are no fixed settings in the pci-mvebu.c driver as opposite of the old arch-specific implementation. It is up to the board or platform dts file to define how PCIe config space could be mapped into physical CPU address space. mbus specific target and attribute numbers, required for mbus mappings of config space registers are also read from device tree files, in exactly same format as are read for PCIe MEM and PCIe IO space mappings. During probing of Orion PCIe controller, pci-mvebu.c driver ask kernel mbus driver to map config space into CPU physical address range (based on DTS offset and size). Config space stays mapped in physical address range while PCIe controller is bind to driver. Note that layout of PCIe config space is not standard PCIe ECAM. It is same as layout accessed indirectly via CF8/CFC registers used in other Armada PCIe controllers. Support for extended PCIe registers in this layout is non-standard and hence it is Marvell specific layout. The main issue with this layout is that config space of PCIe bus in not coherent in address range. And neither address range of one PCIe device is coherent. Therefore it is not possible to use PCI core .map_bus callback for implementing access into config space. And because Orion is 32-bit platform it is not a wise idea to map whole 256 MB PCIe config space into CPU virtual address space permanently. So because layout of config space via direct or indirect method is same, functions mvebu_pcie_child_rd_conf() and mvebu_pcie_child_wd_conf() are slightly modified to support also direct config space access method. Functions calculates where in physical address range is requested config space register and do virtual mapping at request time. After register access it is unmapped from virtual address range. Links: https://www.kernel.org/doc/html/latest/arm/marvell.html Signed-off-by: Pali Rohár --- Changes in v3: * Completely rewritten * Implement full support for accessing PCIe config space based on device tree details without any harcoded address in pci-mvebu.c driver --- drivers/pci/controller/Kconfig | 4 +- drivers/pci/controller/pci-mvebu.c | 142 +++++++++++++++++++++++++++-- 2 files changed, 136 insertions(+), 10 deletions(-) diff --git a/drivers/pci/controller/Kconfig b/drivers/pci/controller/Kconfig index 8da2efdc5177..ae5a430387bc 100644 --- a/drivers/pci/controller/Kconfig +++ b/drivers/pci/controller/Kconfig @@ -5,7 +5,7 @@ menu "PCI controller drivers" config PCI_MVEBU tristate "Marvell EBU PCIe controller" - depends on ARCH_MVEBU || ARCH_DOVE || COMPILE_TEST + depends on ARCH_MVEBU || ARCH_DOVE || ARCH_ORION5X || COMPILE_TEST depends on MVEBU_MBUS depends on ARM depends on OF @@ -15,7 +15,7 @@ config PCI_MVEBU select HOTPLUG_PCI_PCIE help Add support for Marvell EBU PCIe controller. This PCIe controller - is used on 32-bit Marvell ARM SoCs: Dove, Kirkwood, Armada 370, + is used on 32-bit Marvell ARM SoCs: Orion, Kirkwood, Dove, Armada 370, Armada XP, Armada 375, Armada 38x and Armada 39x. config PCI_AARDVARK diff --git a/drivers/pci/controller/pci-mvebu.c b/drivers/pci/controller/pci-mvebu.c index 9986dd486680..2ef04a8241fc 100644 --- a/drivers/pci/controller/pci-mvebu.c +++ b/drivers/pci/controller/pci-mvebu.c @@ -96,6 +96,7 @@ struct mvebu_pcie { struct resource io; struct resource realio; struct resource mem; + struct resource cfg; int nports; }; @@ -127,6 +128,7 @@ struct mvebu_pcie_port { struct mvebu_pcie_window iowin; u32 saved_pcie_stat; struct resource regs; + struct resource cfg; u8 slot_power_limit_value; u8 slot_power_limit_scale; struct irq_domain *rp_irq_domain; @@ -409,6 +411,7 @@ static int mvebu_pcie_child_rd_conf(struct pci_bus *bus, u32 devfn, int where, struct mvebu_pcie *pcie = bus->sysdata; struct mvebu_pcie_port *port; void __iomem *conf_data; + u32 offset; port = mvebu_pcie_find_port(pcie, bus, devfn); if (!port) @@ -417,10 +420,20 @@ static int mvebu_pcie_child_rd_conf(struct pci_bus *bus, u32 devfn, int where, if (!mvebu_pcie_link_up(port)) return PCIBIOS_DEVICE_NOT_FOUND; - conf_data = port->base + PCIE_CONF_DATA_OFF; + if (resource_size(&port->cfg)) { + offset = PCIE_CONF_ADDR(bus->number, devfn, where) & ~PCIE_CONF_ADDR_EN; + if (offset >= resource_size(&port->cfg)) + return PCIBIOS_DEVICE_NOT_FOUND; - mvebu_writel(port, PCIE_CONF_ADDR(bus->number, devfn, where), - PCIE_CONF_ADDR_OFF); + conf_data = pci_remap_cfgspace(port->cfg.start + offset, size); + if (!conf_data) + return PCIBIOS_DEVICE_NOT_FOUND; + } else { + conf_data = port->base + PCIE_CONF_DATA_OFF; + + mvebu_writel(port, PCIE_CONF_ADDR(bus->number, devfn, where), + PCIE_CONF_ADDR_OFF); + } switch (size) { case 1: @@ -433,9 +446,14 @@ static int mvebu_pcie_child_rd_conf(struct pci_bus *bus, u32 devfn, int where, *val = readl_relaxed(conf_data); break; default: + if (resource_size(&port->cfg)) + iounmap(conf_data); return PCIBIOS_BAD_REGISTER_NUMBER; } + if (resource_size(&port->cfg)) + iounmap(conf_data); + return PCIBIOS_SUCCESSFUL; } @@ -445,6 +463,7 @@ static int mvebu_pcie_child_wr_conf(struct pci_bus *bus, u32 devfn, struct mvebu_pcie *pcie = bus->sysdata; struct mvebu_pcie_port *port; void __iomem *conf_data; + u32 offset; port = mvebu_pcie_find_port(pcie, bus, devfn); if (!port) @@ -453,10 +472,20 @@ static int mvebu_pcie_child_wr_conf(struct pci_bus *bus, u32 devfn, if (!mvebu_pcie_link_up(port)) return PCIBIOS_DEVICE_NOT_FOUND; - conf_data = port->base + PCIE_CONF_DATA_OFF; + if (resource_size(&port->cfg)) { + offset = PCIE_CONF_ADDR(bus->number, devfn, where) & ~PCIE_CONF_ADDR_EN; + if (offset >= resource_size(&port->cfg)) + return PCIBIOS_DEVICE_NOT_FOUND; + + conf_data = pci_remap_cfgspace(port->cfg.start + offset, size); + if (!conf_data) + return PCIBIOS_DEVICE_NOT_FOUND; + } else { + conf_data = port->base + PCIE_CONF_DATA_OFF; - mvebu_writel(port, PCIE_CONF_ADDR(bus->number, devfn, where), - PCIE_CONF_ADDR_OFF); + mvebu_writel(port, PCIE_CONF_ADDR(bus->number, devfn, where), + PCIE_CONF_ADDR_OFF); + } switch (size) { case 1: @@ -469,9 +498,14 @@ static int mvebu_pcie_child_wr_conf(struct pci_bus *bus, u32 devfn, writel(val, conf_data); break; default: + if (resource_size(&port->cfg)) + iounmap(conf_data); return PCIBIOS_BAD_REGISTER_NUMBER; } + if (resource_size(&port->cfg)) + iounmap(conf_data); + return PCIBIOS_SUCCESSFUL; } @@ -1472,6 +1506,7 @@ static void __iomem *mvebu_pcie_map_registers(struct platform_device *pdev, static int mvebu_get_tgt_attr(struct device_node *np, int devfn, unsigned long type, + unsigned long offset, unsigned int *tgt, unsigned int *attr) { @@ -1493,6 +1528,7 @@ static int mvebu_get_tgt_attr(struct device_node *np, int devfn, for (i = 0; i < nranges; i++, range += rangesz) { u32 flags = of_read_number(range, 1); u32 slot = of_read_number(range + 1, 1); + u32 dtaddr = of_read_number(range + 2, 1); u64 cpuaddr = of_read_number(range + na, pna); unsigned long rtype; @@ -1503,6 +1539,9 @@ static int mvebu_get_tgt_attr(struct device_node *np, int devfn, else continue; + if (dtaddr != offset) + continue; + if (slot == PCI_SLOT(devfn) && type == rtype) { *tgt = DT_CPUADDR_TO_TARGET(cpuaddr); *attr = DT_CPUADDR_TO_ATTR(cpuaddr); @@ -1513,6 +1552,43 @@ static int mvebu_get_tgt_attr(struct device_node *np, int devfn, return -ENOENT; } +static int mvebu_get_cfg_tgt_attr(struct device_node *np, phys_addr_t start, + struct resource *res, + unsigned int *tgt, unsigned int *attr) +{ + const __be32 *addrp; + unsigned int flags; + u64 offset; + u64 size; + int ret; + + /* get second cell from assigned-addresses property */ + addrp = of_get_address(np, 1, &size, &flags); + if (!addrp) + return -EINVAL; + + if (!(flags & IORESOURCE_MEM)) + return -EINVAL; + + if (be32_to_cpu(addrp[1]) != 0x0) + return -EINVAL; + + flags |= IORESOURCE_MEM_NONPOSTED; + offset = be32_to_cpu(addrp[2]); + + ret = mvebu_get_tgt_attr(of_get_parent(np), 0, IORESOURCE_MEM, offset, tgt, attr); + if (ret) + return ret; + + memset(res, 0, sizeof(*res)); + res->start = start; + res->end = start + size - 1; + res->flags = flags; + res->name = "PCI CFG"; + + return 0; +} + static int mvebu_pcie_suspend(struct device *dev) { struct mvebu_pcie *pcie; @@ -1592,7 +1668,7 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, goto skip; } - ret = mvebu_get_tgt_attr(dev->of_node, port->devfn, IORESOURCE_MEM, + ret = mvebu_get_tgt_attr(dev->of_node, port->devfn, IORESOURCE_MEM, 0, &port->mem_target, &port->mem_attr); if (ret < 0) { dev_err(dev, "%s: cannot get tgt/attr for mem window\n", @@ -1601,7 +1677,7 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, } if (resource_size(&pcie->io) != 0) { - mvebu_get_tgt_attr(dev->of_node, port->devfn, IORESOURCE_IO, + mvebu_get_tgt_attr(dev->of_node, port->devfn, IORESOURCE_IO, 0, &port->io_target, &port->io_attr); } else { port->io_target = -1; @@ -1794,6 +1870,20 @@ static int mvebu_pcie_parse_request_resources(struct mvebu_pcie *pcie) return ret; } + if (of_device_is_compatible(dev->of_node, "marvell,orion5x-pcie")) { + /* Get the PCIe configuration space aperture */ + mvebu_mbus_get_pcie_cfg_aperture(&pcie->cfg); + if (resource_size(&pcie->cfg) == 0) { + dev_err(dev, "invalid config space aperature size\n"); + return -EINVAL; + } + + pcie->cfg.name = "PCI CFG"; + ret = devm_request_resource(dev, &iomem_resource, &pcie->cfg); + if (ret) + return ret; + } + return 0; } @@ -1804,6 +1894,7 @@ static int mvebu_pcie_probe(struct platform_device *pdev) struct pci_host_bridge *bridge; struct device_node *np = dev->of_node; struct device_node *child; + phys_addr_t pcie_cfg_offset; int num, i, ret; bridge = devm_pci_alloc_host_bridge(dev, sizeof(struct mvebu_pcie)); @@ -1818,6 +1909,8 @@ static int mvebu_pcie_probe(struct platform_device *pdev) if (ret) return ret; + pcie_cfg_offset = pcie->cfg.start; + num = of_get_available_child_count(np); pcie->ports = devm_kcalloc(dev, num, sizeof(*pcie->ports), GFP_KERNEL); @@ -1852,6 +1945,32 @@ static int mvebu_pcie_probe(struct platform_device *pdev) if (ret < 0) continue; + if (resource_size(&pcie->cfg) != 0) { + unsigned int cfg_target, cfg_attr; + + ret = mvebu_get_cfg_tgt_attr(child, pcie_cfg_offset, &port->cfg, &cfg_target, &cfg_attr); + if (ret) { + dev_err(dev, "%s: missing address range for cfg space\n", port->name); + goto err_port_down; + } + + if (port->cfg.end > pcie->cfg.end) { + dev_err(dev, "%s: requested cfg space of %u bytes is too large, available only %u bytes\n", + port->name, resource_size(&port->cfg), pcie->cfg.end - pcie_cfg_offset + 1); + port->cfg.start = port->cfg.end = 0; + goto err_port_down; + } + + ret = mvebu_mbus_add_window_by_id(cfg_target, cfg_attr, port->cfg.start, resource_size(&port->cfg)); + if (ret) { + dev_info(dev, "%s: cannot add mbus window for cfg space: %d\n", port->name, ret); + port->cfg.start = port->cfg.end = 0; + goto err_port_down; + } + + pcie_cfg_offset += resource_size(&port->cfg); + } + port->base = mvebu_pcie_map_registers(pdev, child, port); if (IS_ERR(port->base)) { dev_err(dev, "%s: cannot map registers\n", port->name); @@ -2011,6 +2130,9 @@ static int mvebu_pcie_probe(struct platform_device *pdev) port->base = NULL; err_port_down: + if (port->cfg.end && resource_size(&port->cfg)) + mvebu_mbus_del_window(port->cfg.start, resource_size(&port->cfg)); + mvebu_pcie_powerdown(port); } @@ -2090,6 +2212,9 @@ static int mvebu_pcie_remove(struct platform_device *pdev) if (port->memwin.size) mvebu_pcie_del_windows(port, port->memwin.base, port->memwin.size); + if (port->cfg.end && resource_size(&port->cfg)) + mvebu_mbus_del_window(port->cfg.start, resource_size(&port->cfg)); + /* Power down card and disable clocks. Must be the last step. */ mvebu_pcie_powerdown(port); } @@ -2102,6 +2227,7 @@ static const struct of_device_id mvebu_pcie_of_match_table[] = { { .compatible = "marvell,armada-370-pcie", }, { .compatible = "marvell,dove-pcie", }, { .compatible = "marvell,kirkwood-pcie", }, + { .compatible = "marvell,orion5x-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 26BB8ECAAD5 for ; Mon, 5 Sep 2022 19:49:36 +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=wOQx1uhF6Sg1i9kf0g5E9q7tVv1SahVQ3VceDyJrcbY=; b=e4QmQvOHz+fX7Q jDtFAbQs+ZF7upwxkYTZQ9iUjHOWJdeHkXihq0r8kGWZMoTeqvzQAuYFq271g7+tAZX5izSyv+/RH lxPuFrDZehf8+532CRhixLnqLGBGTNF6Sfo2mz6NizSHoImVXINIogmC0WjUU0QsGl2t+w2reGoml LyB5ZesRZsSudZOR7xgZ8KMZjD2ffDTVj41eMhOfQbBdsQ9AaDUFDpLtCVdjs1yftaDZBoEqLuG0M wvPTpurR0yvAdQMONGIbxRKRhjTxsxq/hLaKQ0UhdGPqrIk/qGKg8OlZK4DL7zgvvTPPNMd9hI0nm 5hUuUaY8BG0RcoKYLysA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oVI4v-009djC-5o; Mon, 05 Sep 2022 19:48:17 +0000 Received: from ams.source.kernel.org ([145.40.68.75]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oVHik-009Ff0-Dw for linux-arm-kernel@lists.infradead.org; Mon, 05 Sep 2022 19:25:25 +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 ams.source.kernel.org (Postfix) with ESMTPS id DD593B815D5; Mon, 5 Sep 2022 19:25:18 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3D17AC433D6; Mon, 5 Sep 2022 19:25:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1662405917; bh=SXwJBeHNvftKq6M7GE7LYhPnEKUJ1AN/65rM+2MAXfo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=D7wL2NabC/FAYEcXLM1B+pgI+y4/G87OSlPn1LeDkV/FJNjA7IWN4VkbmiZW6/IzO 4LfaMfubGzhBe9FeB8lBQ2vrxN5+ZUbG0Bx09jlfXQRNjwRUfmzbVVA5MBeUvAiIxs q3pYe4QPdLD4HUK2eKf3dtLI4XL+sXTNcCwtf5hGTZHAm4yRNMcpLLwgyF+EbVQh9C rHR4qAlGe8dVa8cJmgIw0tp/g/hszQzkhy7bk5SHfo8OdF9VRqIemFCMQ8Lq1Gokol Z2GtP1mf3BbYaM27jUtlGubcgkeovErPHmEsvjRbbA3h+Vjb11hufAYcAg7ZS0spW/ 1YnoYXN0jQPtg== Received: by pali.im (Postfix) id EA6917D7; Mon, 5 Sep 2022 21:25:16 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Bjorn Helgaas , Lorenzo Pieralisi , Rob Herring , Krzysztof Kozlowski , Andrew Lunn , Sebastian Hesselbarth , Gregory Clement , Russell King , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , Thomas Petazzoni , Mauri Sandberg Cc: linux-pci@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v3 6/7] PCI: mvebu: Add support for Orion PCIe controller Date: Mon, 5 Sep 2022 21:23:09 +0200 Message-Id: <20220905192310.22786-7-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220905192310.22786-1-pali@kernel.org> References: <20220718202843.6766-1-maukka@ext.kapsi.fi> <20220905192310.22786-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220905_122522_820101_02434E87 X-CRM114-Status: GOOD ( 37.23 ) 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 T3Jpb24gUENJZSBjb250cm9sbGVyIGhhcyBzYW1lIHJlZ2lzdGVyIHNldHMsIHNhbWUgQVBJcywg c2FtZSBmdW5jdGlvbmFsaXR5CmFuZCBhbHNvIHNhbWUgYnVncyByZWxhdGVkIHRvIFBDSWUgUm9v dCBQb3J0cyBhcyBuZXcgUENJZSBjb250cm9sbGVycyBmcm9tCk1hcnZlbGwgZm91bmQgb24gS2ly a3dvb2QsIERvdmUgb3IgQXJtYWRhIHByb2R1Y3RzLiBTbyBwY2ktbXZlYnUuYyBzaG91bGQKd29y ayBmaW5lIHdpdGggT3Jpb24gUENJZSBjb250cm9sbGVycyB0b28uCgpCdXQgT3Jpb24gUENJZSBj b250cm9sbGVyIGhhcyBhZGRpdGlvbmFsIGJ1ZyAtIGJyb2tlbiBNYXJ2ZWxsIENGOC9DRkMKcmVn aXN0ZXJzIHdoaWNoIGFyZSB1c2VkIGZvciBjb25maWcgc3BhY2UgYWNjZXNzLiBUaGlzIGhhcmR3 YXJlIGJ1ZyBpcwpkb2N1bWVudGVkIGluIE1hcnZlbGwgT3Jpb24gRnVuY3Rpb25hbCBFcnJhdGEs IGxpbmtlZCBmcm9tIGtlcm5lbCBkb2NzCmh0dHBzOi8vd3d3Lmtlcm5lbC5vcmcvZG9jL2h0bWwv bGF0ZXN0L2FybS9tYXJ2ZWxsLmh0bWwuIERvY3VtZW50IGNvbnRhaW5zCmFsc28gb2ZmaWNpYWwg d29ya2Fyb3VuZCwgYnV0IHRoYXQgd29ya2Fyb3VuZCBkb2VzIG5vdCB3b3JrIHdoZW4gQ1BVIG9y Cm90aGVyIHNpZGUgb2YgUENJZSBsaW5rIGlzIGRvaW5nIFBDSWUgVExQIG9wZXJhdGlvbnMuIEJl Y2F1c2Ugb2YgcmFjZQpjb25kaXRpb25zIHRoYXQgb2ZmaWNpYWwgd29ya2Fyb3VuZCBpcyB1bnVz YWJsZSBmb3Iga2VybmVsLCBhbnkgb3RoZXIKbXVsdGktdGhyZWFkZWQgc3lzdGVtcyBhbmQgYW55 IFBDSWUgY2FyZCB3aXRoIGJ1cyBtYXN0ZXJpbmcgc3VwcG9ydC4KCkluc3RlYWQgTGludXgga2Vy bmVsIGZvciBhIGxvbmcgdGltZSBpbXBsZW1lbnRzIGRpZmZlcmVudCB1bmRvY3VtZW50ZWQKd29y a2Fyb3VuZCAod2hpY2ggZG9lcyBub3QgaGF2ZSB0aGlzIGlzc3VlKSB2aWEgcGxhdGZvcm0gY29k ZSBmb3VuZCBpbgphcmNoL2FybS9tYWNoLW9yaW9uNXgvcGNpLmMgYW5kIGFyY2gvYXJtL3BsYXQt b3Jpb24vcGNpZS5jIGZpbGVzLiBJdCBtYXBzClBDSWUgY29uZmlnIHNwYWNlIGRpcmVjdGx5IGlu dG8gQ1BVIHBoeXNpY2FsIGFkZHJlc3Mgc3BhY2UgdmlhIE1hcnZlbGwgbWJ1cwpkcml2ZXIgYW5k IHRoZW4ga2VybmVsIGFjY2VzcyBkaXJlY3RseSBtYXBwZWQgcGh5c2ljYWwgYWRkcmVzcyBvZiBj b25maWcKc3BhY2UuIFRoZSBvbmx5IGRpc2FkdmFudGFnZSBvZiB0aGlzIHdvcmthcm91bmQgaXMg dGhhdCBpdCByZXF1aXJlZAphZGRpdGlvbmFsIDE2IE1CIG9mIHBoeXNpY2FsIGFkZHJlc3Mgc3Bh Y2UgYW5kIG9ubHkgc3RhbmRhcmQgUENJIGNvbmZpZwpzcGFjZSByZWdpc3RlcnMgYXJlIGFjY2Vz c2libGUuCgpUZXN0aW5nIHByb3ZlZCB0aGF0IHZpYSBtYnVzIHRoZSBwaHlzaWNhbCBzaXplIGNh biBiZSBvZiB0aGlzIHNwZWNpYWwKYWRkcmVzcyByYW5nZSBpbmNyZWFzZWQgdG8gMjU2IE1CIGFu ZCB0aGVuIHdob2xlIFBDSWUgY29uZmlnIHNwYWNlLAppbmNsdWRpbmcgUENJZSByZWdpc3RlcnMs IGlzIGFjY2Vzc2libGUuIFNvIHRoZSBvbmx5IGRpc2FkdmFudGFnZSBpcwpyZXF1aXJlbWVudCBv ZiBmcmVlIDI1NiBNQiBpbiBwaHlzaWNhbCBhZGRyZXNzIHNwYWNlLgoKU28gZm9yIE9yaW9uIHN1 cHBvcnQgaW4gcGNpLW12ZWJ1LmMgZHJpdmVyLCB0aGlzIGNoYW5nZSByZWltcGxlbWVudHMKYXJj aC1zcGVjaWZpYyBtYXBwaW5nIG9mIGNvbmZpZyBzcGFjZSB3aXRoIGV4aXN0aW5nIG1idXMgZHJp dmVyIGFuZAprZXJuZWwgZnVuY3Rpb24gcGNpX3JlbWFwX2NmZ3NwYWNlKCkgd2hpY2ggc2ltcGxp ZnkgcGh5c2ljYWwgc3BhY2UKbWFwcGluZ3MuIFRoZXJlZm9yZSBwY2ktbXZlYnUuYyBkcml2ZXIg ZG9lcyBub3QgaGF2ZSB0byByZWxheSBvbiBzdGF0aWMKdmlydHVhbCBNTVUgbWFwcGluZ3MgbGlr ZSBvbGQgYXJjaC1zcGVjaWZpYyBjb2RlLgoKTGlrZSB3aXRoIGFueSBhZGRyZXNzIHJhbmdlcyBz ZXR0aW5ncyBhbmQgY29uZmlndXJhdGlvbnMsIHRoaXMgT3Jpb24gY29kZQpyZWFkcyBwaHlzaWNh bCBjb25maWcgc3BhY2UgYWRkcmVzcyByYW5nZSBmcm9tIGRldmljZSB0cmVlIGZpbGVzLiBUaGVy ZSBhcmUKbm8gZml4ZWQgc2V0dGluZ3MgaW4gdGhlIHBjaS1tdmVidS5jIGRyaXZlciBhcyBvcHBv c2l0ZSBvZiB0aGUgb2xkCmFyY2gtc3BlY2lmaWMgaW1wbGVtZW50YXRpb24uIEl0IGlzIHVwIHRv IHRoZSBib2FyZCBvciBwbGF0Zm9ybSBkdHMgZmlsZSB0bwpkZWZpbmUgaG93IFBDSWUgY29uZmln IHNwYWNlIGNvdWxkIGJlIG1hcHBlZCBpbnRvIHBoeXNpY2FsIENQVSBhZGRyZXNzCnNwYWNlLgoK bWJ1cyBzcGVjaWZpYyB0YXJnZXQgYW5kIGF0dHJpYnV0ZSBudW1iZXJzLCByZXF1aXJlZCBmb3Ig bWJ1cyBtYXBwaW5ncyBvZgpjb25maWcgc3BhY2UgcmVnaXN0ZXJzIGFyZSBhbHNvIHJlYWQgZnJv bSBkZXZpY2UgdHJlZSBmaWxlcywgaW4gZXhhY3RseQpzYW1lIGZvcm1hdCBhcyBhcmUgcmVhZCBm b3IgUENJZSBNRU0gYW5kIFBDSWUgSU8gc3BhY2UgbWFwcGluZ3MuCgpEdXJpbmcgcHJvYmluZyBv ZiBPcmlvbiBQQ0llIGNvbnRyb2xsZXIsIHBjaS1tdmVidS5jIGRyaXZlciBhc2sga2VybmVsIG1i dXMKZHJpdmVyIHRvIG1hcCBjb25maWcgc3BhY2UgaW50byBDUFUgcGh5c2ljYWwgYWRkcmVzcyBy YW5nZSAoYmFzZWQgb24gRFRTCm9mZnNldCBhbmQgc2l6ZSkuIENvbmZpZyBzcGFjZSBzdGF5cyBt YXBwZWQgaW4gcGh5c2ljYWwgYWRkcmVzcyByYW5nZSB3aGlsZQpQQ0llIGNvbnRyb2xsZXIgaXMg YmluZCB0byBkcml2ZXIuCgpOb3RlIHRoYXQgbGF5b3V0IG9mIFBDSWUgY29uZmlnIHNwYWNlIGlz IG5vdCBzdGFuZGFyZCBQQ0llIEVDQU0uIEl0IGlzIHNhbWUKYXMgbGF5b3V0IGFjY2Vzc2VkIGlu ZGlyZWN0bHkgdmlhIENGOC9DRkMgcmVnaXN0ZXJzIHVzZWQgaW4gb3RoZXIgQXJtYWRhClBDSWUg Y29udHJvbGxlcnMuIFN1cHBvcnQgZm9yIGV4dGVuZGVkIFBDSWUgcmVnaXN0ZXJzIGluIHRoaXMg bGF5b3V0IGlzCm5vbi1zdGFuZGFyZCBhbmQgaGVuY2UgaXQgaXMgTWFydmVsbCBzcGVjaWZpYyBs YXlvdXQuCgpUaGUgbWFpbiBpc3N1ZSB3aXRoIHRoaXMgbGF5b3V0IGlzIHRoYXQgY29uZmlnIHNw YWNlIG9mIFBDSWUgYnVzIGluIG5vdApjb2hlcmVudCBpbiBhZGRyZXNzIHJhbmdlLiBBbmQgbmVp dGhlciBhZGRyZXNzIHJhbmdlIG9mIG9uZSBQQ0llIGRldmljZSBpcwpjb2hlcmVudC4gVGhlcmVm b3JlIGl0IGlzIG5vdCBwb3NzaWJsZSB0byB1c2UgUENJIGNvcmUgLm1hcF9idXMgY2FsbGJhY2sK Zm9yIGltcGxlbWVudGluZyBhY2Nlc3MgaW50byBjb25maWcgc3BhY2UuIEFuZCBiZWNhdXNlIE9y aW9uIGlzIDMyLWJpdApwbGF0Zm9ybSBpdCBpcyBub3QgYSB3aXNlIGlkZWEgdG8gbWFwIHdob2xl IDI1NiBNQiBQQ0llIGNvbmZpZyBzcGFjZSBpbnRvCkNQVSB2aXJ0dWFsIGFkZHJlc3Mgc3BhY2Ug cGVybWFuZW50bHkuCgpTbyBiZWNhdXNlIGxheW91dCBvZiBjb25maWcgc3BhY2UgdmlhIGRpcmVj dCBvciBpbmRpcmVjdCBtZXRob2QgaXMgc2FtZSwKZnVuY3Rpb25zIG12ZWJ1X3BjaWVfY2hpbGRf cmRfY29uZigpIGFuZCBtdmVidV9wY2llX2NoaWxkX3dkX2NvbmYoKSBhcmUKc2xpZ2h0bHkgbW9k aWZpZWQgdG8gc3VwcG9ydCBhbHNvIGRpcmVjdCBjb25maWcgc3BhY2UgYWNjZXNzIG1ldGhvZC4K RnVuY3Rpb25zIGNhbGN1bGF0ZXMgd2hlcmUgaW4gcGh5c2ljYWwgYWRkcmVzcyByYW5nZSBpcyBy ZXF1ZXN0ZWQgY29uZmlnCnNwYWNlIHJlZ2lzdGVyIGFuZCBkbyB2aXJ0dWFsIG1hcHBpbmcgYXQg cmVxdWVzdCB0aW1lLiBBZnRlciByZWdpc3RlcgphY2Nlc3MgaXQgaXMgdW5tYXBwZWQgZnJvbSB2 aXJ0dWFsIGFkZHJlc3MgcmFuZ2UuCgpMaW5rczogaHR0cHM6Ly93d3cua2VybmVsLm9yZy9kb2Mv aHRtbC9sYXRlc3QvYXJtL21hcnZlbGwuaHRtbApTaWduZWQtb2ZmLWJ5OiBQYWxpIFJvaMOhciA8 cGFsaUBrZXJuZWwub3JnPgotLS0KQ2hhbmdlcyBpbiB2MzoKKiBDb21wbGV0ZWx5IHJld3JpdHRl bgoqIEltcGxlbWVudCBmdWxsIHN1cHBvcnQgZm9yIGFjY2Vzc2luZyBQQ0llIGNvbmZpZyBzcGFj ZSBiYXNlZCBvbiBkZXZpY2UKICB0cmVlIGRldGFpbHMgd2l0aG91dCBhbnkgaGFyY29kZWQgYWRk cmVzcyBpbiBwY2ktbXZlYnUuYyBkcml2ZXIKLS0tCiBkcml2ZXJzL3BjaS9jb250cm9sbGVyL0tj b25maWcgICAgIHwgICA0ICstCiBkcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jIHwg MTQyICsrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDEzNiBp bnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9j b250cm9sbGVyL0tjb25maWcgYi9kcml2ZXJzL3BjaS9jb250cm9sbGVyL0tjb25maWcKaW5kZXgg OGRhMmVmZGM1MTc3Li5hZTVhNDMwMzg3YmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2NvbnRy b2xsZXIvS2NvbmZpZworKysgYi9kcml2ZXJzL3BjaS9jb250cm9sbGVyL0tjb25maWcKQEAgLTUs NyArNSw3IEBAIG1lbnUgIlBDSSBjb250cm9sbGVyIGRyaXZlcnMiCiAKIGNvbmZpZyBQQ0lfTVZF QlUKIAl0cmlzdGF0ZSAiTWFydmVsbCBFQlUgUENJZSBjb250cm9sbGVyIgotCWRlcGVuZHMgb24g QVJDSF9NVkVCVSB8fCBBUkNIX0RPVkUgfHwgQ09NUElMRV9URVNUCisJZGVwZW5kcyBvbiBBUkNI X01WRUJVIHx8IEFSQ0hfRE9WRSB8fCBBUkNIX09SSU9ONVggfHwgQ09NUElMRV9URVNUCiAJZGVw ZW5kcyBvbiBNVkVCVV9NQlVTCiAJZGVwZW5kcyBvbiBBUk0KIAlkZXBlbmRzIG9uIE9GCkBAIC0x NSw3ICsxNSw3IEBAIGNvbmZpZyBQQ0lfTVZFQlUKIAlzZWxlY3QgSE9UUExVR19QQ0lfUENJRQog CWhlbHAKIAkgQWRkIHN1cHBvcnQgZm9yIE1hcnZlbGwgRUJVIFBDSWUgY29udHJvbGxlci4gVGhp cyBQQ0llIGNvbnRyb2xsZXIKLQkgaXMgdXNlZCBvbiAzMi1iaXQgTWFydmVsbCBBUk0gU29Dczog RG92ZSwgS2lya3dvb2QsIEFybWFkYSAzNzAsCisJIGlzIHVzZWQgb24gMzItYml0IE1hcnZlbGwg QVJNIFNvQ3M6IE9yaW9uLCBLaXJrd29vZCwgRG92ZSwgQXJtYWRhIDM3MCwKIAkgQXJtYWRhIFhQ LCBBcm1hZGEgMzc1LCBBcm1hZGEgMzh4IGFuZCBBcm1hZGEgMzl4LgogCiBjb25maWcgUENJX0FB UkRWQVJLCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jIGIv ZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUuYwppbmRleCA5OTg2ZGQ0ODY2ODAuLjJl ZjA0YTgyNDFmYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUu YworKysgYi9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jCkBAIC05Niw2ICs5Niw3 IEBAIHN0cnVjdCBtdmVidV9wY2llIHsKIAlzdHJ1Y3QgcmVzb3VyY2UgaW87CiAJc3RydWN0IHJl c291cmNlIHJlYWxpbzsKIAlzdHJ1Y3QgcmVzb3VyY2UgbWVtOworCXN0cnVjdCByZXNvdXJjZSBj Zmc7CiAJaW50IG5wb3J0czsKIH07CiAKQEAgLTEyNyw2ICsxMjgsNyBAQCBzdHJ1Y3QgbXZlYnVf cGNpZV9wb3J0IHsKIAlzdHJ1Y3QgbXZlYnVfcGNpZV93aW5kb3cgaW93aW47CiAJdTMyIHNhdmVk X3BjaWVfc3RhdDsKIAlzdHJ1Y3QgcmVzb3VyY2UgcmVnczsKKwlzdHJ1Y3QgcmVzb3VyY2UgY2Zn OwogCXU4IHNsb3RfcG93ZXJfbGltaXRfdmFsdWU7CiAJdTggc2xvdF9wb3dlcl9saW1pdF9zY2Fs ZTsKIAlzdHJ1Y3QgaXJxX2RvbWFpbiAqcnBfaXJxX2RvbWFpbjsKQEAgLTQwOSw2ICs0MTEsNyBA QCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfY2hpbGRfcmRfY29uZihzdHJ1Y3QgcGNpX2J1cyAqYnVz LCB1MzIgZGV2Zm4sIGludCB3aGVyZSwKIAlzdHJ1Y3QgbXZlYnVfcGNpZSAqcGNpZSA9IGJ1cy0+ c3lzZGF0YTsKIAlzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0OwogCXZvaWQgX19pb21lbSAq Y29uZl9kYXRhOworCXUzMiBvZmZzZXQ7CiAKIAlwb3J0ID0gbXZlYnVfcGNpZV9maW5kX3BvcnQo cGNpZSwgYnVzLCBkZXZmbik7CiAJaWYgKCFwb3J0KQpAQCAtNDE3LDEwICs0MjAsMjAgQEAgc3Rh dGljIGludCBtdmVidV9wY2llX2NoaWxkX3JkX2NvbmYoc3RydWN0IHBjaV9idXMgKmJ1cywgdTMy IGRldmZuLCBpbnQgd2hlcmUsCiAJaWYgKCFtdmVidV9wY2llX2xpbmtfdXAocG9ydCkpCiAJCXJl dHVybiBQQ0lCSU9TX0RFVklDRV9OT1RfRk9VTkQ7CiAKLQljb25mX2RhdGEgPSBwb3J0LT5iYXNl ICsgUENJRV9DT05GX0RBVEFfT0ZGOworCWlmIChyZXNvdXJjZV9zaXplKCZwb3J0LT5jZmcpKSB7 CisJCW9mZnNldCA9IFBDSUVfQ09ORl9BRERSKGJ1cy0+bnVtYmVyLCBkZXZmbiwgd2hlcmUpICYg flBDSUVfQ09ORl9BRERSX0VOOworCQlpZiAob2Zmc2V0ID49IHJlc291cmNlX3NpemUoJnBvcnQt PmNmZykpCisJCQlyZXR1cm4gUENJQklPU19ERVZJQ0VfTk9UX0ZPVU5EOwogCi0JbXZlYnVfd3Jp dGVsKHBvcnQsIFBDSUVfQ09ORl9BRERSKGJ1cy0+bnVtYmVyLCBkZXZmbiwgd2hlcmUpLAotCQkg ICAgIFBDSUVfQ09ORl9BRERSX09GRik7CisJCWNvbmZfZGF0YSA9IHBjaV9yZW1hcF9jZmdzcGFj ZShwb3J0LT5jZmcuc3RhcnQgKyBvZmZzZXQsIHNpemUpOworCQlpZiAoIWNvbmZfZGF0YSkKKwkJ CXJldHVybiBQQ0lCSU9TX0RFVklDRV9OT1RfRk9VTkQ7CisJfSBlbHNlIHsKKwkJY29uZl9kYXRh ID0gcG9ydC0+YmFzZSArIFBDSUVfQ09ORl9EQVRBX09GRjsKKworCQltdmVidV93cml0ZWwocG9y dCwgUENJRV9DT05GX0FERFIoYnVzLT5udW1iZXIsIGRldmZuLCB3aGVyZSksCisJCQkgICAgIFBD SUVfQ09ORl9BRERSX09GRik7CisJfQogCiAJc3dpdGNoIChzaXplKSB7CiAJY2FzZSAxOgpAQCAt NDMzLDkgKzQ0NiwxNCBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfY2hpbGRfcmRfY29uZihzdHJ1 Y3QgcGNpX2J1cyAqYnVzLCB1MzIgZGV2Zm4sIGludCB3aGVyZSwKIAkJKnZhbCA9IHJlYWRsX3Jl bGF4ZWQoY29uZl9kYXRhKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKKwkJaWYgKHJlc291cmNlX3Np emUoJnBvcnQtPmNmZykpCisJCQlpb3VubWFwKGNvbmZfZGF0YSk7CiAJCXJldHVybiBQQ0lCSU9T X0JBRF9SRUdJU1RFUl9OVU1CRVI7CiAJfQogCisJaWYgKHJlc291cmNlX3NpemUoJnBvcnQtPmNm ZykpCisJCWlvdW5tYXAoY29uZl9kYXRhKTsKKwogCXJldHVybiBQQ0lCSU9TX1NVQ0NFU1NGVUw7 CiB9CiAKQEAgLTQ0NSw2ICs0NjMsNyBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfY2hpbGRfd3Jf Y29uZihzdHJ1Y3QgcGNpX2J1cyAqYnVzLCB1MzIgZGV2Zm4sCiAJc3RydWN0IG12ZWJ1X3BjaWUg KnBjaWUgPSBidXMtPnN5c2RhdGE7CiAJc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydDsKIAl2 b2lkIF9faW9tZW0gKmNvbmZfZGF0YTsKKwl1MzIgb2Zmc2V0OwogCiAJcG9ydCA9IG12ZWJ1X3Bj aWVfZmluZF9wb3J0KHBjaWUsIGJ1cywgZGV2Zm4pOwogCWlmICghcG9ydCkKQEAgLTQ1MywxMCAr NDcyLDIwIEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9jaGlsZF93cl9jb25mKHN0cnVjdCBwY2lf YnVzICpidXMsIHUzMiBkZXZmbiwKIAlpZiAoIW12ZWJ1X3BjaWVfbGlua191cChwb3J0KSkKIAkJ cmV0dXJuIFBDSUJJT1NfREVWSUNFX05PVF9GT1VORDsKIAotCWNvbmZfZGF0YSA9IHBvcnQtPmJh c2UgKyBQQ0lFX0NPTkZfREFUQV9PRkY7CisJaWYgKHJlc291cmNlX3NpemUoJnBvcnQtPmNmZykp IHsKKwkJb2Zmc2V0ID0gUENJRV9DT05GX0FERFIoYnVzLT5udW1iZXIsIGRldmZuLCB3aGVyZSkg JiB+UENJRV9DT05GX0FERFJfRU47CisJCWlmIChvZmZzZXQgPj0gcmVzb3VyY2Vfc2l6ZSgmcG9y dC0+Y2ZnKSkKKwkJCXJldHVybiBQQ0lCSU9TX0RFVklDRV9OT1RfRk9VTkQ7CisKKwkJY29uZl9k YXRhID0gcGNpX3JlbWFwX2NmZ3NwYWNlKHBvcnQtPmNmZy5zdGFydCArIG9mZnNldCwgc2l6ZSk7 CisJCWlmICghY29uZl9kYXRhKQorCQkJcmV0dXJuIFBDSUJJT1NfREVWSUNFX05PVF9GT1VORDsK Kwl9IGVsc2UgeworCQljb25mX2RhdGEgPSBwb3J0LT5iYXNlICsgUENJRV9DT05GX0RBVEFfT0ZG OwogCi0JbXZlYnVfd3JpdGVsKHBvcnQsIFBDSUVfQ09ORl9BRERSKGJ1cy0+bnVtYmVyLCBkZXZm biwgd2hlcmUpLAotCQkgICAgIFBDSUVfQ09ORl9BRERSX09GRik7CisJCW12ZWJ1X3dyaXRlbChw b3J0LCBQQ0lFX0NPTkZfQUREUihidXMtPm51bWJlciwgZGV2Zm4sIHdoZXJlKSwKKwkJCSAgICAg UENJRV9DT05GX0FERFJfT0ZGKTsKKwl9CiAKIAlzd2l0Y2ggKHNpemUpIHsKIAljYXNlIDE6CkBA IC00NjksOSArNDk4LDE0IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9jaGlsZF93cl9jb25mKHN0 cnVjdCBwY2lfYnVzICpidXMsIHUzMiBkZXZmbiwKIAkJd3JpdGVsKHZhbCwgY29uZl9kYXRhKTsK IAkJYnJlYWs7CiAJZGVmYXVsdDoKKwkJaWYgKHJlc291cmNlX3NpemUoJnBvcnQtPmNmZykpCisJ CQlpb3VubWFwKGNvbmZfZGF0YSk7CiAJCXJldHVybiBQQ0lCSU9TX0JBRF9SRUdJU1RFUl9OVU1C RVI7CiAJfQogCisJaWYgKHJlc291cmNlX3NpemUoJnBvcnQtPmNmZykpCisJCWlvdW5tYXAoY29u Zl9kYXRhKTsKKwogCXJldHVybiBQQ0lCSU9TX1NVQ0NFU1NGVUw7CiB9CiAKQEAgLTE0NzIsNiAr MTUwNiw3IEBAIHN0YXRpYyB2b2lkIF9faW9tZW0gKm12ZWJ1X3BjaWVfbWFwX3JlZ2lzdGVycyhz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAogCiBzdGF0aWMgaW50IG12ZWJ1X2dldF90Z3Rf YXR0cihzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLCBpbnQgZGV2Zm4sCiAJCQkgICAgICB1bnNpZ25l ZCBsb25nIHR5cGUsCisJCQkgICAgICB1bnNpZ25lZCBsb25nIG9mZnNldCwKIAkJCSAgICAgIHVu c2lnbmVkIGludCAqdGd0LAogCQkJICAgICAgdW5zaWduZWQgaW50ICphdHRyKQogewpAQCAtMTQ5 Myw2ICsxNTI4LDcgQEAgc3RhdGljIGludCBtdmVidV9nZXRfdGd0X2F0dHIoc3RydWN0IGRldmlj ZV9ub2RlICpucCwgaW50IGRldmZuLAogCWZvciAoaSA9IDA7IGkgPCBucmFuZ2VzOyBpKyssIHJh bmdlICs9IHJhbmdlc3opIHsKIAkJdTMyIGZsYWdzID0gb2ZfcmVhZF9udW1iZXIocmFuZ2UsIDEp OwogCQl1MzIgc2xvdCA9IG9mX3JlYWRfbnVtYmVyKHJhbmdlICsgMSwgMSk7CisJCXUzMiBkdGFk ZHIgPSBvZl9yZWFkX251bWJlcihyYW5nZSArIDIsIDEpOwogCQl1NjQgY3B1YWRkciA9IG9mX3Jl YWRfbnVtYmVyKHJhbmdlICsgbmEsIHBuYSk7CiAJCXVuc2lnbmVkIGxvbmcgcnR5cGU7CiAKQEAg LTE1MDMsNiArMTUzOSw5IEBAIHN0YXRpYyBpbnQgbXZlYnVfZ2V0X3RndF9hdHRyKHN0cnVjdCBk ZXZpY2Vfbm9kZSAqbnAsIGludCBkZXZmbiwKIAkJZWxzZQogCQkJY29udGludWU7CiAKKwkJaWYg KGR0YWRkciAhPSBvZmZzZXQpCisJCQljb250aW51ZTsKKwogCQlpZiAoc2xvdCA9PSBQQ0lfU0xP VChkZXZmbikgJiYgdHlwZSA9PSBydHlwZSkgewogCQkJKnRndCA9IERUX0NQVUFERFJfVE9fVEFS R0VUKGNwdWFkZHIpOwogCQkJKmF0dHIgPSBEVF9DUFVBRERSX1RPX0FUVFIoY3B1YWRkcik7CkBA IC0xNTEzLDYgKzE1NTIsNDMgQEAgc3RhdGljIGludCBtdmVidV9nZXRfdGd0X2F0dHIoc3RydWN0 IGRldmljZV9ub2RlICpucCwgaW50IGRldmZuLAogCXJldHVybiAtRU5PRU5UOwogfQogCitzdGF0 aWMgaW50IG12ZWJ1X2dldF9jZmdfdGd0X2F0dHIoc3RydWN0IGRldmljZV9ub2RlICpucCwgcGh5 c19hZGRyX3Qgc3RhcnQsCisJCQkJICBzdHJ1Y3QgcmVzb3VyY2UgKnJlcywKKwkJCQkgIHVuc2ln bmVkIGludCAqdGd0LCB1bnNpZ25lZCBpbnQgKmF0dHIpCit7CisJY29uc3QgX19iZTMyICphZGRy cDsKKwl1bnNpZ25lZCBpbnQgZmxhZ3M7CisJdTY0IG9mZnNldDsKKwl1NjQgc2l6ZTsKKwlpbnQg cmV0OworCisJLyogZ2V0IHNlY29uZCBjZWxsIGZyb20gYXNzaWduZWQtYWRkcmVzc2VzIHByb3Bl cnR5ICovCisJYWRkcnAgPSBvZl9nZXRfYWRkcmVzcyhucCwgMSwgJnNpemUsICZmbGFncyk7CisJ aWYgKCFhZGRycCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoIShmbGFncyAmIElPUkVTT1VS Q0VfTUVNKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoYmUzMl90b19jcHUoYWRkcnBbMV0p ICE9IDB4MCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlmbGFncyB8PSBJT1JFU09VUkNFX01FTV9O T05QT1NURUQ7CisJb2Zmc2V0ID0gYmUzMl90b19jcHUoYWRkcnBbMl0pOworCisJcmV0ID0gbXZl YnVfZ2V0X3RndF9hdHRyKG9mX2dldF9wYXJlbnQobnApLCAwLCBJT1JFU09VUkNFX01FTSwgb2Zm c2V0LCB0Z3QsIGF0dHIpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwltZW1zZXQocmVz LCAwLCBzaXplb2YoKnJlcykpOworCXJlcy0+c3RhcnQgPSBzdGFydDsKKwlyZXMtPmVuZCA9IHN0 YXJ0ICsgc2l6ZSAtIDE7CisJcmVzLT5mbGFncyA9IGZsYWdzOworCXJlcy0+bmFtZSA9ICJQQ0kg Q0ZHIjsKKworCXJldHVybiAwOworfQorCiBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfc3VzcGVuZChz dHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IG12ZWJ1X3BjaWUgKnBjaWU7CkBAIC0xNTky LDcgKzE2NjgsNyBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcGFyc2VfcG9ydChzdHJ1Y3QgbXZl YnVfcGNpZSAqcGNpZSwKIAkJZ290byBza2lwOwogCX0KIAotCXJldCA9IG12ZWJ1X2dldF90Z3Rf YXR0cihkZXYtPm9mX25vZGUsIHBvcnQtPmRldmZuLCBJT1JFU09VUkNFX01FTSwKKwlyZXQgPSBt dmVidV9nZXRfdGd0X2F0dHIoZGV2LT5vZl9ub2RlLCBwb3J0LT5kZXZmbiwgSU9SRVNPVVJDRV9N RU0sIDAsCiAJCQkJICZwb3J0LT5tZW1fdGFyZ2V0LCAmcG9ydC0+bWVtX2F0dHIpOwogCWlmIChy ZXQgPCAwKSB7CiAJCWRldl9lcnIoZGV2LCAiJXM6IGNhbm5vdCBnZXQgdGd0L2F0dHIgZm9yIG1l bSB3aW5kb3dcbiIsCkBAIC0xNjAxLDcgKzE2NzcsNyBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVf cGFyc2VfcG9ydChzdHJ1Y3QgbXZlYnVfcGNpZSAqcGNpZSwKIAl9CiAKIAlpZiAocmVzb3VyY2Vf c2l6ZSgmcGNpZS0+aW8pICE9IDApIHsKLQkJbXZlYnVfZ2V0X3RndF9hdHRyKGRldi0+b2Zfbm9k ZSwgcG9ydC0+ZGV2Zm4sIElPUkVTT1VSQ0VfSU8sCisJCW12ZWJ1X2dldF90Z3RfYXR0cihkZXYt Pm9mX25vZGUsIHBvcnQtPmRldmZuLCBJT1JFU09VUkNFX0lPLCAwLAogCQkJCSAgICZwb3J0LT5p b190YXJnZXQsICZwb3J0LT5pb19hdHRyKTsKIAl9IGVsc2UgewogCQlwb3J0LT5pb190YXJnZXQg PSAtMTsKQEAgLTE3OTQsNiArMTg3MCwyMCBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcGFyc2Vf cmVxdWVzdF9yZXNvdXJjZXMoc3RydWN0IG12ZWJ1X3BjaWUgKnBjaWUpCiAJCQlyZXR1cm4gcmV0 OwogCX0KIAorCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShkZXYtPm9mX25vZGUsICJtYXJ2 ZWxsLG9yaW9uNXgtcGNpZSIpKSB7CisJCS8qIEdldCB0aGUgUENJZSBjb25maWd1cmF0aW9uIHNw YWNlIGFwZXJ0dXJlICovCisJCW12ZWJ1X21idXNfZ2V0X3BjaWVfY2ZnX2FwZXJ0dXJlKCZwY2ll LT5jZmcpOworCQlpZiAocmVzb3VyY2Vfc2l6ZSgmcGNpZS0+Y2ZnKSA9PSAwKSB7CisJCQlkZXZf ZXJyKGRldiwgImludmFsaWQgY29uZmlnIHNwYWNlIGFwZXJhdHVyZSBzaXplXG4iKTsKKwkJCXJl dHVybiAtRUlOVkFMOworCQl9CisKKwkJcGNpZS0+Y2ZnLm5hbWUgPSAiUENJIENGRyI7CisJCXJl dCA9IGRldm1fcmVxdWVzdF9yZXNvdXJjZShkZXYsICZpb21lbV9yZXNvdXJjZSwgJnBjaWUtPmNm Zyk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCX0KKwogCXJldHVybiAwOwogfQogCkBA IC0xODA0LDYgKzE4OTQsNyBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcHJvYmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKIAlzdHJ1Y3QgcGNpX2hvc3RfYnJpZGdlICpicmlkZ2U7CiAJ c3RydWN0IGRldmljZV9ub2RlICpucCA9IGRldi0+b2Zfbm9kZTsKIAlzdHJ1Y3QgZGV2aWNlX25v ZGUgKmNoaWxkOworCXBoeXNfYWRkcl90IHBjaWVfY2ZnX29mZnNldDsKIAlpbnQgbnVtLCBpLCBy ZXQ7CiAKIAlicmlkZ2UgPSBkZXZtX3BjaV9hbGxvY19ob3N0X2JyaWRnZShkZXYsIHNpemVvZihz dHJ1Y3QgbXZlYnVfcGNpZSkpOwpAQCAtMTgxOCw2ICsxOTA5LDggQEAgc3RhdGljIGludCBtdmVi dV9wY2llX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKHJldCkKIAkJ cmV0dXJuIHJldDsKIAorCXBjaWVfY2ZnX29mZnNldCA9IHBjaWUtPmNmZy5zdGFydDsKKwogCW51 bSA9IG9mX2dldF9hdmFpbGFibGVfY2hpbGRfY291bnQobnApOwogCiAJcGNpZS0+cG9ydHMgPSBk ZXZtX2tjYWxsb2MoZGV2LCBudW0sIHNpemVvZigqcGNpZS0+cG9ydHMpLCBHRlBfS0VSTkVMKTsK QEAgLTE4NTIsNiArMTk0NSwzMiBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcHJvYmUoc3RydWN0 IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJaWYgKHJldCA8IDApCiAJCQljb250aW51ZTsKIAor CQlpZiAocmVzb3VyY2Vfc2l6ZSgmcGNpZS0+Y2ZnKSAhPSAwKSB7CisJCQl1bnNpZ25lZCBpbnQg Y2ZnX3RhcmdldCwgY2ZnX2F0dHI7CisKKwkJCXJldCA9IG12ZWJ1X2dldF9jZmdfdGd0X2F0dHIo Y2hpbGQsIHBjaWVfY2ZnX29mZnNldCwgJnBvcnQtPmNmZywgJmNmZ190YXJnZXQsICZjZmdfYXR0 cik7CisJCQlpZiAocmV0KSB7CisJCQkJZGV2X2VycihkZXYsICIlczogbWlzc2luZyBhZGRyZXNz IHJhbmdlIGZvciBjZmcgc3BhY2VcbiIsIHBvcnQtPm5hbWUpOworCQkJCWdvdG8gZXJyX3BvcnRf ZG93bjsKKwkJCX0KKworCQkJaWYgKHBvcnQtPmNmZy5lbmQgPiBwY2llLT5jZmcuZW5kKSB7CisJ CQkJZGV2X2VycihkZXYsICIlczogcmVxdWVzdGVkIGNmZyBzcGFjZSBvZiAldSBieXRlcyBpcyB0 b28gbGFyZ2UsIGF2YWlsYWJsZSBvbmx5ICV1IGJ5dGVzXG4iLAorCQkJCQlwb3J0LT5uYW1lLCBy ZXNvdXJjZV9zaXplKCZwb3J0LT5jZmcpLCBwY2llLT5jZmcuZW5kIC0gcGNpZV9jZmdfb2Zmc2V0 ICsgMSk7CisJCQkJcG9ydC0+Y2ZnLnN0YXJ0ID0gcG9ydC0+Y2ZnLmVuZCA9IDA7CisJCQkJZ290 byBlcnJfcG9ydF9kb3duOworCQkJfQorCisJCQlyZXQgPSBtdmVidV9tYnVzX2FkZF93aW5kb3df YnlfaWQoY2ZnX3RhcmdldCwgY2ZnX2F0dHIsIHBvcnQtPmNmZy5zdGFydCwgcmVzb3VyY2Vfc2l6 ZSgmcG9ydC0+Y2ZnKSk7CisJCQlpZiAocmV0KSB7CisJCQkJZGV2X2luZm8oZGV2LCAiJXM6IGNh bm5vdCBhZGQgbWJ1cyB3aW5kb3cgZm9yIGNmZyBzcGFjZTogJWRcbiIsIHBvcnQtPm5hbWUsIHJl dCk7CisJCQkJcG9ydC0+Y2ZnLnN0YXJ0ID0gcG9ydC0+Y2ZnLmVuZCA9IDA7CisJCQkJZ290byBl cnJfcG9ydF9kb3duOworCQkJfQorCisJCQlwY2llX2NmZ19vZmZzZXQgKz0gcmVzb3VyY2Vfc2l6 ZSgmcG9ydC0+Y2ZnKTsKKwkJfQorCiAJCXBvcnQtPmJhc2UgPSBtdmVidV9wY2llX21hcF9yZWdp c3RlcnMocGRldiwgY2hpbGQsIHBvcnQpOwogCQlpZiAoSVNfRVJSKHBvcnQtPmJhc2UpKSB7CiAJ CQlkZXZfZXJyKGRldiwgIiVzOiBjYW5ub3QgbWFwIHJlZ2lzdGVyc1xuIiwgcG9ydC0+bmFtZSk7 CkBAIC0yMDExLDYgKzIxMzAsOSBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcHJvYmUoc3RydWN0 IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJcG9ydC0+YmFzZSA9IE5VTEw7CiAKIGVycl9wb3J0 X2Rvd246CisJCWlmIChwb3J0LT5jZmcuZW5kICYmIHJlc291cmNlX3NpemUoJnBvcnQtPmNmZykp CisJCQltdmVidV9tYnVzX2RlbF93aW5kb3cocG9ydC0+Y2ZnLnN0YXJ0LCByZXNvdXJjZV9zaXpl KCZwb3J0LT5jZmcpKTsKKwogCQltdmVidV9wY2llX3Bvd2VyZG93bihwb3J0KTsKIAl9CiAKQEAg LTIwOTAsNiArMjIxMiw5IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9yZW1vdmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKIAkJaWYgKHBvcnQtPm1lbXdpbi5zaXplKQogCQkJbXZlYnVf cGNpZV9kZWxfd2luZG93cyhwb3J0LCBwb3J0LT5tZW13aW4uYmFzZSwgcG9ydC0+bWVtd2luLnNp emUpOwogCisJCWlmIChwb3J0LT5jZmcuZW5kICYmIHJlc291cmNlX3NpemUoJnBvcnQtPmNmZykp CisJCQltdmVidV9tYnVzX2RlbF93aW5kb3cocG9ydC0+Y2ZnLnN0YXJ0LCByZXNvdXJjZV9zaXpl KCZwb3J0LT5jZmcpKTsKKwogCQkvKiBQb3dlciBkb3duIGNhcmQgYW5kIGRpc2FibGUgY2xvY2tz LiBNdXN0IGJlIHRoZSBsYXN0IHN0ZXAuICovCiAJCW12ZWJ1X3BjaWVfcG93ZXJkb3duKHBvcnQp OwogCX0KQEAgLTIxMDIsNiArMjIyNyw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNl X2lkIG12ZWJ1X3BjaWVfb2ZfbWF0Y2hfdGFibGVbXSA9IHsKIAl7IC5jb21wYXRpYmxlID0gIm1h cnZlbGwsYXJtYWRhLTM3MC1wY2llIiwgfSwKIAl7IC5jb21wYXRpYmxlID0gIm1hcnZlbGwsZG92 ZS1wY2llIiwgfSwKIAl7IC5jb21wYXRpYmxlID0gIm1hcnZlbGwsa2lya3dvb2QtcGNpZSIsIH0s CisJeyAuY29tcGF0aWJsZSA9ICJtYXJ2ZWxsLG9yaW9uNXgtcGNpZSIsIH0sCiAJe30sCiB9Owog Ci0tIAoyLjIwLjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3Rz LmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9saW51eC1hcm0ta2VybmVsCg==