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 7DDF1C433EF for ; Fri, 6 May 2022 13:40:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1441819AbiEFNo3 (ORCPT ); Fri, 6 May 2022 09:44:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42730 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1352819AbiEFNo2 (ORCPT ); Fri, 6 May 2022 09:44:28 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D3F2FFEF; Fri, 6 May 2022 06:40:44 -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 E8A90620C0; Fri, 6 May 2022 13:40:43 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED8B8C385B6; Fri, 6 May 2022 13:40:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1651844443; bh=zIIw6XCAEpxNTqxanLLraeRQ6N5E8O0yhBukjo7ea78=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=k19azJxpNO/MBhjI/HcZ5VJopuFnB7dF2itSD+UoSQj0VY3H13zZJN3gdjOlnPC4z f5QD4dNgqGTC44pjA4slW3dqHaX+vmuqqroSYXcZ1LlYXZhyWRK5AKdXdCSiA4GMxd 9ejA/+ZCs8YxOiuLIlM3aO4c6feaJIGoCuaT/3kFmrPA7Bkn5arsvRXQVNzoDVu9vJ Yybx7Gzf8ffV/dIGnsEs/lt8VWIfxcrgc1/0LxRcrfLZKxLv0xsP9Fhv5YWzcKw7yz ctBDY4ZYVL/9xkuk3Nqe1bnXeEWmaqJxjkyK7IFM5RjQ2PEkgiCBOtb9dRCShRwcca 9+fqjB/7Bq0Hg== Received: by pali.im (Postfix) id 9A47D13C0; Fri, 6 May 2022 15:40:41 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Thomas Gleixner , Marc Zyngier , Rob Herring , Bjorn Helgaas , Andrew Lunn , Gregory Clement , Sebastian Hesselbarth , Thomas Petazzoni , Lorenzo Pieralisi , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , =?UTF-8?q?Marek=20Beh=C3=BAn?= Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 5/6] PCI: mvebu: Implement support for interrupts on emulated bridge Date: Fri, 6 May 2022 15:40:28 +0200 Message-Id: <20220506134029.21470-6-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220506134029.21470-1-pali@kernel.org> References: <20220506134029.21470-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 This adds support for PME and ERR interrupts reported by emulated bridge (for PME and AER kernel drivers) via new Root Port irq chip as these interrupts from PCIe Root Ports are handled by mvebu hardware completely separately from INTx and MSI interrupts send by real PCIe devices. With this change, kernel PME and AER drivers start working as they can acquire required interrupt lines (provided by mvebu rp virtual irq chip). Note that for this support, device tree files has to be properly adjusted to provide "interrupts" or "interrupts-extended" property with summary interrupt source and "interrupt-names" property with "summary" string. If device tree files do not provide these properties then driver would work as before and would not provide interrupts on emulated bridge, like before. Signed-off-by: Pali Rohár --- drivers/pci/controller/pci-mvebu.c | 208 ++++++++++++++++++++++++++--- 1 file changed, 189 insertions(+), 19 deletions(-) diff --git a/drivers/pci/controller/pci-mvebu.c b/drivers/pci/controller/pci-mvebu.c index 3c48b15e3948..74923202fe95 100644 --- a/drivers/pci/controller/pci-mvebu.c +++ b/drivers/pci/controller/pci-mvebu.c @@ -56,8 +56,16 @@ #define PCIE_CONF_DATA_OFF 0x18fc #define PCIE_INT_CAUSE_OFF 0x1900 #define PCIE_INT_UNMASK_OFF 0x1910 +#define PCIE_INT_DET_COR BIT(8) +#define PCIE_INT_DET_NONFATAL BIT(9) +#define PCIE_INT_DET_FATAL BIT(10) +#define PCIE_INT_ERR_FATAL BIT(16) +#define PCIE_INT_ERR_NONFATAL BIT(17) +#define PCIE_INT_ERR_COR BIT(18) #define PCIE_INT_INTX(i) BIT(24+i) #define PCIE_INT_PM_PME BIT(28) +#define PCIE_INT_DET_MASK (PCIE_INT_DET_COR | PCIE_INT_DET_NONFATAL | PCIE_INT_DET_FATAL) +#define PCIE_INT_ERR_MASK (PCIE_INT_ERR_FATAL | PCIE_INT_ERR_NONFATAL | PCIE_INT_ERR_COR) #define PCIE_INT_ALL_MASK GENMASK(31, 0) #define PCIE_CTRL_OFF 0x1a00 #define PCIE_CTRL_X1_MODE 0x0001 @@ -120,9 +128,12 @@ struct mvebu_pcie_port { struct resource regs; u8 slot_power_limit_value; u8 slot_power_limit_scale; + struct irq_domain *rp_irq_domain; struct irq_domain *intx_irq_domain; raw_spinlock_t irq_lock; + int summary_irq; int intx_irq; + bool pme_pending; }; static inline void mvebu_writel(struct mvebu_pcie_port *port, u32 val, u32 reg) @@ -321,12 +332,27 @@ static void mvebu_pcie_setup_hw(struct mvebu_pcie_port *port) /* Clear all interrupt causes. */ mvebu_writel(port, ~PCIE_INT_ALL_MASK, PCIE_INT_CAUSE_OFF); - /* Check if "intx" interrupt was specified in DT. */ - if (port->intx_irq > 0) + /* + * Unmask all error interrupts which are internally generated. + * They cannot be disabled by SERR# Enable bit in PCI Command register, + * see Figure 6-3: Pseudo Logic Diagram for Error Message Controls in + * PCIe base specification. + * Internally generated mvebu interrupts are reported via mvebu summary + * interrupt which requires "summary" interrupt to be specified in DT. + */ + if (port->summary_irq > 0) { + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + unmask |= PCIE_INT_DET_MASK; + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + } + + /* Check if "summary" or "intx" interrupt was specified in DT. */ + if (port->summary_irq > 0 || port->intx_irq > 0) return; /* - * Fallback code when "intx" interrupt was not specified in DT: + * Fallback code when neither "summary" interrupt, nor "intx" + * interrupt was specified in DT: * Unmask all legacy INTx interrupts as driver does not provide a way * for masking and unmasking of individual legacy INTx interrupts. * Legacy INTx are reported via one shared GIC source and therefore @@ -603,11 +629,16 @@ mvebu_pci_bridge_emul_base_conf_read(struct pci_bridge_emul *bridge, case PCI_INTERRUPT_LINE: { /* * From the whole 32bit register we support reading from HW only - * one bit: PCI_BRIDGE_CTL_BUS_RESET. + * two bits: PCI_BRIDGE_CTL_BUS_RESET and PCI_BRIDGE_CTL_SERR. * Other bits are retrieved only from emulated config buffer. */ __le32 *cfgspace = (__le32 *)&bridge->conf; u32 val = le32_to_cpu(cfgspace[PCI_INTERRUPT_LINE / 4]); + if ((mvebu_readl(port, PCIE_INT_UNMASK_OFF) & + PCIE_INT_ERR_MASK) == PCIE_INT_ERR_MASK) + val |= PCI_BRIDGE_CTL_SERR << 16; + else + val &= ~(PCI_BRIDGE_CTL_SERR << 16); if (mvebu_readl(port, PCIE_CTRL_OFF) & PCIE_CTRL_MASTER_HOT_RESET) val |= PCI_BRIDGE_CTL_BUS_RESET << 16; else @@ -675,6 +706,11 @@ mvebu_pci_bridge_emul_pcie_conf_read(struct pci_bridge_emul *bridge, break; } + case PCI_EXP_RTCTL: + *value = (mvebu_readl(port, PCIE_INT_UNMASK_OFF) & + PCIE_INT_PM_PME) ? PCI_EXP_RTCTL_PMEIE : 0; + break; + case PCI_EXP_RTSTA: *value = mvebu_readl(port, PCIE_RC_RTSTA); break; @@ -780,6 +816,14 @@ mvebu_pci_bridge_emul_base_conf_write(struct pci_bridge_emul *bridge, break; case PCI_INTERRUPT_LINE: + if (mask & (PCI_BRIDGE_CTL_SERR << 16)) { + u32 unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + if (new & (PCI_BRIDGE_CTL_SERR << 16)) + unmask |= PCIE_INT_ERR_MASK; + else + unmask &= ~PCIE_INT_ERR_MASK; + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + } if (mask & (PCI_BRIDGE_CTL_BUS_RESET << 16)) { u32 ctrl = mvebu_readl(port, PCIE_CTRL_OFF); if (new & (PCI_BRIDGE_CTL_BUS_RESET << 16)) @@ -838,10 +882,25 @@ mvebu_pci_bridge_emul_pcie_conf_write(struct pci_bridge_emul *bridge, * PME Status bit in Root Status Register (PCIE_RC_RTSTA) * is read-only and can be cleared only by writing 0b to the * Interrupt Cause RW0C register (PCIE_INT_CAUSE_OFF). So - * clear PME via Interrupt Cause. + * clear PME via Interrupt Cause and also set port->pme_pending + * variable to false value to start processing PME interrupts + * in interrupt handler again. */ - if (new & PCI_EXP_RTSTA_PME) + if (new & PCI_EXP_RTSTA_PME) { mvebu_writel(port, ~PCIE_INT_PM_PME, PCIE_INT_CAUSE_OFF); + port->pme_pending = false; + } + break; + + case PCI_EXP_RTCTL: + if (mask & PCI_EXP_RTCTL_PMEIE) { + u32 unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + if (new & PCI_EXP_RTCTL_PMEIE) + unmask |= PCIE_INT_PM_PME; + else + unmask &= ~PCIE_INT_PM_PME; + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + } break; case PCI_EXP_DEVCTL2: @@ -924,6 +983,14 @@ static int mvebu_pci_bridge_emul_init(struct mvebu_pcie_port *port) bridge_flags |= PCI_BRIDGE_EMUL_NO_IO_FORWARD; } + /* + * Interrupts on emulated bridge are supported only when "summary" + * interrupt was specified in DT. Without it emulated bridge cannot + * emulate interrupts. + */ + if (port->summary_irq > 0) + bridge->conf.intpin = PCI_INTERRUPT_INTA; + /* * Older mvebu hardware provides PCIe Capability structure only in * version 1. New hardware provides it in version 2. @@ -1071,6 +1138,26 @@ static const struct irq_domain_ops mvebu_pcie_intx_irq_domain_ops = { .xlate = irq_domain_xlate_onecell, }; +static struct irq_chip rp_irq_chip = { + .name = "mvebu-rp", +}; + +static int mvebu_pcie_rp_irq_map(struct irq_domain *h, + unsigned int virq, irq_hw_number_t hwirq) +{ + struct mvebu_pcie_port *port = h->host_data; + + irq_set_chip_and_handler(virq, &rp_irq_chip, handle_simple_irq); + irq_set_chip_data(virq, port); + + return 0; +} + +static const struct irq_domain_ops mvebu_pcie_rp_irq_domain_ops = { + .map = mvebu_pcie_rp_irq_map, + .xlate = irq_domain_xlate_onecell, +}; + static int mvebu_pcie_init_irq_domain(struct mvebu_pcie_port *port) { struct device *dev = &port->pcie->pdev->dev; @@ -1093,6 +1180,22 @@ static int mvebu_pcie_init_irq_domain(struct mvebu_pcie_port *port) return -ENOMEM; } + /* + * When "summary" interrupt was not specified in DT then there is no support + * for interrupts on emulated root bridge. So skip following initialization. + */ + if (port->summary_irq <= 0) + return 0; + + port->rp_irq_domain = irq_domain_add_linear(NULL, 1, + &mvebu_pcie_rp_irq_domain_ops, + port); + if (!port->rp_irq_domain) { + irq_domain_remove(port->intx_irq_domain); + dev_err(dev, "Failed to add Root Port IRQ domain for %s\n", port->name); + return -ENOMEM; + } + return 0; } @@ -1110,6 +1213,34 @@ static void mvebu_pcie_irq_handler(struct irq_desc *desc) unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); status = cause & unmask; + /* Process PME interrupt */ + if ((status & PCIE_INT_PM_PME) && !port->pme_pending) { + /* + * Do not clear PME interrupt bit in Cause Register as it + * invalidates also content of Root Status Register. Instead + * set port->pme_pending variable to true to indicate that + * next time PME interrupt should be ignored until variable + * is back to the false value. + */ + port->pme_pending = true; + if (generic_handle_domain_irq(port->rp_irq_domain, 0) == -EINVAL) + dev_err_ratelimited(dev, "unhandled PME IRQ\n"); + } + + /* Process ERR interrupt */ + if (status & PCIE_INT_ERR_MASK) { + mvebu_writel(port, ~PCIE_INT_ERR_MASK, PCIE_INT_CAUSE_OFF); + if (generic_handle_domain_irq(port->rp_irq_domain, 0) == -EINVAL) + dev_err_ratelimited(dev, "unhandled ERR IRQ\n"); + } + + /* Process local ERR interrupt */ + if (status & PCIE_INT_DET_MASK) { + mvebu_writel(port, ~PCIE_INT_DET_MASK, PCIE_INT_CAUSE_OFF); + if (generic_handle_domain_irq(port->rp_irq_domain, 0) == -EINVAL) + dev_err_ratelimited(dev, "unhandled ERR IRQ\n"); + } + /* Process legacy INTx interrupts */ for (i = 0; i < PCI_NUM_INTX; i++) { if (!(status & PCIE_INT_INTX(i))) @@ -1124,9 +1255,29 @@ static void mvebu_pcie_irq_handler(struct irq_desc *desc) static int mvebu_pcie_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) { - /* Interrupt support on mvebu emulated bridges is not implemented yet */ - if (dev->bus->number == 0) - return 0; /* Proper return code 0 == NO_IRQ */ + struct mvebu_pcie_port *port; + struct mvebu_pcie *pcie; + + if (dev->bus->number == 0) { + /* + * Each emulated root bridge for every mvebu port has its own + * Root Port irq chip and irq domain. Argument pin is the INTx + * pin (1=INTA, 2=INTB, 3=INTC, 4=INTD) and hwirq for function + * irq_create_mapping() is indexed from zero. + */ + pcie = dev->bus->sysdata; + port = mvebu_pcie_find_port(pcie, dev->bus, PCI_DEVFN(slot, 0)); + if (!port) + return 0; /* Proper return code 0 == NO_IRQ */ + /* + * port->rp_irq_domain is available only when "summary" + * interrupt was specified in DT. When is not available then + * interrupts for emulated root bridge are not provided. + */ + if (port->summary_irq <= 0) + return 0; /* Proper return code 0 == NO_IRQ */ + return irq_create_mapping(port->rp_irq_domain, pin - 1); + } return of_irq_parse_and_map_pci(dev, slot, pin); } @@ -1321,17 +1472,32 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, } /* - * Old DT bindings do not contain "intx" interrupt + * Old DT bindings do not contain "summary" interrupt * so do not fail probing driver when interrupt does not exist. */ - port->intx_irq = of_irq_get_byname(child, "intx"); - if (port->intx_irq == -EPROBE_DEFER) { - ret = port->intx_irq; + port->summary_irq = of_irq_get_byname(child, "summary"); + if (port->summary_irq == -EPROBE_DEFER) { + ret = port->summary_irq; goto err; - } - if (port->intx_irq <= 0) { - dev_warn(dev, "%s: legacy INTx interrupts cannot be masked individually, " - "%pOF does not contain intx interrupt\n", + } else if (port->summary_irq <= 0) { + /* + * When "summary" interrupt (which includes also intx) is + * unsupported then fallback to dedicated "intx" interrupt. + * Old DT bindings do not contain "intx" interrupt so do not + * fail probing driver when interrupt does not exist. + */ + port->intx_irq = of_irq_get_byname(child, "intx"); + if (port->intx_irq == -EPROBE_DEFER) { + ret = port->intx_irq; + goto err; + } + if (port->intx_irq <= 0) { + dev_warn(dev, "%s: legacy INTx interrupts cannot be masked individually, " + "%pOF does not contain intx interrupt\n", + port->name, child); + } + dev_warn(dev, "%s: interrupts on Root Port are unsupported, " + "%pOF does not contain summary interrupt\n", port->name, child); } @@ -1540,7 +1706,8 @@ static int mvebu_pcie_probe(struct platform_device *pdev) for (i = 0; i < pcie->nports; i++) { struct mvebu_pcie_port *port = &pcie->ports[i]; - int irq = port->intx_irq; + int irq = (port->summary_irq > 0) ? port->summary_irq : + (port->intx_irq > 0) ? port->intx_irq : 0; child = port->dn; if (!child) @@ -1688,7 +1855,8 @@ static int mvebu_pcie_remove(struct platform_device *pdev) for (i = 0; i < pcie->nports; i++) { struct mvebu_pcie_port *port = &pcie->ports[i]; - int irq = port->intx_irq; + int irq = (port->summary_irq > 0) ? port->summary_irq : + (port->intx_irq > 0) ? port->intx_irq : 0; if (!port->base) continue; @@ -1710,6 +1878,8 @@ static int mvebu_pcie_remove(struct platform_device *pdev) /* Remove IRQ domains. */ if (port->intx_irq_domain) irq_domain_remove(port->intx_irq_domain); + if (port->rp_irq_domain) + irq_domain_remove(port->rp_irq_domain); /* Free config space for emulated root bridge. */ pci_bridge_emul_cleanup(&port->bridge); -- 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 AEB07C433EF for ; Fri, 6 May 2022 13:43:24 +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=GPeHvIgou0Htxk15mys1e29at7LcII2qhzR88eel5I4=; b=y0OBPSl7QTZB1L I4cxPwl6t5GGS5oZW7hFyon2bypqbZkEjhRR3ly1hbKXVkEAprbZ9H5XPdeZsHgJWFNKdt4B39vt7 ljQ2RhDfcCNAJiOrZV8mHDCNdQwOr+R6gAkwIpD/X8ecZCobjXELdc4q9CkK55hnp17YH7tYW9XMw UH0jXjoao3szo25ItYqnpgCeoKqeTfcHiSyB32LsPX+kNReVPIESUfAADB6KT0tsplY+75EVD5Y8h LDg3zS5utf+haSrjhOwSyBAk9x1K1Cgygag9nkLE18v7UXRgoH1I7+dc3QuTa0hzOz5NVJY9+xcxt l2Dp4aR1zkYZOTwE2U1g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nmyDn-003Z1F-1N; Fri, 06 May 2022 13:42:15 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nmyCK-003YB6-Qj for linux-arm-kernel@lists.infradead.org; Fri, 06 May 2022 13:40:48 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 4BE73620CA; Fri, 6 May 2022 13:40:44 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED8B8C385B6; Fri, 6 May 2022 13:40:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1651844443; bh=zIIw6XCAEpxNTqxanLLraeRQ6N5E8O0yhBukjo7ea78=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=k19azJxpNO/MBhjI/HcZ5VJopuFnB7dF2itSD+UoSQj0VY3H13zZJN3gdjOlnPC4z f5QD4dNgqGTC44pjA4slW3dqHaX+vmuqqroSYXcZ1LlYXZhyWRK5AKdXdCSiA4GMxd 9ejA/+ZCs8YxOiuLIlM3aO4c6feaJIGoCuaT/3kFmrPA7Bkn5arsvRXQVNzoDVu9vJ Yybx7Gzf8ffV/dIGnsEs/lt8VWIfxcrgc1/0LxRcrfLZKxLv0xsP9Fhv5YWzcKw7yz ctBDY4ZYVL/9xkuk3Nqe1bnXeEWmaqJxjkyK7IFM5RjQ2PEkgiCBOtb9dRCShRwcca 9+fqjB/7Bq0Hg== Received: by pali.im (Postfix) id 9A47D13C0; Fri, 6 May 2022 15:40:41 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Thomas Gleixner , Marc Zyngier , Rob Herring , Bjorn Helgaas , Andrew Lunn , Gregory Clement , Sebastian Hesselbarth , Thomas Petazzoni , Lorenzo Pieralisi , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , =?UTF-8?q?Marek=20Beh=C3=BAn?= Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 5/6] PCI: mvebu: Implement support for interrupts on emulated bridge Date: Fri, 6 May 2022 15:40:28 +0200 Message-Id: <20220506134029.21470-6-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220506134029.21470-1-pali@kernel.org> References: <20220506134029.21470-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220506_064044_987874_43369FDF X-CRM114-Status: GOOD ( 36.99 ) 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 VGhpcyBhZGRzIHN1cHBvcnQgZm9yIFBNRSBhbmQgRVJSIGludGVycnVwdHMgcmVwb3J0ZWQgYnkg ZW11bGF0ZWQgYnJpZGdlCihmb3IgUE1FIGFuZCBBRVIga2VybmVsIGRyaXZlcnMpIHZpYSBuZXcg Um9vdCBQb3J0IGlycSBjaGlwIGFzIHRoZXNlCmludGVycnVwdHMgZnJvbSBQQ0llIFJvb3QgUG9y dHMgYXJlIGhhbmRsZWQgYnkgbXZlYnUgaGFyZHdhcmUgY29tcGxldGVseQpzZXBhcmF0ZWx5IGZy b20gSU5UeCBhbmQgTVNJIGludGVycnVwdHMgc2VuZCBieSByZWFsIFBDSWUgZGV2aWNlcy4KCldp dGggdGhpcyBjaGFuZ2UsIGtlcm5lbCBQTUUgYW5kIEFFUiBkcml2ZXJzIHN0YXJ0IHdvcmtpbmcg YXMgdGhleSBjYW4KYWNxdWlyZSByZXF1aXJlZCBpbnRlcnJ1cHQgbGluZXMgKHByb3ZpZGVkIGJ5 IG12ZWJ1IHJwIHZpcnR1YWwgaXJxIGNoaXApLgoKTm90ZSB0aGF0IGZvciB0aGlzIHN1cHBvcnQs IGRldmljZSB0cmVlIGZpbGVzIGhhcyB0byBiZSBwcm9wZXJseSBhZGp1c3RlZAp0byBwcm92aWRl ICJpbnRlcnJ1cHRzIiBvciAiaW50ZXJydXB0cy1leHRlbmRlZCIgcHJvcGVydHkgd2l0aCBzdW1t YXJ5CmludGVycnVwdCBzb3VyY2UgYW5kICJpbnRlcnJ1cHQtbmFtZXMiIHByb3BlcnR5IHdpdGgg InN1bW1hcnkiIHN0cmluZy4KCklmIGRldmljZSB0cmVlIGZpbGVzIGRvIG5vdCBwcm92aWRlIHRo ZXNlIHByb3BlcnRpZXMgdGhlbiBkcml2ZXIgd291bGQgd29yawphcyBiZWZvcmUgYW5kIHdvdWxk IG5vdCBwcm92aWRlIGludGVycnVwdHMgb24gZW11bGF0ZWQgYnJpZGdlLCBsaWtlIGJlZm9yZS4K ClNpZ25lZC1vZmYtYnk6IFBhbGkgUm9ow6FyIDxwYWxpQGtlcm5lbC5vcmc+Ci0tLQogZHJpdmVy cy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUuYyB8IDIwOCArKysrKysrKysrKysrKysrKysrKysr KysrKy0tLQogMSBmaWxlIGNoYW5nZWQsIDE4OSBpbnNlcnRpb25zKCspLCAxOSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jIGIvZHJp dmVycy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUuYwppbmRleCAzYzQ4YjE1ZTM5NDguLjc0OTIz MjAyZmU5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUuYwor KysgYi9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jCkBAIC01Niw4ICs1NiwxNiBA QAogI2RlZmluZSBQQ0lFX0NPTkZfREFUQV9PRkYJMHgxOGZjCiAjZGVmaW5lIFBDSUVfSU5UX0NB VVNFX09GRgkweDE5MDAKICNkZWZpbmUgUENJRV9JTlRfVU5NQVNLX09GRgkweDE5MTAKKyNkZWZp bmUgIFBDSUVfSU5UX0RFVF9DT1IJCUJJVCg4KQorI2RlZmluZSAgUENJRV9JTlRfREVUX05PTkZB VEFMCQlCSVQoOSkKKyNkZWZpbmUgIFBDSUVfSU5UX0RFVF9GQVRBTAkJQklUKDEwKQorI2RlZmlu ZSAgUENJRV9JTlRfRVJSX0ZBVEFMCQlCSVQoMTYpCisjZGVmaW5lICBQQ0lFX0lOVF9FUlJfTk9O RkFUQUwJCUJJVCgxNykKKyNkZWZpbmUgIFBDSUVfSU5UX0VSUl9DT1IJCUJJVCgxOCkKICNkZWZp bmUgIFBDSUVfSU5UX0lOVFgoaSkJCUJJVCgyNCtpKQogI2RlZmluZSAgUENJRV9JTlRfUE1fUE1F CQlCSVQoMjgpCisjZGVmaW5lICBQQ0lFX0lOVF9ERVRfTUFTSwkJKFBDSUVfSU5UX0RFVF9DT1Ig fCBQQ0lFX0lOVF9ERVRfTk9ORkFUQUwgfCBQQ0lFX0lOVF9ERVRfRkFUQUwpCisjZGVmaW5lICBQ Q0lFX0lOVF9FUlJfTUFTSwkJKFBDSUVfSU5UX0VSUl9GQVRBTCB8IFBDSUVfSU5UX0VSUl9OT05G QVRBTCB8IFBDSUVfSU5UX0VSUl9DT1IpCiAjZGVmaW5lICBQQ0lFX0lOVF9BTExfTUFTSwkJR0VO TUFTSygzMSwgMCkKICNkZWZpbmUgUENJRV9DVFJMX09GRgkJMHgxYTAwCiAjZGVmaW5lICBQQ0lF X0NUUkxfWDFfTU9ERQkJMHgwMDAxCkBAIC0xMjAsOSArMTI4LDEyIEBAIHN0cnVjdCBtdmVidV9w Y2llX3BvcnQgewogCXN0cnVjdCByZXNvdXJjZSByZWdzOwogCXU4IHNsb3RfcG93ZXJfbGltaXRf dmFsdWU7CiAJdTggc2xvdF9wb3dlcl9saW1pdF9zY2FsZTsKKwlzdHJ1Y3QgaXJxX2RvbWFpbiAq cnBfaXJxX2RvbWFpbjsKIAlzdHJ1Y3QgaXJxX2RvbWFpbiAqaW50eF9pcnFfZG9tYWluOwogCXJh d19zcGlubG9ja190IGlycV9sb2NrOworCWludCBzdW1tYXJ5X2lycTsKIAlpbnQgaW50eF9pcnE7 CisJYm9vbCBwbWVfcGVuZGluZzsKIH07CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBtdmVidV93cml0 ZWwoc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCwgdTMyIHZhbCwgdTMyIHJlZykKQEAgLTMy MSwxMiArMzMyLDI3IEBAIHN0YXRpYyB2b2lkIG12ZWJ1X3BjaWVfc2V0dXBfaHcoc3RydWN0IG12 ZWJ1X3BjaWVfcG9ydCAqcG9ydCkKIAkvKiBDbGVhciBhbGwgaW50ZXJydXB0IGNhdXNlcy4gKi8K IAltdmVidV93cml0ZWwocG9ydCwgflBDSUVfSU5UX0FMTF9NQVNLLCBQQ0lFX0lOVF9DQVVTRV9P RkYpOwogCi0JLyogQ2hlY2sgaWYgImludHgiIGludGVycnVwdCB3YXMgc3BlY2lmaWVkIGluIERU LiAqLwotCWlmIChwb3J0LT5pbnR4X2lycSA+IDApCisJLyoKKwkgKiBVbm1hc2sgYWxsIGVycm9y IGludGVycnVwdHMgd2hpY2ggYXJlIGludGVybmFsbHkgZ2VuZXJhdGVkLgorCSAqIFRoZXkgY2Fu bm90IGJlIGRpc2FibGVkIGJ5IFNFUlIjIEVuYWJsZSBiaXQgaW4gUENJIENvbW1hbmQgcmVnaXN0 ZXIsCisJICogc2VlIEZpZ3VyZSA2LTM6IFBzZXVkbyBMb2dpYyBEaWFncmFtIGZvciBFcnJvciBN ZXNzYWdlIENvbnRyb2xzIGluCisJICogUENJZSBiYXNlIHNwZWNpZmljYXRpb24uCisJICogSW50 ZXJuYWxseSBnZW5lcmF0ZWQgbXZlYnUgaW50ZXJydXB0cyBhcmUgcmVwb3J0ZWQgdmlhIG12ZWJ1 IHN1bW1hcnkKKwkgKiBpbnRlcnJ1cHQgd2hpY2ggcmVxdWlyZXMgInN1bW1hcnkiIGludGVycnVw dCB0byBiZSBzcGVjaWZpZWQgaW4gRFQuCisJICovCisJaWYgKHBvcnQtPnN1bW1hcnlfaXJxID4g MCkgeworCQl1bm1hc2sgPSBtdmVidV9yZWFkbChwb3J0LCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsK KwkJdW5tYXNrIHw9IFBDSUVfSU5UX0RFVF9NQVNLOworCQltdmVidV93cml0ZWwocG9ydCwgdW5t YXNrLCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsKKwl9CisKKwkvKiBDaGVjayBpZiAic3VtbWFyeSIg b3IgImludHgiIGludGVycnVwdCB3YXMgc3BlY2lmaWVkIGluIERULiAqLworCWlmIChwb3J0LT5z dW1tYXJ5X2lycSA+IDAgfHwgcG9ydC0+aW50eF9pcnEgPiAwKQogCQlyZXR1cm47CiAKIAkvKgot CSAqIEZhbGxiYWNrIGNvZGUgd2hlbiAiaW50eCIgaW50ZXJydXB0IHdhcyBub3Qgc3BlY2lmaWVk IGluIERUOgorCSAqIEZhbGxiYWNrIGNvZGUgd2hlbiBuZWl0aGVyICJzdW1tYXJ5IiBpbnRlcnJ1 cHQsIG5vciAiaW50eCIKKwkgKiBpbnRlcnJ1cHQgd2FzIHNwZWNpZmllZCBpbiBEVDoKIAkgKiBV bm1hc2sgYWxsIGxlZ2FjeSBJTlR4IGludGVycnVwdHMgYXMgZHJpdmVyIGRvZXMgbm90IHByb3Zp ZGUgYSB3YXkKIAkgKiBmb3IgbWFza2luZyBhbmQgdW5tYXNraW5nIG9mIGluZGl2aWR1YWwgbGVn YWN5IElOVHggaW50ZXJydXB0cy4KIAkgKiBMZWdhY3kgSU5UeCBhcmUgcmVwb3J0ZWQgdmlhIG9u ZSBzaGFyZWQgR0lDIHNvdXJjZSBhbmQgdGhlcmVmb3JlCkBAIC02MDMsMTEgKzYyOSwxNiBAQCBt dmVidV9wY2lfYnJpZGdlX2VtdWxfYmFzZV9jb25mX3JlYWQoc3RydWN0IHBjaV9icmlkZ2VfZW11 bCAqYnJpZGdlLAogCWNhc2UgUENJX0lOVEVSUlVQVF9MSU5FOiB7CiAJCS8qCiAJCSAqIEZyb20g dGhlIHdob2xlIDMyYml0IHJlZ2lzdGVyIHdlIHN1cHBvcnQgcmVhZGluZyBmcm9tIEhXIG9ubHkK LQkJICogb25lIGJpdDogUENJX0JSSURHRV9DVExfQlVTX1JFU0VULgorCQkgKiB0d28gYml0czog UENJX0JSSURHRV9DVExfQlVTX1JFU0VUIGFuZCBQQ0lfQlJJREdFX0NUTF9TRVJSLgogCQkgKiBP dGhlciBiaXRzIGFyZSByZXRyaWV2ZWQgb25seSBmcm9tIGVtdWxhdGVkIGNvbmZpZyBidWZmZXIu CiAJCSAqLwogCQlfX2xlMzIgKmNmZ3NwYWNlID0gKF9fbGUzMiAqKSZicmlkZ2UtPmNvbmY7CiAJ CXUzMiB2YWwgPSBsZTMyX3RvX2NwdShjZmdzcGFjZVtQQ0lfSU5URVJSVVBUX0xJTkUgLyA0XSk7 CisJCWlmICgobXZlYnVfcmVhZGwocG9ydCwgUENJRV9JTlRfVU5NQVNLX09GRikgJgorCQkgICAg ICBQQ0lFX0lOVF9FUlJfTUFTSykgPT0gUENJRV9JTlRfRVJSX01BU0spCisJCQl2YWwgfD0gUENJ X0JSSURHRV9DVExfU0VSUiA8PCAxNjsKKwkJZWxzZQorCQkJdmFsICY9IH4oUENJX0JSSURHRV9D VExfU0VSUiA8PCAxNik7CiAJCWlmIChtdmVidV9yZWFkbChwb3J0LCBQQ0lFX0NUUkxfT0ZGKSAm IFBDSUVfQ1RSTF9NQVNURVJfSE9UX1JFU0VUKQogCQkJdmFsIHw9IFBDSV9CUklER0VfQ1RMX0JV U19SRVNFVCA8PCAxNjsKIAkJZWxzZQpAQCAtNjc1LDYgKzcwNiwxMSBAQCBtdmVidV9wY2lfYnJp ZGdlX2VtdWxfcGNpZV9jb25mX3JlYWQoc3RydWN0IHBjaV9icmlkZ2VfZW11bCAqYnJpZGdlLAog CQlicmVhazsKIAl9CiAKKwljYXNlIFBDSV9FWFBfUlRDVEw6CisJCSp2YWx1ZSA9IChtdmVidV9y ZWFkbChwb3J0LCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKSAmCisJCQkgIFBDSUVfSU5UX1BNX1BNRSkg PyBQQ0lfRVhQX1JUQ1RMX1BNRUlFIDogMDsKKwkJYnJlYWs7CisKIAljYXNlIFBDSV9FWFBfUlRT VEE6CiAJCSp2YWx1ZSA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfUkNfUlRTVEEpOwogCQlicmVh azsKQEAgLTc4MCw2ICs4MTYsMTQgQEAgbXZlYnVfcGNpX2JyaWRnZV9lbXVsX2Jhc2VfY29uZl93 cml0ZShzdHJ1Y3QgcGNpX2JyaWRnZV9lbXVsICpicmlkZ2UsCiAJCWJyZWFrOwogCiAJY2FzZSBQ Q0lfSU5URVJSVVBUX0xJTkU6CisJCWlmIChtYXNrICYgKFBDSV9CUklER0VfQ1RMX1NFUlIgPDwg MTYpKSB7CisJCQl1MzIgdW5tYXNrID0gbXZlYnVfcmVhZGwocG9ydCwgUENJRV9JTlRfVU5NQVNL X09GRik7CisJCQlpZiAobmV3ICYgKFBDSV9CUklER0VfQ1RMX1NFUlIgPDwgMTYpKQorCQkJCXVu bWFzayB8PSBQQ0lFX0lOVF9FUlJfTUFTSzsKKwkJCWVsc2UKKwkJCQl1bm1hc2sgJj0gflBDSUVf SU5UX0VSUl9NQVNLOworCQkJbXZlYnVfd3JpdGVsKHBvcnQsIHVubWFzaywgUENJRV9JTlRfVU5N QVNLX09GRik7CisJCX0KIAkJaWYgKG1hc2sgJiAoUENJX0JSSURHRV9DVExfQlVTX1JFU0VUIDw8 IDE2KSkgewogCQkJdTMyIGN0cmwgPSBtdmVidV9yZWFkbChwb3J0LCBQQ0lFX0NUUkxfT0ZGKTsK IAkJCWlmIChuZXcgJiAoUENJX0JSSURHRV9DVExfQlVTX1JFU0VUIDw8IDE2KSkKQEAgLTgzOCwx MCArODgyLDI1IEBAIG12ZWJ1X3BjaV9icmlkZ2VfZW11bF9wY2llX2NvbmZfd3JpdGUoc3RydWN0 IHBjaV9icmlkZ2VfZW11bCAqYnJpZGdlLAogCQkgKiBQTUUgU3RhdHVzIGJpdCBpbiBSb290IFN0 YXR1cyBSZWdpc3RlciAoUENJRV9SQ19SVFNUQSkKIAkJICogaXMgcmVhZC1vbmx5IGFuZCBjYW4g YmUgY2xlYXJlZCBvbmx5IGJ5IHdyaXRpbmcgMGIgdG8gdGhlCiAJCSAqIEludGVycnVwdCBDYXVz ZSBSVzBDIHJlZ2lzdGVyIChQQ0lFX0lOVF9DQVVTRV9PRkYpLiBTbwotCQkgKiBjbGVhciBQTUUg dmlhIEludGVycnVwdCBDYXVzZS4KKwkJICogY2xlYXIgUE1FIHZpYSBJbnRlcnJ1cHQgQ2F1c2Ug YW5kIGFsc28gc2V0IHBvcnQtPnBtZV9wZW5kaW5nCisJCSAqIHZhcmlhYmxlIHRvIGZhbHNlIHZh bHVlIHRvIHN0YXJ0IHByb2Nlc3NpbmcgUE1FIGludGVycnVwdHMKKwkJICogaW4gaW50ZXJydXB0 IGhhbmRsZXIgYWdhaW4uCiAJCSAqLwotCQlpZiAobmV3ICYgUENJX0VYUF9SVFNUQV9QTUUpCisJ CWlmIChuZXcgJiBQQ0lfRVhQX1JUU1RBX1BNRSkgewogCQkJbXZlYnVfd3JpdGVsKHBvcnQsIH5Q Q0lFX0lOVF9QTV9QTUUsIFBDSUVfSU5UX0NBVVNFX09GRik7CisJCQlwb3J0LT5wbWVfcGVuZGlu ZyA9IGZhbHNlOworCQl9CisJCWJyZWFrOworCisJY2FzZSBQQ0lfRVhQX1JUQ1RMOgorCQlpZiAo bWFzayAmIFBDSV9FWFBfUlRDVExfUE1FSUUpIHsKKwkJCXUzMiB1bm1hc2sgPSBtdmVidV9yZWFk bChwb3J0LCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsKKwkJCWlmIChuZXcgJiBQQ0lfRVhQX1JUQ1RM X1BNRUlFKQorCQkJCXVubWFzayB8PSBQQ0lFX0lOVF9QTV9QTUU7CisJCQllbHNlCisJCQkJdW5t YXNrICY9IH5QQ0lFX0lOVF9QTV9QTUU7CisJCQltdmVidV93cml0ZWwocG9ydCwgdW5tYXNrLCBQ Q0lFX0lOVF9VTk1BU0tfT0ZGKTsKKwkJfQogCQlicmVhazsKIAogCWNhc2UgUENJX0VYUF9ERVZD VEwyOgpAQCAtOTI0LDYgKzk4MywxNCBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaV9icmlkZ2VfZW11 bF9pbml0KHN0cnVjdCBtdmVidV9wY2llX3BvcnQgKnBvcnQpCiAJCWJyaWRnZV9mbGFncyB8PSBQ Q0lfQlJJREdFX0VNVUxfTk9fSU9fRk9SV0FSRDsKIAl9CiAKKwkvKgorCSAqIEludGVycnVwdHMg b24gZW11bGF0ZWQgYnJpZGdlIGFyZSBzdXBwb3J0ZWQgb25seSB3aGVuICJzdW1tYXJ5IgorCSAq IGludGVycnVwdCB3YXMgc3BlY2lmaWVkIGluIERULiBXaXRob3V0IGl0IGVtdWxhdGVkIGJyaWRn ZSBjYW5ub3QKKwkgKiBlbXVsYXRlIGludGVycnVwdHMuCisJICovCisJaWYgKHBvcnQtPnN1bW1h cnlfaXJxID4gMCkKKwkJYnJpZGdlLT5jb25mLmludHBpbiA9IFBDSV9JTlRFUlJVUFRfSU5UQTsK KwogCS8qCiAJICogT2xkZXIgbXZlYnUgaGFyZHdhcmUgcHJvdmlkZXMgUENJZSBDYXBhYmlsaXR5 IHN0cnVjdHVyZSBvbmx5IGluCiAJICogdmVyc2lvbiAxLiBOZXcgaGFyZHdhcmUgcHJvdmlkZXMg aXQgaW4gdmVyc2lvbiAyLgpAQCAtMTA3MSw2ICsxMTM4LDI2IEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgaXJxX2RvbWFpbl9vcHMgbXZlYnVfcGNpZV9pbnR4X2lycV9kb21haW5fb3BzID0gewogCS54 bGF0ZSA9IGlycV9kb21haW5feGxhdGVfb25lY2VsbCwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgaXJx X2NoaXAgcnBfaXJxX2NoaXAgPSB7CisJLm5hbWUgPSAibXZlYnUtcnAiLAorfTsKKworc3RhdGlj IGludCBtdmVidV9wY2llX3JwX2lycV9tYXAoc3RydWN0IGlycV9kb21haW4gKmgsCisJCQkJICAg dW5zaWduZWQgaW50IHZpcnEsIGlycV9od19udW1iZXJfdCBod2lycSkKK3sKKwlzdHJ1Y3QgbXZl YnVfcGNpZV9wb3J0ICpwb3J0ID0gaC0+aG9zdF9kYXRhOworCisJaXJxX3NldF9jaGlwX2FuZF9o YW5kbGVyKHZpcnEsICZycF9pcnFfY2hpcCwgaGFuZGxlX3NpbXBsZV9pcnEpOworCWlycV9zZXRf Y2hpcF9kYXRhKHZpcnEsIHBvcnQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgaXJxX2RvbWFpbl9vcHMgbXZlYnVfcGNpZV9ycF9pcnFfZG9tYWluX29wcyA9IHsKKwku bWFwID0gbXZlYnVfcGNpZV9ycF9pcnFfbWFwLAorCS54bGF0ZSA9IGlycV9kb21haW5feGxhdGVf b25lY2VsbCwKK307CisKIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9pbml0X2lycV9kb21haW4oc3Ry dWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCkKIHsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcG9y dC0+cGNpZS0+cGRldi0+ZGV2OwpAQCAtMTA5Myw2ICsxMTgwLDIyIEBAIHN0YXRpYyBpbnQgbXZl YnVfcGNpZV9pbml0X2lycV9kb21haW4oc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCkKIAkJ cmV0dXJuIC1FTk9NRU07CiAJfQogCisJLyoKKwkgKiBXaGVuICJzdW1tYXJ5IiBpbnRlcnJ1cHQg d2FzIG5vdCBzcGVjaWZpZWQgaW4gRFQgdGhlbiB0aGVyZSBpcyBubyBzdXBwb3J0CisJICogZm9y IGludGVycnVwdHMgb24gZW11bGF0ZWQgcm9vdCBicmlkZ2UuIFNvIHNraXAgZm9sbG93aW5nIGlu aXRpYWxpemF0aW9uLgorCSAqLworCWlmIChwb3J0LT5zdW1tYXJ5X2lycSA8PSAwKQorCQlyZXR1 cm4gMDsKKworCXBvcnQtPnJwX2lycV9kb21haW4gPSBpcnFfZG9tYWluX2FkZF9saW5lYXIoTlVM TCwgMSwKKwkJCQkJCSAgICAgICZtdmVidV9wY2llX3JwX2lycV9kb21haW5fb3BzLAorCQkJCQkJ ICAgICAgcG9ydCk7CisJaWYgKCFwb3J0LT5ycF9pcnFfZG9tYWluKSB7CisJCWlycV9kb21haW5f cmVtb3ZlKHBvcnQtPmludHhfaXJxX2RvbWFpbik7CisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRv IGFkZCBSb290IFBvcnQgSVJRIGRvbWFpbiBmb3IgJXNcbiIsIHBvcnQtPm5hbWUpOworCQlyZXR1 cm4gLUVOT01FTTsKKwl9CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTExMCw2ICsxMjEzLDM0IEBA IHN0YXRpYyB2b2lkIG12ZWJ1X3BjaWVfaXJxX2hhbmRsZXIoc3RydWN0IGlycV9kZXNjICpkZXNj KQogCXVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfSU5UX1VOTUFTS19PRkYpOwogCXN0 YXR1cyA9IGNhdXNlICYgdW5tYXNrOwogCisJLyogUHJvY2VzcyBQTUUgaW50ZXJydXB0ICovCisJ aWYgKChzdGF0dXMgJiBQQ0lFX0lOVF9QTV9QTUUpICYmICFwb3J0LT5wbWVfcGVuZGluZykgewor CQkvKgorCQkgKiBEbyBub3QgY2xlYXIgUE1FIGludGVycnVwdCBiaXQgaW4gQ2F1c2UgUmVnaXN0 ZXIgYXMgaXQKKwkJICogaW52YWxpZGF0ZXMgYWxzbyBjb250ZW50IG9mIFJvb3QgU3RhdHVzIFJl Z2lzdGVyLiBJbnN0ZWFkCisJCSAqIHNldCBwb3J0LT5wbWVfcGVuZGluZyB2YXJpYWJsZSB0byB0 cnVlIHRvIGluZGljYXRlIHRoYXQKKwkJICogbmV4dCB0aW1lIFBNRSBpbnRlcnJ1cHQgc2hvdWxk IGJlIGlnbm9yZWQgdW50aWwgdmFyaWFibGUKKwkJICogaXMgYmFjayB0byB0aGUgZmFsc2UgdmFs dWUuCisJCSAqLworCQlwb3J0LT5wbWVfcGVuZGluZyA9IHRydWU7CisJCWlmIChnZW5lcmljX2hh bmRsZV9kb21haW5faXJxKHBvcnQtPnJwX2lycV9kb21haW4sIDApID09IC1FSU5WQUwpCisJCQlk ZXZfZXJyX3JhdGVsaW1pdGVkKGRldiwgInVuaGFuZGxlZCBQTUUgSVJRXG4iKTsKKwl9CisKKwkv KiBQcm9jZXNzIEVSUiBpbnRlcnJ1cHQgKi8KKwlpZiAoc3RhdHVzICYgUENJRV9JTlRfRVJSX01B U0spIHsKKwkJbXZlYnVfd3JpdGVsKHBvcnQsIH5QQ0lFX0lOVF9FUlJfTUFTSywgUENJRV9JTlRf Q0FVU0VfT0ZGKTsKKwkJaWYgKGdlbmVyaWNfaGFuZGxlX2RvbWFpbl9pcnEocG9ydC0+cnBfaXJx X2RvbWFpbiwgMCkgPT0gLUVJTlZBTCkKKwkJCWRldl9lcnJfcmF0ZWxpbWl0ZWQoZGV2LCAidW5o YW5kbGVkIEVSUiBJUlFcbiIpOworCX0KKworCS8qIFByb2Nlc3MgbG9jYWwgRVJSIGludGVycnVw dCAqLworCWlmIChzdGF0dXMgJiBQQ0lFX0lOVF9ERVRfTUFTSykgeworCQltdmVidV93cml0ZWwo cG9ydCwgflBDSUVfSU5UX0RFVF9NQVNLLCBQQ0lFX0lOVF9DQVVTRV9PRkYpOworCQlpZiAoZ2Vu ZXJpY19oYW5kbGVfZG9tYWluX2lycShwb3J0LT5ycF9pcnFfZG9tYWluLCAwKSA9PSAtRUlOVkFM KQorCQkJZGV2X2Vycl9yYXRlbGltaXRlZChkZXYsICJ1bmhhbmRsZWQgRVJSIElSUVxuIik7CisJ fQorCiAJLyogUHJvY2VzcyBsZWdhY3kgSU5UeCBpbnRlcnJ1cHRzICovCiAJZm9yIChpID0gMDsg aSA8IFBDSV9OVU1fSU5UWDsgaSsrKSB7CiAJCWlmICghKHN0YXR1cyAmIFBDSUVfSU5UX0lOVFgo aSkpKQpAQCAtMTEyNCw5ICsxMjU1LDI5IEBAIHN0YXRpYyB2b2lkIG12ZWJ1X3BjaWVfaXJxX2hh bmRsZXIoc3RydWN0IGlycV9kZXNjICpkZXNjKQogCiBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfbWFw X2lycShjb25zdCBzdHJ1Y3QgcGNpX2RldiAqZGV2LCB1OCBzbG90LCB1OCBwaW4pCiB7Ci0JLyog SW50ZXJydXB0IHN1cHBvcnQgb24gbXZlYnUgZW11bGF0ZWQgYnJpZGdlcyBpcyBub3QgaW1wbGVt ZW50ZWQgeWV0ICovCi0JaWYgKGRldi0+YnVzLT5udW1iZXIgPT0gMCkKLQkJcmV0dXJuIDA7IC8q IFByb3BlciByZXR1cm4gY29kZSAwID09IE5PX0lSUSAqLworCXN0cnVjdCBtdmVidV9wY2llX3Bv cnQgKnBvcnQ7CisJc3RydWN0IG12ZWJ1X3BjaWUgKnBjaWU7CisKKwlpZiAoZGV2LT5idXMtPm51 bWJlciA9PSAwKSB7CisJCS8qCisJCSAqIEVhY2ggZW11bGF0ZWQgcm9vdCBicmlkZ2UgZm9yIGV2 ZXJ5IG12ZWJ1IHBvcnQgaGFzIGl0cyBvd24KKwkJICogUm9vdCBQb3J0IGlycSBjaGlwIGFuZCBp cnEgZG9tYWluLiBBcmd1bWVudCBwaW4gaXMgdGhlIElOVHgKKwkJICogcGluICgxPUlOVEEsIDI9 SU5UQiwgMz1JTlRDLCA0PUlOVEQpIGFuZCBod2lycSBmb3IgZnVuY3Rpb24KKwkJICogaXJxX2Ny ZWF0ZV9tYXBwaW5nKCkgaXMgaW5kZXhlZCBmcm9tIHplcm8uCisJCSAqLworCQlwY2llID0gZGV2 LT5idXMtPnN5c2RhdGE7CisJCXBvcnQgPSBtdmVidV9wY2llX2ZpbmRfcG9ydChwY2llLCBkZXYt PmJ1cywgUENJX0RFVkZOKHNsb3QsIDApKTsKKwkJaWYgKCFwb3J0KQorCQkJcmV0dXJuIDA7IC8q IFByb3BlciByZXR1cm4gY29kZSAwID09IE5PX0lSUSAqLworCQkvKgorCQkgKiBwb3J0LT5ycF9p cnFfZG9tYWluIGlzIGF2YWlsYWJsZSBvbmx5IHdoZW4gInN1bW1hcnkiCisJCSAqIGludGVycnVw dCB3YXMgc3BlY2lmaWVkIGluIERULiBXaGVuIGlzIG5vdCBhdmFpbGFibGUgdGhlbgorCQkgKiBp bnRlcnJ1cHRzIGZvciBlbXVsYXRlZCByb290IGJyaWRnZSBhcmUgbm90IHByb3ZpZGVkLgorCQkg Ki8KKwkJaWYgKHBvcnQtPnN1bW1hcnlfaXJxIDw9IDApCisJCQlyZXR1cm4gMDsgLyogUHJvcGVy IHJldHVybiBjb2RlIDAgPT0gTk9fSVJRICovCisJCXJldHVybiBpcnFfY3JlYXRlX21hcHBpbmco cG9ydC0+cnBfaXJxX2RvbWFpbiwgcGluIC0gMSk7CisJfQogCiAJcmV0dXJuIG9mX2lycV9wYXJz ZV9hbmRfbWFwX3BjaShkZXYsIHNsb3QsIHBpbik7CiB9CkBAIC0xMzIxLDE3ICsxNDcyLDMyIEBA IHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9wYXJzZV9wb3J0KHN0cnVjdCBtdmVidV9wY2llICpwY2ll LAogCX0KIAogCS8qCi0JICogT2xkIERUIGJpbmRpbmdzIGRvIG5vdCBjb250YWluICJpbnR4IiBp bnRlcnJ1cHQKKwkgKiBPbGQgRFQgYmluZGluZ3MgZG8gbm90IGNvbnRhaW4gInN1bW1hcnkiIGlu dGVycnVwdAogCSAqIHNvIGRvIG5vdCBmYWlsIHByb2JpbmcgZHJpdmVyIHdoZW4gaW50ZXJydXB0 IGRvZXMgbm90IGV4aXN0LgogCSAqLwotCXBvcnQtPmludHhfaXJxID0gb2ZfaXJxX2dldF9ieW5h bWUoY2hpbGQsICJpbnR4Iik7Ci0JaWYgKHBvcnQtPmludHhfaXJxID09IC1FUFJPQkVfREVGRVIp IHsKLQkJcmV0ID0gcG9ydC0+aW50eF9pcnE7CisJcG9ydC0+c3VtbWFyeV9pcnEgPSBvZl9pcnFf Z2V0X2J5bmFtZShjaGlsZCwgInN1bW1hcnkiKTsKKwlpZiAocG9ydC0+c3VtbWFyeV9pcnEgPT0g LUVQUk9CRV9ERUZFUikgeworCQlyZXQgPSBwb3J0LT5zdW1tYXJ5X2lycTsKIAkJZ290byBlcnI7 Ci0JfQotCWlmIChwb3J0LT5pbnR4X2lycSA8PSAwKSB7Ci0JCWRldl93YXJuKGRldiwgIiVzOiBs ZWdhY3kgSU5UeCBpbnRlcnJ1cHRzIGNhbm5vdCBiZSBtYXNrZWQgaW5kaXZpZHVhbGx5LCAiCi0J CQkgICAgICAiJXBPRiBkb2VzIG5vdCBjb250YWluIGludHggaW50ZXJydXB0XG4iLAorCX0gZWxz ZSBpZiAocG9ydC0+c3VtbWFyeV9pcnEgPD0gMCkgeworCQkvKgorCQkgKiBXaGVuICJzdW1tYXJ5 IiBpbnRlcnJ1cHQgKHdoaWNoIGluY2x1ZGVzIGFsc28gaW50eCkgaXMKKwkJICogdW5zdXBwb3J0 ZWQgdGhlbiBmYWxsYmFjayB0byBkZWRpY2F0ZWQgImludHgiIGludGVycnVwdC4KKwkJICogT2xk IERUIGJpbmRpbmdzIGRvIG5vdCBjb250YWluICJpbnR4IiBpbnRlcnJ1cHQgc28gZG8gbm90CisJ CSAqIGZhaWwgcHJvYmluZyBkcml2ZXIgd2hlbiBpbnRlcnJ1cHQgZG9lcyBub3QgZXhpc3QuCisJ CSAqLworCQlwb3J0LT5pbnR4X2lycSA9IG9mX2lycV9nZXRfYnluYW1lKGNoaWxkLCAiaW50eCIp OworCQlpZiAocG9ydC0+aW50eF9pcnEgPT0gLUVQUk9CRV9ERUZFUikgeworCQkJcmV0ID0gcG9y dC0+aW50eF9pcnE7CisJCQlnb3RvIGVycjsKKwkJfQorCQlpZiAocG9ydC0+aW50eF9pcnEgPD0g MCkgeworCQkJZGV2X3dhcm4oZGV2LCAiJXM6IGxlZ2FjeSBJTlR4IGludGVycnVwdHMgY2Fubm90 IGJlIG1hc2tlZCBpbmRpdmlkdWFsbHksICIKKwkJCQkgICAgICAiJXBPRiBkb2VzIG5vdCBjb250 YWluIGludHggaW50ZXJydXB0XG4iLAorCQkJCSBwb3J0LT5uYW1lLCBjaGlsZCk7CisJCX0KKwkJ ZGV2X3dhcm4oZGV2LCAiJXM6IGludGVycnVwdHMgb24gUm9vdCBQb3J0IGFyZSB1bnN1cHBvcnRl ZCwgIgorCQkJICAgICAgIiVwT0YgZG9lcyBub3QgY29udGFpbiBzdW1tYXJ5IGludGVycnVwdFxu IiwKIAkJCSBwb3J0LT5uYW1lLCBjaGlsZCk7CiAJfQogCkBAIC0xNTQwLDcgKzE3MDYsOCBAQCBz dGF0aWMgaW50IG12ZWJ1X3BjaWVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK IAogCWZvciAoaSA9IDA7IGkgPCBwY2llLT5ucG9ydHM7IGkrKykgewogCQlzdHJ1Y3QgbXZlYnVf cGNpZV9wb3J0ICpwb3J0ID0gJnBjaWUtPnBvcnRzW2ldOwotCQlpbnQgaXJxID0gcG9ydC0+aW50 eF9pcnE7CisJCWludCBpcnEgPSAocG9ydC0+c3VtbWFyeV9pcnEgPiAwKSA/IHBvcnQtPnN1bW1h cnlfaXJxIDoKKwkJCSAgKHBvcnQtPmludHhfaXJxID4gMCkgPyBwb3J0LT5pbnR4X2lycSA6IDA7 CiAKIAkJY2hpbGQgPSBwb3J0LT5kbjsKIAkJaWYgKCFjaGlsZCkKQEAgLTE2ODgsNyArMTg1NSw4 IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq cGRldikKIAogCWZvciAoaSA9IDA7IGkgPCBwY2llLT5ucG9ydHM7IGkrKykgewogCQlzdHJ1Y3Qg bXZlYnVfcGNpZV9wb3J0ICpwb3J0ID0gJnBjaWUtPnBvcnRzW2ldOwotCQlpbnQgaXJxID0gcG9y dC0+aW50eF9pcnE7CisJCWludCBpcnEgPSAocG9ydC0+c3VtbWFyeV9pcnEgPiAwKSA/IHBvcnQt PnN1bW1hcnlfaXJxIDoKKwkJCSAgKHBvcnQtPmludHhfaXJxID4gMCkgPyBwb3J0LT5pbnR4X2ly cSA6IDA7CiAKIAkJaWYgKCFwb3J0LT5iYXNlKQogCQkJY29udGludWU7CkBAIC0xNzEwLDYgKzE4 NzgsOCBAQCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCiAJCS8qIFJlbW92ZSBJUlEgZG9tYWlucy4gKi8KIAkJaWYgKHBvcnQtPmludHhf aXJxX2RvbWFpbikKIAkJCWlycV9kb21haW5fcmVtb3ZlKHBvcnQtPmludHhfaXJxX2RvbWFpbik7 CisJCWlmIChwb3J0LT5ycF9pcnFfZG9tYWluKQorCQkJaXJxX2RvbWFpbl9yZW1vdmUocG9ydC0+ cnBfaXJxX2RvbWFpbik7CiAKIAkJLyogRnJlZSBjb25maWcgc3BhY2UgZm9yIGVtdWxhdGVkIHJv b3QgYnJpZGdlLiAqLwogCQlwY2lfYnJpZGdlX2VtdWxfY2xlYW51cCgmcG9ydC0+YnJpZGdlKTsK LS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMu aW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2xpbnV4LWFybS1rZXJuZWwK