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 0C8D4C433FE for ; Tue, 22 Feb 2022 15:51:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233718AbiBVPwQ (ORCPT ); Tue, 22 Feb 2022 10:52:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43146 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233722AbiBVPwP (ORCPT ); Tue, 22 Feb 2022 10:52:15 -0500 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A35194B42B; Tue, 22 Feb 2022 07:51:47 -0800 (PST) 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 EA863616B8; Tue, 22 Feb 2022 15:51:46 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0A4EBC340E8; Tue, 22 Feb 2022 15:51:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1645545106; bh=mY/MU/xFwb7fz41UP252uY75ozP2yat3dnFzeMU3rts=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KNnJaJfJswrp9FQckzeC6CluPeZy0wtgrwIMv5qztGZ31DF2ffMypvPpPGyLtQ913 FG4wvyGsXnC/zsZVtHglMiEezRIQvxV4T3S1XFHmMJiV2ZmJf2lzkKKoSwrB9CiuJg WRd0HIMq2VeLuDwibCfBvJzjsEWsm2Mxb+lNcxInfLSzTDrfaDq6ZvJQN/sZJG3Pvc dOeuvu28co/NkoGgDJQT8rIGVMBIrNWDWgSg7HiCjVxvG9Yj8G20/BRTD+LtTQoMD8 neVe7nSpEjIRErrQXlq0leqsAmfCrjKegWZPWBDLxefl+5FvmxyzSCICJJtcukK2jv zxbiipfDLPHMg== Received: by pali.im (Postfix) id B41F8FDB; Tue, 22 Feb 2022 16:51:45 +0100 (CET) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , Bjorn Helgaas , Rob Herring , Thomas Petazzoni , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , =?UTF-8?q?Marek=20Beh=C3=BAn?= , Russell King Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v4 11/12] PCI: mvebu: Implement support for legacy INTx interrupts Date: Tue, 22 Feb 2022 16:50:29 +0100 Message-Id: <20220222155030.988-12-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220222155030.988-1-pali@kernel.org> References: <20220222155030.988-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 legacy INTx interrupts received from other PCIe devices and which are reported by a new INTx irq chip. With this change, kernel can distinguish between INTA, INTB, INTC and INTD interrupts. Note that for this support, device tree files has to be properly adjusted to provide "interrupts" or "interrupts-extended" property with intx interrupt source, "interrupt-names" property with "intx" string and also 'interrupt-controller' subnode must be defined. If device tree files do not provide these nodes then driver would work as before. Signed-off-by: Pali Rohár --- drivers/pci/controller/pci-mvebu.c | 159 +++++++++++++++++++++++++++++ 1 file changed, 159 insertions(+) diff --git a/drivers/pci/controller/pci-mvebu.c b/drivers/pci/controller/pci-mvebu.c index d096289035bc..a75d2b9196f9 100644 --- a/drivers/pci/controller/pci-mvebu.c +++ b/drivers/pci/controller/pci-mvebu.c @@ -111,6 +111,9 @@ struct mvebu_pcie_port { struct mvebu_pcie_window iowin; u32 saved_pcie_stat; struct resource regs; + struct irq_domain *intx_irq_domain; + raw_spinlock_t irq_lock; + int intx_irq; }; static inline void mvebu_writel(struct mvebu_pcie_port *port, u32 val, u32 reg) @@ -289,7 +292,18 @@ static void mvebu_pcie_setup_hw(struct mvebu_pcie_port *port) /* Point PCIe unit MBUS decode windows to DRAM space. */ mvebu_pcie_setup_wins(port); + /* Mask all interrupt sources. */ + mvebu_writel(port, ~PCIE_INT_ALL_MASK, PCIE_INT_UNMASK_OFF); + + /* 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; + /* + * Fallback code when "intx" interrupt was not 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 @@ -927,6 +941,108 @@ static struct pci_ops mvebu_pcie_ops = { .write = mvebu_pcie_wr_conf, }; +static void mvebu_pcie_intx_irq_mask(struct irq_data *d) +{ + struct mvebu_pcie_port *port = d->domain->host_data; + irq_hw_number_t hwirq = irqd_to_hwirq(d); + unsigned long flags; + u32 unmask; + + raw_spin_lock_irqsave(&port->irq_lock, flags); + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + unmask &= ~PCIE_INT_INTX(hwirq); + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + raw_spin_unlock_irqrestore(&port->irq_lock, flags); +} + +static void mvebu_pcie_intx_irq_unmask(struct irq_data *d) +{ + struct mvebu_pcie_port *port = d->domain->host_data; + irq_hw_number_t hwirq = irqd_to_hwirq(d); + unsigned long flags; + u32 unmask; + + raw_spin_lock_irqsave(&port->irq_lock, flags); + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + unmask |= PCIE_INT_INTX(hwirq); + mvebu_writel(port, unmask, PCIE_INT_UNMASK_OFF); + raw_spin_unlock_irqrestore(&port->irq_lock, flags); +} + +static struct irq_chip intx_irq_chip = { + .name = "mvebu-INTx", + .irq_mask = mvebu_pcie_intx_irq_mask, + .irq_unmask = mvebu_pcie_intx_irq_unmask, +}; + +static int mvebu_pcie_intx_irq_map(struct irq_domain *h, + unsigned int virq, irq_hw_number_t hwirq) +{ + struct mvebu_pcie_port *port = h->host_data; + + irq_set_status_flags(virq, IRQ_LEVEL); + irq_set_chip_and_handler(virq, &intx_irq_chip, handle_level_irq); + irq_set_chip_data(virq, port); + + return 0; +} + +static const struct irq_domain_ops mvebu_pcie_intx_irq_domain_ops = { + .map = mvebu_pcie_intx_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; + struct device_node *pcie_intc_node; + + raw_spin_lock_init(&port->irq_lock); + + pcie_intc_node = of_get_next_child(port->dn, NULL); + if (!pcie_intc_node) { + dev_err(dev, "No PCIe Intc node found for %s\n", port->name); + return -ENODEV; + } + + port->intx_irq_domain = irq_domain_add_linear(pcie_intc_node, PCI_NUM_INTX, + &mvebu_pcie_intx_irq_domain_ops, + port); + of_node_put(pcie_intc_node); + if (!port->intx_irq_domain) { + dev_err(dev, "Failed to get INTx IRQ domain for %s\n", port->name); + return -ENOMEM; + } + + return 0; +} + +static void mvebu_pcie_irq_handler(struct irq_desc *desc) +{ + struct mvebu_pcie_port *port = irq_desc_get_handler_data(desc); + struct irq_chip *chip = irq_desc_get_chip(desc); + struct device *dev = &port->pcie->pdev->dev; + u32 cause, unmask, status; + int i; + + chained_irq_enter(chip, desc); + + cause = mvebu_readl(port, PCIE_INT_CAUSE_OFF); + unmask = mvebu_readl(port, PCIE_INT_UNMASK_OFF); + status = cause & unmask; + + /* Process legacy INTx interrupts */ + for (i = 0; i < PCI_NUM_INTX; i++) { + if (!(status & PCIE_INT_INTX(i))) + continue; + + if (generic_handle_domain_irq(port->intx_irq_domain, i) == -EINVAL) + dev_err_ratelimited(dev, "unexpected INT%c IRQ\n", (char)i+'A'); + } + + chained_irq_exit(chip, 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 */ @@ -1124,6 +1240,21 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, port->io_attr = -1; } + /* + * 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); + } + reset_gpio = of_get_named_gpio_flags(child, "reset-gpios", 0, &flags); if (reset_gpio == -EPROBE_DEFER) { ret = reset_gpio; @@ -1320,6 +1451,7 @@ 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) @@ -1347,6 +1479,22 @@ static int mvebu_pcie_probe(struct platform_device *pdev) continue; } + if (irq > 0) { + ret = mvebu_pcie_init_irq_domain(port); + if (ret) { + dev_err(dev, "%s: cannot init irq domain\n", + port->name); + pci_bridge_emul_cleanup(&port->bridge); + devm_iounmap(dev, port->base); + port->base = NULL; + mvebu_pcie_powerdown(port); + continue; + } + irq_set_chained_handler_and_data(irq, + mvebu_pcie_irq_handler, + port); + } + /* * PCIe topology exported by mvebu hw is quite complicated. In * reality has something like N fully independent host bridges @@ -1450,6 +1598,7 @@ 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; if (!port->base) continue; @@ -1462,6 +1611,16 @@ static int mvebu_pcie_remove(struct platform_device *pdev) /* Mask all interrupt sources. */ mvebu_writel(port, ~PCIE_INT_ALL_MASK, PCIE_INT_UNMASK_OFF); + /* Clear all interrupt causes. */ + mvebu_writel(port, ~PCIE_INT_ALL_MASK, PCIE_INT_CAUSE_OFF); + + if (irq > 0) + irq_set_chained_handler_and_data(irq, NULL, NULL); + + /* Remove IRQ domains. */ + if (port->intx_irq_domain) + irq_domain_remove(port->intx_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 125B9C433F5 for ; Tue, 22 Feb 2022 15:58:21 +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=WvDgT6VxL+nzhccmtwBOg+snsDFV6T6jmf1Xr/BkBoo=; b=4dNN4WkU51lQEH Ln3Ipq6PQd9fBbNYPU1+RYXkqMEfGsR1WE2P6NB2YSBabBXAP9rSIx03QWeVQuAoXrA22vh5TUww/ mfLWVkpBg2+tzUKcV6xpeFl92c91Y9wMD6YL+09U2pVXHip9S+MgiU37EatjkNKKVNV6nZXYzt2Eg bWwzlzbmohd0NwXPo0tHGNPj50rIGgndnfjfJ+wXB215wynchkrgDp46hdgsZ4HDpiBJbikDgEUeJ JvZ4jOJzw6G0oc/HdQZdhnV9q3evUtJbD4dzriAdjsi1P8hBzKWwjopYUD4e0aHvub6uvb4M25dt/ ll5+Nb326MEEvg9gkIEQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nMXWv-00ASCb-1z; Tue, 22 Feb 2022 15:56:46 +0000 Received: from ams.source.kernel.org ([2604:1380:4601:e00::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nMXS9-00APjJ-5F for linux-arm-kernel@lists.infradead.org; Tue, 22 Feb 2022 15:51:52 +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 8CBFFB81A2B; Tue, 22 Feb 2022 15:51:47 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0A4EBC340E8; Tue, 22 Feb 2022 15:51:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1645545106; bh=mY/MU/xFwb7fz41UP252uY75ozP2yat3dnFzeMU3rts=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KNnJaJfJswrp9FQckzeC6CluPeZy0wtgrwIMv5qztGZ31DF2ffMypvPpPGyLtQ913 FG4wvyGsXnC/zsZVtHglMiEezRIQvxV4T3S1XFHmMJiV2ZmJf2lzkKKoSwrB9CiuJg WRd0HIMq2VeLuDwibCfBvJzjsEWsm2Mxb+lNcxInfLSzTDrfaDq6ZvJQN/sZJG3Pvc dOeuvu28co/NkoGgDJQT8rIGVMBIrNWDWgSg7HiCjVxvG9Yj8G20/BRTD+LtTQoMD8 neVe7nSpEjIRErrQXlq0leqsAmfCrjKegWZPWBDLxefl+5FvmxyzSCICJJtcukK2jv zxbiipfDLPHMg== Received: by pali.im (Postfix) id B41F8FDB; Tue, 22 Feb 2022 16:51:45 +0100 (CET) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , Bjorn Helgaas , Rob Herring , Thomas Petazzoni , =?UTF-8?q?Krzysztof=20Wilczy=C5=84ski?= , =?UTF-8?q?Marek=20Beh=C3=BAn?= , Russell King Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v4 11/12] PCI: mvebu: Implement support for legacy INTx interrupts Date: Tue, 22 Feb 2022 16:50:29 +0100 Message-Id: <20220222155030.988-12-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220222155030.988-1-pali@kernel.org> References: <20220222155030.988-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220222_075149_555735_3D9CA45D X-CRM114-Status: GOOD ( 26.01 ) 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 VGhpcyBhZGRzIHN1cHBvcnQgZm9yIGxlZ2FjeSBJTlR4IGludGVycnVwdHMgcmVjZWl2ZWQgZnJv bSBvdGhlciBQQ0llCmRldmljZXMgYW5kIHdoaWNoIGFyZSByZXBvcnRlZCBieSBhIG5ldyBJTlR4 IGlycSBjaGlwLgoKV2l0aCB0aGlzIGNoYW5nZSwga2VybmVsIGNhbiBkaXN0aW5ndWlzaCBiZXR3 ZWVuIElOVEEsIElOVEIsIElOVEMgYW5kIElOVEQKaW50ZXJydXB0cy4KCk5vdGUgdGhhdCBmb3Ig dGhpcyBzdXBwb3J0LCBkZXZpY2UgdHJlZSBmaWxlcyBoYXMgdG8gYmUgcHJvcGVybHkgYWRqdXN0 ZWQKdG8gcHJvdmlkZSAiaW50ZXJydXB0cyIgb3IgImludGVycnVwdHMtZXh0ZW5kZWQiIHByb3Bl cnR5IHdpdGggaW50eAppbnRlcnJ1cHQgc291cmNlLCAiaW50ZXJydXB0LW5hbWVzIiBwcm9wZXJ0 eSB3aXRoICJpbnR4IiBzdHJpbmcgYW5kIGFsc28KJ2ludGVycnVwdC1jb250cm9sbGVyJyBzdWJu b2RlIG11c3QgYmUgZGVmaW5lZC4KCklmIGRldmljZSB0cmVlIGZpbGVzIGRvIG5vdCBwcm92aWRl IHRoZXNlIG5vZGVzIHRoZW4gZHJpdmVyIHdvdWxkIHdvcmsgYXMKYmVmb3JlLgoKU2lnbmVkLW9m Zi1ieTogUGFsaSBSb2jDoXIgPHBhbGlAa2VybmVsLm9yZz4KLS0tCiBkcml2ZXJzL3BjaS9jb250 cm9sbGVyL3BjaS1tdmVidS5jIHwgMTU5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAx IGZpbGUgY2hhbmdlZCwgMTU5IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bj aS9jb250cm9sbGVyL3BjaS1tdmVidS5jIGIvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktbXZl YnUuYwppbmRleCBkMDk2Mjg5MDM1YmMuLmE3NWQyYjkxOTZmOSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUuYworKysgYi9kcml2ZXJzL3BjaS9jb250cm9sbGVy L3BjaS1tdmVidS5jCkBAIC0xMTEsNiArMTExLDkgQEAgc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCB7 CiAJc3RydWN0IG12ZWJ1X3BjaWVfd2luZG93IGlvd2luOwogCXUzMiBzYXZlZF9wY2llX3N0YXQ7 CiAJc3RydWN0IHJlc291cmNlIHJlZ3M7CisJc3RydWN0IGlycV9kb21haW4gKmludHhfaXJxX2Rv bWFpbjsKKwlyYXdfc3BpbmxvY2tfdCBpcnFfbG9jazsKKwlpbnQgaW50eF9pcnE7CiB9OwogCiBz dGF0aWMgaW5saW5lIHZvaWQgbXZlYnVfd3JpdGVsKHN0cnVjdCBtdmVidV9wY2llX3BvcnQgKnBv cnQsIHUzMiB2YWwsIHUzMiByZWcpCkBAIC0yODksNyArMjkyLDE4IEBAIHN0YXRpYyB2b2lkIG12 ZWJ1X3BjaWVfc2V0dXBfaHcoc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCkKIAkvKiBQb2lu dCBQQ0llIHVuaXQgTUJVUyBkZWNvZGUgd2luZG93cyB0byBEUkFNIHNwYWNlLiAqLwogCW12ZWJ1 X3BjaWVfc2V0dXBfd2lucyhwb3J0KTsKIAorCS8qIE1hc2sgYWxsIGludGVycnVwdCBzb3VyY2Vz LiAqLworCW12ZWJ1X3dyaXRlbChwb3J0LCB+UENJRV9JTlRfQUxMX01BU0ssIFBDSUVfSU5UX1VO TUFTS19PRkYpOworCisJLyogQ2xlYXIgYWxsIGludGVycnVwdCBjYXVzZXMuICovCisJbXZlYnVf d3JpdGVsKHBvcnQsIH5QQ0lFX0lOVF9BTExfTUFTSywgUENJRV9JTlRfQ0FVU0VfT0ZGKTsKKwor CS8qIENoZWNrIGlmICJpbnR4IiBpbnRlcnJ1cHQgd2FzIHNwZWNpZmllZCBpbiBEVC4gKi8KKwlp ZiAocG9ydC0+aW50eF9pcnEgPiAwKQorCQlyZXR1cm47CisKIAkvKgorCSAqIEZhbGxiYWNrIGNv ZGUgd2hlbiAiaW50eCIgaW50ZXJydXB0IHdhcyBub3Qgc3BlY2lmaWVkIGluIERUOgogCSAqIFVu bWFzayBhbGwgbGVnYWN5IElOVHggaW50ZXJydXB0cyBhcyBkcml2ZXIgZG9lcyBub3QgcHJvdmlk ZSBhIHdheQogCSAqIGZvciBtYXNraW5nIGFuZCB1bm1hc2tpbmcgb2YgaW5kaXZpZHVhbCBsZWdh Y3kgSU5UeCBpbnRlcnJ1cHRzLgogCSAqIExlZ2FjeSBJTlR4IGFyZSByZXBvcnRlZCB2aWEgb25l IHNoYXJlZCBHSUMgc291cmNlIGFuZCB0aGVyZWZvcmUKQEAgLTkyNyw2ICs5NDEsMTA4IEBAIHN0 YXRpYyBzdHJ1Y3QgcGNpX29wcyBtdmVidV9wY2llX29wcyA9IHsKIAkud3JpdGUgPSBtdmVidV9w Y2llX3dyX2NvbmYsCiB9OwogCitzdGF0aWMgdm9pZCBtdmVidV9wY2llX2ludHhfaXJxX21hc2so c3RydWN0IGlycV9kYXRhICpkKQoreworCXN0cnVjdCBtdmVidV9wY2llX3BvcnQgKnBvcnQgPSBk LT5kb21haW4tPmhvc3RfZGF0YTsKKwlpcnFfaHdfbnVtYmVyX3QgaHdpcnEgPSBpcnFkX3RvX2h3 aXJxKGQpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdTMyIHVubWFzazsKKworCXJhd19zcGlu X2xvY2tfaXJxc2F2ZSgmcG9ydC0+aXJxX2xvY2ssIGZsYWdzKTsKKwl1bm1hc2sgPSBtdmVidV9y ZWFkbChwb3J0LCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsKKwl1bm1hc2sgJj0gflBDSUVfSU5UX0lO VFgoaHdpcnEpOworCW12ZWJ1X3dyaXRlbChwb3J0LCB1bm1hc2ssIFBDSUVfSU5UX1VOTUFTS19P RkYpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb3J0LT5pcnFfbG9jaywgZmxhZ3Mp OworfQorCitzdGF0aWMgdm9pZCBtdmVidV9wY2llX2ludHhfaXJxX3VubWFzayhzdHJ1Y3QgaXJx X2RhdGEgKmQpCit7CisJc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCA9IGQtPmRvbWFpbi0+ aG9zdF9kYXRhOworCWlycV9od19udW1iZXJfdCBod2lycSA9IGlycWRfdG9faHdpcnEoZCk7CisJ dW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgdW5tYXNrOworCisJcmF3X3NwaW5fbG9ja19pcnFz YXZlKCZwb3J0LT5pcnFfbG9jaywgZmxhZ3MpOworCXVubWFzayA9IG12ZWJ1X3JlYWRsKHBvcnQs IFBDSUVfSU5UX1VOTUFTS19PRkYpOworCXVubWFzayB8PSBQQ0lFX0lOVF9JTlRYKGh3aXJxKTsK KwltdmVidV93cml0ZWwocG9ydCwgdW5tYXNrLCBQQ0lFX0lOVF9VTk1BU0tfT0ZGKTsKKwlyYXdf c3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+aXJxX2xvY2ssIGZsYWdzKTsKK30KKworc3Rh dGljIHN0cnVjdCBpcnFfY2hpcCBpbnR4X2lycV9jaGlwID0geworCS5uYW1lID0gIm12ZWJ1LUlO VHgiLAorCS5pcnFfbWFzayA9IG12ZWJ1X3BjaWVfaW50eF9pcnFfbWFzaywKKwkuaXJxX3VubWFz ayA9IG12ZWJ1X3BjaWVfaW50eF9pcnFfdW5tYXNrLAorfTsKKworc3RhdGljIGludCBtdmVidV9w Y2llX2ludHhfaXJxX21hcChzdHJ1Y3QgaXJxX2RvbWFpbiAqaCwKKwkJCQkgICB1bnNpZ25lZCBp bnQgdmlycSwgaXJxX2h3X251bWJlcl90IGh3aXJxKQoreworCXN0cnVjdCBtdmVidV9wY2llX3Bv cnQgKnBvcnQgPSBoLT5ob3N0X2RhdGE7CisKKwlpcnFfc2V0X3N0YXR1c19mbGFncyh2aXJxLCBJ UlFfTEVWRUwpOworCWlycV9zZXRfY2hpcF9hbmRfaGFuZGxlcih2aXJxLCAmaW50eF9pcnFfY2hp cCwgaGFuZGxlX2xldmVsX2lycSk7CisJaXJxX3NldF9jaGlwX2RhdGEodmlycSwgcG9ydCk7CisK KwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBpcnFfZG9tYWluX29wcyBtdmVi dV9wY2llX2ludHhfaXJxX2RvbWFpbl9vcHMgPSB7CisJLm1hcCA9IG12ZWJ1X3BjaWVfaW50eF9p cnFfbWFwLAorCS54bGF0ZSA9IGlycV9kb21haW5feGxhdGVfb25lY2VsbCwKK307CisKK3N0YXRp YyBpbnQgbXZlYnVfcGNpZV9pbml0X2lycV9kb21haW4oc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAq cG9ydCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcG9ydC0+cGNpZS0+cGRldi0+ZGV2Owor CXN0cnVjdCBkZXZpY2Vfbm9kZSAqcGNpZV9pbnRjX25vZGU7CisKKwlyYXdfc3Bpbl9sb2NrX2lu aXQoJnBvcnQtPmlycV9sb2NrKTsKKworCXBjaWVfaW50Y19ub2RlID0gb2ZfZ2V0X25leHRfY2hp bGQocG9ydC0+ZG4sIE5VTEwpOworCWlmICghcGNpZV9pbnRjX25vZGUpIHsKKwkJZGV2X2Vycihk ZXYsICJObyBQQ0llIEludGMgbm9kZSBmb3VuZCBmb3IgJXNcbiIsIHBvcnQtPm5hbWUpOworCQly ZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlwb3J0LT5pbnR4X2lycV9kb21haW4gPSBpcnFfZG9tYWlu X2FkZF9saW5lYXIocGNpZV9pbnRjX25vZGUsIFBDSV9OVU1fSU5UWCwKKwkJCQkJCSAgICAgICZt dmVidV9wY2llX2ludHhfaXJxX2RvbWFpbl9vcHMsCisJCQkJCQkgICAgICBwb3J0KTsKKwlvZl9u b2RlX3B1dChwY2llX2ludGNfbm9kZSk7CisJaWYgKCFwb3J0LT5pbnR4X2lycV9kb21haW4pIHsK KwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gZ2V0IElOVHggSVJRIGRvbWFpbiBmb3IgJXNcbiIs IHBvcnQtPm5hbWUpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIHZvaWQgbXZlYnVfcGNpZV9pcnFfaGFuZGxlcihzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2Mp Cit7CisJc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCA9IGlycV9kZXNjX2dldF9oYW5kbGVy X2RhdGEoZGVzYyk7CisJc3RydWN0IGlycV9jaGlwICpjaGlwID0gaXJxX2Rlc2NfZ2V0X2NoaXAo ZGVzYyk7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBvcnQtPnBjaWUtPnBkZXYtPmRldjsKKwl1 MzIgY2F1c2UsIHVubWFzaywgc3RhdHVzOworCWludCBpOworCisJY2hhaW5lZF9pcnFfZW50ZXIo Y2hpcCwgZGVzYyk7CisKKwljYXVzZSA9IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfSU5UX0NBVVNF X09GRik7CisJdW5tYXNrID0gbXZlYnVfcmVhZGwocG9ydCwgUENJRV9JTlRfVU5NQVNLX09GRik7 CisJc3RhdHVzID0gY2F1c2UgJiB1bm1hc2s7CisKKwkvKiBQcm9jZXNzIGxlZ2FjeSBJTlR4IGlu dGVycnVwdHMgKi8KKwlmb3IgKGkgPSAwOyBpIDwgUENJX05VTV9JTlRYOyBpKyspIHsKKwkJaWYg KCEoc3RhdHVzICYgUENJRV9JTlRfSU5UWChpKSkpCisJCQljb250aW51ZTsKKworCQlpZiAoZ2Vu ZXJpY19oYW5kbGVfZG9tYWluX2lycShwb3J0LT5pbnR4X2lycV9kb21haW4sIGkpID09IC1FSU5W QUwpCisJCQlkZXZfZXJyX3JhdGVsaW1pdGVkKGRldiwgInVuZXhwZWN0ZWQgSU5UJWMgSVJRXG4i LCAoY2hhcilpKydBJyk7CisJfQorCisJY2hhaW5lZF9pcnFfZXhpdChjaGlwLCBkZXNjKTsKK30K Kwogc3RhdGljIGludCBtdmVidV9wY2llX21hcF9pcnEoY29uc3Qgc3RydWN0IHBjaV9kZXYgKmRl diwgdTggc2xvdCwgdTggcGluKQogewogCS8qIEludGVycnVwdCBzdXBwb3J0IG9uIG12ZWJ1IGVt dWxhdGVkIGJyaWRnZXMgaXMgbm90IGltcGxlbWVudGVkIHlldCAqLwpAQCAtMTEyNCw2ICsxMjQw LDIxIEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9wYXJzZV9wb3J0KHN0cnVjdCBtdmVidV9wY2ll ICpwY2llLAogCQlwb3J0LT5pb19hdHRyID0gLTE7CiAJfQogCisJLyoKKwkgKiBPbGQgRFQgYmlu ZGluZ3MgZG8gbm90IGNvbnRhaW4gImludHgiIGludGVycnVwdAorCSAqIHNvIGRvIG5vdCBmYWls IHByb2JpbmcgZHJpdmVyIHdoZW4gaW50ZXJydXB0IGRvZXMgbm90IGV4aXN0LgorCSAqLworCXBv cnQtPmludHhfaXJxID0gb2ZfaXJxX2dldF9ieW5hbWUoY2hpbGQsICJpbnR4Iik7CisJaWYgKHBv cnQtPmludHhfaXJxID09IC1FUFJPQkVfREVGRVIpIHsKKwkJcmV0ID0gcG9ydC0+aW50eF9pcnE7 CisJCWdvdG8gZXJyOworCX0KKwlpZiAocG9ydC0+aW50eF9pcnEgPD0gMCkgeworCQlkZXZfd2Fy bihkZXYsICIlczogbGVnYWN5IElOVHggaW50ZXJydXB0cyBjYW5ub3QgYmUgbWFza2VkIGluZGl2 aWR1YWxseSwgIgorCQkJICAgICAgIiVwT0YgZG9lcyBub3QgY29udGFpbiBpbnR4IGludGVycnVw dFxuIiwKKwkJCSBwb3J0LT5uYW1lLCBjaGlsZCk7CisJfQorCiAJcmVzZXRfZ3BpbyA9IG9mX2dl dF9uYW1lZF9ncGlvX2ZsYWdzKGNoaWxkLCAicmVzZXQtZ3Bpb3MiLCAwLCAmZmxhZ3MpOwogCWlm IChyZXNldF9ncGlvID09IC1FUFJPQkVfREVGRVIpIHsKIAkJcmV0ID0gcmVzZXRfZ3BpbzsKQEAg LTEzMjAsNiArMTQ1MSw3IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9wcm9iZShzdHJ1Y3QgcGxh dGZvcm1fZGV2aWNlICpwZGV2KQogCiAJZm9yIChpID0gMDsgaSA8IHBjaWUtPm5wb3J0czsgaSsr KSB7CiAJCXN0cnVjdCBtdmVidV9wY2llX3BvcnQgKnBvcnQgPSAmcGNpZS0+cG9ydHNbaV07CisJ CWludCBpcnEgPSBwb3J0LT5pbnR4X2lycTsKIAogCQljaGlsZCA9IHBvcnQtPmRuOwogCQlpZiAo IWNoaWxkKQpAQCAtMTM0Nyw2ICsxNDc5LDIyIEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9wcm9i ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCQkJY29udGludWU7CiAJCX0KIAorCQlp ZiAoaXJxID4gMCkgeworCQkJcmV0ID0gbXZlYnVfcGNpZV9pbml0X2lycV9kb21haW4ocG9ydCk7 CisJCQlpZiAocmV0KSB7CisJCQkJZGV2X2VycihkZXYsICIlczogY2Fubm90IGluaXQgaXJxIGRv bWFpblxuIiwKKwkJCQkJcG9ydC0+bmFtZSk7CisJCQkJcGNpX2JyaWRnZV9lbXVsX2NsZWFudXAo JnBvcnQtPmJyaWRnZSk7CisJCQkJZGV2bV9pb3VubWFwKGRldiwgcG9ydC0+YmFzZSk7CisJCQkJ cG9ydC0+YmFzZSA9IE5VTEw7CisJCQkJbXZlYnVfcGNpZV9wb3dlcmRvd24ocG9ydCk7CisJCQkJ Y29udGludWU7CisJCQl9CisJCQlpcnFfc2V0X2NoYWluZWRfaGFuZGxlcl9hbmRfZGF0YShpcnEs CisJCQkJCQkJIG12ZWJ1X3BjaWVfaXJxX2hhbmRsZXIsCisJCQkJCQkJIHBvcnQpOworCQl9CisK IAkJLyoKIAkJICogUENJZSB0b3BvbG9neSBleHBvcnRlZCBieSBtdmVidSBodyBpcyBxdWl0ZSBj b21wbGljYXRlZC4gSW4KIAkJICogcmVhbGl0eSBoYXMgc29tZXRoaW5nIGxpa2UgTiBmdWxseSBp bmRlcGVuZGVudCBob3N0IGJyaWRnZXMKQEAgLTE0NTAsNiArMTU5OCw3IEBAIHN0YXRpYyBpbnQg bXZlYnVfcGNpZV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogCWZvciAo aSA9IDA7IGkgPCBwY2llLT5ucG9ydHM7IGkrKykgewogCQlzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0 ICpwb3J0ID0gJnBjaWUtPnBvcnRzW2ldOworCQlpbnQgaXJxID0gcG9ydC0+aW50eF9pcnE7CiAK IAkJaWYgKCFwb3J0LT5iYXNlKQogCQkJY29udGludWU7CkBAIC0xNDYyLDYgKzE2MTEsMTYgQEAg c3RhdGljIGludCBtdmVidV9wY2llX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 KQogCQkvKiBNYXNrIGFsbCBpbnRlcnJ1cHQgc291cmNlcy4gKi8KIAkJbXZlYnVfd3JpdGVsKHBv cnQsIH5QQ0lFX0lOVF9BTExfTUFTSywgUENJRV9JTlRfVU5NQVNLX09GRik7CiAKKwkJLyogQ2xl YXIgYWxsIGludGVycnVwdCBjYXVzZXMuICovCisJCW12ZWJ1X3dyaXRlbChwb3J0LCB+UENJRV9J TlRfQUxMX01BU0ssIFBDSUVfSU5UX0NBVVNFX09GRik7CisKKwkJaWYgKGlycSA+IDApCisJCQlp cnFfc2V0X2NoYWluZWRfaGFuZGxlcl9hbmRfZGF0YShpcnEsIE5VTEwsIE5VTEwpOworCisJCS8q IFJlbW92ZSBJUlEgZG9tYWlucy4gKi8KKwkJaWYgKHBvcnQtPmludHhfaXJxX2RvbWFpbikKKwkJ CWlycV9kb21haW5fcmVtb3ZlKHBvcnQtPmludHhfaXJxX2RvbWFpbik7CisKIAkJLyogRnJlZSBj b25maWcgc3BhY2UgZm9yIGVtdWxhdGVkIHJvb3QgYnJpZGdlLiAqLwogCQlwY2lfYnJpZGdlX2Vt dWxfY2xlYW51cCgmcG9ydC0+YnJpZGdlKTsKIAotLSAKMi4yMC4xCgoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5n IGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5p bmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=