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 DBAD4C433EF for ; Mon, 11 Apr 2022 19:01:29 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1349303AbiDKTDj (ORCPT ); Mon, 11 Apr 2022 15:03:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58788 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1349300AbiDKTDi (ORCPT ); Mon, 11 Apr 2022 15:03:38 -0400 Received: from ams.source.kernel.org (ams.source.kernel.org [145.40.68.75]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9FF2E32074; Mon, 11 Apr 2022 12:01:22 -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 49B92B8186E; Mon, 11 Apr 2022 19:01:21 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B67E4C385A3; Mon, 11 Apr 2022 19:01:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1649703680; bh=5YHL3Hjh0AaP8CgfCJ3QGpsdMmryF5kIFHovdhn9HfY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=MEN0upl3gefvglj04rR/Z42Ixd7YZPRTqaUyQbzo6QWV4KiRlzDCAYhbF+nuIUaYq NCDV8edSYRVWsaNmFpcHnm+itf5BFO4m2qauSI2CTZLYnxTWAbBIZt6lzdsxORoT+b 2WWOHd3Sab8tvK5yFv2uA2FdZtVqWubDV6VFaDHXLCSzwcuFHUpErMPIzybLXoVLNd UJNRt5vDAZ/u6nVWwgmuPkRONCXgigpqAcvDzT7DwPPOtrMsiMnq4TaBllTmzo1QJ4 94UIboeWyitqPRZXdEIXxV6/6gopUr9C64eGMXWmpUD5BYUXS/eYSr5wcst7A0WaSo km/K4otPbl5PA== Received: by pali.im (Postfix) id 6D882947; Mon, 11 Apr 2022 21:01:19 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , Bjorn Helgaas , Rob Herring , Andrew Lunn , 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-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v4 4/4] PCI: mvebu: Add support for sending Set_Slot_Power_Limit message Date: Mon, 11 Apr 2022 20:58:59 +0200 Message-Id: <20220411185859.32722-5-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220411185859.32722-1-pali@kernel.org> References: <20220411185859.32722-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 If DT supplies the 'slot-power-limit-milliwatt' property, program the value in the Slot Power Limit in the Slot Capabilities register and program the Root Port to send a Set_Slot_Power_Limit Message when the Link transitions to DL_Up. Signed-off-by: Pali Rohár Reviewed-by: Rob Herring --- Changes in v2: * Fix handling of slot power limit with scale x1.0 (0x00 value) * Use FIELD_PREP instead of _SHIFT macros * Changed commit message to Bjorn's suggestion * Changed comments in the code to match PCIe spec * Preserve user settings of PCI_EXP_SLTCTL_ASPL_DISABLE bit --- drivers/pci/controller/pci-mvebu.c | 96 ++++++++++++++++++++++++++++-- 1 file changed, 91 insertions(+), 5 deletions(-) diff --git a/drivers/pci/controller/pci-mvebu.c b/drivers/pci/controller/pci-mvebu.c index a75d2b9196f9..26ae7c29fece 100644 --- a/drivers/pci/controller/pci-mvebu.c +++ b/drivers/pci/controller/pci-mvebu.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -66,6 +67,12 @@ #define PCIE_STAT_BUS 0xff00 #define PCIE_STAT_DEV 0x1f0000 #define PCIE_STAT_LINK_DOWN BIT(0) +#define PCIE_SSPL_OFF 0x1a0c +#define PCIE_SSPL_VALUE_SHIFT 0 +#define PCIE_SSPL_VALUE_MASK GENMASK(7, 0) +#define PCIE_SSPL_SCALE_SHIFT 8 +#define PCIE_SSPL_SCALE_MASK GENMASK(9, 8) +#define PCIE_SSPL_ENABLE BIT(16) #define PCIE_RC_RTSTA 0x1a14 #define PCIE_DEBUG_CTRL 0x1a60 #define PCIE_DEBUG_SOFT_RESET BIT(20) @@ -111,6 +118,8 @@ struct mvebu_pcie_port { struct mvebu_pcie_window iowin; u32 saved_pcie_stat; struct resource regs; + u8 slot_power_limit_value; + u8 slot_power_limit_scale; struct irq_domain *intx_irq_domain; raw_spinlock_t irq_lock; int intx_irq; @@ -239,7 +248,7 @@ static void mvebu_pcie_setup_wins(struct mvebu_pcie_port *port) static void mvebu_pcie_setup_hw(struct mvebu_pcie_port *port) { - u32 ctrl, lnkcap, cmd, dev_rev, unmask; + u32 ctrl, lnkcap, cmd, dev_rev, unmask, sspl; /* Setup PCIe controller to Root Complex mode. */ ctrl = mvebu_readl(port, PCIE_CTRL_OFF); @@ -292,6 +301,20 @@ 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); + /* + * Program Root Port to automatically send Set_Slot_Power_Limit + * PCIe Message when changing status from Dl_Down to Dl_Up and valid + * slot power limit was specified. + */ + sspl = mvebu_readl(port, PCIE_SSPL_OFF); + sspl &= ~(PCIE_SSPL_VALUE_MASK | PCIE_SSPL_SCALE_MASK | PCIE_SSPL_ENABLE); + if (port->slot_power_limit_value) { + sspl |= port->slot_power_limit_value << PCIE_SSPL_VALUE_SHIFT; + sspl |= port->slot_power_limit_scale << PCIE_SSPL_SCALE_SHIFT; + sspl |= PCIE_SSPL_ENABLE; + } + mvebu_writel(port, sspl, PCIE_SSPL_OFF); + /* Mask all interrupt sources. */ mvebu_writel(port, ~PCIE_INT_ALL_MASK, PCIE_INT_UNMASK_OFF); @@ -628,9 +651,23 @@ mvebu_pci_bridge_emul_pcie_conf_read(struct pci_bridge_emul *bridge, (PCI_EXP_LNKSTA_DLLLA << 16) : 0); break; - case PCI_EXP_SLTCTL: - *value = PCI_EXP_SLTSTA_PDS << 16; + case PCI_EXP_SLTCTL: { + u16 slotsta = le16_to_cpu(bridge->pcie_conf.slotsta); + u32 val = 0; + /* + * When slot power limit was not specified in DT then + * ASPL_DISABLE bit is stored only in emulated config space. + * Otherwise reflect status of PCIE_SSPL_ENABLE bit in HW. + */ + if (!port->slot_power_limit_value) + val |= slotctl & PCI_EXP_SLTCTL_ASPL_DISABLE; + else if (!(mvebu_readl(port, PCIE_SSPL_OFF) & PCIE_SSPL_ENABLE)) + val |= PCI_EXP_SLTCTL_ASPL_DISABLE; + /* This callback is 32-bit and in high bits is slot status. */ + val |= slotsta << 16; + *value = val; break; + } case PCI_EXP_RTSTA: *value = mvebu_readl(port, PCIE_RC_RTSTA); @@ -774,6 +811,22 @@ mvebu_pci_bridge_emul_pcie_conf_write(struct pci_bridge_emul *bridge, mvebu_writel(port, new, PCIE_CAP_PCIEXP + PCI_EXP_LNKCTL); break; + case PCI_EXP_SLTCTL: + /* + * Allow to change PCIE_SSPL_ENABLE bit only when slot power + * limit was specified in DT and configured into HW. + */ + if ((mask & PCI_EXP_SLTCTL_ASPL_DISABLE) && + port->slot_power_limit_value) { + u32 sspl = mvebu_readl(port, PCIE_SSPL_OFF); + if (new & PCI_EXP_SLTCTL_ASPL_DISABLE) + sspl &= ~PCIE_SSPL_ENABLE; + else + sspl |= PCIE_SSPL_ENABLE; + mvebu_writel(port, sspl, PCIE_SSPL_OFF); + } + break; + case PCI_EXP_RTSTA: /* * PME Status bit in Root Status Register (PCIE_RC_RTSTA) @@ -868,8 +921,26 @@ static int mvebu_pci_bridge_emul_init(struct mvebu_pcie_port *port) /* * Older mvebu hardware provides PCIe Capability structure only in * version 1. New hardware provides it in version 2. + * Enable slot support which is emulated. */ - bridge->pcie_conf.cap = cpu_to_le16(pcie_cap_ver); + bridge->pcie_conf.cap = cpu_to_le16(pcie_cap_ver | PCI_EXP_FLAGS_SLOT); + + /* + * Set Presence Detect State bit permanently as there is no support for + * unplugging PCIe card from the slot. Assume that PCIe card is always + * connected in slot. + * + * Set physical slot number to port+1 as mvebu ports are indexed from + * zero and zero value is reserved for ports within the same silicon + * as Root Port which is not mvebu case. + * + * Also set correct slot power limit. + */ + bridge->pcie_conf.slotcap = cpu_to_le32( + FIELD_PREP(PCI_EXP_SLTCAP_SPLV, port->slot_power_limit_value) | + FIELD_PREP(PCI_EXP_SLTCAP_SPLS, port->slot_power_limit_scale) | + FIELD_PREP(PCI_EXP_SLTCAP_PSN, port->port+1)); + bridge->pcie_conf.slotsta = cpu_to_le16(PCI_EXP_SLTSTA_PDS); bridge->subsystem_vendor_id = ssdev_id & 0xffff; bridge->subsystem_id = ssdev_id >> 16; @@ -1191,6 +1262,7 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, { struct device *dev = &pcie->pdev->dev; enum of_gpio_flags flags; + u32 slot_power_limit; int reset_gpio, ret; u32 num_lanes; @@ -1291,6 +1363,15 @@ static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie, port->reset_gpio = gpio_to_desc(reset_gpio); } + slot_power_limit = of_pci_get_slot_power_limit(child, + &port->slot_power_limit_value, + &port->slot_power_limit_scale); + if (slot_power_limit) + dev_info(dev, "%s: Slot power limit %u.%uW\n", + port->name, + slot_power_limit / 1000, + (slot_power_limit / 100) % 10); + port->clk = of_clk_get_by_name(child, NULL); if (IS_ERR(port->clk)) { dev_err(dev, "%s: cannot get clock\n", port->name); @@ -1587,7 +1668,7 @@ static int mvebu_pcie_remove(struct platform_device *pdev) { struct mvebu_pcie *pcie = platform_get_drvdata(pdev); struct pci_host_bridge *bridge = pci_host_bridge_from_priv(pcie); - u32 cmd; + u32 cmd, sspl; int i; /* Remove PCI bus with all devices. */ @@ -1624,6 +1705,11 @@ static int mvebu_pcie_remove(struct platform_device *pdev) /* Free config space for emulated root bridge. */ pci_bridge_emul_cleanup(&port->bridge); + /* Disable sending Set_Slot_Power_Limit PCIe Message. */ + sspl = mvebu_readl(port, PCIE_SSPL_OFF); + sspl &= ~(PCIE_SSPL_VALUE_MASK | PCIE_SSPL_SCALE_MASK | PCIE_SSPL_ENABLE); + mvebu_writel(port, sspl, PCIE_SSPL_OFF); + /* Disable and clear BARs and windows. */ mvebu_pcie_disable_wins(port); -- 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 6ED3DC433F5 for ; Mon, 11 Apr 2022 19:03:17 +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=l6VLxMSajylS3lLwtGVB419bC+DcuAvYibs9GjEDDvY=; b=AcArmQMS/m5+dt SZJtQ8D4P+k/5ZbjysjB6Bpf+Ob+acw+RisNeWfaxtET+aH7iqYlJH+eK7cphXOAWo1BjyIw+3V+9 52cfhiJoF3qu6/mozKqrdMiakXSuB1NpGe7QPnb1gUnI4J9qg+m8fTdKco1DgWolvWyiIygGV0eqE CTBZ8so3C/U8xMzbSL+06Zd8t+OYKFt9GCMcaPTjK25JmUdNkjxavRFJFyNuFpqcKYhx4O/UNPRiY A3GEtO936Tdvlg0+41Uw0kUUMHJM7VhfQu/t7A8z+vmEGhzvC5YEp8YtzNdKuwbkdaJqclb0eCB61 noCtLBzDNixt79LhSEnw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ndzIW-00AGgA-My; Mon, 11 Apr 2022 19:02:00 +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 1ndzHy-00AGQF-5U for linux-arm-kernel@lists.infradead.org; Mon, 11 Apr 2022 19:01:28 +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 6D090B81870; Mon, 11 Apr 2022 19:01:21 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B67E4C385A3; Mon, 11 Apr 2022 19:01:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1649703680; bh=5YHL3Hjh0AaP8CgfCJ3QGpsdMmryF5kIFHovdhn9HfY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=MEN0upl3gefvglj04rR/Z42Ixd7YZPRTqaUyQbzo6QWV4KiRlzDCAYhbF+nuIUaYq NCDV8edSYRVWsaNmFpcHnm+itf5BFO4m2qauSI2CTZLYnxTWAbBIZt6lzdsxORoT+b 2WWOHd3Sab8tvK5yFv2uA2FdZtVqWubDV6VFaDHXLCSzwcuFHUpErMPIzybLXoVLNd UJNRt5vDAZ/u6nVWwgmuPkRONCXgigpqAcvDzT7DwPPOtrMsiMnq4TaBllTmzo1QJ4 94UIboeWyitqPRZXdEIXxV6/6gopUr9C64eGMXWmpUD5BYUXS/eYSr5wcst7A0WaSo km/K4otPbl5PA== Received: by pali.im (Postfix) id 6D882947; Mon, 11 Apr 2022 21:01:19 +0200 (CEST) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Lorenzo Pieralisi , Bjorn Helgaas , Rob Herring , Andrew Lunn , 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-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v4 4/4] PCI: mvebu: Add support for sending Set_Slot_Power_Limit message Date: Mon, 11 Apr 2022 20:58:59 +0200 Message-Id: <20220411185859.32722-5-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20220411185859.32722-1-pali@kernel.org> References: <20220411185859.32722-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220411_120126_564234_2A8998BB X-CRM114-Status: GOOD ( 25.12 ) 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 SWYgRFQgc3VwcGxpZXMgdGhlICdzbG90LXBvd2VyLWxpbWl0LW1pbGxpd2F0dCcgcHJvcGVydHks IHByb2dyYW0KdGhlIHZhbHVlIGluIHRoZSBTbG90IFBvd2VyIExpbWl0IGluIHRoZSBTbG90IENh cGFiaWxpdGllcyByZWdpc3RlcgphbmQgcHJvZ3JhbSB0aGUgUm9vdCBQb3J0IHRvIHNlbmQgYSBT ZXRfU2xvdF9Qb3dlcl9MaW1pdCBNZXNzYWdlCndoZW4gdGhlIExpbmsgdHJhbnNpdGlvbnMgdG8g RExfVXAuCgpTaWduZWQtb2ZmLWJ5OiBQYWxpIFJvaMOhciA8cGFsaUBrZXJuZWwub3JnPgpSZXZp ZXdlZC1ieTogUm9iIEhlcnJpbmcgPHJvYmhAa2VybmVsLm9yZz4KLS0tCkNoYW5nZXMgaW4gdjI6 CiogRml4IGhhbmRsaW5nIG9mIHNsb3QgcG93ZXIgbGltaXQgd2l0aCBzY2FsZSB4MS4wICgweDAw IHZhbHVlKQoqIFVzZSBGSUVMRF9QUkVQIGluc3RlYWQgb2YgX1NISUZUIG1hY3JvcwoqIENoYW5n ZWQgY29tbWl0IG1lc3NhZ2UgdG8gQmpvcm4ncyBzdWdnZXN0aW9uCiogQ2hhbmdlZCBjb21tZW50 cyBpbiB0aGUgY29kZSB0byBtYXRjaCBQQ0llIHNwZWMKKiBQcmVzZXJ2ZSB1c2VyIHNldHRpbmdz IG9mIFBDSV9FWFBfU0xUQ1RMX0FTUExfRElTQUJMRSBiaXQKLS0tCiBkcml2ZXJzL3BjaS9jb250 cm9sbGVyL3BjaS1tdmVidS5jIHwgOTYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCiAx IGZpbGUgY2hhbmdlZCwgOTEgaW5zZXJ0aW9ucygrKSwgNSBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jIGIvZHJpdmVycy9wY2kvY29u dHJvbGxlci9wY2ktbXZlYnUuYwppbmRleCBhNzVkMmI5MTk2ZjkuLjI2YWU3YzI5ZmVjZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9wY2kvY29udHJvbGxlci9wY2ktbXZlYnUuYworKysgYi9kcml2ZXJz L3BjaS9jb250cm9sbGVyL3BjaS1tdmVidS5jCkBAIC04LDYgKzgsNyBAQAogI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4 L3BjaS5oPgorI2luY2x1ZGUgPGxpbnV4L2JpdGZpZWxkLmg+CiAjaW5jbHVkZSA8bGludXgvY2xr Lmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CkBA IC02Niw2ICs2NywxMiBAQAogI2RlZmluZSAgUENJRV9TVEFUX0JVUyAgICAgICAgICAgICAgICAg IDB4ZmYwMAogI2RlZmluZSAgUENJRV9TVEFUX0RFViAgICAgICAgICAgICAgICAgIDB4MWYwMDAw CiAjZGVmaW5lICBQQ0lFX1NUQVRfTElOS19ET1dOCQlCSVQoMCkKKyNkZWZpbmUgUENJRV9TU1BM X09GRgkJMHgxYTBjCisjZGVmaW5lICBQQ0lFX1NTUExfVkFMVUVfU0hJRlQJCTAKKyNkZWZpbmUg IFBDSUVfU1NQTF9WQUxVRV9NQVNLCQlHRU5NQVNLKDcsIDApCisjZGVmaW5lICBQQ0lFX1NTUExf U0NBTEVfU0hJRlQJCTgKKyNkZWZpbmUgIFBDSUVfU1NQTF9TQ0FMRV9NQVNLCQlHRU5NQVNLKDks IDgpCisjZGVmaW5lICBQQ0lFX1NTUExfRU5BQkxFCQlCSVQoMTYpCiAjZGVmaW5lIFBDSUVfUkNf UlRTVEEJCTB4MWExNAogI2RlZmluZSBQQ0lFX0RFQlVHX0NUUkwgICAgICAgICAweDFhNjAKICNk ZWZpbmUgIFBDSUVfREVCVUdfU09GVF9SRVNFVAkJQklUKDIwKQpAQCAtMTExLDYgKzExOCw4IEBA IHN0cnVjdCBtdmVidV9wY2llX3BvcnQgewogCXN0cnVjdCBtdmVidV9wY2llX3dpbmRvdyBpb3dp bjsKIAl1MzIgc2F2ZWRfcGNpZV9zdGF0OwogCXN0cnVjdCByZXNvdXJjZSByZWdzOworCXU4IHNs b3RfcG93ZXJfbGltaXRfdmFsdWU7CisJdTggc2xvdF9wb3dlcl9saW1pdF9zY2FsZTsKIAlzdHJ1 Y3QgaXJxX2RvbWFpbiAqaW50eF9pcnFfZG9tYWluOwogCXJhd19zcGlubG9ja190IGlycV9sb2Nr OwogCWludCBpbnR4X2lycTsKQEAgLTIzOSw3ICsyNDgsNyBAQCBzdGF0aWMgdm9pZCBtdmVidV9w Y2llX3NldHVwX3dpbnMoc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCkKIAogc3RhdGljIHZv aWQgbXZlYnVfcGNpZV9zZXR1cF9odyhzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0KQogewot CXUzMiBjdHJsLCBsbmtjYXAsIGNtZCwgZGV2X3JldiwgdW5tYXNrOworCXUzMiBjdHJsLCBsbmtj YXAsIGNtZCwgZGV2X3JldiwgdW5tYXNrLCBzc3BsOwogCiAJLyogU2V0dXAgUENJZSBjb250cm9s bGVyIHRvIFJvb3QgQ29tcGxleCBtb2RlLiAqLwogCWN0cmwgPSBtdmVidV9yZWFkbChwb3J0LCBQ Q0lFX0NUUkxfT0ZGKTsKQEAgLTI5Miw2ICszMDEsMjAgQEAgc3RhdGljIHZvaWQgbXZlYnVfcGNp ZV9zZXR1cF9odyhzdHJ1Y3QgbXZlYnVfcGNpZV9wb3J0ICpwb3J0KQogCS8qIFBvaW50IFBDSWUg dW5pdCBNQlVTIGRlY29kZSB3aW5kb3dzIHRvIERSQU0gc3BhY2UuICovCiAJbXZlYnVfcGNpZV9z ZXR1cF93aW5zKHBvcnQpOwogCisJLyoKKwkgKiBQcm9ncmFtIFJvb3QgUG9ydCB0byBhdXRvbWF0 aWNhbGx5IHNlbmQgU2V0X1Nsb3RfUG93ZXJfTGltaXQKKwkgKiBQQ0llIE1lc3NhZ2Ugd2hlbiBj aGFuZ2luZyBzdGF0dXMgZnJvbSBEbF9Eb3duIHRvIERsX1VwIGFuZCB2YWxpZAorCSAqIHNsb3Qg cG93ZXIgbGltaXQgd2FzIHNwZWNpZmllZC4KKwkgKi8KKwlzc3BsID0gbXZlYnVfcmVhZGwocG9y dCwgUENJRV9TU1BMX09GRik7CisJc3NwbCAmPSB+KFBDSUVfU1NQTF9WQUxVRV9NQVNLIHwgUENJ RV9TU1BMX1NDQUxFX01BU0sgfCBQQ0lFX1NTUExfRU5BQkxFKTsKKwlpZiAocG9ydC0+c2xvdF9w b3dlcl9saW1pdF92YWx1ZSkgeworCQlzc3BsIHw9IHBvcnQtPnNsb3RfcG93ZXJfbGltaXRfdmFs dWUgPDwgUENJRV9TU1BMX1ZBTFVFX1NISUZUOworCQlzc3BsIHw9IHBvcnQtPnNsb3RfcG93ZXJf bGltaXRfc2NhbGUgPDwgUENJRV9TU1BMX1NDQUxFX1NISUZUOworCQlzc3BsIHw9IFBDSUVfU1NQ TF9FTkFCTEU7CisJfQorCW12ZWJ1X3dyaXRlbChwb3J0LCBzc3BsLCBQQ0lFX1NTUExfT0ZGKTsK KwogCS8qIE1hc2sgYWxsIGludGVycnVwdCBzb3VyY2VzLiAqLwogCW12ZWJ1X3dyaXRlbChwb3J0 LCB+UENJRV9JTlRfQUxMX01BU0ssIFBDSUVfSU5UX1VOTUFTS19PRkYpOwogCkBAIC02MjgsOSAr NjUxLDIzIEBAIG12ZWJ1X3BjaV9icmlkZ2VfZW11bF9wY2llX2NvbmZfcmVhZChzdHJ1Y3QgcGNp X2JyaWRnZV9lbXVsICpicmlkZ2UsCiAJCQkgIChQQ0lfRVhQX0xOS1NUQV9ETExMQSA8PCAxNikg OiAwKTsKIAkJYnJlYWs7CiAKLQljYXNlIFBDSV9FWFBfU0xUQ1RMOgotCQkqdmFsdWUgPSBQQ0lf RVhQX1NMVFNUQV9QRFMgPDwgMTY7CisJY2FzZSBQQ0lfRVhQX1NMVENUTDogeworCQl1MTYgc2xv dHN0YSA9IGxlMTZfdG9fY3B1KGJyaWRnZS0+cGNpZV9jb25mLnNsb3RzdGEpOworCQl1MzIgdmFs ID0gMDsKKwkJLyoKKwkJICogV2hlbiBzbG90IHBvd2VyIGxpbWl0IHdhcyBub3Qgc3BlY2lmaWVk IGluIERUIHRoZW4KKwkJICogQVNQTF9ESVNBQkxFIGJpdCBpcyBzdG9yZWQgb25seSBpbiBlbXVs YXRlZCBjb25maWcgc3BhY2UuCisJCSAqIE90aGVyd2lzZSByZWZsZWN0IHN0YXR1cyBvZiBQQ0lF X1NTUExfRU5BQkxFIGJpdCBpbiBIVy4KKwkJICovCisJCWlmICghcG9ydC0+c2xvdF9wb3dlcl9s aW1pdF92YWx1ZSkKKwkJCXZhbCB8PSBzbG90Y3RsICYgUENJX0VYUF9TTFRDVExfQVNQTF9ESVNB QkxFOworCQllbHNlIGlmICghKG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfU1NQTF9PRkYpICYgUENJ RV9TU1BMX0VOQUJMRSkpCisJCQl2YWwgfD0gUENJX0VYUF9TTFRDVExfQVNQTF9ESVNBQkxFOwor CQkvKiBUaGlzIGNhbGxiYWNrIGlzIDMyLWJpdCBhbmQgaW4gaGlnaCBiaXRzIGlzIHNsb3Qgc3Rh dHVzLiAqLworCQl2YWwgfD0gc2xvdHN0YSA8PCAxNjsKKwkJKnZhbHVlID0gdmFsOwogCQlicmVh azsKKwl9CiAKIAljYXNlIFBDSV9FWFBfUlRTVEE6CiAJCSp2YWx1ZSA9IG12ZWJ1X3JlYWRsKHBv cnQsIFBDSUVfUkNfUlRTVEEpOwpAQCAtNzc0LDYgKzgxMSwyMiBAQCBtdmVidV9wY2lfYnJpZGdl X2VtdWxfcGNpZV9jb25mX3dyaXRlKHN0cnVjdCBwY2lfYnJpZGdlX2VtdWwgKmJyaWRnZSwKIAkJ bXZlYnVfd3JpdGVsKHBvcnQsIG5ldywgUENJRV9DQVBfUENJRVhQICsgUENJX0VYUF9MTktDVEwp OwogCQlicmVhazsKIAorCWNhc2UgUENJX0VYUF9TTFRDVEw6CisJCS8qCisJCSAqIEFsbG93IHRv IGNoYW5nZSBQQ0lFX1NTUExfRU5BQkxFIGJpdCBvbmx5IHdoZW4gc2xvdCBwb3dlcgorCQkgKiBs aW1pdCB3YXMgc3BlY2lmaWVkIGluIERUIGFuZCBjb25maWd1cmVkIGludG8gSFcuCisJCSAqLwor CQlpZiAoKG1hc2sgJiBQQ0lfRVhQX1NMVENUTF9BU1BMX0RJU0FCTEUpICYmCisJCSAgICBwb3J0 LT5zbG90X3Bvd2VyX2xpbWl0X3ZhbHVlKSB7CisJCQl1MzIgc3NwbCA9IG12ZWJ1X3JlYWRsKHBv cnQsIFBDSUVfU1NQTF9PRkYpOworCQkJaWYgKG5ldyAmIFBDSV9FWFBfU0xUQ1RMX0FTUExfRElT QUJMRSkKKwkJCQlzc3BsICY9IH5QQ0lFX1NTUExfRU5BQkxFOworCQkJZWxzZQorCQkJCXNzcGwg fD0gUENJRV9TU1BMX0VOQUJMRTsKKwkJCW12ZWJ1X3dyaXRlbChwb3J0LCBzc3BsLCBQQ0lFX1NT UExfT0ZGKTsKKwkJfQorCQlicmVhazsKKwogCWNhc2UgUENJX0VYUF9SVFNUQToKIAkJLyoKIAkJ ICogUE1FIFN0YXR1cyBiaXQgaW4gUm9vdCBTdGF0dXMgUmVnaXN0ZXIgKFBDSUVfUkNfUlRTVEEp CkBAIC04NjgsOCArOTIxLDI2IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpX2JyaWRnZV9lbXVsX2lu aXQoc3RydWN0IG12ZWJ1X3BjaWVfcG9ydCAqcG9ydCkKIAkvKgogCSAqIE9sZGVyIG12ZWJ1IGhh cmR3YXJlIHByb3ZpZGVzIFBDSWUgQ2FwYWJpbGl0eSBzdHJ1Y3R1cmUgb25seSBpbgogCSAqIHZl cnNpb24gMS4gTmV3IGhhcmR3YXJlIHByb3ZpZGVzIGl0IGluIHZlcnNpb24gMi4KKwkgKiBFbmFi bGUgc2xvdCBzdXBwb3J0IHdoaWNoIGlzIGVtdWxhdGVkLgogCSAqLwotCWJyaWRnZS0+cGNpZV9j b25mLmNhcCA9IGNwdV90b19sZTE2KHBjaWVfY2FwX3Zlcik7CisJYnJpZGdlLT5wY2llX2NvbmYu Y2FwID0gY3B1X3RvX2xlMTYocGNpZV9jYXBfdmVyIHwgUENJX0VYUF9GTEFHU19TTE9UKTsKKwor CS8qCisJICogU2V0IFByZXNlbmNlIERldGVjdCBTdGF0ZSBiaXQgcGVybWFuZW50bHkgYXMgdGhl cmUgaXMgbm8gc3VwcG9ydCBmb3IKKwkgKiB1bnBsdWdnaW5nIFBDSWUgY2FyZCBmcm9tIHRoZSBz bG90LiBBc3N1bWUgdGhhdCBQQ0llIGNhcmQgaXMgYWx3YXlzCisJICogY29ubmVjdGVkIGluIHNs b3QuCisJICoKKwkgKiBTZXQgcGh5c2ljYWwgc2xvdCBudW1iZXIgdG8gcG9ydCsxIGFzIG12ZWJ1 IHBvcnRzIGFyZSBpbmRleGVkIGZyb20KKwkgKiB6ZXJvIGFuZCB6ZXJvIHZhbHVlIGlzIHJlc2Vy dmVkIGZvciBwb3J0cyB3aXRoaW4gdGhlIHNhbWUgc2lsaWNvbgorCSAqIGFzIFJvb3QgUG9ydCB3 aGljaCBpcyBub3QgbXZlYnUgY2FzZS4KKwkgKgorCSAqIEFsc28gc2V0IGNvcnJlY3Qgc2xvdCBw b3dlciBsaW1pdC4KKwkgKi8KKwlicmlkZ2UtPnBjaWVfY29uZi5zbG90Y2FwID0gY3B1X3RvX2xl MzIoCisJCUZJRUxEX1BSRVAoUENJX0VYUF9TTFRDQVBfU1BMViwgcG9ydC0+c2xvdF9wb3dlcl9s aW1pdF92YWx1ZSkgfAorCQlGSUVMRF9QUkVQKFBDSV9FWFBfU0xUQ0FQX1NQTFMsIHBvcnQtPnNs b3RfcG93ZXJfbGltaXRfc2NhbGUpIHwKKwkJRklFTERfUFJFUChQQ0lfRVhQX1NMVENBUF9QU04s IHBvcnQtPnBvcnQrMSkpOworCWJyaWRnZS0+cGNpZV9jb25mLnNsb3RzdGEgPSBjcHVfdG9fbGUx NihQQ0lfRVhQX1NMVFNUQV9QRFMpOwogCiAJYnJpZGdlLT5zdWJzeXN0ZW1fdmVuZG9yX2lkID0g c3NkZXZfaWQgJiAweGZmZmY7CiAJYnJpZGdlLT5zdWJzeXN0ZW1faWQgPSBzc2Rldl9pZCA+PiAx NjsKQEAgLTExOTEsNiArMTI2Miw3IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9wYXJzZV9wb3J0 KHN0cnVjdCBtdmVidV9wY2llICpwY2llLAogewogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwY2ll LT5wZGV2LT5kZXY7CiAJZW51bSBvZl9ncGlvX2ZsYWdzIGZsYWdzOworCXUzMiBzbG90X3Bvd2Vy X2xpbWl0OwogCWludCByZXNldF9ncGlvLCByZXQ7CiAJdTMyIG51bV9sYW5lczsKIApAQCAtMTI5 MSw2ICsxMzYzLDE1IEBAIHN0YXRpYyBpbnQgbXZlYnVfcGNpZV9wYXJzZV9wb3J0KHN0cnVjdCBt dmVidV9wY2llICpwY2llLAogCQlwb3J0LT5yZXNldF9ncGlvID0gZ3Bpb190b19kZXNjKHJlc2V0 X2dwaW8pOwogCX0KIAorCXNsb3RfcG93ZXJfbGltaXQgPSBvZl9wY2lfZ2V0X3Nsb3RfcG93ZXJf bGltaXQoY2hpbGQsCisJCQkJJnBvcnQtPnNsb3RfcG93ZXJfbGltaXRfdmFsdWUsCisJCQkJJnBv cnQtPnNsb3RfcG93ZXJfbGltaXRfc2NhbGUpOworCWlmIChzbG90X3Bvd2VyX2xpbWl0KQorCQlk ZXZfaW5mbyhkZXYsICIlczogU2xvdCBwb3dlciBsaW1pdCAldS4ldVdcbiIsCisJCQkgcG9ydC0+ bmFtZSwKKwkJCSBzbG90X3Bvd2VyX2xpbWl0IC8gMTAwMCwKKwkJCSAoc2xvdF9wb3dlcl9saW1p dCAvIDEwMCkgJSAxMCk7CisKIAlwb3J0LT5jbGsgPSBvZl9jbGtfZ2V0X2J5X25hbWUoY2hpbGQs IE5VTEwpOwogCWlmIChJU19FUlIocG9ydC0+Y2xrKSkgewogCQlkZXZfZXJyKGRldiwgIiVzOiBj YW5ub3QgZ2V0IGNsb2NrXG4iLCBwb3J0LT5uYW1lKTsKQEAgLTE1ODcsNyArMTY2OCw3IEBAIHN0 YXRpYyBpbnQgbXZlYnVfcGNpZV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK IHsKIAlzdHJ1Y3QgbXZlYnVfcGNpZSAqcGNpZSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYp OwogCXN0cnVjdCBwY2lfaG9zdF9icmlkZ2UgKmJyaWRnZSA9IHBjaV9ob3N0X2JyaWRnZV9mcm9t X3ByaXYocGNpZSk7Ci0JdTMyIGNtZDsKKwl1MzIgY21kLCBzc3BsOwogCWludCBpOwogCiAJLyog UmVtb3ZlIFBDSSBidXMgd2l0aCBhbGwgZGV2aWNlcy4gKi8KQEAgLTE2MjQsNiArMTcwNSwxMSBA QCBzdGF0aWMgaW50IG12ZWJ1X3BjaWVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk ZXYpCiAJCS8qIEZyZWUgY29uZmlnIHNwYWNlIGZvciBlbXVsYXRlZCByb290IGJyaWRnZS4gKi8K IAkJcGNpX2JyaWRnZV9lbXVsX2NsZWFudXAoJnBvcnQtPmJyaWRnZSk7CiAKKwkJLyogRGlzYWJs ZSBzZW5kaW5nIFNldF9TbG90X1Bvd2VyX0xpbWl0IFBDSWUgTWVzc2FnZS4gKi8KKwkJc3NwbCA9 IG12ZWJ1X3JlYWRsKHBvcnQsIFBDSUVfU1NQTF9PRkYpOworCQlzc3BsICY9IH4oUENJRV9TU1BM X1ZBTFVFX01BU0sgfCBQQ0lFX1NTUExfU0NBTEVfTUFTSyB8IFBDSUVfU1NQTF9FTkFCTEUpOwor CQltdmVidV93cml0ZWwocG9ydCwgc3NwbCwgUENJRV9TU1BMX09GRik7CisKIAkJLyogRGlzYWJs ZSBhbmQgY2xlYXIgQkFScyBhbmQgd2luZG93cy4gKi8KIAkJbXZlYnVfcGNpZV9kaXNhYmxlX3dp bnMocG9ydCk7CiAKLS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1r ZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWls bWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK