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 B048DC32793 for ; Wed, 17 Aug 2022 23:03:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229572AbiHQXDl (ORCPT ); Wed, 17 Aug 2022 19:03:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34946 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242086AbiHQXDl (ORCPT ); Wed, 17 Aug 2022 19:03:41 -0400 Received: from ams.source.kernel.org (ams.source.kernel.org [IPv6:2604:1380:4601:e00::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 31E47A50F6; Wed, 17 Aug 2022 16:03:39 -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 ams.source.kernel.org (Postfix) with ESMTPS id B9ECFB81FCC; Wed, 17 Aug 2022 23:03:37 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0F1C4C43140; Wed, 17 Aug 2022 23:03:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1660777416; bh=lgW5f/v0qSxgkHrNjAqybtRTzfetRdmdVzUBSAlIV5w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ZFaYqrKzgvt6kvzkh+Npk/YVeKgZI0fzIbR//n3JUdyyEtGVS9P5H5Q5GdfgPaIgQ /7qDmuvHATEpBajqKaB5miDiVpR+ombNoJZaS2siIY2aojzXqnZEolBcsIgbU78vTZ KVhf7iGy/U6Zpy/jOKMBzhqNmtmD7K1/bvYq14fgpT5lwl12IOaIRmJtDyid2tl17w 0xKFpcDK4nuC7eyC7F9mJNn0p/N4STKPqrly/UjVpejaQ7I5eeQnhhnAVbdYQYjHnU iSM4iFPf4wzKOxkrOPcQ8Lrg/Lg3kWmJINAasvEoFB1GllriVqPVJwvA4T6wax7Eik q7V3/LWcySvZg== Received: by pali.im (Postfix) id 618D927CB; Thu, 18 Aug 2022 01:03:33 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , Bjorn Helgaas , Rob Herring , Andrew Lunn , Sebastian Hesselbarth , Gregory Clement , Thomas Petazzoni Cc: linux-pci@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 2/4] PCI: mvebu: Implement support for interrupts on emulated bridge Date: Thu, 18 Aug 2022 01:00:34 +0200 Message-Id: <20220817230036.817-3-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220817230036.817-1-pali@kernel.org> References: <20220817230036.817-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 error interrupt source and "interrupt-names" property with "error" 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 | 256 ++++++++++++++++++++++++++--- 1 file changed, 237 insertions(+), 19 deletions(-) diff --git a/drivers/pci/controller/pci-mvebu.c b/drivers/pci/controller/pci-mvebu.c index 54ce5d43b695..e69bdaa8de43 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 error_irq; int intx_irq; + bool pme_pending; }; static inline void mvebu_writel(struct mvebu_pcie_port *port, u32 val, u32 reg) @@ -321,9 +332,19 @@ 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) - return; + /* + * 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 "error" interrupt to be specified in DT. + */ + if (port->error_irq > 0) { + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + unmask |= PCIE_INT_DET_MASK; + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + } /* * Fallback code when "intx" interrupt was not specified in DT: @@ -335,10 +356,12 @@ static void mvebu_pcie_setup_hw(struct mvebu_pcie_port *port) * performance penalty as every PCIe interrupt handler needs to be * called when some interrupt is triggered. */ - unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); - unmask |= PCIE_INT_INTX(0) | PCIE_INT_INTX(1) | - PCIE_INT_INTX(2) | PCIE_INT_INTX(3); - mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + if (port->intx_irq <= 0) { + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + unmask |= PCIE_INT_INTX(0) | PCIE_INT_INTX(1) | + PCIE_INT_INTX(2) | PCIE_INT_INTX(3); + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + } } static struct mvebu_pcie_port *mvebu_pcie_find_port(struct mvebu_pcie *pcie, @@ -603,11 +626,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 +703,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 +813,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)) && port->error_irq > 0) { + 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 +879,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) && port->error_irq > 0) { + 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 +980,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 "error" + * interrupt was specified in DT. Without it emulated bridge cannot + * emulate interrupts. + */ + if (port->error_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. @@ -1072,6 +1136,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; @@ -1094,10 +1178,72 @@ static int mvebu_pcie_init_irq_domain(struct mvebu_pcie_port *port) return -ENOMEM; } + /* + * When "error" interrupt was not specified in DT then there is no + * support for interrupts on emulated root bridge. So skip following + * initialization. + */ + if (port->error_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; } -static irqreturn_t mvebu_pcie_irq_handler(int irq, void *arg) +static irqreturn_t mvebu_pcie_error_irq_handler(int irq, void *arg) +{ + struct mvebu_pcie_port *port = arg; + struct device *dev = &port->pcie->pdev->dev; + u32 cause, unmask, status; + + cause = mvebu_readl(port, PCIE_INT_CAUSE_OFF); + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + status = cause & unmask; + + /* "error" interrupt handler does not process INTX interrupts */ + status &= ~(PCIE_INT_INTX(0) | PCIE_INT_INTX(1) | + PCIE_INT_INTX(2) | PCIE_INT_INTX(3)); + + /* 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"); + } + + return status ? IRQ_HANDLED : IRQ_NONE; +} + +static irqreturn_t mvebu_pcie_intx_irq_handler(int irq, void *arg) { struct mvebu_pcie_port *port = arg; struct device *dev = &port->pcie->pdev->dev; @@ -1108,6 +1254,10 @@ static irqreturn_t mvebu_pcie_irq_handler(int irq, void *arg) unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); status = cause & unmask; + /* "intx" interrupt handler process only INTX interrupts */ + status &= PCIE_INT_INTX(0) | PCIE_INT_INTX(1) | + PCIE_INT_INTX(2) | PCIE_INT_INTX(3); + /* Process legacy INTx interrupts */ for (i = 0; i < PCI_NUM_INTX; i++) { if (!(status & PCIE_INT_INTX(i))) @@ -1122,9 +1272,29 @@ static irqreturn_t mvebu_pcie_irq_handler(int irq, void *arg) 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 "error" interrupt + * was specified in DT. When is not available then interrupts + * for emulated root bridge are not provided. + */ + if (port->error_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); } @@ -1333,6 +1503,21 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, port->name, child); } + /* + * Old DT bindings do not contain "error" interrupt + * so do not fail probing driver when interrupt does not exist. + */ + port->error_irq = of_irq_get_byname(child, "error"); + if (port->error_irq == -EPROBE_DEFER) { + ret = port->error_irq; + goto err; + } + if (port->error_irq <= 0) { + dev_warn(dev, "%s: interrupts on Root Port are unsupported, " + "%pOF does not contain error interrupt\n", + port->name, child); + } + reset_gpio = of_get_named_gpio_flags(child, "reset-gpios", 0, &flags); if (reset_gpio == -EPROBE_DEFER) { ret = reset_gpio; @@ -1538,7 +1723,6 @@ 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; child = port->dn; if (!child) @@ -1566,7 +1750,7 @@ static int mvebu_pcie_probe(struct platform_device *pdev) continue; } - if (irq > 0) { + if (port->error_irq > 0 || port->intx_irq > 0) { ret = mvebu_pcie_init_irq_domain(port); if (ret) { dev_err(dev, "%s: cannot init irq domain\n", @@ -1577,14 +1761,42 @@ static int mvebu_pcie_probe(struct platform_device *pdev) mvebu_pcie_powerdown(port); continue; } + } + + if (port->error_irq > 0) { + ret = devm_request_irq(dev, port->error_irq, + mvebu_pcie_error_irq_handler, + IRQF_SHARED | IRQF_NO_THREAD, + port->name, port); + if (ret) { + dev_err(dev, "%s: cannot register error interrupt handler: %d\n", + port->name, ret); + if (port->intx_irq_domain) + irq_domain_remove(port->intx_irq_domain); + if (port->rp_irq_domain) + irq_domain_remove(port->rp_irq_domain); + pci_bridge_emul_cleanup(&port->bridge); + devm_iounmap(dev, port->base); + port->base = NULL; + mvebu_pcie_powerdown(port); + continue; + } + } - ret = devm_request_irq(dev, irq, mvebu_pcie_irq_handler, + if (port->intx_irq > 0) { + ret = devm_request_irq(dev, port->intx_irq, + mvebu_pcie_intx_irq_handler, IRQF_SHARED | IRQF_NO_THREAD, port->name, port); if (ret) { - dev_err(dev, "%s: cannot register interrupt handler: %d\n", + dev_err(dev, "%s: cannot register intx interrupt handler: %d\n", port->name, ret); - irq_domain_remove(port->intx_irq_domain); + if (port->error_irq > 0) + devm_free_irq(dev, port->error_irq, port); + if (port->intx_irq_domain) + irq_domain_remove(port->intx_irq_domain); + if (port->rp_irq_domain) + irq_domain_remove(port->rp_irq_domain); pci_bridge_emul_cleanup(&port->bridge); devm_iounmap(dev, port->base); port->base = NULL; @@ -1722,6 +1934,12 @@ static int mvebu_pcie_remove(struct platform_device *pdev) } irq_domain_remove(port->intx_irq_domain); } + if (port->rp_irq_domain) { + int virq = irq_find_mapping(port->rp_irq_domain, 0); + if (virq > 0) + irq_dispose_mapping(virq); + 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 20BD7C25B08 for ; Wed, 17 Aug 2022 23:05:32 +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=pcR5GI7plMGCL4kMtFQuFVZsAoQHKTfSaATjbModFbM=; b=tXjSN1Q0x4LC65 TyROBh3acRiNvFhXhzj/iO/stmYDurAN3n/tK/+Ps75O196XI/cjQPVUA3MVTpueDqArvHsCwNztM VDSkxhUgr+cBILGk+czZGvWBKYa9Lj+n5YkOv/JRIQ6QNxV3XKqZksUJGCvIFXPZ2ET4l1ioGTxeu 5D4NxOXUVA5QODUycDt32rTNwl4z3jmHA5hfOxG6mhJmLJRdk31cXFcsJcaCajdoy582/hvxdrunP Udhz5HF77j/uO1Wuh6YwfQXcr0Xvy3qGqPLzhHC07Vu2gVt5XJF+Eu4yKnItbslQ79qfjJ14H9ntX 8h/EUaX4XtZuENvTSEgg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oOS5G-008Dyc-Kc; Wed, 17 Aug 2022 23:04:22 +0000 Received: from dfw.source.kernel.org ([139.178.84.217]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oOS4Y-008DB4-4s for linux-arm-kernel@lists.infradead.org; Wed, 17 Aug 2022 23:03:40 +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 0230660EFA; Wed, 17 Aug 2022 23:03:37 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0F1C4C43140; Wed, 17 Aug 2022 23:03:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1660777416; bh=lgW5f/v0qSxgkHrNjAqybtRTzfetRdmdVzUBSAlIV5w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ZFaYqrKzgvt6kvzkh+Npk/YVeKgZI0fzIbR//n3JUdyyEtGVS9P5H5Q5GdfgPaIgQ /7qDmuvHATEpBajqKaB5miDiVpR+ombNoJZaS2siIY2aojzXqnZEolBcsIgbU78vTZ KVhf7iGy/U6Zpy/jOKMBzhqNmtmD7K1/bvYq14fgpT5lwl12IOaIRmJtDyid2tl17w 0xKFpcDK4nuC7eyC7F9mJNn0p/N4STKPqrly/UjVpejaQ7I5eeQnhhnAVbdYQYjHnU iSM4iFPf4wzKOxkrOPcQ8Lrg/Lg3kWmJINAasvEoFB1GllriVqPVJwvA4T6wax7Eik q7V3/LWcySvZg== Received: by pali.im (Postfix) id 618D927CB; Thu, 18 Aug 2022 01:03:33 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , Bjorn Helgaas , Rob Herring , Andrew Lunn , Sebastian Hesselbarth , Gregory Clement , Thomas Petazzoni Cc: linux-pci@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 2/4] PCI: mvebu: Implement support for interrupts on emulated bridge Date: Thu, 18 Aug 2022 01:00:34 +0200 Message-Id: <20220817230036.817-3-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220817230036.817-1-pali@kernel.org> References: <20220817230036.817-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220817_160338_328149_1032F8D1 X-CRM114-Status: GOOD ( 38.32 ) 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 ICJpbnRlcnJ1cHRzIiBvciAiaW50ZXJydXB0cy1leHRlbmRlZCIgcHJvcGVydHkgd2l0aCBlcnJv cgppbnRlcnJ1cHQgc291cmNlIGFuZCAiaW50ZXJydXB0LW5hbWVzIiBwcm9wZXJ0eSB3aXRoICJl cnJvciIgc3RyaW5nLgoKSWYgZGV2aWNlIHRyZWUgZmlsZXMgZG8gbm90IHByb3ZpZGUgdGhlc2Ug cHJvcGVydGllcyB0aGVuIGRyaXZlciB3b3VsZCB3b3JrCmFzIGJlZm9yZSBhbmQgd291bGQgbm90 IHByb3ZpZGUgaW50ZXJydXB0cyBvbiBlbXVsYXRlZCBicmlkZ2UsIGxpa2UgYmVmb3JlLgoKU2ln bmVkLW9mZi1ieTogUGFsaSBSb2jDoXIgPHBhbGlAa2VybmVsLm9yZz4KLS0tCiBkcml2ZXJzL3Bj aS9jb250cm9sbGVyL3BjaS1tdmVidS5jIHwgMjU2ICsrKysrKysrKysrKysrKysrKysrKysrKysr LS0tCiAxIGZpbGUgY2hhbmdlZCwgMjM3IGluc2VydGlvbnMoKyksIDE5IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLW12ZWJ1LmMgYi9kcml2ZXJz L3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jCmluZGV4IDU0Y2U1ZDQzYjY5NS4uZTY5YmRhYThk ZTQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jCisrKyBi L2RyaXZlcnMvcGNpL2NvbnRyb2xsZXIvcGNpLW12ZWJ1LmMKQEAgLTU2LDggKzU2LDE2IEBACiAj ZGVmaW5lIFBDSUVfQ09ORl9EQVRBX09GRgkweDE4ZmMKICNkZWZpbmUgUENJRV9JTlRfQ0FVU0Vf T0ZGCTB4MTkwMAogI2RlZmluZSBQQ0lFX0lOVF9VTk1BU0tfT0ZGCTB4MTkxMAorI2RlZmluZSAg UENJRV9JTlRfREVUX0NPUgkJQklUKDgpCisjZGVmaW5lICBQQ0lFX0lOVF9ERVRfTk9ORkFUQUwJ CUJJVCg5KQorI2RlZmluZSAgUENJRV9JTlRfREVUX0ZBVEFMCQlCSVQoMTApCisjZGVmaW5lICBQ Q0lFX0lOVF9FUlJfRkFUQUwJCUJJVCgxNikKKyNkZWZpbmUgIFBDSUVfSU5UX0VSUl9OT05GQVRB TAkJQklUKDE3KQorI2RlZmluZSAgUENJRV9JTlRfRVJSX0NPUgkJQklUKDE4KQogI2RlZmluZSAg UENJRV9JTlRfSU5UWChpKQkJQklUKDI0K2kpCiAjZGVmaW5lICBQQ0lFX0lOVF9QTV9QTUUJCUJJ VCgyOCkKKyNkZWZpbmUgIFBDSUVfSU5UX0RFVF9NQVNLCQkoUENJRV9JTlRfREVUX0NPUiB8IFBD SUVfSU5UX0RFVF9OT05GQVRBTCB8IFBDSUVfSU5UX0RFVF9GQVRBTCkKKyNkZWZpbmUgIFBDSUVf SU5UX0VSUl9NQVNLCQkoUENJRV9JTlRfRVJSX0ZBVEFMIHwgUENJRV9JTlRfRVJSX05PTkZBVEFM IHwgUENJRV9JTlRfRVJSX0NPUikKICNkZWZpbmUgIFBDSUVfSU5UX0FMTF9NQVNLCQlHRU5NQVNL KDMxLCAwKQogI2RlZmluZSBQQ0lFX0NUUkxfT0ZGCQkweDFhMDAKICNkZWZpbmUgIFBDSUVfQ1RS TF9YMV9NT0RFCQkweDAwMDEKQEAgLTEyMCw5ICsxMjgsMTIgQEAgc3RydWN0IG12ZWJ1X3BjaWVf cG9ydCB7CiAJc3RydWN0IHJlc291cmNlIHJlZ3M7CiAJdTggc2xvdF9wb3dlcl9saW1pdF92YWx1 ZTsKIAl1OCBzbG90X3Bvd2VyX2xpbWl0X3NjYWxlOworCXN0cnVjdCBpcnFfZG9tYWluICpycF9p cnFfZG9tYWluOwogCXN0cnVjdCBpcnFfZG9tYWluICppbnR4X2lycV9kb21haW47CiAJcmF3X3Nw aW5sb2NrX3QgaXJxX2xvY2s7CisJaW50IGVycm9yX2lycTsKIAlpbnQgaW50eF9pcnE7CisJYm9v bCBwbWVfcGVuZGluZzsKIH07CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBtdmVidV93cml0ZWwoc3Ry dWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCwgdTMyIHZhbCwgdTMyIHJlZykKQEAgLTMyMSw5ICsz MzIsMTkgQEAgc3RhdGljIHZvaWQgbXZlYnVfcGNpZV9zZXR1cF9odyhzdHJ1Y3QgbXZlYnVfcGNp ZV9wb3J0ICpwb3J0KQogCS8qIENsZWFyIGFsbCBpbnRlcnJ1cHQgY2F1c2VzLiAqLwogCW12ZWJ1 X3dyaXRlbChwb3J0LCB+UENJRV9JTlRfQUxMX01BU0ssIFBDSUVfSU5UX0NBVVNFX09GRik7CiAK LQkvKiBDaGVjayBpZiAiaW50eCIgaW50ZXJydXB0IHdhcyBzcGVjaWZpZWQgaW4gRFQuICovCi0J aWYgKHBvcnQtPmludHhfaXJxID4gMCkKLQkJcmV0dXJuOworCS8qCisJICogVW5tYXNrIGFsbCBl cnJvciBpbnRlcnJ1cHRzIHdoaWNoIGFyZSBpbnRlcm5hbGx5IGdlbmVyYXRlZC4KKwkgKiBUaGV5 IGNhbm5vdCBiZSBkaXNhYmxlZCBieSBTRVJSIyBFbmFibGUgYml0IGluIFBDSSBDb21tYW5kIHJl Z2lzdGVyLAorCSAqIHNlZSBGaWd1cmUgNi0zOiBQc2V1ZG8gTG9naWMgRGlhZ3JhbSBmb3IgRXJy b3IgTWVzc2FnZSBDb250cm9scyBpbgorCSAqIFBDSWUgYmFzZSBzcGVjaWZpY2F0aW9uLgorCSAq IEludGVybmFsbHkgZ2VuZXJhdGVkIG12ZWJ1IGludGVycnVwdHMgYXJlIHJlcG9ydGVkIHZpYSBt dmVidSBzdW1tYXJ5CisJICogaW50ZXJydXB0IHdoaWNoIHJlcXVpcmVzICJlcnJvciIgaW50ZXJy dXB0IHRvIGJlIHNwZWNpZmllZCBpbiBEVC4KKwkgKi8KKwlpZiAocG9ydC0+ZXJyb3JfaXJxID4g MCkgeworCQl1bm1hc2sgPSBtdmVidV9yZWFkbChwb3J0LCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsK KwkJdW5tYXNrIHw9IFBDSUVfSU5UX0RFVF9NQVNLOworCQltdmVidV93cml0ZWwocG9ydCwgdW5t YXNrLCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsKKwl9CiAKIAkvKgogCSAqIEZhbGxiYWNrIGNvZGUg d2hlbiAiaW50eCIgaW50ZXJydXB0IHdhcyBub3Qgc3BlY2lmaWVkIGluIERUOgpAQCAtMzM1LDEw ICszNTYsMTIgQEAgc3RhdGljIHZvaWQgbXZlYnVfcGNpZV9zZXR1cF9odyhzdHJ1Y3QgbXZlYnVf cGNpZV9wb3J0ICpwb3J0KQogCSAqIHBlcmZvcm1hbmNlIHBlbmFsdHkgYXMgZXZlcnkgUENJZSBp bnRlcnJ1cHQgaGFuZGxlciBuZWVkcyB0byBiZQogCSAqIGNhbGxlZCB3aGVuIHNvbWUgaW50ZXJy dXB0IGlzIHRyaWdnZXJlZC4KIAkgKi8KLQl1bm1hc2sgPSBtdmVidV9yZWFkbChwb3J0LCBQQ0lF X0lOVF9VTk1BU0tfT0ZGKTsKLQl1bm1hc2sgfD0gUENJRV9JTlRfSU5UWCgwKSB8IFBDSUVfSU5U X0lOVFgoMSkgfAotCQkgIFBDSUVfSU5UX0lOVFgoMikgfCBQQ0lFX0lOVF9JTlRYKDMpOwotCW12 ZWJ1X3dyaXRlbChwb3J0LCB1bm1hc2ssIFBDSUVfSU5UX1VOTUFTS19PRkYpOworCWlmIChwb3J0 LT5pbnR4X2lycSA8PSAwKSB7CisJCXVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfSU5U X1VOTUFTS19PRkYpOworCQl1bm1hc2sgfD0gUENJRV9JTlRfSU5UWCgwKSB8IFBDSUVfSU5UX0lO VFgoMSkgfAorCQkJICBQQ0lFX0lOVF9JTlRYKDIpIHwgUENJRV9JTlRfSU5UWCgzKTsKKwkJbXZl YnVfd3JpdGVsKHBvcnQsIHVubWFzaywgUENJRV9JTlRfVU5NQVNLX09GRik7CisJfQogfQogCiBz dGF0aWMgc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqbXZlYnVfcGNpZV9maW5kX3BvcnQoc3RydWN0 IG12ZWJ1X3BjaWUgKnBjaWUsCkBAIC02MDMsMTEgKzYyNiwxNiBAQCBtdmVidV9wY2lfYnJpZGdl X2VtdWxfYmFzZV9jb25mX3JlYWQoc3RydWN0IHBjaV9icmlkZ2VfZW11bCAqYnJpZGdlLAogCWNh c2UgUENJX0lOVEVSUlVQVF9MSU5FOiB7CiAJCS8qCiAJCSAqIEZyb20gdGhlIHdob2xlIDMyYml0 IHJlZ2lzdGVyIHdlIHN1cHBvcnQgcmVhZGluZyBmcm9tIEhXIG9ubHkKLQkJICogb25lIGJpdDog UENJX0JSSURHRV9DVExfQlVTX1JFU0VULgorCQkgKiB0d28gYml0czogUENJX0JSSURHRV9DVExf QlVTX1JFU0VUIGFuZCBQQ0lfQlJJREdFX0NUTF9TRVJSLgogCQkgKiBPdGhlciBiaXRzIGFyZSBy ZXRyaWV2ZWQgb25seSBmcm9tIGVtdWxhdGVkIGNvbmZpZyBidWZmZXIuCiAJCSAqLwogCQlfX2xl MzIgKmNmZ3NwYWNlID0gKF9fbGUzMiAqKSZicmlkZ2UtPmNvbmY7CiAJCXUzMiB2YWwgPSBsZTMy X3RvX2NwdShjZmdzcGFjZVtQQ0lfSU5URVJSVVBUX0xJTkUgLyA0XSk7CisJCWlmICgobXZlYnVf cmVhZGwocG9ydCwgUENJRV9JTlRfVU5NQVNLX09GRikgJgorCQkgICAgICBQQ0lFX0lOVF9FUlJf TUFTSykgPT0gUENJRV9JTlRfRVJSX01BU0spCisJCQl2YWwgfD0gUENJX0JSSURHRV9DVExfU0VS UiA8PCAxNjsKKwkJZWxzZQorCQkJdmFsICY9IH4oUENJX0JSSURHRV9DVExfU0VSUiA8PCAxNik7 CiAJCWlmIChtdmVidV9yZWFkbChwb3J0LCBQQ0lFX0NUUkxfT0ZGKSAmIFBDSUVfQ1RSTF9NQVNU RVJfSE9UX1JFU0VUKQogCQkJdmFsIHw9IFBDSV9CUklER0VfQ1RMX0JVU19SRVNFVCA8PCAxNjsK IAkJZWxzZQpAQCAtNjc1LDYgKzcwMywxMSBAQCBtdmVidV9wY2lfYnJpZGdlX2VtdWxfcGNpZV9j b25mX3JlYWQoc3RydWN0IHBjaV9icmlkZ2VfZW11bCAqYnJpZGdlLAogCQlicmVhazsKIAl9CiAK KwljYXNlIFBDSV9FWFBfUlRDVEw6CisJCSp2YWx1ZSA9IChtdmVidV9yZWFkbChwb3J0LCBQQ0lF X0lOVF9VTk1BU0tfT0ZGKSAmCisJCQkgIFBDSUVfSU5UX1BNX1BNRSkgPyBQQ0lfRVhQX1JUQ1RM X1BNRUlFIDogMDsKKwkJYnJlYWs7CisKIAljYXNlIFBDSV9FWFBfUlRTVEE6CiAJCSp2YWx1ZSA9 IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfUkNfUlRTVEEpOwogCQlicmVhazsKQEAgLTc4MCw2ICs4 MTMsMTQgQEAgbXZlYnVfcGNpX2JyaWRnZV9lbXVsX2Jhc2VfY29uZl93cml0ZShzdHJ1Y3QgcGNp X2JyaWRnZV9lbXVsICpicmlkZ2UsCiAJCWJyZWFrOwogCiAJY2FzZSBQQ0lfSU5URVJSVVBUX0xJ TkU6CisJCWlmICgobWFzayAmIChQQ0lfQlJJREdFX0NUTF9TRVJSIDw8IDE2KSkgJiYgcG9ydC0+ ZXJyb3JfaXJxID4gMCkgeworCQkJdTMyIHVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVf SU5UX1VOTUFTS19PRkYpOworCQkJaWYgKG5ldyAmIChQQ0lfQlJJREdFX0NUTF9TRVJSIDw8IDE2 KSkKKwkJCQl1bm1hc2sgfD0gUENJRV9JTlRfRVJSX01BU0s7CisJCQllbHNlCisJCQkJdW5tYXNr ICY9IH5QQ0lFX0lOVF9FUlJfTUFTSzsKKwkJCW12ZWJ1X3dyaXRlbChwb3J0LCB1bm1hc2ssIFBD SUVfSU5UX1VOTUFTS19PRkYpOworCQl9CiAJCWlmIChtYXNrICYgKFBDSV9CUklER0VfQ1RMX0JV U19SRVNFVCA8PCAxNikpIHsKIAkJCXUzMiBjdHJsID0gbXZlYnVfcmVhZGwocG9ydCwgUENJRV9D VFJMX09GRik7CiAJCQlpZiAobmV3ICYgKFBDSV9CUklER0VfQ1RMX0JVU19SRVNFVCA8PCAxNikp CkBAIC04MzgsMTAgKzg3OSwyNSBAQCBtdmVidV9wY2lfYnJpZGdlX2VtdWxfcGNpZV9jb25mX3dy aXRlKHN0cnVjdCBwY2lfYnJpZGdlX2VtdWwgKmJyaWRnZSwKIAkJICogUE1FIFN0YXR1cyBiaXQg aW4gUm9vdCBTdGF0dXMgUmVnaXN0ZXIgKFBDSUVfUkNfUlRTVEEpCiAJCSAqIGlzIHJlYWQtb25s eSBhbmQgY2FuIGJlIGNsZWFyZWQgb25seSBieSB3cml0aW5nIDBiIHRvIHRoZQogCQkgKiBJbnRl cnJ1cHQgQ2F1c2UgUlcwQyByZWdpc3RlciAoUENJRV9JTlRfQ0FVU0VfT0ZGKS4gU28KLQkJICog Y2xlYXIgUE1FIHZpYSBJbnRlcnJ1cHQgQ2F1c2UuCisJCSAqIGNsZWFyIFBNRSB2aWEgSW50ZXJy dXB0IENhdXNlIGFuZCBhbHNvIHNldCBwb3J0LT5wbWVfcGVuZGluZworCQkgKiB2YXJpYWJsZSB0 byBmYWxzZSB2YWx1ZSB0byBzdGFydCBwcm9jZXNzaW5nIFBNRSBpbnRlcnJ1cHRzCisJCSAqIGlu IGludGVycnVwdCBoYW5kbGVyIGFnYWluLgogCQkgKi8KLQkJaWYgKG5ldyAmIFBDSV9FWFBfUlRT VEFfUE1FKQorCQlpZiAobmV3ICYgUENJX0VYUF9SVFNUQV9QTUUpIHsKIAkJCW12ZWJ1X3dyaXRl bChwb3J0LCB+UENJRV9JTlRfUE1fUE1FLCBQQ0lFX0lOVF9DQVVTRV9PRkYpOworCQkJcG9ydC0+ cG1lX3BlbmRpbmcgPSBmYWxzZTsKKwkJfQorCQlicmVhazsKKworCWNhc2UgUENJX0VYUF9SVENU TDoKKwkJaWYgKChtYXNrICYgUENJX0VYUF9SVENUTF9QTUVJRSkgJiYgcG9ydC0+ZXJyb3JfaXJx ID4gMCkgeworCQkJdTMyIHVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfSU5UX1VOTUFT S19PRkYpOworCQkJaWYgKG5ldyAmIFBDSV9FWFBfUlRDVExfUE1FSUUpCisJCQkJdW5tYXNrIHw9 IFBDSUVfSU5UX1BNX1BNRTsKKwkJCWVsc2UKKwkJCQl1bm1hc2sgJj0gflBDSUVfSU5UX1BNX1BN RTsKKwkJCW12ZWJ1X3dyaXRlbChwb3J0LCB1bm1hc2ssIFBDSUVfSU5UX1VOTUFTS19PRkYpOwor CQl9CiAJCWJyZWFrOwogCiAJY2FzZSBQQ0lfRVhQX0RFVkNUTDI6CkBAIC05MjQsNiArOTgwLDE0 IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpX2JyaWRnZV9lbXVsX2luaXQoc3RydWN0IG12ZWJ1X3Bj aWVfcG9ydCAqcG9ydCkKIAkJYnJpZGdlX2ZsYWdzIHw9IFBDSV9CUklER0VfRU1VTF9OT19JT19G T1JXQVJEOwogCX0KIAorCS8qCisJICogSW50ZXJydXB0cyBvbiBlbXVsYXRlZCBicmlkZ2UgYXJl IHN1cHBvcnRlZCBvbmx5IHdoZW4gImVycm9yIgorCSAqIGludGVycnVwdCB3YXMgc3BlY2lmaWVk IGluIERULiBXaXRob3V0IGl0IGVtdWxhdGVkIGJyaWRnZSBjYW5ub3QKKwkgKiBlbXVsYXRlIGlu dGVycnVwdHMuCisJICovCisJaWYgKHBvcnQtPmVycm9yX2lycSA+IDApCisJCWJyaWRnZS0+Y29u Zi5pbnRwaW4gPSBQQ0lfSU5URVJSVVBUX0lOVEE7CisKIAkvKgogCSAqIE9sZGVyIG12ZWJ1IGhh cmR3YXJlIHByb3ZpZGVzIFBDSWUgQ2FwYWJpbGl0eSBzdHJ1Y3R1cmUgb25seSBpbgogCSAqIHZl cnNpb24gMS4gTmV3IGhhcmR3YXJlIHByb3ZpZGVzIGl0IGluIHZlcnNpb24gMi4KQEAgLTEwNzIs NiArMTEzNiwyNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGlycV9kb21haW5fb3BzIG12ZWJ1X3Bj aWVfaW50eF9pcnFfZG9tYWluX29wcyA9IHsKIAkueGxhdGUgPSBpcnFfZG9tYWluX3hsYXRlX29u ZWNlbGwsCiB9OwogCitzdGF0aWMgc3RydWN0IGlycV9jaGlwIHJwX2lycV9jaGlwID0geworCS5u YW1lID0gIm12ZWJ1LXJwIiwKK307CisKK3N0YXRpYyBpbnQgbXZlYnVfcGNpZV9ycF9pcnFfbWFw KHN0cnVjdCBpcnFfZG9tYWluICpoLAorCQkJCSAgIHVuc2lnbmVkIGludCB2aXJxLCBpcnFfaHdf bnVtYmVyX3QgaHdpcnEpCit7CisJc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCA9IGgtPmhv c3RfZGF0YTsKKworCWlycV9zZXRfY2hpcF9hbmRfaGFuZGxlcih2aXJxLCAmcnBfaXJxX2NoaXAs IGhhbmRsZV9zaW1wbGVfaXJxKTsKKwlpcnFfc2V0X2NoaXBfZGF0YSh2aXJxLCBwb3J0KTsKKwor CXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGlycV9kb21haW5fb3BzIG12ZWJ1 X3BjaWVfcnBfaXJxX2RvbWFpbl9vcHMgPSB7CisJLm1hcCA9IG12ZWJ1X3BjaWVfcnBfaXJxX21h cCwKKwkueGxhdGUgPSBpcnFfZG9tYWluX3hsYXRlX29uZWNlbGwsCit9OworCiBzdGF0aWMgaW50 IG12ZWJ1X3BjaWVfaW5pdF9pcnFfZG9tYWluKHN0cnVjdCBtdmVidV9wY2llX3BvcnQgKnBvcnQp CiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBvcnQtPnBjaWUtPnBkZXYtPmRldjsKQEAgLTEw OTQsMTAgKzExNzgsNzIgQEAgc3RhdGljIGludCBtdmVidV9wY2llX2luaXRfaXJxX2RvbWFpbihz dHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0KQogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKKwkv KgorCSAqIFdoZW4gImVycm9yIiBpbnRlcnJ1cHQgd2FzIG5vdCBzcGVjaWZpZWQgaW4gRFQgdGhl biB0aGVyZSBpcyBubworCSAqIHN1cHBvcnQgZm9yIGludGVycnVwdHMgb24gZW11bGF0ZWQgcm9v dCBicmlkZ2UuIFNvIHNraXAgZm9sbG93aW5nCisJICogaW5pdGlhbGl6YXRpb24uCisJICovCisJ aWYgKHBvcnQtPmVycm9yX2lycSA8PSAwKQorCQlyZXR1cm4gMDsKKworCXBvcnQtPnJwX2lycV9k b21haW4gPSBpcnFfZG9tYWluX2FkZF9saW5lYXIoTlVMTCwgMSwKKwkJCQkJCSAgICAgICZtdmVi dV9wY2llX3JwX2lycV9kb21haW5fb3BzLAorCQkJCQkJICAgICAgcG9ydCk7CisJaWYgKCFwb3J0 LT5ycF9pcnFfZG9tYWluKSB7CisJCWlycV9kb21haW5fcmVtb3ZlKHBvcnQtPmludHhfaXJxX2Rv bWFpbik7CisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGFkZCBSb290IFBvcnQgSVJRIGRvbWFp biBmb3IgJXNcbiIsIHBvcnQtPm5hbWUpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKIAlyZXR1 cm4gMDsKIH0KIAotc3RhdGljIGlycXJldHVybl90IG12ZWJ1X3BjaWVfaXJxX2hhbmRsZXIoaW50 IGlycSwgdm9pZCAqYXJnKQorc3RhdGljIGlycXJldHVybl90IG12ZWJ1X3BjaWVfZXJyb3JfaXJx X2hhbmRsZXIoaW50IGlycSwgdm9pZCAqYXJnKQoreworCXN0cnVjdCBtdmVidV9wY2llX3BvcnQg KnBvcnQgPSBhcmc7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBvcnQtPnBjaWUtPnBkZXYtPmRl djsKKwl1MzIgY2F1c2UsIHVubWFzaywgc3RhdHVzOworCisJY2F1c2UgPSBtdmVidV9yZWFkbChw b3J0LCBQQ0lFX0lOVF9DQVVTRV9PRkYpOworCXVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBD SUVfSU5UX1VOTUFTS19PRkYpOworCXN0YXR1cyA9IGNhdXNlICYgdW5tYXNrOworCisJLyogImVy cm9yIiBpbnRlcnJ1cHQgaGFuZGxlciBkb2VzIG5vdCBwcm9jZXNzIElOVFggaW50ZXJydXB0cyAq LworCXN0YXR1cyAmPSB+KFBDSUVfSU5UX0lOVFgoMCkgfCBQQ0lFX0lOVF9JTlRYKDEpIHwKKwkJ ICAgIFBDSUVfSU5UX0lOVFgoMikgfCBQQ0lFX0lOVF9JTlRYKDMpKTsKKworCS8qIFByb2Nlc3Mg UE1FIGludGVycnVwdCAqLworCWlmICgoc3RhdHVzICYgUENJRV9JTlRfUE1fUE1FKSAmJiAhcG9y dC0+cG1lX3BlbmRpbmcpIHsKKwkJLyoKKwkJICogRG8gbm90IGNsZWFyIFBNRSBpbnRlcnJ1cHQg Yml0IGluIENhdXNlIFJlZ2lzdGVyIGFzIGl0CisJCSAqIGludmFsaWRhdGVzIGFsc28gY29udGVu dCBvZiBSb290IFN0YXR1cyBSZWdpc3Rlci4gSW5zdGVhZAorCQkgKiBzZXQgcG9ydC0+cG1lX3Bl bmRpbmcgdmFyaWFibGUgdG8gdHJ1ZSB0byBpbmRpY2F0ZSB0aGF0CisJCSAqIG5leHQgdGltZSBQ TUUgaW50ZXJydXB0IHNob3VsZCBiZSBpZ25vcmVkIHVudGlsIHZhcmlhYmxlCisJCSAqIGlzIGJh Y2sgdG8gdGhlIGZhbHNlIHZhbHVlLgorCQkgKi8KKwkJcG9ydC0+cG1lX3BlbmRpbmcgPSB0cnVl OworCQlpZiAoZ2VuZXJpY19oYW5kbGVfZG9tYWluX2lycShwb3J0LT5ycF9pcnFfZG9tYWluLCAw KSA9PSAtRUlOVkFMKQorCQkJZGV2X2Vycl9yYXRlbGltaXRlZChkZXYsICJ1bmhhbmRsZWQgUE1F IElSUVxuIik7CisJfQorCisJLyogUHJvY2VzcyBFUlIgaW50ZXJydXB0ICovCisJaWYgKHN0YXR1 cyAmIFBDSUVfSU5UX0VSUl9NQVNLKSB7CisJCW12ZWJ1X3dyaXRlbChwb3J0LCB+UENJRV9JTlRf RVJSX01BU0ssIFBDSUVfSU5UX0NBVVNFX09GRik7CisJCWlmIChnZW5lcmljX2hhbmRsZV9kb21h aW5faXJxKHBvcnQtPnJwX2lycV9kb21haW4sIDApID09IC1FSU5WQUwpCisJCQlkZXZfZXJyX3Jh dGVsaW1pdGVkKGRldiwgInVuaGFuZGxlZCBFUlIgSVJRXG4iKTsKKwl9CisKKwkvKiBQcm9jZXNz IGxvY2FsIEVSUiBpbnRlcnJ1cHQgKi8KKwlpZiAoc3RhdHVzICYgUENJRV9JTlRfREVUX01BU0sp IHsKKwkJbXZlYnVfd3JpdGVsKHBvcnQsIH5QQ0lFX0lOVF9ERVRfTUFTSywgUENJRV9JTlRfQ0FV U0VfT0ZGKTsKKwkJaWYgKGdlbmVyaWNfaGFuZGxlX2RvbWFpbl9pcnEocG9ydC0+cnBfaXJxX2Rv bWFpbiwgMCkgPT0gLUVJTlZBTCkKKwkJCWRldl9lcnJfcmF0ZWxpbWl0ZWQoZGV2LCAidW5oYW5k bGVkIEVSUiBJUlFcbiIpOworCX0KKworCXJldHVybiBzdGF0dXMgPyBJUlFfSEFORExFRCA6IElS UV9OT05FOworfQorCitzdGF0aWMgaXJxcmV0dXJuX3QgbXZlYnVfcGNpZV9pbnR4X2lycV9oYW5k bGVyKGludCBpcnEsIHZvaWQgKmFyZykKIHsKIAlzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0 ID0gYXJnOwogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwb3J0LT5wY2llLT5wZGV2LT5kZXY7CkBA IC0xMTA4LDYgKzEyNTQsMTAgQEAgc3RhdGljIGlycXJldHVybl90IG12ZWJ1X3BjaWVfaXJxX2hh bmRsZXIoaW50IGlycSwgdm9pZCAqYXJnKQogCXVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBD SUVfSU5UX1VOTUFTS19PRkYpOwogCXN0YXR1cyA9IGNhdXNlICYgdW5tYXNrOwogCisJLyogImlu dHgiIGludGVycnVwdCBoYW5kbGVyIHByb2Nlc3Mgb25seSBJTlRYIGludGVycnVwdHMgKi8KKwlz dGF0dXMgJj0gUENJRV9JTlRfSU5UWCgwKSB8IFBDSUVfSU5UX0lOVFgoMSkgfAorCQkgIFBDSUVf SU5UX0lOVFgoMikgfCBQQ0lFX0lOVF9JTlRYKDMpOworCiAJLyogUHJvY2VzcyBsZWdhY3kgSU5U eCBpbnRlcnJ1cHRzICovCiAJZm9yIChpID0gMDsgaSA8IFBDSV9OVU1fSU5UWDsgaSsrKSB7CiAJ CWlmICghKHN0YXR1cyAmIFBDSUVfSU5UX0lOVFgoaSkpKQpAQCAtMTEyMiw5ICsxMjcyLDI5IEBA IHN0YXRpYyBpcnFyZXR1cm5fdCBtdmVidV9wY2llX2lycV9oYW5kbGVyKGludCBpcnEsIHZvaWQg KmFyZykKIAogc3RhdGljIGludCBtdmVidV9wY2llX21hcF9pcnEoY29uc3Qgc3RydWN0IHBjaV9k ZXYgKmRldiwgdTggc2xvdCwgdTggcGluKQogewotCS8qIEludGVycnVwdCBzdXBwb3J0IG9uIG12 ZWJ1IGVtdWxhdGVkIGJyaWRnZXMgaXMgbm90IGltcGxlbWVudGVkIHlldCAqLwotCWlmIChkZXYt PmJ1cy0+bnVtYmVyID09IDApCi0JCXJldHVybiAwOyAvKiBQcm9wZXIgcmV0dXJuIGNvZGUgMCA9 PSBOT19JUlEgKi8KKwlzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0OworCXN0cnVjdCBtdmVi dV9wY2llICpwY2llOworCisJaWYgKGRldi0+YnVzLT5udW1iZXIgPT0gMCkgeworCQkvKgorCQkg KiBFYWNoIGVtdWxhdGVkIHJvb3QgYnJpZGdlIGZvciBldmVyeSBtdmVidSBwb3J0IGhhcyBpdHMg b3duCisJCSAqIFJvb3QgUG9ydCBpcnEgY2hpcCBhbmQgaXJxIGRvbWFpbi4gQXJndW1lbnQgcGlu IGlzIHRoZSBJTlR4CisJCSAqIHBpbiAoMT1JTlRBLCAyPUlOVEIsIDM9SU5UQywgND1JTlREKSBh bmQgaHdpcnEgZm9yIGZ1bmN0aW9uCisJCSAqIGlycV9jcmVhdGVfbWFwcGluZygpIGlzIGluZGV4 ZWQgZnJvbSB6ZXJvLgorCQkgKi8KKwkJcGNpZSA9IGRldi0+YnVzLT5zeXNkYXRhOworCQlwb3J0 ID0gbXZlYnVfcGNpZV9maW5kX3BvcnQocGNpZSwgZGV2LT5idXMsIFBDSV9ERVZGTihzbG90LCAw KSk7CisJCWlmICghcG9ydCkKKwkJCXJldHVybiAwOyAvKiBQcm9wZXIgcmV0dXJuIGNvZGUgMCA9 PSBOT19JUlEgKi8KKwkJLyoKKwkJICogcG9ydC0+cnBfaXJxX2RvbWFpbiBpcyBhdmFpbGFibGUg b25seSB3aGVuICJlcnJvciIgaW50ZXJydXB0CisJCSAqIHdhcyBzcGVjaWZpZWQgaW4gRFQuIFdo ZW4gaXMgbm90IGF2YWlsYWJsZSB0aGVuIGludGVycnVwdHMKKwkJICogZm9yIGVtdWxhdGVkIHJv b3QgYnJpZGdlIGFyZSBub3QgcHJvdmlkZWQuCisJCSAqLworCQlpZiAocG9ydC0+ZXJyb3JfaXJx IDw9IDApCisJCQlyZXR1cm4gMDsgLyogUHJvcGVyIHJldHVybiBjb2RlIDAgPT0gTk9fSVJRICov CisJCXJldHVybiBpcnFfY3JlYXRlX21hcHBpbmcocG9ydC0+cnBfaXJxX2RvbWFpbiwgcGluIC0g MSk7CisJfQogCiAJcmV0dXJuIG9mX2lycV9wYXJzZV9hbmRfbWFwX3BjaShkZXYsIHNsb3QsIHBp bik7CiB9CkBAIC0xMzMzLDYgKzE1MDMsMjEgQEAgc3RhdGljIGludCBtdmVidV9wY2llX3BhcnNl X3BvcnQoc3RydWN0IG12ZWJ1X3BjaWUgKnBjaWUsCiAJCQkgcG9ydC0+bmFtZSwgY2hpbGQpOwog CX0KIAorCS8qCisJICogT2xkIERUIGJpbmRpbmdzIGRvIG5vdCBjb250YWluICJlcnJvciIgaW50 ZXJydXB0CisJICogc28gZG8gbm90IGZhaWwgcHJvYmluZyBkcml2ZXIgd2hlbiBpbnRlcnJ1cHQg ZG9lcyBub3QgZXhpc3QuCisJICovCisJcG9ydC0+ZXJyb3JfaXJxID0gb2ZfaXJxX2dldF9ieW5h bWUoY2hpbGQsICJlcnJvciIpOworCWlmIChwb3J0LT5lcnJvcl9pcnEgPT0gLUVQUk9CRV9ERUZF UikgeworCQlyZXQgPSBwb3J0LT5lcnJvcl9pcnE7CisJCWdvdG8gZXJyOworCX0KKwlpZiAocG9y dC0+ZXJyb3JfaXJxIDw9IDApIHsKKwkJZGV2X3dhcm4oZGV2LCAiJXM6IGludGVycnVwdHMgb24g Um9vdCBQb3J0IGFyZSB1bnN1cHBvcnRlZCwgIgorCQkJICAgICAgIiVwT0YgZG9lcyBub3QgY29u dGFpbiBlcnJvciBpbnRlcnJ1cHRcbiIsCisJCQkgcG9ydC0+bmFtZSwgY2hpbGQpOworCX0KKwog CXJlc2V0X2dwaW8gPSBvZl9nZXRfbmFtZWRfZ3Bpb19mbGFncyhjaGlsZCwgInJlc2V0LWdwaW9z IiwgMCwgJmZsYWdzKTsKIAlpZiAocmVzZXRfZ3BpbyA9PSAtRVBST0JFX0RFRkVSKSB7CiAJCXJl dCA9IHJlc2V0X2dwaW87CkBAIC0xNTM4LDcgKzE3MjMsNiBAQCBzdGF0aWMgaW50IG12ZWJ1X3Bj aWVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogCWZvciAoaSA9IDA7IGkg PCBwY2llLT5ucG9ydHM7IGkrKykgewogCQlzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0ID0g JnBjaWUtPnBvcnRzW2ldOwotCQlpbnQgaXJxID0gcG9ydC0+aW50eF9pcnE7CiAKIAkJY2hpbGQg PSBwb3J0LT5kbjsKIAkJaWYgKCFjaGlsZCkKQEAgLTE1NjYsNyArMTc1MCw3IEBAIHN0YXRpYyBp bnQgbXZlYnVfcGNpZV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCQkJY29u dGludWU7CiAJCX0KIAotCQlpZiAoaXJxID4gMCkgeworCQlpZiAocG9ydC0+ZXJyb3JfaXJxID4g MCB8fCBwb3J0LT5pbnR4X2lycSA+IDApIHsKIAkJCXJldCA9IG12ZWJ1X3BjaWVfaW5pdF9pcnFf ZG9tYWluKHBvcnQpOwogCQkJaWYgKHJldCkgewogCQkJCWRldl9lcnIoZGV2LCAiJXM6IGNhbm5v dCBpbml0IGlycSBkb21haW5cbiIsCkBAIC0xNTc3LDE0ICsxNzYxLDQyIEBAIHN0YXRpYyBpbnQg bXZlYnVfcGNpZV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCQkJCW12ZWJ1 X3BjaWVfcG93ZXJkb3duKHBvcnQpOwogCQkJCWNvbnRpbnVlOwogCQkJfQorCQl9CisKKwkJaWYg KHBvcnQtPmVycm9yX2lycSA+IDApIHsKKwkJCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoZGV2LCBw b3J0LT5lcnJvcl9pcnEsCisJCQkJCSAgICAgICBtdmVidV9wY2llX2Vycm9yX2lycV9oYW5kbGVy LAorCQkJCQkgICAgICAgSVJRRl9TSEFSRUQgfCBJUlFGX05PX1RIUkVBRCwKKwkJCQkJICAgICAg IHBvcnQtPm5hbWUsIHBvcnQpOworCQkJaWYgKHJldCkgeworCQkJCWRldl9lcnIoZGV2LCAiJXM6 IGNhbm5vdCByZWdpc3RlciBlcnJvciBpbnRlcnJ1cHQgaGFuZGxlcjogJWRcbiIsCisJCQkJCXBv cnQtPm5hbWUsIHJldCk7CisJCQkJaWYgKHBvcnQtPmludHhfaXJxX2RvbWFpbikKKwkJCQkJaXJx X2RvbWFpbl9yZW1vdmUocG9ydC0+aW50eF9pcnFfZG9tYWluKTsKKwkJCQlpZiAocG9ydC0+cnBf aXJxX2RvbWFpbikKKwkJCQkJaXJxX2RvbWFpbl9yZW1vdmUocG9ydC0+cnBfaXJxX2RvbWFpbik7 CisJCQkJcGNpX2JyaWRnZV9lbXVsX2NsZWFudXAoJnBvcnQtPmJyaWRnZSk7CisJCQkJZGV2bV9p b3VubWFwKGRldiwgcG9ydC0+YmFzZSk7CisJCQkJcG9ydC0+YmFzZSA9IE5VTEw7CisJCQkJbXZl YnVfcGNpZV9wb3dlcmRvd24ocG9ydCk7CisJCQkJY29udGludWU7CisJCQl9CisJCX0KIAotCQkJ cmV0ID0gZGV2bV9yZXF1ZXN0X2lycShkZXYsIGlycSwgbXZlYnVfcGNpZV9pcnFfaGFuZGxlciwK KwkJaWYgKHBvcnQtPmludHhfaXJxID4gMCkgeworCQkJcmV0ID0gZGV2bV9yZXF1ZXN0X2lycShk ZXYsIHBvcnQtPmludHhfaXJxLAorCQkJCQkgICAgICAgbXZlYnVfcGNpZV9pbnR4X2lycV9oYW5k bGVyLAogCQkJCQkgICAgICAgSVJRRl9TSEFSRUQgfCBJUlFGX05PX1RIUkVBRCwKIAkJCQkJICAg ICAgIHBvcnQtPm5hbWUsIHBvcnQpOwogCQkJaWYgKHJldCkgewotCQkJCWRldl9lcnIoZGV2LCAi JXM6IGNhbm5vdCByZWdpc3RlciBpbnRlcnJ1cHQgaGFuZGxlcjogJWRcbiIsCisJCQkJZGV2X2Vy cihkZXYsICIlczogY2Fubm90IHJlZ2lzdGVyIGludHggaW50ZXJydXB0IGhhbmRsZXI6ICVkXG4i LAogCQkJCQlwb3J0LT5uYW1lLCByZXQpOwotCQkJCWlycV9kb21haW5fcmVtb3ZlKHBvcnQtPmlu dHhfaXJxX2RvbWFpbik7CisJCQkJaWYgKHBvcnQtPmVycm9yX2lycSA+IDApCisJCQkJCWRldm1f ZnJlZV9pcnEoZGV2LCBwb3J0LT5lcnJvcl9pcnEsIHBvcnQpOworCQkJCWlmIChwb3J0LT5pbnR4 X2lycV9kb21haW4pCisJCQkJCWlycV9kb21haW5fcmVtb3ZlKHBvcnQtPmludHhfaXJxX2RvbWFp bik7CisJCQkJaWYgKHBvcnQtPnJwX2lycV9kb21haW4pCisJCQkJCWlycV9kb21haW5fcmVtb3Zl KHBvcnQtPnJwX2lycV9kb21haW4pOwogCQkJCXBjaV9icmlkZ2VfZW11bF9jbGVhbnVwKCZwb3J0 LT5icmlkZ2UpOwogCQkJCWRldm1faW91bm1hcChkZXYsIHBvcnQtPmJhc2UpOwogCQkJCXBvcnQt PmJhc2UgPSBOVUxMOwpAQCAtMTcyMiw2ICsxOTM0LDEyIEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNp ZV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJCX0KIAkJCWlycV9kb21h aW5fcmVtb3ZlKHBvcnQtPmludHhfaXJxX2RvbWFpbik7CiAJCX0KKwkJaWYgKHBvcnQtPnJwX2ly cV9kb21haW4pIHsKKwkJCWludCB2aXJxID0gaXJxX2ZpbmRfbWFwcGluZyhwb3J0LT5ycF9pcnFf ZG9tYWluLCAwKTsKKwkJCWlmICh2aXJxID4gMCkKKwkJCQlpcnFfZGlzcG9zZV9tYXBwaW5nKHZp cnEpOworCQkJaXJxX2RvbWFpbl9yZW1vdmUocG9ydC0+cnBfaXJxX2RvbWFpbik7CisJCX0KIAog CQkvKiBGcmVlIGNvbmZpZyBzcGFjZSBmb3IgZW11bGF0ZWQgcm9vdCBicmlkZ2UuICovCiAJCXBj aV9icmlkZ2VfZW11bF9jbGVhbnVwKCZwb3J0LT5icmlkZ2UpOwotLSAKMi4yMC4xCgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5l bCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=