From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B8BA116E893; Mon, 27 May 2024 16:15:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.199 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1716826535; cv=none; b=eK1WJGkewx95r7IiJej3uCfIb0a70xX9fTpZfpWYhsZoWt1f/6dobPCuVg2c+HVQ6OuHO7wKXyuoTcjZCwVdG1Ggw8wev2hNQ+7RalQ5jXE4Kd3JdH18gQL3qmehN9ghQk2dLhFlmCIfOR/51HoHJVTpTHJgajU5ycJ30o6BCK4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1716826535; c=relaxed/simple; bh=8LbOVPDes+S/JwJt6q32rZAoQPobCVX+rovAVuIFdRU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=oD24HuCdmzUbZQRANHMK1nzcdWb58lRcNF4KfiXCOkf4O/W+AWjTAYoFjVebrjO30rMnEPsCWe3KBUNKY/I1B8iTNE5kWS4cN3eQRhh3bYoO2nWSHqa+1o+cxpdiL/WbtiMXBhFQwYqVQbwIX6puCHogKs0GPFNlflAxD3x812M= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=FVd9+tfQ; arc=none smtp.client-ip=217.70.183.199 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="FVd9+tfQ" Received: by mail.gandi.net (Postfix) with ESMTPA id 87468FF811; Mon, 27 May 2024 16:15:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1716826531; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=yjNRz52stJ36/fH3SVMIz99NWadg59zYIFnqd5Fj4vI=; b=FVd9+tfQCt5RQz7cTho3a1Qtlf8iQNcx6ZTpm3nYzdLTTkfx7BXvTN4UTyyW9pBxUS6mIJ aBdp0pu83BDNa8CX1Zz9p/Mqr8i1ZwyDfRRILqXe7ENqCVIKAa9Yr9oYxUTH1kzzkfMwu1 K4YjDelnXbwVar6sqgWVsBSoC8HUwSmugJm+dxObtLUXPWkwSbYLIzfkFGZ1Apyr1LWxVM B4b0oOUgSOjVaz1r7s2kivdToCuvkRvoxe6TsfnHgfvu4JwpOSouIo0/AWWaT3Al5aRTsk AAQ8SVLmx5qhmDRVAnkRQJsBZjOihFTfyyoZjqm1+MqPIZs6QcFu1NmC1ZdCJA== From: Herve Codina To: Simon Horman , Sai Krishna Gajula , Herve Codina , Thomas Gleixner , Rob Herring , Krzysztof Kozlowski , Conor Dooley , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Lee Jones , Arnd Bergmann , Horatiu Vultur , UNGLinuxDriver@microchip.com, Andrew Lunn , Heiner Kallweit , Russell King , Saravana Kannan , Bjorn Helgaas , Philipp Zabel , Lars Povlsen , Steen Hegelund , Daniel Machon , Alexandre Belloni Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, netdev@vger.kernel.org, linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Allan Nielsen , Steen Hegelund , Luca Ceresoli , Thomas Petazzoni Subject: [PATCH v2 18/19] mfd: Add support for LAN966x PCI device Date: Mon, 27 May 2024 18:14:45 +0200 Message-ID: <20240527161450.326615-19-herve.codina@bootlin.com> X-Mailer: git-send-email 2.45.0 In-Reply-To: <20240527161450.326615-1-herve.codina@bootlin.com> References: <20240527161450.326615-1-herve.codina@bootlin.com> Precedence: bulk X-Mailing-List: linux-pci@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-GND-Sasl: herve.codina@bootlin.com Add a PCI driver that handles the LAN966x PCI device using a device-tree overlay. This overlay is applied to the PCI device DT node and allows to describe components that are present in the device. The memory from the device-tree is remapped to the BAR memory thanks to "ranges" properties computed at runtime by the PCI core during the PCI enumeration. The PCI device itself acts as an interrupt controller and is used as the parent of the internal LAN966x interrupt controller to route the interrupts to the assigned PCI INTx interrupt. Signed-off-by: Herve Codina --- drivers/mfd/Kconfig | 24 ++++ drivers/mfd/Makefile | 4 + drivers/mfd/lan966x_pci.c | 229 +++++++++++++++++++++++++++++++++++ drivers/mfd/lan966x_pci.dtso | 167 +++++++++++++++++++++++++ drivers/pci/quirks.c | 1 + 5 files changed, 425 insertions(+) create mode 100644 drivers/mfd/lan966x_pci.c create mode 100644 drivers/mfd/lan966x_pci.dtso diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index 266b4f54af60..15db144bc09b 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -144,6 +144,30 @@ config MFD_ATMEL_FLEXCOM by the probe function of this MFD driver according to a device tree property. +config MFD_LAN966X_PCI + tristate "Microchip LAN966x PCIe Support" + depends on PCI + select OF + select OF_OVERLAY + select IRQ_DOMAIN + help + This enables the support for the LAN966x PCIe device. + This is used to drive the LAN966x PCIe device from the host system + to which it is connected. + + This driver uses an overlay to load other drivers to support for + LAN966x internal components. + Even if this driver does not depend on these other drivers, in order + to have a fully functional board, the following drivers are needed: + - fixed-clock (COMMON_CLK) + - lan966x-oic (LAN966X_OIC) + - lan966x-cpu-syscon (MFD_SYSCON) + - lan966x-switch-reset (RESET_MCHP_SPARX5) + - lan966x-pinctrl (PINCTRL_OCELOT) + - lan966x-serdes (PHY_LAN966X_SERDES) + - lan966x-miim (MDIO_MSCC_MIIM) + - lan966x-switch (LAN966X_SWITCH) + config MFD_ATMEL_HLCDC tristate "Atmel HLCDC (High-end LCD Controller)" select MFD_CORE diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index c66f07edcd0e..165a9674ff48 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -284,3 +284,7 @@ rsmu-i2c-objs := rsmu_core.o rsmu_i2c.o rsmu-spi-objs := rsmu_core.o rsmu_spi.o obj-$(CONFIG_MFD_RSMU_I2C) += rsmu-i2c.o obj-$(CONFIG_MFD_RSMU_SPI) += rsmu-spi.o + +lan966x-pci-objs := lan966x_pci.o +lan966x-pci-objs += lan966x_pci.dtbo.o +obj-$(CONFIG_MFD_LAN966X_PCI) += lan966x-pci.o diff --git a/drivers/mfd/lan966x_pci.c b/drivers/mfd/lan966x_pci.c new file mode 100644 index 000000000000..a0a59860928f --- /dev/null +++ b/drivers/mfd/lan966x_pci.c @@ -0,0 +1,229 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Microchip LAN966x PCI driver + * + * Copyright (c) 2024 Microchip Technology Inc. and its subsidiaries. + * + * Authors: + * Clément Léger + * Hervé Codina + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* Embedded dtbo symbols created by cmd_wrap_S_dtb in scripts/Makefile.lib */ +extern char __dtbo_lan966x_pci_begin[]; +extern char __dtbo_lan966x_pci_end[]; + +struct pci_dev_intr_ctrl { + struct pci_dev *pci_dev; + struct irq_domain *irq_domain; + int irq; +}; + +static int pci_dev_irq_domain_map(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw) +{ + irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq); + return 0; +} + +static const struct irq_domain_ops pci_dev_irq_domain_ops = { + .map = pci_dev_irq_domain_map, + .xlate = irq_domain_xlate_onecell, +}; + +static irqreturn_t pci_dev_irq_handler(int irq, void *data) +{ + struct pci_dev_intr_ctrl *intr_ctrl = data; + int ret; + + ret = generic_handle_domain_irq(intr_ctrl->irq_domain, 0); + return ret ? IRQ_NONE : IRQ_HANDLED; +} + +static struct pci_dev_intr_ctrl *pci_dev_create_intr_ctrl(struct pci_dev *pdev) +{ + struct pci_dev_intr_ctrl *intr_ctrl; + struct fwnode_handle *fwnode; + int ret; + + if (!pdev->irq) + return ERR_PTR(-EOPNOTSUPP); + + fwnode = dev_fwnode(&pdev->dev); + if (!fwnode) + return ERR_PTR(-ENODEV); + + intr_ctrl = kmalloc(sizeof(*intr_ctrl), GFP_KERNEL); + if (!intr_ctrl) + return ERR_PTR(-ENOMEM); + + intr_ctrl->pci_dev = pdev; + + intr_ctrl->irq_domain = irq_domain_create_linear(fwnode, 1, &pci_dev_irq_domain_ops, + intr_ctrl); + if (!intr_ctrl->irq_domain) { + pci_err(pdev, "Failed to create irqdomain\n"); + ret = -ENOMEM; + goto err_free_intr_ctrl; + } + + ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_INTX); + if (ret < 0) { + pci_err(pdev, "Unable alloc irq vector (%d)\n", ret); + goto err_remove_domain; + } + intr_ctrl->irq = pci_irq_vector(pdev, 0); + ret = request_irq(intr_ctrl->irq, pci_dev_irq_handler, IRQF_SHARED, + dev_name(&pdev->dev), intr_ctrl); + if (ret) { + pci_err(pdev, "Unable to request irq %d (%d)\n", intr_ctrl->irq, ret); + goto err_free_irq_vector; + } + + return intr_ctrl; + +err_free_irq_vector: + pci_free_irq_vectors(pdev); +err_remove_domain: + irq_domain_remove(intr_ctrl->irq_domain); +err_free_intr_ctrl: + kfree(intr_ctrl); + return ERR_PTR(ret); +} + +static void pci_dev_remove_intr_ctrl(struct pci_dev_intr_ctrl *intr_ctrl) +{ + free_irq(intr_ctrl->irq, intr_ctrl); + pci_free_irq_vectors(intr_ctrl->pci_dev); + irq_dispose_mapping(irq_find_mapping(intr_ctrl->irq_domain, 0)); + irq_domain_remove(intr_ctrl->irq_domain); + kfree(intr_ctrl); +} + +static void devm_pci_dev_remove_intr_ctrl(void *data) +{ + struct pci_dev_intr_ctrl *intr_ctrl = data; + + pci_dev_remove_intr_ctrl(intr_ctrl); +} + +static int devm_pci_dev_create_intr_ctrl(struct pci_dev *pdev) +{ + struct pci_dev_intr_ctrl *intr_ctrl; + + intr_ctrl = pci_dev_create_intr_ctrl(pdev); + + if (IS_ERR(intr_ctrl)) + return PTR_ERR(intr_ctrl); + + return devm_add_action_or_reset(&pdev->dev, devm_pci_dev_remove_intr_ctrl, intr_ctrl); +} + +struct lan966x_pci { + struct device *dev; + struct pci_dev *pci_dev; + int ovcs_id; +}; + +static int lan966x_pci_load_overlay(struct lan966x_pci *data) +{ + u32 dtbo_size = __dtbo_lan966x_pci_end - __dtbo_lan966x_pci_begin; + void *dtbo_start = __dtbo_lan966x_pci_begin; + int ret; + + ret = of_overlay_fdt_apply(dtbo_start, dtbo_size, &data->ovcs_id, data->dev->of_node); + if (ret) + return ret; + + return 0; +} + +static void lan966x_pci_unload_overlay(struct lan966x_pci *data) +{ + of_overlay_remove(&data->ovcs_id); +} + +static int lan966x_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) +{ + struct device *dev = &pdev->dev; + struct lan966x_pci *data; + int ret; + + if (!dev->of_node) { + dev_err(dev, "Missing of_node for device\n"); + return -EINVAL; + } + + /* Need to be done before devm_pci_dev_create_intr_ctrl. + * It allocates an IRQ and so pdev->irq is updated + */ + ret = pcim_enable_device(pdev); + if (ret) + return ret; + + ret = devm_pci_dev_create_intr_ctrl(pdev); + if (ret) + return ret; + + data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + dev_set_drvdata(dev, data); + data->dev = dev; + data->pci_dev = pdev; + + ret = lan966x_pci_load_overlay(data); + if (ret) + return ret; + + pci_set_master(pdev); + + ret = of_platform_default_populate(dev->of_node, NULL, dev); + if (ret) + goto err_unload_overlay; + + return 0; + +err_unload_overlay: + lan966x_pci_unload_overlay(data); + return ret; +} + +static void lan966x_pci_remove(struct pci_dev *pdev) +{ + struct device *dev = &pdev->dev; + struct lan966x_pci *data = dev_get_drvdata(dev); + + of_platform_depopulate(dev); + + lan966x_pci_unload_overlay(data); + + pci_clear_master(pdev); +} + +static struct pci_device_id lan966x_pci_ids[] = { + { PCI_DEVICE(0x1055, 0x9660) }, + { 0, } +}; +MODULE_DEVICE_TABLE(pci, lan966x_pci_ids); + +static struct pci_driver lan966x_pci_driver = { + .name = "mchp_lan966x_pci", + .id_table = lan966x_pci_ids, + .probe = lan966x_pci_probe, + .remove = lan966x_pci_remove, +}; +module_pci_driver(lan966x_pci_driver); + +MODULE_AUTHOR("Herve Codina "); +MODULE_DESCRIPTION("Microchip LAN966x PCI driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/mfd/lan966x_pci.dtso b/drivers/mfd/lan966x_pci.dtso new file mode 100644 index 000000000000..041f4319e4cd --- /dev/null +++ b/drivers/mfd/lan966x_pci.dtso @@ -0,0 +1,167 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2022 Microchip UNG + */ + +#include +#include +#include +#include +#include + +/dts-v1/; +/plugin/; + +/ { + fragment@0 { + target-path=""; + __overlay__ { + #address-cells = <3>; + #size-cells = <2>; + + pci-ep-bus@0 { + compatible = "simple-bus"; + #address-cells = <1>; + #size-cells = <1>; + + /* + * map @0xe2000000 (32MB) to BAR0 (CPU) + * map @0xe0000000 (16MB) to BAR1 (AMBA) + */ + ranges = <0xe2000000 0x00 0x00 0x00 0x2000000 + 0xe0000000 0x01 0x00 0x00 0x1000000>; + + oic: oic@e00c0120 { + compatible = "microchip,lan966x-oic"; + #interrupt-cells = <2>; + interrupt-controller; + interrupts = <0>; /* PCI INTx assigned interrupt */ + reg = <0xe00c0120 0x190>; + }; + + cpu_clk: cpu_clk { + compatible = "fixed-clock"; + #clock-cells = <0>; + clock-frequency = <600000000>; // CPU clock = 600MHz + }; + + ddr_clk: ddr_clk { + compatible = "fixed-clock"; + #clock-cells = <0>; + clock-frequency = <30000000>; // Fabric clock = 30MHz + }; + + sys_clk: sys_clk { + compatible = "fixed-clock"; + #clock-cells = <0>; + clock-frequency = <15625000>; // System clock = 15.625MHz + }; + + cpu_ctrl: syscon@e00c0000 { + compatible = "microchip,lan966x-cpu-syscon", "syscon"; + reg = <0xe00c0000 0xa8>; + }; + + reset: reset@e200400c { + compatible = "microchip,lan966x-switch-reset"; + reg = <0xe200400c 0x4>; + reg-names = "gcb"; + #reset-cells = <1>; + cpu-syscon = <&cpu_ctrl>; + }; + + gpio: pinctrl@e2004064 { + compatible = "microchip,lan966x-pinctrl"; + reg = <0xe2004064 0xb4>, + <0xe2010024 0x138>; + resets = <&reset 0>; + reset-names = "switch"; + gpio-controller; + #gpio-cells = <2>; + gpio-ranges = <&gpio 0 0 78>; + interrupt-parent = <&oic>; + interrupt-controller; + interrupts = <17 IRQ_TYPE_LEVEL_HIGH>; + #interrupt-cells = <2>; + + tod_pins: tod_pins { + pins = "GPIO_36"; + function = "ptpsync_1"; + }; + + fc0_a_pins: fcb4-i2c-pins { + /* RXD, TXD */ + pins = "GPIO_9", "GPIO_10"; + function = "fc0_a"; + }; + + }; + + serdes: serdes@e202c000 { + compatible = "microchip,lan966x-serdes"; + reg = <0xe202c000 0x9c>, + <0xe2004010 0x4>; + #phy-cells = <2>; + }; + + mdio1: mdio@e200413c { + #address-cells = <1>; + #size-cells = <0>; + compatible = "microchip,lan966x-miim"; + reg = <0xe200413c 0x24>, + <0xe2010020 0x4>; + + resets = <&reset 0>; + reset-names = "switch"; + + lan966x_phy0: ethernet-lan966x_phy@1 { + reg = <1>; + }; + + lan966x_phy1: ethernet-lan966x_phy@2 { + reg = <2>; + }; + }; + + switch: switch@e0000000 { + compatible = "microchip,lan966x-switch"; + reg = <0xe0000000 0x0100000>, + <0xe2000000 0x0800000>; + reg-names = "cpu", "gcb"; + + interrupt-parent = <&oic>; + interrupts = <12 IRQ_TYPE_LEVEL_HIGH>, + <9 IRQ_TYPE_LEVEL_HIGH>; + interrupt-names = "xtr", "ana"; + + resets = <&reset 0>; + reset-names = "switch"; + + pinctrl-names = "default"; + pinctrl-0 = <&tod_pins>; + + ethernet-ports { + #address-cells = <1>; + #size-cells = <0>; + + port0: port@0 { + phy-handle = <&lan966x_phy0>; + + reg = <0>; + phy-mode = "gmii"; + phys = <&serdes 0 CU(0)>; + }; + + port1: port@1 { + phy-handle = <&lan966x_phy1>; + + reg = <1>; + phy-mode = "gmii"; + phys = <&serdes 1 CU(1)>; + }; + }; + }; + }; + }; + }; +}; diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c index 568410e64ce6..4bfc3f2aafa4 100644 --- a/drivers/pci/quirks.c +++ b/drivers/pci/quirks.c @@ -6241,6 +6241,7 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0xa76e, dpc_log_size); DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_XILINX, 0x5020, of_pci_make_dev_node); DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_XILINX, 0x5021, of_pci_make_dev_node); DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_REDHAT, 0x0005, of_pci_make_dev_node); +DECLARE_PCI_FIXUP_FINAL(0x1055, 0x9660, of_pci_make_dev_node); /* * Devices known to require a longer delay before first config space access -- 2.45.0 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 949E8C25B78 for ; Mon, 27 May 2024 16:17: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=+hKgcJemXYHA1tSB4Je45DuwZIm1PZy4mL5bJw2lYLI=; b=z2+7uRfwW9+KOo vN+7A6VvoKvtbVSGZSwyUWOEiotBkLjRtmsMUWfG5nLu1xN54ruIimtMnUhhVzvWmeBLMQwZAhL4F +HHCp1/S2PY/kvNoGVoNxsSszM8NLncSl/fN3e05X6iS6HZ4GF+4yZxkjWKx/OxqXeeUZWqD2/DSi LlapKq8y9DqayO8xfDT3fBAPSfSd7hHVkI6TnfFYY4kJQam0XSbtWsc9bQ1EAnDSYylSUlxyNLGlQ hc8RD0Wc5rCrvQdywCeRxyazhw06xeF4l1Q905qmcULeIN9sR2QxFFq2fTJWKcj6ml2nY4SWtbgRi 75uQ5WMwL6tU5LdvDhZw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1sBd23-0000000FnpT-1usx; Mon, 27 May 2024 16:17:07 +0000 Received: from relay9-d.mail.gandi.net ([217.70.183.199]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1sBd0W-0000000FmmP-3ztt for linux-arm-kernel@lists.infradead.org; Mon, 27 May 2024 16:15:46 +0000 Received: by mail.gandi.net (Postfix) with ESMTPA id 87468FF811; Mon, 27 May 2024 16:15:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1716826531; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=yjNRz52stJ36/fH3SVMIz99NWadg59zYIFnqd5Fj4vI=; b=FVd9+tfQCt5RQz7cTho3a1Qtlf8iQNcx6ZTpm3nYzdLTTkfx7BXvTN4UTyyW9pBxUS6mIJ aBdp0pu83BDNa8CX1Zz9p/Mqr8i1ZwyDfRRILqXe7ENqCVIKAa9Yr9oYxUTH1kzzkfMwu1 K4YjDelnXbwVar6sqgWVsBSoC8HUwSmugJm+dxObtLUXPWkwSbYLIzfkFGZ1Apyr1LWxVM B4b0oOUgSOjVaz1r7s2kivdToCuvkRvoxe6TsfnHgfvu4JwpOSouIo0/AWWaT3Al5aRTsk AAQ8SVLmx5qhmDRVAnkRQJsBZjOihFTfyyoZjqm1+MqPIZs6QcFu1NmC1ZdCJA== From: Herve Codina To: Simon Horman , Sai Krishna Gajula , Herve Codina , Thomas Gleixner , Rob Herring , Krzysztof Kozlowski , Conor Dooley , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Lee Jones , Arnd Bergmann , Horatiu Vultur , UNGLinuxDriver@microchip.com, Andrew Lunn , Heiner Kallweit , Russell King , Saravana Kannan , Bjorn Helgaas , Philipp Zabel , Lars Povlsen , Steen Hegelund , Daniel Machon , Alexandre Belloni Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, netdev@vger.kernel.org, linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Allan Nielsen , Steen Hegelund , Luca Ceresoli , Thomas Petazzoni Subject: [PATCH v2 18/19] mfd: Add support for LAN966x PCI device Date: Mon, 27 May 2024 18:14:45 +0200 Message-ID: <20240527161450.326615-19-herve.codina@bootlin.com> X-Mailer: git-send-email 2.45.0 In-Reply-To: <20240527161450.326615-1-herve.codina@bootlin.com> References: <20240527161450.326615-1-herve.codina@bootlin.com> MIME-Version: 1.0 X-GND-Sasl: herve.codina@bootlin.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240527_091533_612132_ED7C6D7A X-CRM114-Status: GOOD ( 32.38 ) 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 QWRkIGEgUENJIGRyaXZlciB0aGF0IGhhbmRsZXMgdGhlIExBTjk2NnggUENJIGRldmljZSB1c2lu ZyBhIGRldmljZS10cmVlCm92ZXJsYXkuIFRoaXMgb3ZlcmxheSBpcyBhcHBsaWVkIHRvIHRoZSBQ Q0kgZGV2aWNlIERUIG5vZGUgYW5kIGFsbG93cyB0bwpkZXNjcmliZSBjb21wb25lbnRzIHRoYXQg YXJlIHByZXNlbnQgaW4gdGhlIGRldmljZS4KClRoZSBtZW1vcnkgZnJvbSB0aGUgZGV2aWNlLXRy ZWUgaXMgcmVtYXBwZWQgdG8gdGhlIEJBUiBtZW1vcnkgdGhhbmtzIHRvCiJyYW5nZXMiIHByb3Bl cnRpZXMgY29tcHV0ZWQgYXQgcnVudGltZSBieSB0aGUgUENJIGNvcmUgZHVyaW5nIHRoZSBQQ0kK ZW51bWVyYXRpb24uClRoZSBQQ0kgZGV2aWNlIGl0c2VsZiBhY3RzIGFzIGFuIGludGVycnVwdCBj b250cm9sbGVyIGFuZCBpcyB1c2VkIGFzIHRoZQpwYXJlbnQgb2YgdGhlIGludGVybmFsIExBTjk2 NnggaW50ZXJydXB0IGNvbnRyb2xsZXIgdG8gcm91dGUgdGhlCmludGVycnVwdHMgdG8gdGhlIGFz c2lnbmVkIFBDSSBJTlR4IGludGVycnVwdC4KClNpZ25lZC1vZmYtYnk6IEhlcnZlIENvZGluYSA8 aGVydmUuY29kaW5hQGJvb3RsaW4uY29tPgotLS0KIGRyaXZlcnMvbWZkL0tjb25maWcgICAgICAg ICAgfCAgMjQgKysrKwogZHJpdmVycy9tZmQvTWFrZWZpbGUgICAgICAgICB8ICAgNCArCiBkcml2 ZXJzL21mZC9sYW45NjZ4X3BjaS5jICAgIHwgMjI5ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrCiBkcml2ZXJzL21mZC9sYW45NjZ4X3BjaS5kdHNvIHwgMTY3ICsrKysrKysrKysr KysrKysrKysrKysrKysKIGRyaXZlcnMvcGNpL3F1aXJrcy5jICAgICAgICAgfCAgIDEgKwogNSBm aWxlcyBjaGFuZ2VkLCA0MjUgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvbWZkL2xhbjk2NnhfcGNpLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21mZC9sYW45 NjZ4X3BjaS5kdHNvCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvS2NvbmZpZyBiL2RyaXZlcnMv bWZkL0tjb25maWcKaW5kZXggMjY2YjRmNTRhZjYwLi4xNWRiMTQ0YmMwOWIgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvbWZkL0tjb25maWcKKysrIGIvZHJpdmVycy9tZmQvS2NvbmZpZwpAQCAtMTQ0LDYg KzE0NCwzMCBAQCBjb25maWcgTUZEX0FUTUVMX0ZMRVhDT00KIAkgIGJ5IHRoZSBwcm9iZSBmdW5j dGlvbiBvZiB0aGlzIE1GRCBkcml2ZXIgYWNjb3JkaW5nIHRvIGEgZGV2aWNlIHRyZWUKIAkgIHBy b3BlcnR5LgogCitjb25maWcgTUZEX0xBTjk2NlhfUENJCisJdHJpc3RhdGUgIk1pY3JvY2hpcCBM QU45NjZ4IFBDSWUgU3VwcG9ydCIKKwlkZXBlbmRzIG9uIFBDSQorCXNlbGVjdCBPRgorCXNlbGVj dCBPRl9PVkVSTEFZCisJc2VsZWN0IElSUV9ET01BSU4KKwloZWxwCisJICBUaGlzIGVuYWJsZXMg dGhlIHN1cHBvcnQgZm9yIHRoZSBMQU45NjZ4IFBDSWUgZGV2aWNlLgorCSAgVGhpcyBpcyB1c2Vk IHRvIGRyaXZlIHRoZSBMQU45NjZ4IFBDSWUgZGV2aWNlIGZyb20gdGhlIGhvc3Qgc3lzdGVtCisJ ICB0byB3aGljaCBpdCBpcyBjb25uZWN0ZWQuCisKKwkgIFRoaXMgZHJpdmVyIHVzZXMgYW4gb3Zl cmxheSB0byBsb2FkIG90aGVyIGRyaXZlcnMgdG8gc3VwcG9ydCBmb3IKKwkgIExBTjk2NnggaW50 ZXJuYWwgY29tcG9uZW50cy4KKwkgIEV2ZW4gaWYgdGhpcyBkcml2ZXIgZG9lcyBub3QgZGVwZW5k IG9uIHRoZXNlIG90aGVyIGRyaXZlcnMsIGluIG9yZGVyCisJICB0byBoYXZlIGEgZnVsbHkgZnVu Y3Rpb25hbCBib2FyZCwgdGhlIGZvbGxvd2luZyBkcml2ZXJzIGFyZSBuZWVkZWQ6CisJICAgIC0g Zml4ZWQtY2xvY2sgKENPTU1PTl9DTEspCisJICAgIC0gbGFuOTY2eC1vaWMgKExBTjk2NlhfT0lD KQorCSAgICAtIGxhbjk2NngtY3B1LXN5c2NvbiAoTUZEX1NZU0NPTikKKwkgICAgLSBsYW45NjZ4 LXN3aXRjaC1yZXNldCAoUkVTRVRfTUNIUF9TUEFSWDUpCisJICAgIC0gbGFuOTY2eC1waW5jdHJs IChQSU5DVFJMX09DRUxPVCkKKwkgICAgLSBsYW45NjZ4LXNlcmRlcyAoUEhZX0xBTjk2NlhfU0VS REVTKQorCSAgICAtIGxhbjk2NngtbWlpbSAoTURJT19NU0NDX01JSU0pCisJICAgIC0gbGFuOTY2 eC1zd2l0Y2ggKExBTjk2NlhfU1dJVENIKQorCiBjb25maWcgTUZEX0FUTUVMX0hMQ0RDCiAJdHJp c3RhdGUgIkF0bWVsIEhMQ0RDIChIaWdoLWVuZCBMQ0QgQ29udHJvbGxlcikiCiAJc2VsZWN0IE1G RF9DT1JFCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9NYWtlZmlsZSBiL2RyaXZlcnMvbWZkL01h a2VmaWxlCmluZGV4IGM2NmYwN2VkY2QwZS4uMTY1YTk2NzRmZjQ4IDEwMDY0NAotLS0gYS9kcml2 ZXJzL21mZC9NYWtlZmlsZQorKysgYi9kcml2ZXJzL21mZC9NYWtlZmlsZQpAQCAtMjg0LDMgKzI4 NCw3IEBAIHJzbXUtaTJjLW9ianMJCQk6PSByc211X2NvcmUubyByc211X2kyYy5vCiByc211LXNw aS1vYmpzCQkJOj0gcnNtdV9jb3JlLm8gcnNtdV9zcGkubwogb2JqLSQoQ09ORklHX01GRF9SU01V X0kyQykJKz0gcnNtdS1pMmMubwogb2JqLSQoQ09ORklHX01GRF9SU01VX1NQSSkJKz0gcnNtdS1z cGkubworCitsYW45NjZ4LXBjaS1vYmpzCQk6PSBsYW45NjZ4X3BjaS5vCitsYW45NjZ4LXBjaS1v YmpzCQkrPSBsYW45NjZ4X3BjaS5kdGJvLm8KK29iai0kKENPTkZJR19NRkRfTEFOOTY2WF9QQ0kp CSs9IGxhbjk2NngtcGNpLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL2xhbjk2NnhfcGNpLmMg Yi9kcml2ZXJzL21mZC9sYW45NjZ4X3BjaS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uYTBhNTk4NjA5MjhmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZmQv bGFuOTY2eF9wY2kuYwpAQCAtMCwwICsxLDIyOSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAKKy8qCisgKiBNaWNyb2NoaXAgTEFOOTY2eCBQQ0kgZHJpdmVyCisgKgorICog Q29weXJpZ2h0IChjKSAyMDI0IE1pY3JvY2hpcCBUZWNobm9sb2d5IEluYy4gYW5kIGl0cyBzdWJz aWRpYXJpZXMuCisgKgorICogQXV0aG9yczoKKyAqCUNsw6ltZW50IEzDqWdlciA8Y2xlbWVudC5s ZWdlckBib290bGluLmNvbT4KKyAqCUhlcnbDqSBDb2RpbmEgPGhlcnZlLmNvZGluYUBib290bGlu LmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGludXgvaXJxLmg+CisjaW5jbHVkZSA8bGludXgvaXJx ZG9tYWluLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9k dWxlLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9wbGF0Zm9y bS5oPgorI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKwor LyogRW1iZWRkZWQgZHRibyBzeW1ib2xzIGNyZWF0ZWQgYnkgY21kX3dyYXBfU19kdGIgaW4gc2Ny aXB0cy9NYWtlZmlsZS5saWIgKi8KK2V4dGVybiBjaGFyIF9fZHRib19sYW45NjZ4X3BjaV9iZWdp bltdOworZXh0ZXJuIGNoYXIgX19kdGJvX2xhbjk2NnhfcGNpX2VuZFtdOworCitzdHJ1Y3QgcGNp X2Rldl9pbnRyX2N0cmwgeworCXN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2OworCXN0cnVjdCBpcnFf ZG9tYWluICppcnFfZG9tYWluOworCWludCBpcnE7Cit9OworCitzdGF0aWMgaW50IHBjaV9kZXZf aXJxX2RvbWFpbl9tYXAoc3RydWN0IGlycV9kb21haW4gKmQsIHVuc2lnbmVkIGludCB2aXJxLCBp cnFfaHdfbnVtYmVyX3QgaHcpCit7CisJaXJxX3NldF9jaGlwX2FuZF9oYW5kbGVyKHZpcnEsICZk dW1teV9pcnFfY2hpcCwgaGFuZGxlX3NpbXBsZV9pcnEpOworCXJldHVybiAwOworfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGlycV9kb21haW5fb3BzIHBjaV9kZXZfaXJxX2RvbWFpbl9vcHMgPSB7 CisJLm1hcCA9IHBjaV9kZXZfaXJxX2RvbWFpbl9tYXAsCisJLnhsYXRlID0gaXJxX2RvbWFpbl94 bGF0ZV9vbmVjZWxsLAorfTsKKworc3RhdGljIGlycXJldHVybl90IHBjaV9kZXZfaXJxX2hhbmRs ZXIoaW50IGlycSwgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgcGNpX2Rldl9pbnRyX2N0cmwgKmlu dHJfY3RybCA9IGRhdGE7CisJaW50IHJldDsKKworCXJldCA9IGdlbmVyaWNfaGFuZGxlX2RvbWFp bl9pcnEoaW50cl9jdHJsLT5pcnFfZG9tYWluLCAwKTsKKwlyZXR1cm4gcmV0ID8gSVJRX05PTkUg OiBJUlFfSEFORExFRDsKK30KKworc3RhdGljIHN0cnVjdCBwY2lfZGV2X2ludHJfY3RybCAqcGNp X2Rldl9jcmVhdGVfaW50cl9jdHJsKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQoreworCXN0cnVjdCBw Y2lfZGV2X2ludHJfY3RybCAqaW50cl9jdHJsOworCXN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25v ZGU7CisJaW50IHJldDsKKworCWlmICghcGRldi0+aXJxKQorCQlyZXR1cm4gRVJSX1BUUigtRU9Q Tk9UU1VQUCk7CisKKwlmd25vZGUgPSBkZXZfZndub2RlKCZwZGV2LT5kZXYpOworCWlmICghZndu b2RlKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKKworCWludHJfY3RybCA9IGttYWxsb2Mo c2l6ZW9mKCppbnRyX2N0cmwpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWludHJfY3RybCkKKwkJcmV0 dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwlpbnRyX2N0cmwtPnBjaV9kZXYgPSBwZGV2OworCisJ aW50cl9jdHJsLT5pcnFfZG9tYWluID0gaXJxX2RvbWFpbl9jcmVhdGVfbGluZWFyKGZ3bm9kZSwg MSwgJnBjaV9kZXZfaXJxX2RvbWFpbl9vcHMsCisJCQkJCQkJIGludHJfY3RybCk7CisJaWYgKCFp bnRyX2N0cmwtPmlycV9kb21haW4pIHsKKwkJcGNpX2VycihwZGV2LCAiRmFpbGVkIHRvIGNyZWF0 ZSBpcnFkb21haW5cbiIpOworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGVycl9mcmVlX2ludHJf Y3RybDsKKwl9CisKKwlyZXQgPSBwY2lfYWxsb2NfaXJxX3ZlY3RvcnMocGRldiwgMSwgMSwgUENJ X0lSUV9JTlRYKTsKKwlpZiAocmV0IDwgMCkgeworCQlwY2lfZXJyKHBkZXYsICJVbmFibGUgYWxs b2MgaXJxIHZlY3RvciAoJWQpXG4iLCByZXQpOworCQlnb3RvIGVycl9yZW1vdmVfZG9tYWluOwor CX0KKwlpbnRyX2N0cmwtPmlycSA9IHBjaV9pcnFfdmVjdG9yKHBkZXYsIDApOworCXJldCA9IHJl cXVlc3RfaXJxKGludHJfY3RybC0+aXJxLCBwY2lfZGV2X2lycV9oYW5kbGVyLCBJUlFGX1NIQVJF RCwKKwkJCSAgZGV2X25hbWUoJnBkZXYtPmRldiksIGludHJfY3RybCk7CisJaWYgKHJldCkgewor CQlwY2lfZXJyKHBkZXYsICJVbmFibGUgdG8gcmVxdWVzdCBpcnEgJWQgKCVkKVxuIiwgaW50cl9j dHJsLT5pcnEsIHJldCk7CisJCWdvdG8gZXJyX2ZyZWVfaXJxX3ZlY3RvcjsKKwl9CisKKwlyZXR1 cm4gaW50cl9jdHJsOworCitlcnJfZnJlZV9pcnFfdmVjdG9yOgorCXBjaV9mcmVlX2lycV92ZWN0 b3JzKHBkZXYpOworZXJyX3JlbW92ZV9kb21haW46CisJaXJxX2RvbWFpbl9yZW1vdmUoaW50cl9j dHJsLT5pcnFfZG9tYWluKTsKK2Vycl9mcmVlX2ludHJfY3RybDoKKwlrZnJlZShpbnRyX2N0cmwp OworCXJldHVybiBFUlJfUFRSKHJldCk7Cit9CisKK3N0YXRpYyB2b2lkIHBjaV9kZXZfcmVtb3Zl X2ludHJfY3RybChzdHJ1Y3QgcGNpX2Rldl9pbnRyX2N0cmwgKmludHJfY3RybCkKK3sKKwlmcmVl X2lycShpbnRyX2N0cmwtPmlycSwgaW50cl9jdHJsKTsKKwlwY2lfZnJlZV9pcnFfdmVjdG9ycyhp bnRyX2N0cmwtPnBjaV9kZXYpOworCWlycV9kaXNwb3NlX21hcHBpbmcoaXJxX2ZpbmRfbWFwcGlu ZyhpbnRyX2N0cmwtPmlycV9kb21haW4sIDApKTsKKwlpcnFfZG9tYWluX3JlbW92ZShpbnRyX2N0 cmwtPmlycV9kb21haW4pOworCWtmcmVlKGludHJfY3RybCk7Cit9CisKK3N0YXRpYyB2b2lkIGRl dm1fcGNpX2Rldl9yZW1vdmVfaW50cl9jdHJsKHZvaWQgKmRhdGEpCit7CisJc3RydWN0IHBjaV9k ZXZfaW50cl9jdHJsICppbnRyX2N0cmwgPSBkYXRhOworCisJcGNpX2Rldl9yZW1vdmVfaW50cl9j dHJsKGludHJfY3RybCk7Cit9CisKK3N0YXRpYyBpbnQgZGV2bV9wY2lfZGV2X2NyZWF0ZV9pbnRy X2N0cmwoc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7CisJc3RydWN0IHBjaV9kZXZfaW50cl9jdHJs ICppbnRyX2N0cmw7CisKKwlpbnRyX2N0cmwgPSBwY2lfZGV2X2NyZWF0ZV9pbnRyX2N0cmwocGRl dik7CisKKwlpZiAoSVNfRVJSKGludHJfY3RybCkpCisJCXJldHVybiBQVFJfRVJSKGludHJfY3Ry bCk7CisKKwlyZXR1cm4gZGV2bV9hZGRfYWN0aW9uX29yX3Jlc2V0KCZwZGV2LT5kZXYsIGRldm1f cGNpX2Rldl9yZW1vdmVfaW50cl9jdHJsLCBpbnRyX2N0cmwpOworfQorCitzdHJ1Y3QgbGFuOTY2 eF9wY2kgeworCXN0cnVjdCBkZXZpY2UgKmRldjsKKwlzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldjsK KwlpbnQgb3Zjc19pZDsKK307CisKK3N0YXRpYyBpbnQgbGFuOTY2eF9wY2lfbG9hZF9vdmVybGF5 KHN0cnVjdCBsYW45NjZ4X3BjaSAqZGF0YSkKK3sKKwl1MzIgZHRib19zaXplID0gX19kdGJvX2xh bjk2NnhfcGNpX2VuZCAtIF9fZHRib19sYW45NjZ4X3BjaV9iZWdpbjsKKwl2b2lkICpkdGJvX3N0 YXJ0ID0gX19kdGJvX2xhbjk2NnhfcGNpX2JlZ2luOworCWludCByZXQ7CisKKwlyZXQgPSBvZl9v dmVybGF5X2ZkdF9hcHBseShkdGJvX3N0YXJ0LCBkdGJvX3NpemUsICZkYXRhLT5vdmNzX2lkLCBk YXRhLT5kZXYtPm9mX25vZGUpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIHZvaWQgbGFuOTY2eF9wY2lfdW5sb2FkX292ZXJsYXkoc3RydWN0IGxh bjk2NnhfcGNpICpkYXRhKQoreworCW9mX292ZXJsYXlfcmVtb3ZlKCZkYXRhLT5vdmNzX2lkKTsK K30KKworc3RhdGljIGludCBsYW45NjZ4X3BjaV9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwg Y29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQoreworCXN0cnVjdCBkZXZpY2UgKmRldiA9 ICZwZGV2LT5kZXY7CisJc3RydWN0IGxhbjk2NnhfcGNpICpkYXRhOworCWludCByZXQ7CisKKwlp ZiAoIWRldi0+b2Zfbm9kZSkgeworCQlkZXZfZXJyKGRldiwgIk1pc3Npbmcgb2Zfbm9kZSBmb3Ig ZGV2aWNlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJLyogTmVlZCB0byBiZSBkb25l IGJlZm9yZSBkZXZtX3BjaV9kZXZfY3JlYXRlX2ludHJfY3RybC4KKwkgKiBJdCBhbGxvY2F0ZXMg YW4gSVJRIGFuZCBzbyBwZGV2LT5pcnEgaXMgdXBkYXRlZAorCSAqLworCXJldCA9IHBjaW1fZW5h YmxlX2RldmljZShwZGV2KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJcmV0ID0gZGV2 bV9wY2lfZGV2X2NyZWF0ZV9pbnRyX2N0cmwocGRldik7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJl dDsKKworCWRhdGEgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmRhdGEpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIWRhdGEpCisJCXJldHVybiAtRU5PTUVNOworCisJZGV2X3NldF9kcnZkYXRhKGRl diwgZGF0YSk7CisJZGF0YS0+ZGV2ID0gZGV2OworCWRhdGEtPnBjaV9kZXYgPSBwZGV2OworCisJ cmV0ID0gbGFuOTY2eF9wY2lfbG9hZF9vdmVybGF5KGRhdGEpOworCWlmIChyZXQpCisJCXJldHVy biByZXQ7CisKKwlwY2lfc2V0X21hc3RlcihwZGV2KTsKKworCXJldCA9IG9mX3BsYXRmb3JtX2Rl ZmF1bHRfcG9wdWxhdGUoZGV2LT5vZl9ub2RlLCBOVUxMLCBkZXYpOworCWlmIChyZXQpCisJCWdv dG8gZXJyX3VubG9hZF9vdmVybGF5OworCisJcmV0dXJuIDA7CisKK2Vycl91bmxvYWRfb3Zlcmxh eToKKwlsYW45NjZ4X3BjaV91bmxvYWRfb3ZlcmxheShkYXRhKTsKKwlyZXR1cm4gcmV0OworfQor CitzdGF0aWMgdm9pZCBsYW45NjZ4X3BjaV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7 CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3QgbGFuOTY2eF9wY2kg KmRhdGEgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKKworCW9mX3BsYXRmb3JtX2RlcG9wdWxhdGUo ZGV2KTsKKworCWxhbjk2NnhfcGNpX3VubG9hZF9vdmVybGF5KGRhdGEpOworCisJcGNpX2NsZWFy X21hc3RlcihwZGV2KTsKK30KKworc3RhdGljIHN0cnVjdCBwY2lfZGV2aWNlX2lkIGxhbjk2Nnhf cGNpX2lkc1tdID0geworCXsgUENJX0RFVklDRSgweDEwNTUsIDB4OTY2MCkgfSwKKwl7IDAsIH0K K307CitNT0RVTEVfREVWSUNFX1RBQkxFKHBjaSwgbGFuOTY2eF9wY2lfaWRzKTsKKworc3RhdGlj IHN0cnVjdCBwY2lfZHJpdmVyIGxhbjk2NnhfcGNpX2RyaXZlciA9IHsKKwkubmFtZSA9ICJtY2hw X2xhbjk2NnhfcGNpIiwKKwkuaWRfdGFibGUgPSBsYW45NjZ4X3BjaV9pZHMsCisJLnByb2JlID0g bGFuOTY2eF9wY2lfcHJvYmUsCisJLnJlbW92ZSA9IGxhbjk2NnhfcGNpX3JlbW92ZSwKK307Citt b2R1bGVfcGNpX2RyaXZlcihsYW45NjZ4X3BjaV9kcml2ZXIpOworCitNT0RVTEVfQVVUSE9SKCJI ZXJ2ZSBDb2RpbmEgPGhlcnZlLmNvZGluYUBib290bGluLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQ VElPTigiTWljcm9jaGlwIExBTjk2NnggUENJIGRyaXZlciIpOworTU9EVUxFX0xJQ0VOU0UoIkdQ TCIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvbGFuOTY2eF9wY2kuZHRzbyBiL2RyaXZlcnMv bWZkL2xhbjk2NnhfcGNpLmR0c28KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi4wNDFmNDMxOWU0Y2QKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL21mZC9sYW45NjZ4 X3BjaS5kdHNvCkBAIC0wLDAgKzEsMTY3IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMiBNaWNyb2NoaXAgVU5HCisgKi8KKwor I2luY2x1ZGUgPGR0LWJpbmRpbmdzL2Nsb2NrL21pY3JvY2hpcCxsYW45NjZ4Lmg+CisjaW5jbHVk ZSA8ZHQtYmluZGluZ3MvaW50ZXJydXB0LWNvbnRyb2xsZXIvaXJxLmg+CisjaW5jbHVkZSA8ZHQt YmluZGluZ3MvbWZkL2F0bWVsLWZsZXhjb20uaD4KKyNpbmNsdWRlIDxkdC1iaW5kaW5ncy9waHkv cGh5LWxhbjk2Nngtc2VyZGVzLmg+CisjaW5jbHVkZSA8ZHQtYmluZGluZ3MvZ3Bpby9ncGlvLmg+ CisKKy9kdHMtdjEvOworL3BsdWdpbi87CisKKy8geworCWZyYWdtZW50QDAgeworCQl0YXJnZXQt cGF0aD0iIjsKKwkJX19vdmVybGF5X18geworCQkJI2FkZHJlc3MtY2VsbHMgPSA8Mz47CisJCQkj c2l6ZS1jZWxscyA9IDwyPjsKKworCQkJcGNpLWVwLWJ1c0AwIHsKKwkJCQljb21wYXRpYmxlID0g InNpbXBsZS1idXMiOworCQkJCSNhZGRyZXNzLWNlbGxzID0gPDE+OworCQkJCSNzaXplLWNlbGxz ID0gPDE+OworCisJCQkJLyoKKwkJCQkgKiBtYXAgQDB4ZTIwMDAwMDAgKDMyTUIpIHRvIEJBUjAg KENQVSkKKwkJCQkgKiBtYXAgQDB4ZTAwMDAwMDAgKDE2TUIpIHRvIEJBUjEgKEFNQkEpCisJCQkJ ICovCisJCQkJcmFuZ2VzID0gPDB4ZTIwMDAwMDAgMHgwMCAweDAwIDB4MDAgMHgyMDAwMDAwCisJ CQkJICAgICAgICAgIDB4ZTAwMDAwMDAgMHgwMSAweDAwIDB4MDAgMHgxMDAwMDAwPjsKKworCQkJ CW9pYzogb2ljQGUwMGMwMTIwIHsKKwkJCQkJY29tcGF0aWJsZSA9ICJtaWNyb2NoaXAsbGFuOTY2 eC1vaWMiOworCQkJCQkjaW50ZXJydXB0LWNlbGxzID0gPDI+OworCQkJCQlpbnRlcnJ1cHQtY29u dHJvbGxlcjsKKwkJCQkJaW50ZXJydXB0cyA9IDwwPjsgLyogUENJIElOVHggYXNzaWduZWQgaW50 ZXJydXB0ICovCisJCQkJCXJlZyA9IDwweGUwMGMwMTIwIDB4MTkwPjsKKwkJCQl9OworCisJCQkJ Y3B1X2NsazogY3B1X2NsayB7CisJCQkJCWNvbXBhdGlibGUgPSAiZml4ZWQtY2xvY2siOworCQkJ CQkjY2xvY2stY2VsbHMgPSA8MD47CisJCQkJCWNsb2NrLWZyZXF1ZW5jeSA9IDw2MDAwMDAwMDA+ OyAgLy8gQ1BVIGNsb2NrID0gNjAwTUh6CisJCQkJfTsKKworCQkJCWRkcl9jbGs6IGRkcl9jbGsg eworCQkJCQljb21wYXRpYmxlID0gImZpeGVkLWNsb2NrIjsKKwkJCQkJI2Nsb2NrLWNlbGxzID0g PDA+OworCQkJCQljbG9jay1mcmVxdWVuY3kgPSA8MzAwMDAwMDA+OyAgLy8gRmFicmljIGNsb2Nr ID0gMzBNSHoKKwkJCQl9OworCisJCQkJc3lzX2Nsazogc3lzX2NsayB7CisJCQkJCWNvbXBhdGli bGUgPSAiZml4ZWQtY2xvY2siOworCQkJCQkjY2xvY2stY2VsbHMgPSA8MD47CisJCQkJCWNsb2Nr LWZyZXF1ZW5jeSA9IDwxNTYyNTAwMD47ICAvLyBTeXN0ZW0gY2xvY2sgPSAxNS42MjVNSHoKKwkJ CQl9OworCisJCQkJY3B1X2N0cmw6IHN5c2NvbkBlMDBjMDAwMCB7CisJCQkJCWNvbXBhdGlibGUg PSAibWljcm9jaGlwLGxhbjk2NngtY3B1LXN5c2NvbiIsICJzeXNjb24iOworCQkJCQlyZWcgPSA8 MHhlMDBjMDAwMCAweGE4PjsKKwkJCQl9OworCisJCQkJcmVzZXQ6IHJlc2V0QGUyMDA0MDBjIHsK KwkJCQkJY29tcGF0aWJsZSA9ICJtaWNyb2NoaXAsbGFuOTY2eC1zd2l0Y2gtcmVzZXQiOworCQkJ CQlyZWcgPSA8MHhlMjAwNDAwYyAweDQ+OworCQkJCQlyZWctbmFtZXMgPSAiZ2NiIjsKKwkJCQkJ I3Jlc2V0LWNlbGxzID0gPDE+OworCQkJCQljcHUtc3lzY29uID0gPCZjcHVfY3RybD47CisJCQkJ fTsKKworCQkJCWdwaW86IHBpbmN0cmxAZTIwMDQwNjQgeworCQkJCQljb21wYXRpYmxlID0gIm1p Y3JvY2hpcCxsYW45NjZ4LXBpbmN0cmwiOworCQkJCQlyZWcgPSA8MHhlMjAwNDA2NCAweGI0PiwK KwkJCQkJICAgICAgPDB4ZTIwMTAwMjQgMHgxMzg+OworCQkJCQlyZXNldHMgPSA8JnJlc2V0IDA+ OworCQkJCQlyZXNldC1uYW1lcyA9ICJzd2l0Y2giOworCQkJCQlncGlvLWNvbnRyb2xsZXI7CisJ CQkJCSNncGlvLWNlbGxzID0gPDI+OworCQkJCQlncGlvLXJhbmdlcyA9IDwmZ3BpbyAwIDAgNzg+ OworCQkJCQlpbnRlcnJ1cHQtcGFyZW50ID0gPCZvaWM+OworCQkJCQlpbnRlcnJ1cHQtY29udHJv bGxlcjsKKwkJCQkJaW50ZXJydXB0cyA9IDwxNyBJUlFfVFlQRV9MRVZFTF9ISUdIPjsKKwkJCQkJ I2ludGVycnVwdC1jZWxscyA9IDwyPjsKKworCQkJCQl0b2RfcGluczogdG9kX3BpbnMgeworCQkJ CQkJcGlucyA9ICJHUElPXzM2IjsKKwkJCQkJCWZ1bmN0aW9uID0gInB0cHN5bmNfMSI7CisJCQkJ CX07CisKKwkJCQkJZmMwX2FfcGluczogZmNiNC1pMmMtcGlucyB7CisJCQkJCQkvKiBSWEQsIFRY RCAqLworCQkJCQkJcGlucyA9ICJHUElPXzkiLCAiR1BJT18xMCI7CisJCQkJCQlmdW5jdGlvbiA9 ICJmYzBfYSI7CisJCQkJCX07CisKKwkJCQl9OworCisJCQkJc2VyZGVzOiBzZXJkZXNAZTIwMmMw MDAgeworCQkJCQljb21wYXRpYmxlID0gIm1pY3JvY2hpcCxsYW45NjZ4LXNlcmRlcyI7CisJCQkJ CXJlZyA9IDwweGUyMDJjMDAwIDB4OWM+LAorCQkJCQkgICAgICA8MHhlMjAwNDAxMCAweDQ+Owor CQkJCQkjcGh5LWNlbGxzID0gPDI+OworCQkJCX07CisKKwkJCQltZGlvMTogbWRpb0BlMjAwNDEz YyB7CisJCQkJCSNhZGRyZXNzLWNlbGxzID0gPDE+OworCQkJCQkjc2l6ZS1jZWxscyA9IDwwPjsK KwkJCQkJY29tcGF0aWJsZSA9ICJtaWNyb2NoaXAsbGFuOTY2eC1taWltIjsKKwkJCQkJcmVnID0g PDB4ZTIwMDQxM2MgMHgyND4sCisJCQkJCSAgICAgIDwweGUyMDEwMDIwIDB4ND47CisKKwkJCQkJ cmVzZXRzID0gPCZyZXNldCAwPjsKKwkJCQkJcmVzZXQtbmFtZXMgPSAic3dpdGNoIjsKKworCQkJ CQlsYW45NjZ4X3BoeTA6IGV0aGVybmV0LWxhbjk2NnhfcGh5QDEgeworCQkJCQkJcmVnID0gPDE+ OworCQkJCQl9OworCisJCQkJCWxhbjk2NnhfcGh5MTogZXRoZXJuZXQtbGFuOTY2eF9waHlAMiB7 CisJCQkJCQlyZWcgPSA8Mj47CisJCQkJCX07CisJCQkJfTsKKworCQkJCXN3aXRjaDogc3dpdGNo QGUwMDAwMDAwIHsKKwkJCQkJY29tcGF0aWJsZSA9ICJtaWNyb2NoaXAsbGFuOTY2eC1zd2l0Y2gi OworCQkJCQlyZWcgPSA8MHhlMDAwMDAwMCAweDAxMDAwMDA+LAorCQkJCQkgICAgICA8MHhlMjAw MDAwMCAweDA4MDAwMDA+OworCQkJCQlyZWctbmFtZXMgPSAiY3B1IiwgImdjYiI7CisKKwkJCQkJ aW50ZXJydXB0LXBhcmVudCA9IDwmb2ljPjsKKwkJCQkJaW50ZXJydXB0cyA9IDwxMiBJUlFfVFlQ RV9MRVZFTF9ISUdIPiwKKwkJCQkJCSAgICAgPDkgSVJRX1RZUEVfTEVWRUxfSElHSD47CisJCQkJ CWludGVycnVwdC1uYW1lcyA9ICJ4dHIiLCAiYW5hIjsKKworCQkJCQlyZXNldHMgPSA8JnJlc2V0 IDA+OworCQkJCQlyZXNldC1uYW1lcyA9ICJzd2l0Y2giOworCisJCQkJCXBpbmN0cmwtbmFtZXMg PSAiZGVmYXVsdCI7CisJCQkJCXBpbmN0cmwtMCA9IDwmdG9kX3BpbnM+OworCisJCQkJCWV0aGVy bmV0LXBvcnRzIHsKKwkJCQkJCSNhZGRyZXNzLWNlbGxzID0gPDE+OworCQkJCQkJI3NpemUtY2Vs bHMgPSA8MD47CisKKwkJCQkJCXBvcnQwOiBwb3J0QDAgeworCQkJCQkJCXBoeS1oYW5kbGUgPSA8 Jmxhbjk2NnhfcGh5MD47CisKKwkJCQkJCQlyZWcgPSA8MD47CisJCQkJCQkJcGh5LW1vZGUgPSAi Z21paSI7CisJCQkJCQkJcGh5cyA9IDwmc2VyZGVzIDAgQ1UoMCk+OworCQkJCQkJfTsKKworCQkJ CQkJcG9ydDE6IHBvcnRAMSB7CisJCQkJCQkJcGh5LWhhbmRsZSA9IDwmbGFuOTY2eF9waHkxPjsK KworCQkJCQkJCXJlZyA9IDwxPjsKKwkJCQkJCQlwaHktbW9kZSA9ICJnbWlpIjsKKwkJCQkJCQlw aHlzID0gPCZzZXJkZXMgMSBDVSgxKT47CisJCQkJCQl9OworCQkJCQl9OworCQkJCX07CisJCQl9 OworCQl9OworCX07Cit9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcXVpcmtzLmMgYi9kcml2 ZXJzL3BjaS9xdWlya3MuYwppbmRleCA1Njg0MTBlNjRjZTYuLjRiZmMzZjJhYWZhNCAxMDA2NDQK LS0tIGEvZHJpdmVycy9wY2kvcXVpcmtzLmMKKysrIGIvZHJpdmVycy9wY2kvcXVpcmtzLmMKQEAg LTYyNDEsNiArNjI0MSw3IEBAIERFQ0xBUkVfUENJX0ZJWFVQX0hFQURFUihQQ0lfVkVORE9SX0lE X0lOVEVMLCAweGE3NmUsIGRwY19sb2dfc2l6ZSk7CiBERUNMQVJFX1BDSV9GSVhVUF9GSU5BTChQ Q0lfVkVORE9SX0lEX1hJTElOWCwgMHg1MDIwLCBvZl9wY2lfbWFrZV9kZXZfbm9kZSk7CiBERUNM QVJFX1BDSV9GSVhVUF9GSU5BTChQQ0lfVkVORE9SX0lEX1hJTElOWCwgMHg1MDIxLCBvZl9wY2lf bWFrZV9kZXZfbm9kZSk7CiBERUNMQVJFX1BDSV9GSVhVUF9GSU5BTChQQ0lfVkVORE9SX0lEX1JF REhBVCwgMHgwMDA1LCBvZl9wY2lfbWFrZV9kZXZfbm9kZSk7CitERUNMQVJFX1BDSV9GSVhVUF9G SU5BTCgweDEwNTUsIDB4OTY2MCwgb2ZfcGNpX21ha2VfZGV2X25vZGUpOwogCiAvKgogICogRGV2 aWNlcyBrbm93biB0byByZXF1aXJlIGEgbG9uZ2VyIGRlbGF5IGJlZm9yZSBmaXJzdCBjb25maWcg c3BhY2UgYWNjZXNzCi0tIAoyLjQ1LjAKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0t a2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFp bG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==