From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) (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 B7E4A1C0DC7; Tue, 30 Apr 2024 08:39:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.200 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1714466379; cv=none; b=YwHa1slgbI40Unkz9RVrkPM1+C+FDrNXGq/kJnhk5K4tvpf5DyyXyy7UrmG3evdxBOUsU0bDB9rqQxh8q9yTC5hYXBSD72TJn5+Cuy+bx0Y5iBgi8kRu+SV4x7RIm8LEieBGtg84iXkDoaBM6B10OFhYK+9OtvqykyIF/cl0hR4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1714466379; c=relaxed/simple; bh=nliaHWA/NMStS5UotZ7BKISP29iSI3mDU9pVVa55xuI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=kjcjTxXrtAyeohkIiayN/9uB/GYsUKhnccoXMQVI78HHldef0aTQDATebYQ3klUBSLGVZ5aA4yNErw94DCawpWAUCZVC5tCEXDHGB5x5cOe6PY8gO6nu9BdZvgC74zASQcIrlddaR2jx2rkRARWfYzriUqewDH6d/nFmWbpPQzY= 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=Ysu7qESt; arc=none smtp.client-ip=217.70.183.200 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="Ysu7qESt" Received: by mail.gandi.net (Postfix) with ESMTPA id CA7AC2000B; Tue, 30 Apr 2024 08:39:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1714466375; 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=1x6u+GMy96SLnvHnPDRb/JeS/VQcZwMT1qoZIOF3XQc=; b=Ysu7qEStKewqPlfDKZxeb4N/jgwYmmGV23M+nB1ssvvXEtpld6bg0vA+QtO27Wg21aV2kI ndlDkh2GU7qiEFqM5oL8iDq/OWcIwvP1CikwguzY9+pb8ewrumTcdw9ryr7eRqYNOqKwT0 iFiaupFzyYk0He0UThVMkWQsk3hYRmFo02yrvUkz28w3mbUnAu3BJKi5Bf8jE+m2AFegVC oiyPIR4xmhmtjIBXsXRmQYTXYTb+E1ryajRVJml+HHNVA/dCW7Q8Gn4B9xHx/Oufipv7Ba pksW2xIiJ9cg8ytIia9f1zFyfLDjcvY2PWr2YFqvn/fjdJI/+vxC/0I0DSxXYA== From: Herve Codina To: 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 16/17] mfd: Add support for LAN966x PCI device Date: Tue, 30 Apr 2024 10:37:25 +0200 Message-ID: <20240430083730.134918-17-herve.codina@bootlin.com> X-Mailer: git-send-email 2.44.0 In-Reply-To: <20240430083730.134918-1-herve.codina@bootlin.com> References: <20240430083730.134918-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 4b023ee229cf..e5f5d2986dd3 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..d9d886a1948f --- /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_LEGACY); + 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 eff7f5df08e2..9933f245b781 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.44.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 C3696C19F53 for ; Tue, 30 Apr 2024 11:00:49 +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=aKOQY/VEFnwoCRQ+kV1m5d5XV+PLyTTyiISdwCr+vzM=; b=SHn94oJ2+5jjOR 1FLatpiJQaBpFs73lFlwt9CEBvNhLU7Mv5mLj2O6EnpfI6Rb24BpaeZj+p1yzYZy4V3madhf1vBje NdJ6AiF/URwJs4Kaa6peHbAq5Ww9boWuwA9zAdNHfFeRmuGWwaAznTqy8T7d8LqwVY1Yf+eOb5fgc jDzYE+OqWefpO4sBea2/jyVoxeKKnnIPzI6r0WggktoGC81STEQhBDQ2jjVLvQTQH4bN417jZWpJu xhcJvgB0XfGXRcj2dqpVDsM2sU/KJRs85H+YceMYrzpVTwmWNsCO0+WtNUxroolFUsH81yXsDxLjW OLr3fIqKAi10S5727OVQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1s1lDw-000000066Wi-20oB; Tue, 30 Apr 2024 11:00:36 +0000 Received: from relay7-d.mail.gandi.net ([2001:4b98:dc4:8::227]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1s1j1V-00000005dYY-0UPO for linux-arm-kernel@lists.infradead.org; Tue, 30 Apr 2024 08:39:45 +0000 Received: by mail.gandi.net (Postfix) with ESMTPA id CA7AC2000B; Tue, 30 Apr 2024 08:39:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1714466375; 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=1x6u+GMy96SLnvHnPDRb/JeS/VQcZwMT1qoZIOF3XQc=; b=Ysu7qEStKewqPlfDKZxeb4N/jgwYmmGV23M+nB1ssvvXEtpld6bg0vA+QtO27Wg21aV2kI ndlDkh2GU7qiEFqM5oL8iDq/OWcIwvP1CikwguzY9+pb8ewrumTcdw9ryr7eRqYNOqKwT0 iFiaupFzyYk0He0UThVMkWQsk3hYRmFo02yrvUkz28w3mbUnAu3BJKi5Bf8jE+m2AFegVC oiyPIR4xmhmtjIBXsXRmQYTXYTb+E1ryajRVJml+HHNVA/dCW7Q8Gn4B9xHx/Oufipv7Ba pksW2xIiJ9cg8ytIia9f1zFyfLDjcvY2PWr2YFqvn/fjdJI/+vxC/0I0DSxXYA== From: Herve Codina To: 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 16/17] mfd: Add support for LAN966x PCI device Date: Tue, 30 Apr 2024 10:37:25 +0200 Message-ID: <20240430083730.134918-17-herve.codina@bootlin.com> X-Mailer: git-send-email 2.44.0 In-Reply-To: <20240430083730.134918-1-herve.codina@bootlin.com> References: <20240430083730.134918-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-20240430_013937_745054_F09DE51E X-CRM114-Status: GOOD ( 31.95 ) 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 bWZkL0tjb25maWcKaW5kZXggNGIwMjNlZTIyOWNmLi5lNWY1ZDI5ODZkZDMgMTAwNjQ0Ci0tLSBh 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 MDAwMDAwMDAwMC4uZDlkODg2YTE5NDhmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZmQv 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 X0lSUV9MRUdBQ1kpOworCWlmIChyZXQgPCAwKSB7CisJCXBjaV9lcnIocGRldiwgIlVuYWJsZSBh bGxvYyBpcnEgdmVjdG9yICglZClcbiIsIHJldCk7CisJCWdvdG8gZXJyX3JlbW92ZV9kb21haW47 CisJfQorCWludHJfY3RybC0+aXJxID0gcGNpX2lycV92ZWN0b3IocGRldiwgMCk7CisJcmV0ID0g cmVxdWVzdF9pcnEoaW50cl9jdHJsLT5pcnEsIHBjaV9kZXZfaXJxX2hhbmRsZXIsIElSUUZfU0hB UkVELAorCQkJICBkZXZfbmFtZSgmcGRldi0+ZGV2KSwgaW50cl9jdHJsKTsKKwlpZiAocmV0KSB7 CisJCXBjaV9lcnIocGRldiwgIlVuYWJsZSB0byByZXF1ZXN0IGlycSAlZCAoJWQpXG4iLCBpbnRy X2N0cmwtPmlycSwgcmV0KTsKKwkJZ290byBlcnJfZnJlZV9pcnFfdmVjdG9yOworCX0KKworCXJl dHVybiBpbnRyX2N0cmw7CisKK2Vycl9mcmVlX2lycV92ZWN0b3I6CisJcGNpX2ZyZWVfaXJxX3Zl Y3RvcnMocGRldik7CitlcnJfcmVtb3ZlX2RvbWFpbjoKKwlpcnFfZG9tYWluX3JlbW92ZShpbnRy X2N0cmwtPmlycV9kb21haW4pOworZXJyX2ZyZWVfaW50cl9jdHJsOgorCWtmcmVlKGludHJfY3Ry bCk7CisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKworc3RhdGljIHZvaWQgcGNpX2Rldl9yZW1v dmVfaW50cl9jdHJsKHN0cnVjdCBwY2lfZGV2X2ludHJfY3RybCAqaW50cl9jdHJsKQoreworCWZy ZWVfaXJxKGludHJfY3RybC0+aXJxLCBpbnRyX2N0cmwpOworCXBjaV9mcmVlX2lycV92ZWN0b3Jz KGludHJfY3RybC0+cGNpX2Rldik7CisJaXJxX2Rpc3Bvc2VfbWFwcGluZyhpcnFfZmluZF9tYXBw aW5nKGludHJfY3RybC0+aXJxX2RvbWFpbiwgMCkpOworCWlycV9kb21haW5fcmVtb3ZlKGludHJf Y3RybC0+aXJxX2RvbWFpbik7CisJa2ZyZWUoaW50cl9jdHJsKTsKK30KKworc3RhdGljIHZvaWQg ZGV2bV9wY2lfZGV2X3JlbW92ZV9pbnRyX2N0cmwodm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgcGNp X2Rldl9pbnRyX2N0cmwgKmludHJfY3RybCA9IGRhdGE7CisKKwlwY2lfZGV2X3JlbW92ZV9pbnRy X2N0cmwoaW50cl9jdHJsKTsKK30KKworc3RhdGljIGludCBkZXZtX3BjaV9kZXZfY3JlYXRlX2lu dHJfY3RybChzdHJ1Y3QgcGNpX2RldiAqcGRldikKK3sKKwlzdHJ1Y3QgcGNpX2Rldl9pbnRyX2N0 cmwgKmludHJfY3RybDsKKworCWludHJfY3RybCA9IHBjaV9kZXZfY3JlYXRlX2ludHJfY3RybChw ZGV2KTsKKworCWlmIChJU19FUlIoaW50cl9jdHJsKSkKKwkJcmV0dXJuIFBUUl9FUlIoaW50cl9j dHJsKTsKKworCXJldHVybiBkZXZtX2FkZF9hY3Rpb25fb3JfcmVzZXQoJnBkZXYtPmRldiwgZGV2 bV9wY2lfZGV2X3JlbW92ZV9pbnRyX2N0cmwsIGludHJfY3RybCk7Cit9CisKK3N0cnVjdCBsYW45 NjZ4X3BjaSB7CisJc3RydWN0IGRldmljZSAqZGV2OworCXN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2 OworCWludCBvdmNzX2lkOworfTsKKworc3RhdGljIGludCBsYW45NjZ4X3BjaV9sb2FkX292ZXJs YXkoc3RydWN0IGxhbjk2NnhfcGNpICpkYXRhKQoreworCXUzMiBkdGJvX3NpemUgPSBfX2R0Ym9f bGFuOTY2eF9wY2lfZW5kIC0gX19kdGJvX2xhbjk2NnhfcGNpX2JlZ2luOworCXZvaWQgKmR0Ym9f c3RhcnQgPSBfX2R0Ym9fbGFuOTY2eF9wY2lfYmVnaW47CisJaW50IHJldDsKKworCXJldCA9IG9m X292ZXJsYXlfZmR0X2FwcGx5KGR0Ym9fc3RhcnQsIGR0Ym9fc2l6ZSwgJmRhdGEtPm92Y3NfaWQs IGRhdGEtPmRldi0+b2Zfbm9kZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVy biAwOworfQorCitzdGF0aWMgdm9pZCBsYW45NjZ4X3BjaV91bmxvYWRfb3ZlcmxheShzdHJ1Y3Qg bGFuOTY2eF9wY2kgKmRhdGEpCit7CisJb2Zfb3ZlcmxheV9yZW1vdmUoJmRhdGEtPm92Y3NfaWQp OworfQorCitzdGF0aWMgaW50IGxhbjk2NnhfcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2 LCBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQpCit7CisJc3RydWN0IGRldmljZSAqZGV2 ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3QgbGFuOTY2eF9wY2kgKmRhdGE7CisJaW50IHJldDsKKwor CWlmICghZGV2LT5vZl9ub2RlKSB7CisJCWRldl9lcnIoZGV2LCAiTWlzc2luZyBvZl9ub2RlIGZv ciBkZXZpY2VcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBOZWVkIHRvIGJlIGRv bmUgYmVmb3JlIGRldm1fcGNpX2Rldl9jcmVhdGVfaW50cl9jdHJsLgorCSAqIEl0IGFsbG9jYXRl cyBhbiBJUlEgYW5kIHNvIHBkZXYtPmlycSBpcyB1cGRhdGVkCisJICovCisJcmV0ID0gcGNpbV9l bmFibGVfZGV2aWNlKHBkZXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBk ZXZtX3BjaV9kZXZfY3JlYXRlX2ludHJfY3RybChwZGV2KTsKKwlpZiAocmV0KQorCQlyZXR1cm4g cmV0OworCisJZGF0YSA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqZGF0YSksIEdGUF9LRVJO RUwpOworCWlmICghZGF0YSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlkZXZfc2V0X2RydmRhdGEo ZGV2LCBkYXRhKTsKKwlkYXRhLT5kZXYgPSBkZXY7CisJZGF0YS0+cGNpX2RldiA9IHBkZXY7CisK KwlyZXQgPSBsYW45NjZ4X3BjaV9sb2FkX292ZXJsYXkoZGF0YSk7CisJaWYgKHJldCkKKwkJcmV0 dXJuIHJldDsKKworCXBjaV9zZXRfbWFzdGVyKHBkZXYpOworCisJcmV0ID0gb2ZfcGxhdGZvcm1f ZGVmYXVsdF9wb3B1bGF0ZShkZXYtPm9mX25vZGUsIE5VTEwsIGRldik7CisJaWYgKHJldCkKKwkJ Z290byBlcnJfdW5sb2FkX292ZXJsYXk7CisKKwlyZXR1cm4gMDsKKworZXJyX3VubG9hZF9vdmVy bGF5OgorCWxhbjk2NnhfcGNpX3VubG9hZF9vdmVybGF5KGRhdGEpOworCXJldHVybiByZXQ7Cit9 CisKK3N0YXRpYyB2b2lkIGxhbjk2NnhfcGNpX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqcGRldikK K3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCBsYW45NjZ4X3Bj aSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCisJb2ZfcGxhdGZvcm1fZGVwb3B1bGF0 ZShkZXYpOworCisJbGFuOTY2eF9wY2lfdW5sb2FkX292ZXJsYXkoZGF0YSk7CisKKwlwY2lfY2xl YXJfbWFzdGVyKHBkZXYpOworfQorCitzdGF0aWMgc3RydWN0IHBjaV9kZXZpY2VfaWQgbGFuOTY2 eF9wY2lfaWRzW10gPSB7CisJeyBQQ0lfREVWSUNFKDB4MTA1NSwgMHg5NjYwKSB9LAorCXsgMCwg fQorfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBsYW45NjZ4X3BjaV9pZHMpOworCitzdGF0 aWMgc3RydWN0IHBjaV9kcml2ZXIgbGFuOTY2eF9wY2lfZHJpdmVyID0geworCS5uYW1lID0gIm1j aHBfbGFuOTY2eF9wY2kiLAorCS5pZF90YWJsZSA9IGxhbjk2NnhfcGNpX2lkcywKKwkucHJvYmUg PSBsYW45NjZ4X3BjaV9wcm9iZSwKKwkucmVtb3ZlID0gbGFuOTY2eF9wY2lfcmVtb3ZlLAorfTsK K21vZHVsZV9wY2lfZHJpdmVyKGxhbjk2NnhfcGNpX2RyaXZlcik7CisKK01PRFVMRV9BVVRIT1Io IkhlcnZlIENvZGluYSA8aGVydmUuY29kaW5hQGJvb3RsaW4uY29tPiIpOworTU9EVUxFX0RFU0NS SVBUSU9OKCJNaWNyb2NoaXAgTEFOOTY2eCBQQ0kgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgi R1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9sYW45NjZ4X3BjaS5kdHNvIGIvZHJpdmVy cy9tZmQvbGFuOTY2eF9wY2kuZHRzbwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLjA0MWY0MzE5ZTRjZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbWZkL2xhbjk2 NnhfcGNpLmR0c28KQEAgLTAsMCArMSwxNjcgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wCisvKgorICogQ29weXJpZ2h0IChDKSAyMDIyIE1pY3JvY2hpcCBVTkcKKyAqLwor CisjaW5jbHVkZSA8ZHQtYmluZGluZ3MvY2xvY2svbWljcm9jaGlwLGxhbjk2NnguaD4KKyNpbmNs dWRlIDxkdC1iaW5kaW5ncy9pbnRlcnJ1cHQtY29udHJvbGxlci9pcnEuaD4KKyNpbmNsdWRlIDxk dC1iaW5kaW5ncy9tZmQvYXRtZWwtZmxleGNvbS5oPgorI2luY2x1ZGUgPGR0LWJpbmRpbmdzL3Bo eS9waHktbGFuOTY2eC1zZXJkZXMuaD4KKyNpbmNsdWRlIDxkdC1iaW5kaW5ncy9ncGlvL2dwaW8u aD4KKworL2R0cy12MS87CisvcGx1Z2luLzsKKworLyB7CisJZnJhZ21lbnRAMCB7CisJCXRhcmdl dC1wYXRoPSIiOworCQlfX292ZXJsYXlfXyB7CisJCQkjYWRkcmVzcy1jZWxscyA9IDwzPjsKKwkJ CSNzaXplLWNlbGxzID0gPDI+OworCisJCQlwY2ktZXAtYnVzQDAgeworCQkJCWNvbXBhdGlibGUg PSAic2ltcGxlLWJ1cyI7CisJCQkJI2FkZHJlc3MtY2VsbHMgPSA8MT47CisJCQkJI3NpemUtY2Vs bHMgPSA8MT47CisKKwkJCQkvKgorCQkJCSAqIG1hcCBAMHhlMjAwMDAwMCAoMzJNQikgdG8gQkFS MCAoQ1BVKQorCQkJCSAqIG1hcCBAMHhlMDAwMDAwMCAoMTZNQikgdG8gQkFSMSAoQU1CQSkKKwkJ CQkgKi8KKwkJCQlyYW5nZXMgPSA8MHhlMjAwMDAwMCAweDAwIDB4MDAgMHgwMCAweDIwMDAwMDAK KwkJCQkgICAgICAgICAgMHhlMDAwMDAwMCAweDAxIDB4MDAgMHgwMCAweDEwMDAwMDA+OworCisJ CQkJb2ljOiBvaWNAZTAwYzAxMjAgeworCQkJCQljb21wYXRpYmxlID0gIm1pY3JvY2hpcCxsYW45 NjZ4LW9pYyI7CisJCQkJCSNpbnRlcnJ1cHQtY2VsbHMgPSA8Mj47CisJCQkJCWludGVycnVwdC1j b250cm9sbGVyOworCQkJCQlpbnRlcnJ1cHRzID0gPDA+OyAvKiBQQ0kgSU5UeCBhc3NpZ25lZCBp bnRlcnJ1cHQgKi8KKwkJCQkJcmVnID0gPDB4ZTAwYzAxMjAgMHgxOTA+OworCQkJCX07CisKKwkJ CQljcHVfY2xrOiBjcHVfY2xrIHsKKwkJCQkJY29tcGF0aWJsZSA9ICJmaXhlZC1jbG9jayI7CisJ CQkJCSNjbG9jay1jZWxscyA9IDwwPjsKKwkJCQkJY2xvY2stZnJlcXVlbmN5ID0gPDYwMDAwMDAw MD47ICAvLyBDUFUgY2xvY2sgPSA2MDBNSHoKKwkJCQl9OworCisJCQkJZGRyX2NsazogZGRyX2Ns ayB7CisJCQkJCWNvbXBhdGlibGUgPSAiZml4ZWQtY2xvY2siOworCQkJCQkjY2xvY2stY2VsbHMg PSA8MD47CisJCQkJCWNsb2NrLWZyZXF1ZW5jeSA9IDwzMDAwMDAwMD47ICAvLyBGYWJyaWMgY2xv Y2sgPSAzME1IegorCQkJCX07CisKKwkJCQlzeXNfY2xrOiBzeXNfY2xrIHsKKwkJCQkJY29tcGF0 aWJsZSA9ICJmaXhlZC1jbG9jayI7CisJCQkJCSNjbG9jay1jZWxscyA9IDwwPjsKKwkJCQkJY2xv Y2stZnJlcXVlbmN5ID0gPDE1NjI1MDAwPjsgIC8vIFN5c3RlbSBjbG9jayA9IDE1LjYyNU1Iegor CQkJCX07CisKKwkJCQljcHVfY3RybDogc3lzY29uQGUwMGMwMDAwIHsKKwkJCQkJY29tcGF0aWJs ZSA9ICJtaWNyb2NoaXAsbGFuOTY2eC1jcHUtc3lzY29uIiwgInN5c2NvbiI7CisJCQkJCXJlZyA9 IDwweGUwMGMwMDAwIDB4YTg+OworCQkJCX07CisKKwkJCQlyZXNldDogcmVzZXRAZTIwMDQwMGMg eworCQkJCQljb21wYXRpYmxlID0gIm1pY3JvY2hpcCxsYW45NjZ4LXN3aXRjaC1yZXNldCI7CisJ CQkJCXJlZyA9IDwweGUyMDA0MDBjIDB4ND47CisJCQkJCXJlZy1uYW1lcyA9ICJnY2IiOworCQkJ CQkjcmVzZXQtY2VsbHMgPSA8MT47CisJCQkJCWNwdS1zeXNjb24gPSA8JmNwdV9jdHJsPjsKKwkJ CQl9OworCisJCQkJZ3BpbzogcGluY3RybEBlMjAwNDA2NCB7CisJCQkJCWNvbXBhdGlibGUgPSAi bWljcm9jaGlwLGxhbjk2NngtcGluY3RybCI7CisJCQkJCXJlZyA9IDwweGUyMDA0MDY0IDB4YjQ+ LAorCQkJCQkgICAgICA8MHhlMjAxMDAyNCAweDEzOD47CisJCQkJCXJlc2V0cyA9IDwmcmVzZXQg MD47CisJCQkJCXJlc2V0LW5hbWVzID0gInN3aXRjaCI7CisJCQkJCWdwaW8tY29udHJvbGxlcjsK KwkJCQkJI2dwaW8tY2VsbHMgPSA8Mj47CisJCQkJCWdwaW8tcmFuZ2VzID0gPCZncGlvIDAgMCA3 OD47CisJCQkJCWludGVycnVwdC1wYXJlbnQgPSA8Jm9pYz47CisJCQkJCWludGVycnVwdC1jb250 cm9sbGVyOworCQkJCQlpbnRlcnJ1cHRzID0gPDE3IElSUV9UWVBFX0xFVkVMX0hJR0g+OworCQkJ CQkjaW50ZXJydXB0LWNlbGxzID0gPDI+OworCisJCQkJCXRvZF9waW5zOiB0b2RfcGlucyB7CisJ CQkJCQlwaW5zID0gIkdQSU9fMzYiOworCQkJCQkJZnVuY3Rpb24gPSAicHRwc3luY18xIjsKKwkJ CQkJfTsKKworCQkJCQlmYzBfYV9waW5zOiBmY2I0LWkyYy1waW5zIHsKKwkJCQkJCS8qIFJYRCwg VFhEICovCisJCQkJCQlwaW5zID0gIkdQSU9fOSIsICJHUElPXzEwIjsKKwkJCQkJCWZ1bmN0aW9u ID0gImZjMF9hIjsKKwkJCQkJfTsKKworCQkJCX07CisKKwkJCQlzZXJkZXM6IHNlcmRlc0BlMjAy YzAwMCB7CisJCQkJCWNvbXBhdGlibGUgPSAibWljcm9jaGlwLGxhbjk2Nngtc2VyZGVzIjsKKwkJ CQkJcmVnID0gPDB4ZTIwMmMwMDAgMHg5Yz4sCisJCQkJCSAgICAgIDwweGUyMDA0MDEwIDB4ND47 CisJCQkJCSNwaHktY2VsbHMgPSA8Mj47CisJCQkJfTsKKworCQkJCW1kaW8xOiBtZGlvQGUyMDA0 MTNjIHsKKwkJCQkJI2FkZHJlc3MtY2VsbHMgPSA8MT47CisJCQkJCSNzaXplLWNlbGxzID0gPDA+ OworCQkJCQljb21wYXRpYmxlID0gIm1pY3JvY2hpcCxsYW45NjZ4LW1paW0iOworCQkJCQlyZWcg PSA8MHhlMjAwNDEzYyAweDI0PiwKKwkJCQkJICAgICAgPDB4ZTIwMTAwMjAgMHg0PjsKKworCQkJ CQlyZXNldHMgPSA8JnJlc2V0IDA+OworCQkJCQlyZXNldC1uYW1lcyA9ICJzd2l0Y2giOworCisJ CQkJCWxhbjk2NnhfcGh5MDogZXRoZXJuZXQtbGFuOTY2eF9waHlAMSB7CisJCQkJCQlyZWcgPSA8 MT47CisJCQkJCX07CisKKwkJCQkJbGFuOTY2eF9waHkxOiBldGhlcm5ldC1sYW45NjZ4X3BoeUAy IHsKKwkJCQkJCXJlZyA9IDwyPjsKKwkJCQkJfTsKKwkJCQl9OworCisJCQkJc3dpdGNoOiBzd2l0 Y2hAZTAwMDAwMDAgeworCQkJCQljb21wYXRpYmxlID0gIm1pY3JvY2hpcCxsYW45NjZ4LXN3aXRj aCI7CisJCQkJCXJlZyA9IDwweGUwMDAwMDAwIDB4MDEwMDAwMD4sCisJCQkJCSAgICAgIDwweGUy MDAwMDAwIDB4MDgwMDAwMD47CisJCQkJCXJlZy1uYW1lcyA9ICJjcHUiLCAiZ2NiIjsKKworCQkJ CQlpbnRlcnJ1cHQtcGFyZW50ID0gPCZvaWM+OworCQkJCQlpbnRlcnJ1cHRzID0gPDEyIElSUV9U WVBFX0xFVkVMX0hJR0g+LAorCQkJCQkJICAgICA8OSBJUlFfVFlQRV9MRVZFTF9ISUdIPjsKKwkJ CQkJaW50ZXJydXB0LW5hbWVzID0gInh0ciIsICJhbmEiOworCisJCQkJCXJlc2V0cyA9IDwmcmVz ZXQgMD47CisJCQkJCXJlc2V0LW5hbWVzID0gInN3aXRjaCI7CisKKwkJCQkJcGluY3RybC1uYW1l cyA9ICJkZWZhdWx0IjsKKwkJCQkJcGluY3RybC0wID0gPCZ0b2RfcGlucz47CisKKwkJCQkJZXRo ZXJuZXQtcG9ydHMgeworCQkJCQkJI2FkZHJlc3MtY2VsbHMgPSA8MT47CisJCQkJCQkjc2l6ZS1j ZWxscyA9IDwwPjsKKworCQkJCQkJcG9ydDA6IHBvcnRAMCB7CisJCQkJCQkJcGh5LWhhbmRsZSA9 IDwmbGFuOTY2eF9waHkwPjsKKworCQkJCQkJCXJlZyA9IDwwPjsKKwkJCQkJCQlwaHktbW9kZSA9 ICJnbWlpIjsKKwkJCQkJCQlwaHlzID0gPCZzZXJkZXMgMCBDVSgwKT47CisJCQkJCQl9OworCisJ CQkJCQlwb3J0MTogcG9ydEAxIHsKKwkJCQkJCQlwaHktaGFuZGxlID0gPCZsYW45NjZ4X3BoeTE+ OworCisJCQkJCQkJcmVnID0gPDE+OworCQkJCQkJCXBoeS1tb2RlID0gImdtaWkiOworCQkJCQkJ CXBoeXMgPSA8JnNlcmRlcyAxIENVKDEpPjsKKwkJCQkJCX07CisJCQkJCX07CisJCQkJfTsKKwkJ CX07CisJCX07CisJfTsKK307CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9xdWlya3MuYyBiL2Ry aXZlcnMvcGNpL3F1aXJrcy5jCmluZGV4IGVmZjdmNWRmMDhlMi4uOTkzM2YyNDViNzgxIDEwMDY0 NAotLS0gYS9kcml2ZXJzL3BjaS9xdWlya3MuYworKysgYi9kcml2ZXJzL3BjaS9xdWlya3MuYwpA QCAtNjI0MSw2ICs2MjQxLDcgQEAgREVDTEFSRV9QQ0lfRklYVVBfSEVBREVSKFBDSV9WRU5ET1Jf SURfSU5URUwsIDB4YTc2ZSwgZHBjX2xvZ19zaXplKTsKIERFQ0xBUkVfUENJX0ZJWFVQX0ZJTkFM KFBDSV9WRU5ET1JfSURfWElMSU5YLCAweDUwMjAsIG9mX3BjaV9tYWtlX2Rldl9ub2RlKTsKIERF Q0xBUkVfUENJX0ZJWFVQX0ZJTkFMKFBDSV9WRU5ET1JfSURfWElMSU5YLCAweDUwMjEsIG9mX3Bj aV9tYWtlX2Rldl9ub2RlKTsKIERFQ0xBUkVfUENJX0ZJWFVQX0ZJTkFMKFBDSV9WRU5ET1JfSURf UkVESEFULCAweDAwMDUsIG9mX3BjaV9tYWtlX2Rldl9ub2RlKTsKK0RFQ0xBUkVfUENJX0ZJWFVQ X0ZJTkFMKDB4MTA1NSwgMHg5NjYwLCBvZl9wY2lfbWFrZV9kZXZfbm9kZSk7CiAKIC8qCiAgKiBE ZXZpY2VzIGtub3duIHRvIHJlcXVpcmUgYSBsb25nZXIgZGVsYXkgYmVmb3JlIGZpcnN0IGNvbmZp ZyBzcGFjZSBhY2Nlc3MKLS0gCjIuNDQuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFy bS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK