21 files changed, 940 insertions, 79 deletions

diff --git a/Documentation/devicetree/bindings/pci/amlogic,meson-pcie.txt b/Documentation/devicetree/bindings/pci/amlogic,meson-pcie.txt
new file mode 100644
index 000000000000..12b18f82d441
--- /dev/null
+++ b/Documentation/devicetree/bindings/pci/amlogic,meson-pcie.txt
@@ -0,0 +1,70 @@
+Amlogic Meson AXG DWC PCIE SoC controller
+
+Amlogic Meson PCIe host controller is based on the Synopsys DesignWare PCI core.
+It shares common functions with the PCIe DesignWare core driver and
+inherits common properties defined in
+Documentation/devicetree/bindings/pci/designware-pci.txt.
+
+Additional properties are described here:
+
+Required properties:
+- compatible:
+        should contain "amlogic,axg-pcie" to identify the core.
+- reg:
+        should contain the configuration address space.
+- reg-names: Must be
+        - "elbi"        External local bus interface registers
+        - "cfg"         Meson specific registers
+        - "phy"         Meson PCIE PHY registers
+        - "config"      PCIe configuration space
+- reset-gpios: The GPIO to generate PCIe PERST# assert and deassert signal.
+- clocks: Must contain an entry for each entry in clock-names.
+- clock-names: Must include the following entries:
+        - "pclk"       PCIe GEN 100M PLL clock
+        - "port"       PCIe_x(A or B) RC clock gate
+        - "general"    PCIe Phy clock
+        - "mipi"       PCIe_x(A or B) 100M ref clock gate
+- resets: phandle to the reset lines.
+- reset-names: must contain "phy" "port" and "apb"
+       - "phy"         Share PHY reset
+       - "port"        Port A or B reset
+       - "apb"         Share APB reset
+- device_type:
+        should be "pci". As specified in designware-pcie.txt
+
+
+Example configuration:
+
+        pcie: pcie@f9800000 {
+                        compatible = "amlogic,axg-pcie", "snps,dw-pcie";
+                        reg = <0x0 0xf9800000 0x0 0x400000
+                                        0x0 0xff646000 0x0 0x2000
+                                        0x0 0xff644000 0x0 0x2000
+                                        0x0 0xf9f00000 0x0 0x100000>;
+                        reg-names = "elbi", "cfg", "phy", "config";
+                        reset-gpios = <&gpio GPIOX_19 GPIO_ACTIVE_HIGH>;
+                        interrupts = <GIC_SPI 177 IRQ_TYPE_EDGE_RISING>;
+                        #interrupt-cells = <1>;
+                        interrupt-map-mask = <0 0 0 0>;
+                        interrupt-map = <0 0 0 0 &gic GIC_SPI 179 IRQ_TYPE_EDGE_RISING>;
+                        bus-range = <0x0 0xff>;
+                        #address-cells = <3>;
+                        #size-cells = <2>;
+                        device_type = "pci";
+                        ranges = <0x82000000 0 0 0x0 0xf9c00000 0 0x00300000>;
+
+                        clocks = <&clkc CLKID_USB
+                                        &clkc CLKID_MIPI_ENABLE
+                                        &clkc CLKID_PCIE_A
+                                        &clkc CLKID_PCIE_CML_EN0>;
+                        clock-names = "general",
+                                        "mipi",
+                                        "pclk",
+                                        "port";
+                        resets = <&reset RESET_PCIE_PHY>,
+                                <&reset RESET_PCIE_A>,
+                                <&reset RESET_PCIE_APB>;
+                        reset-names = "phy",
+                                        "port",
+                                        "apb";
+        };
diff --git a/Documentation/driver-api/pci/p2pdma.rst b/Documentation/driver-api/pci/p2pdma.rst
index 4c577fa7bef9..6d85b5a2598d 100644
--- a/Documentation/driver-api/pci/p2pdma.rst
+++ b/Documentation/driver-api/pci/p2pdma.rst
@@ -49,7 +49,7 @@ For example, in the NVMe Target Copy Offload implementation:
   in that it exposes any CMB (Controller Memory Buffer) as a P2P memory
   resource (provider), it accepts P2P memory pages as buffers in requests
   to be used directly (client) and it can also make use of the CMB as
-  submission queue entries (orchastrator).
+  submission queue entries (orchestrator).
 * The RDMA driver is a client in this arrangement so that an RNIC
   can DMA directly to the memory exposed by the NVMe device.
 * The NVMe Target driver (nvmet) can orchestrate the data from the RNIC
@@ -111,7 +111,7 @@ that's compatible with all clients using  :c:func:`pci_p2pmem_find()`.
 If more than one provider is supported, the one nearest to all the clients will
 be chosen first. If more than one provider is an equal distance away, the
 one returned will be chosen at random (it is not an arbitrary but
-truely random). This function returns the PCI device to use for the provider
+truly random). This function returns the PCI device to use for the provider
 with a reference taken and therefore when it's no longer needed it should be
 returned with pci_dev_put().
 
diff --git a/MAINTAINERS b/MAINTAINERS
index 5d7beffe9935..4cdf07c51ef8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -11500,6 +11500,7 @@ F:	include/uapi/linux/pci*
 F:      lib/pci*
 F:      arch/x86/pci/
 F:      arch/x86/kernel/quirks.c
+F:      arch/x86/kernel/early-quirks.c
 
 PCI NATIVE HOST BRIDGE AND ENDPOINT DRIVERS
 M:      Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
@@ -11509,6 +11510,13 @@ T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lpieralisi/pci.git/
 S:      Supported
 F:      drivers/pci/controller/
 
+PCIE DRIVER FOR AMLOGIC MESON
+M:      Yue Wang <yue.wang@Amlogic.com>
+L:      linux-pci@vger.kernel.org
+L:      linux-amlogic@lists.infradead.org
+S:      Maintained
+F:      drivers/pci/controller/dwc/pci-meson.c
+
 PCIE DRIVER FOR AXIS ARTPEC
 M:      Jesper Nilsson <jesper.nilsson@axis.com>
 L:      linux-arm-kernel@axis.com
diff --git a/arch/s390/pci/pci.c b/arch/s390/pci/pci.c
index 9f6f392a4461..4266a4de3160 100644
--- a/arch/s390/pci/pci.c
+++ b/arch/s390/pci/pci.c
@@ -651,6 +651,9 @@ int pcibios_add_device(struct pci_dev *pdev)
         struct resource *res;
         int i;
 
+        if (pdev->is_physfn)
+                pdev->no_vf_scan = 1;
+
         pdev->dev.groups = zpci_attr_groups;
         pdev->dev.dma_ops = &s390_pci_dma_ops;
         zpci_map_resources(pdev);
diff --git a/arch/x86/pci/broadcom_bus.c b/arch/x86/pci/broadcom_bus.c
index 526536c81ddc..ca1e8e6dccc8 100644
--- a/arch/x86/pci/broadcom_bus.c
+++ b/arch/x86/pci/broadcom_bus.c
@@ -50,8 +50,8 @@ static void __init cnb20le_res(u8 bus, u8 slot, u8 func)
         word1 = read_pci_config_16(bus, slot, func, 0xc0);
         word2 = read_pci_config_16(bus, slot, func, 0xc2);
         if (word1 != word2) {
-                res.start = (word1 << 16) | 0x0000;
-                res.end   = (word2 << 16) | 0xffff;
+                res.start = ((resource_size_t) word1 << 16) | 0x0000;
+                res.end   = ((resource_size_t) word2 << 16) | 0xffff;
                 res.flags = IORESOURCE_MEM;
                 update_res(info, res.start, res.end, res.flags, 0);
         }
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 2dcc30429e8b..ffe7895aa880 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -73,9 +73,9 @@ config PCI_PF_STUB
         depends on PCI_IOV
         help
           Say Y or M here if you want to enable support for devices that
-          require SR-IOV support, while at the same time the PF itself is
-          not providing any actual services on the host itself such as
-          storage or networking.
+          require SR-IOV support, while at the same time the PF (Physical
+          Function) itself is not providing any actual services on the
+          host itself such as storage or networking.
 
           When in doubt, say N.
 
diff --git a/drivers/pci/controller/dwc/Kconfig b/drivers/pci/controller/dwc/Kconfig
index 6aafec3fad00..0b1ab6b5e234 100644
--- a/drivers/pci/controller/dwc/Kconfig
+++ b/drivers/pci/controller/dwc/Kconfig
@@ -193,4 +193,14 @@ config PCIE_HISI_STB
         help
           Say Y here if you want PCIe controller support on HiSilicon STB SoCs
 
+config PCI_MESON
+        bool "MESON PCIe controller"
+        depends on PCI_MSI_IRQ_DOMAIN
+        select PCIE_DW_HOST
+        help
+          Say Y here if you want to enable PCI controller support on Amlogic
+          SoCs. The PCI controller on Amlogic is based on DesignWare hardware
+          and therefore the driver re-uses the DesignWare core functions to
+          implement the driver.
+
 endmenu
diff --git a/drivers/pci/controller/dwc/Makefile b/drivers/pci/controller/dwc/Makefile
index fcf91eacfc63..e05a0153ffc4 100644
--- a/drivers/pci/controller/dwc/Makefile
+++ b/drivers/pci/controller/dwc/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_PCIE_ARMADA_8K) += pcie-armada8k.o
 obj-$(CONFIG_PCIE_ARTPEC6) += pcie-artpec6.o
 obj-$(CONFIG_PCIE_KIRIN) += pcie-kirin.o
 obj-$(CONFIG_PCIE_HISI_STB) += pcie-histb.o
+obj-$(CONFIG_PCI_MESON) += pci-meson.o
 
 # The following drivers are for devices that use the generic ACPI
 # pci_root.c driver but don't support standard ECAM config access.
diff --git a/drivers/pci/controller/dwc/pci-meson.c b/drivers/pci/controller/dwc/pci-meson.c
new file mode 100644
index 000000000000..241ebe0c4505
--- /dev/null
+++ b/drivers/pci/controller/dwc/pci-meson.c
@@ -0,0 +1,592 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * PCIe host controller driver for Amlogic MESON SoCs
+ *
+ * Copyright (c) 2018 Amlogic, inc.
+ * Author: Yue Wang <yue.wang@amlogic.com>
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/pci.h>
+#include <linux/platform_device.h>
+#include <linux/reset.h>
+#include <linux/resource.h>
+#include <linux/types.h>
+
+#include "pcie-designware.h"
+
+#define to_meson_pcie(x) dev_get_drvdata((x)->dev)
+
+/* External local bus interface registers */
+#define PLR_OFFSET                      0x700
+#define PCIE_PORT_LINK_CTRL_OFF         (PLR_OFFSET + 0x10)
+#define FAST_LINK_MODE                  BIT(7)
+#define LINK_CAPABLE_MASK               GENMASK(21, 16)
+#define LINK_CAPABLE_X1                 BIT(16)
+
+#define PCIE_GEN2_CTRL_OFF              (PLR_OFFSET + 0x10c)
+#define NUM_OF_LANES_MASK               GENMASK(12, 8)
+#define NUM_OF_LANES_X1                 BIT(8)
+#define DIRECT_SPEED_CHANGE             BIT(17)
+
+#define TYPE1_HDR_OFFSET                0x0
+#define PCIE_STATUS_COMMAND             (TYPE1_HDR_OFFSET + 0x04)
+#define PCI_IO_EN                       BIT(0)
+#define PCI_MEM_SPACE_EN                BIT(1)
+#define PCI_BUS_MASTER_EN               BIT(2)
+
+#define PCIE_BASE_ADDR0                 (TYPE1_HDR_OFFSET + 0x10)
+#define PCIE_BASE_ADDR1                 (TYPE1_HDR_OFFSET + 0x14)
+
+#define PCIE_CAP_OFFSET                 0x70
+#define PCIE_DEV_CTRL_DEV_STUS          (PCIE_CAP_OFFSET + 0x08)
+#define PCIE_CAP_MAX_PAYLOAD_MASK       GENMASK(7, 5)
+#define PCIE_CAP_MAX_PAYLOAD_SIZE(x)    ((x) << 5)
+#define PCIE_CAP_MAX_READ_REQ_MASK      GENMASK(14, 12)
+#define PCIE_CAP_MAX_READ_REQ_SIZE(x)   ((x) << 12)
+
+/* PCIe specific config registers */
+#define PCIE_CFG0                       0x0
+#define APP_LTSSM_ENABLE                BIT(7)
+
+#define PCIE_CFG_STATUS12               0x30
+#define IS_SMLH_LINK_UP(x)              ((x) & (1 << 6))
+#define IS_RDLH_LINK_UP(x)              ((x) & (1 << 16))
+#define IS_LTSSM_UP(x)                  ((((x) >> 10) & 0x1f) == 0x11)
+
+#define PCIE_CFG_STATUS17               0x44
+#define PM_CURRENT_STATE(x)             (((x) >> 7) & 0x1)
+
+#define WAIT_LINKUP_TIMEOUT             4000
+#define PORT_CLK_RATE                   100000000UL
+#define MAX_PAYLOAD_SIZE                256
+#define MAX_READ_REQ_SIZE               256
+#define MESON_PCIE_PHY_POWERUP          0x1c
+#define PCIE_RESET_DELAY                500
+#define PCIE_SHARED_RESET               1
+#define PCIE_NORMAL_RESET               0
+
+enum pcie_data_rate {
+        PCIE_GEN1,
+        PCIE_GEN2,
+        PCIE_GEN3,
+        PCIE_GEN4
+};
+
+struct meson_pcie_mem_res {
+        void __iomem *elbi_base;
+        void __iomem *cfg_base;
+        void __iomem *phy_base;
+};
+
+struct meson_pcie_clk_res {
+        struct clk *clk;
+        struct clk *mipi_gate;
+        struct clk *port_clk;
+        struct clk *general_clk;
+};
+
+struct meson_pcie_rc_reset {
+        struct reset_control *phy;
+        struct reset_control *port;
+        struct reset_control *apb;
+};
+
+struct meson_pcie {
+        struct dw_pcie pci;
+        struct meson_pcie_mem_res mem_res;
+        struct meson_pcie_clk_res clk_res;
+        struct meson_pcie_rc_reset mrst;
+        struct gpio_desc *reset_gpio;
+};
+
+static struct reset_control *meson_pcie_get_reset(struct meson_pcie *mp,
+                                                  const char *id,
+                                                  u32 reset_type)
+{
+        struct device *dev = mp->pci.dev;
+        struct reset_control *reset;
+
+        if (reset_type == PCIE_SHARED_RESET)
+                reset = devm_reset_control_get_shared(dev, id);
+        else
+                reset = devm_reset_control_get(dev, id);
+
+        return reset;
+}
+
+static int meson_pcie_get_resets(struct meson_pcie *mp)
+{
+        struct meson_pcie_rc_reset *mrst = &mp->mrst;
+
+        mrst->phy = meson_pcie_get_reset(mp, "phy", PCIE_SHARED_RESET);
+        if (IS_ERR(mrst->phy))
+                return PTR_ERR(mrst->phy);
+        reset_control_deassert(mrst->phy);
+
+        mrst->port = meson_pcie_get_reset(mp, "port", PCIE_NORMAL_RESET);
+        if (IS_ERR(mrst->port))
+                return PTR_ERR(mrst->port);
+        reset_control_deassert(mrst->port);
+
+        mrst->apb = meson_pcie_get_reset(mp, "apb", PCIE_SHARED_RESET);
+        if (IS_ERR(mrst->apb))
+                return PTR_ERR(mrst->apb);
+        reset_control_deassert(mrst->apb);
+
+        return 0;
+}
+
+static void __iomem *meson_pcie_get_mem(struct platform_device *pdev,
+                                        struct meson_pcie *mp,
+                                        const char *id)
+{
+        struct device *dev = mp->pci.dev;
+        struct resource *res;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, id);
+
+        return devm_ioremap_resource(dev, res);
+}
+
+static void __iomem *meson_pcie_get_mem_shared(struct platform_device *pdev,
+                                               struct meson_pcie *mp,
+                                               const char *id)
+{
+        struct device *dev = mp->pci.dev;
+        struct resource *res;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, id);
+        if (!res) {
+                dev_err(dev, "No REG resource %s\n", id);
+                return ERR_PTR(-ENXIO);
+        }
+
+        return devm_ioremap(dev, res->start, resource_size(res));
+}
+
+static int meson_pcie_get_mems(struct platform_device *pdev,
+                               struct meson_pcie *mp)
+{
+        mp->mem_res.elbi_base = meson_pcie_get_mem(pdev, mp, "elbi");
+        if (IS_ERR(mp->mem_res.elbi_base))
+                return PTR_ERR(mp->mem_res.elbi_base);
+
+        mp->mem_res.cfg_base = meson_pcie_get_mem(pdev, mp, "cfg");
+        if (IS_ERR(mp->mem_res.cfg_base))
+                return PTR_ERR(mp->mem_res.cfg_base);
+
+        /* Meson SoC has two PCI controllers use same phy register*/
+        mp->mem_res.phy_base = meson_pcie_get_mem_shared(pdev, mp, "phy");
+        if (IS_ERR(mp->mem_res.phy_base))
+                return PTR_ERR(mp->mem_res.phy_base);
+
+        return 0;
+}
+
+static void meson_pcie_power_on(struct meson_pcie *mp)
+{
+        writel(MESON_PCIE_PHY_POWERUP, mp->mem_res.phy_base);
+}
+
+static void meson_pcie_reset(struct meson_pcie *mp)
+{
+        struct meson_pcie_rc_reset *mrst = &mp->mrst;
+
+        reset_control_assert(mrst->phy);
+        udelay(PCIE_RESET_DELAY);
+        reset_control_deassert(mrst->phy);
+        udelay(PCIE_RESET_DELAY);
+
+        reset_control_assert(mrst->port);
+        reset_control_assert(mrst->apb);
+        udelay(PCIE_RESET_DELAY);
+        reset_control_deassert(mrst->port);
+        reset_control_deassert(mrst->apb);
+        udelay(PCIE_RESET_DELAY);
+}
+
+static inline struct clk *meson_pcie_probe_clock(struct device *dev,
+                                                 const char *id, u64 rate)
+{
+        struct clk *clk;
+        int ret;
+
+        clk = devm_clk_get(dev, id);
+        if (IS_ERR(clk))
+                return clk;
+
+        if (rate) {
+                ret = clk_set_rate(clk, rate);
+                if (ret) {
+                        dev_err(dev, "set clk rate failed, ret = %d\n", ret);
+                        return ERR_PTR(ret);
+                }
+        }
+
+        ret = clk_prepare_enable(clk);
+        if (ret) {
+                dev_err(dev, "couldn't enable clk\n");
+                return ERR_PTR(ret);
+        }
+
+        devm_add_action_or_reset(dev,
+                                 (void (*) (void *))clk_disable_unprepare,
+                                 clk);
+
+        return clk;
+}
+
+static int meson_pcie_probe_clocks(struct meson_pcie *mp)
+{
+        struct device *dev = mp->pci.dev;
+        struct meson_pcie_clk_res *res = &mp->clk_res;
+
+        res->port_clk = meson_pcie_probe_clock(dev, "port", PORT_CLK_RATE);
+        if (IS_ERR(res->port_clk))
+                return PTR_ERR(res->port_clk);
+
+        res->mipi_gate = meson_pcie_probe_clock(dev, "pcie_mipi_en", 0);
+        if (IS_ERR(res->mipi_gate))
+                return PTR_ERR(res->mipi_gate);
+
+        res->general_clk = meson_pcie_probe_clock(dev, "pcie_general", 0);
+        if (IS_ERR(res->general_clk))
+                return PTR_ERR(res->general_clk);
+
+        res->clk = meson_pcie_probe_clock(dev, "pcie", 0);
+        if (IS_ERR(res->clk))
+                return PTR_ERR(res->clk);
+
+        return 0;
+}
+
+static inline void meson_elb_writel(struct meson_pcie *mp, u32 val, u32 reg)
+{
+        writel(val, mp->mem_res.elbi_base + reg);
+}
+
+static inline u32 meson_elb_readl(struct meson_pcie *mp, u32 reg)
+{
+        return readl(mp->mem_res.elbi_base + reg);
+}
+
+static inline u32 meson_cfg_readl(struct meson_pcie *mp, u32 reg)
+{
+        return readl(mp->mem_res.cfg_base + reg);
+}
+
+static inline void meson_cfg_writel(struct meson_pcie *mp, u32 val, u32 reg)
+{
+        writel(val, mp->mem_res.cfg_base + reg);
+}
+
+static void meson_pcie_assert_reset(struct meson_pcie *mp)
+{
+        gpiod_set_value_cansleep(mp->reset_gpio, 0);
+        udelay(500);
+        gpiod_set_value_cansleep(mp->reset_gpio, 1);
+}
+
+static void meson_pcie_init_dw(struct meson_pcie *mp)
+{
+        u32 val;
+
+        val = meson_cfg_readl(mp, PCIE_CFG0);
+        val |= APP_LTSSM_ENABLE;
+        meson_cfg_writel(mp, val, PCIE_CFG0);
+
+        val = meson_elb_readl(mp, PCIE_PORT_LINK_CTRL_OFF);
+        val &= ~LINK_CAPABLE_MASK;
+        meson_elb_writel(mp, val, PCIE_PORT_LINK_CTRL_OFF);
+
+        val = meson_elb_readl(mp, PCIE_PORT_LINK_CTRL_OFF);
+        val |= LINK_CAPABLE_X1 | FAST_LINK_MODE;
+        meson_elb_writel(mp, val, PCIE_PORT_LINK_CTRL_OFF);
+
+        val = meson_elb_readl(mp, PCIE_GEN2_CTRL_OFF);
+        val &= ~NUM_OF_LANES_MASK;
+        meson_elb_writel(mp, val, PCIE_GEN2_CTRL_OFF);
+
+        val = meson_elb_readl(mp, PCIE_GEN2_CTRL_OFF);
+        val |= NUM_OF_LANES_X1 | DIRECT_SPEED_CHANGE;
+        meson_elb_writel(mp, val, PCIE_GEN2_CTRL_OFF);
+
+        meson_elb_writel(mp, 0x0, PCIE_BASE_ADDR0);
+        meson_elb_writel(mp, 0x0, PCIE_BASE_ADDR1);
+}
+
+static int meson_size_to_payload(struct meson_pcie *mp, int size)
+{
+        struct device *dev = mp->pci.dev;
+
+        /*
+         * dwc supports 2^(val+7) payload size, which val is 0~5 default to 1.
+         * So if input size is not 2^order alignment or less than 2^7 or bigger
+         * than 2^12, just set to default size 2^(1+7).
+         */
+        if (!is_power_of_2(size) || size < 128 || size > 4096) {
+                dev_warn(dev, "payload size %d, set to default 256\n", size);
+                return 1;
+        }
+
+        return fls(size) - 8;
+}
+
+static void meson_set_max_payload(struct meson_pcie *mp, int size)
+{
+        u32 val;
+        int max_payload_size = meson_size_to_payload(mp, size);
+
+        val = meson_elb_readl(mp, PCIE_DEV_CTRL_DEV_STUS);
+        val &= ~PCIE_CAP_MAX_PAYLOAD_MASK;
+        meson_elb_writel(mp, val, PCIE_DEV_CTRL_DEV_STUS);
+
+        val = meson_elb_readl(mp, PCIE_DEV_CTRL_DEV_STUS);
+        val |= PCIE_CAP_MAX_PAYLOAD_SIZE(max_payload_size);
+        meson_elb_writel(mp, val, PCIE_DEV_CTRL_DEV_STUS);
+}
+
+static void meson_set_max_rd_req_size(struct meson_pcie *mp, int size)
+{
+        u32 val;
+        int max_rd_req_size = meson_size_to_payload(mp, size);
+
+        val = meson_elb_readl(mp, PCIE_DEV_CTRL_DEV_STUS);
+        val &= ~PCIE_CAP_MAX_READ_REQ_MASK;
+        meson_elb_writel(mp, val, PCIE_DEV_CTRL_DEV_STUS);
+
+        val = meson_elb_readl(mp, PCIE_DEV_CTRL_DEV_STUS);
+        val |= PCIE_CAP_MAX_READ_REQ_SIZE(max_rd_req_size);
+        meson_elb_writel(mp, val, PCIE_DEV_CTRL_DEV_STUS);
+}
+
+static inline void meson_enable_memory_space(struct meson_pcie *mp)
+{
+        /* Set the RC Bus Master, Memory Space and I/O Space enables */
+        meson_elb_writel(mp, PCI_IO_EN | PCI_MEM_SPACE_EN | PCI_BUS_MASTER_EN,
+                         PCIE_STATUS_COMMAND);
+}
+
+static int meson_pcie_establish_link(struct meson_pcie *mp)
+{
+        struct dw_pcie *pci = &mp->pci;
+        struct pcie_port *pp = &pci->pp;
+
+        meson_pcie_init_dw(mp);
+        meson_set_max_payload(mp, MAX_PAYLOAD_SIZE);
+        meson_set_max_rd_req_size(mp, MAX_READ_REQ_SIZE);
+
+        dw_pcie_setup_rc(pp);
+        meson_enable_memory_space(mp);
+
+        meson_pcie_assert_reset(mp);
+
+        return dw_pcie_wait_for_link(pci);
+}
+
+static void meson_pcie_enable_interrupts(struct meson_pcie *mp)
+{
+        if (IS_ENABLED(CONFIG_PCI_MSI))
+                dw_pcie_msi_init(&mp->pci.pp);
+}
+
+static int meson_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
+                                  u32 *val)
+{
+        struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
+        int ret;
+
+        ret = dw_pcie_read(pci->dbi_base + where, size, val);
+        if (ret != PCIBIOS_SUCCESSFUL)
+                return ret;
+
+        /*
+         * There is a bug in the MESON AXG PCIe controller whereby software
+         * cannot program the PCI_CLASS_DEVICE register, so we must fabricate
+         * the return value in the config accessors.
+         */
+        if (where == PCI_CLASS_REVISION && size == 4)
+                *val = (PCI_CLASS_BRIDGE_PCI << 16) | (*val & 0xffff);
+        else if (where == PCI_CLASS_DEVICE && size == 2)
+                *val = PCI_CLASS_BRIDGE_PCI;
+        else if (where == PCI_CLASS_DEVICE && size == 1)
+                *val = PCI_CLASS_BRIDGE_PCI & 0xff;
+        else if (where == PCI_CLASS_DEVICE + 1 && size == 1)
+                *val = (PCI_CLASS_BRIDGE_PCI >> 8) & 0xff;
+
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static int meson_pcie_wr_own_conf(struct pcie_port *pp, int where,
+                                  int size, u32 val)
+{
+        struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
+
+        return dw_pcie_write(pci->dbi_base + where, size, val);
+}
+
+static int meson_pcie_link_up(struct dw_pcie *pci)
+{
+        struct meson_pcie *mp = to_meson_pcie(pci);
+        struct device *dev = pci->dev;
+        u32 speed_okay = 0;
+        u32 cnt = 0;
+        u32 state12, state17, smlh_up, ltssm_up, rdlh_up;
+
+        do {
+                state12 = meson_cfg_readl(mp, PCIE_CFG_STATUS12);
+                state17 = meson_cfg_readl(mp, PCIE_CFG_STATUS17);
+                smlh_up = IS_SMLH_LINK_UP(state12);
+                rdlh_up = IS_RDLH_LINK_UP(state12);
+                ltssm_up = IS_LTSSM_UP(state12);
+
+                if (PM_CURRENT_STATE(state17) < PCIE_GEN3)
+                        speed_okay = 1;
+
+                if (smlh_up)
+                        dev_dbg(dev, "smlh_link_up is on\n");
+                if (rdlh_up)
+                        dev_dbg(dev, "rdlh_link_up is on\n");
+                if (ltssm_up)
+                        dev_dbg(dev, "ltssm_up is on\n");
+                if (speed_okay)
+                        dev_dbg(dev, "speed_okay\n");
+
+                if (smlh_up && rdlh_up && ltssm_up && speed_okay)
+                        return 1;
+
+                cnt++;
+
+                udelay(10);
+        } while (cnt < WAIT_LINKUP_TIMEOUT);
+
+        dev_err(dev, "error: wait linkup timeout\n");
+        return 0;
+}
+
+static int meson_pcie_host_init(struct pcie_port *pp)
+{
+        struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
+        struct meson_pcie *mp = to_meson_pcie(pci);
+        int ret;
+
+        ret = meson_pcie_establish_link(mp);
+        if (ret)
+                return ret;
+
+        meson_pcie_enable_interrupts(mp);
+
+        return 0;
+}
+
+static const struct dw_pcie_host_ops meson_pcie_host_ops = {
+        .rd_own_conf = meson_pcie_rd_own_conf,
+        .wr_own_conf = meson_pcie_wr_own_conf,
+        .host_init = meson_pcie_host_init,
+};
+
+static int meson_add_pcie_port(struct meson_pcie *mp,
+                               struct platform_device *pdev)
+{
+        struct dw_pcie *pci = &mp->pci;
+        struct pcie_port *pp = &pci->pp;
+        struct device *dev = &pdev->dev;
+        int ret;
+
+        if (IS_ENABLED(CONFIG_PCI_MSI)) {
+                pp->msi_irq = platform_get_irq(pdev, 0);
+                if (pp->msi_irq < 0) {
+                        dev_err(dev, "failed to get MSI IRQ\n");
+                        return pp->msi_irq;
+                }
+        }
+
+        pp->ops = &meson_pcie_host_ops;
+        pci->dbi_base = mp->mem_res.elbi_base;
+
+        ret = dw_pcie_host_init(pp);
+        if (ret) {
+                dev_err(dev, "failed to initialize host\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static const struct dw_pcie_ops dw_pcie_ops = {
+        .link_up = meson_pcie_link_up,
+};
+
+static int meson_pcie_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct dw_pcie *pci;
+        struct meson_pcie *mp;
+        int ret;
+
+        mp = devm_kzalloc(dev, sizeof(*mp), GFP_KERNEL);
+        if (!mp)
+                return -ENOMEM;
+
+        pci = &mp->pci;
+        pci->dev = dev;
+        pci->ops = &dw_pcie_ops;
+
+        mp->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
+        if (IS_ERR(mp->reset_gpio)) {
+                dev_err(dev, "get reset gpio failed\n");
+                return PTR_ERR(mp->reset_gpio);
+        }
+
+        ret = meson_pcie_get_resets(mp);
+        if (ret) {
+                dev_err(dev, "get reset resource failed, %d\n", ret);
+                return ret;
+        }
+
+        ret = meson_pcie_get_mems(pdev, mp);
+        if (ret) {
+                dev_err(dev, "get memory resource failed, %d\n", ret);
+                return ret;
+        }
+
+        meson_pcie_power_on(mp);
+        meson_pcie_reset(mp);
+
+        ret = meson_pcie_probe_clocks(mp);
+        if (ret) {
+                dev_err(dev, "init clock resources failed, %d\n", ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, mp);
+
+        ret = meson_add_pcie_port(mp, pdev);
+        if (ret < 0) {
+                dev_err(dev, "Add PCIe port failed, %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static const struct of_device_id meson_pcie_of_match[] = {
+        {
+                .compatible = "amlogic,axg-pcie",
+        },
+        {},
+};
+
+static struct platform_driver meson_pcie_driver = {
+        .probe = meson_pcie_probe,
+        .driver = {
+                .name = "meson-pcie",
+                .of_match_table = meson_pcie_of_match,
+        },
+};
+
+builtin_platform_driver(meson_pcie_driver);
diff --git a/drivers/pci/iov.c b/drivers/pci/iov.c
index 9616eca3182f..3aa115ed3a65 100644
--- a/drivers/pci/iov.c
+++ b/drivers/pci/iov.c
@@ -252,6 +252,27 @@ int __weak pcibios_sriov_disable(struct pci_dev *pdev)
         return 0;
 }
 
+static int sriov_add_vfs(struct pci_dev *dev, u16 num_vfs)
+{
+        unsigned int i;
+        int rc;
+
+        if (dev->no_vf_scan)
+                return 0;
+
+        for (i = 0; i < num_vfs; i++) {
+                rc = pci_iov_add_virtfn(dev, i);
+                if (rc)
+                        goto failed;
+        }
+        return 0;
+failed:
+        while (i--)
+                pci_iov_remove_virtfn(dev, i);
+
+        return rc;
+}
+
 static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
 {
         int rc;
@@ -337,21 +358,15 @@ static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
         msleep(100);
         pci_cfg_access_unlock(dev);
 
-        for (i = 0; i < initial; i++) {
-                rc = pci_iov_add_virtfn(dev, i);
-                if (rc)
-                        goto failed;
-        }
+        rc = sriov_add_vfs(dev, initial);
+        if (rc)
+                goto err_pcibios;
 
         kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
         iov->num_VFs = nr_virtfn;
 
         return 0;
 
-failed:
-        while (i--)
-                pci_iov_remove_virtfn(dev, i);
-
 err_pcibios:
         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
         pci_cfg_access_lock(dev);
@@ -368,17 +383,26 @@ err_pcibios:
         return rc;
 }
 
-static void sriov_disable(struct pci_dev *dev)
+static void sriov_del_vfs(struct pci_dev *dev)
 {
-        int i;
         struct pci_sriov *iov = dev->sriov;
+        int i;
 
-        if (!iov->num_VFs)
+        if (dev->no_vf_scan)
                 return;
 
         for (i = 0; i < iov->num_VFs; i++)
                 pci_iov_remove_virtfn(dev, i);
+}
+
+static void sriov_disable(struct pci_dev *dev)
+{
+        struct pci_sriov *iov = dev->sriov;
+
+        if (!iov->num_VFs)
+                return;
 
+        sriov_del_vfs(dev);
         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
         pci_cfg_access_lock(dev);
         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c
index ae3c5b25dcc7..c25a69fc4fc7 100644
--- a/drivers/pci/p2pdma.c
+++ b/drivers/pci/p2pdma.c
@@ -422,7 +422,7 @@ static int upstream_bridge_distance_warn(struct pci_dev *provider,
  *
  * Returns -1 if any of the clients are not compatible (behind the same
  * root port as the provider), otherwise returns a positive number where
- * a lower number is the preferrable choice. (If there's one client
+ * a lower number is the preferable choice. (If there's one client
  * that's the same as the provider it will return 0, which is best choice).
  *
  * For now, "compatible" means the provider and the clients are all behind
@@ -493,7 +493,7 @@ EXPORT_SYMBOL_GPL(pci_has_p2pmem);
  * @num_clients: number of client devices in the list
  *
  * If multiple devices are behind the same switch, the one "closest" to the
- * client devices in use will be chosen first. (So if one of the providers are
+ * client devices in use will be chosen first. (So if one of the providers is
  * the same as one of the clients, that provider will be used ahead of any
  * other providers that are unrelated). If multiple providers are an equal
  * distance away, one will be chosen at random.
@@ -580,7 +580,7 @@ EXPORT_SYMBOL_GPL(pci_alloc_p2pmem);
  * pci_free_p2pmem - free peer-to-peer DMA memory
  * @pdev: the device the memory was allocated from
  * @addr: address of the memory that was allocated
- * @size: number of bytes that was allocated
+ * @size: number of bytes that were allocated
  */
 void pci_free_p2pmem(struct pci_dev *pdev, void *addr, size_t size)
 {
@@ -617,7 +617,7 @@ EXPORT_SYMBOL_GPL(pci_p2pmem_virt_to_bus);
  * @nents: the number of SG entries in the list
  * @length: number of bytes to allocate
  *
- * Returns 0 on success
+ * Return: %NULL on error or &struct scatterlist pointer and @nents on success
  */
 struct scatterlist *pci_p2pmem_alloc_sgl(struct pci_dev *pdev,
                                          unsigned int *nents, u32 length)
@@ -673,7 +673,7 @@ EXPORT_SYMBOL_GPL(pci_p2pmem_free_sgl);
  *
  * Published memory can be used by other PCI device drivers for
  * peer-2-peer DMA operations. Non-published memory is reserved for
- * exlusive use of the device driver that registers the peer-to-peer
+ * exclusive use of the device driver that registers the peer-to-peer
  * memory.
  */
 void pci_p2pmem_publish(struct pci_dev *pdev, bool publish)
@@ -733,7 +733,7 @@ EXPORT_SYMBOL_GPL(pci_p2pdma_map_sg);
  * @use_p2pdma: returns whether to enable p2pdma or not
  *
  * Parses an attribute value to decide whether to enable p2pdma.
- * The value can select a PCI device (using it's full BDF device
+ * The value can select a PCI device (using its full BDF device
  * name) or a boolean (in any format strtobool() accepts). A false
  * value disables p2pdma, a true value expects the caller
  * to automatically find a compatible device and specifying a PCI device
@@ -784,7 +784,7 @@ EXPORT_SYMBOL_GPL(pci_p2pdma_enable_store);
  *              whether p2pdma is enabled
  * @page: contents of the stored value
  * @p2p_dev: the selected p2p device (NULL if no device is selected)
- * @use_p2pdma: whether p2pdme has been enabled
+ * @use_p2pdma: whether p2pdma has been enabled
  *
  * Attributes that use pci_p2pdma_enable_store() should use this function
  * to show the value of the attribute.
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index bef17c3fca67..33f3f475e5c6 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -1251,30 +1251,29 @@ static int pci_pm_runtime_suspend(struct device *dev)
                 return 0;
         }
 
-        if (!pm || !pm->runtime_suspend)
-                return -ENOSYS;
-
         pci_dev->state_saved = false;
-        error = pm->runtime_suspend(dev);
-        if (error) {
+        if (pm && pm->runtime_suspend) {
+                error = pm->runtime_suspend(dev);
                 /*
                  * -EBUSY and -EAGAIN is used to request the runtime PM core
                  * to schedule a new suspend, so log the event only with debug
                  * log level.
                  */
-                if (error == -EBUSY || error == -EAGAIN)
+                if (error == -EBUSY || error == -EAGAIN) {
                         dev_dbg(dev, "can't suspend now (%pf returned %d)\n",
                                 pm->runtime_suspend, error);
-                else
+                        return error;
+                } else if (error) {
                         dev_err(dev, "can't suspend (%pf returned %d)\n",
                                 pm->runtime_suspend, error);
-
-                return error;
+                        return error;
+                }
         }
 
         pci_fixup_device(pci_fixup_suspend, pci_dev);
 
-        if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
+        if (pm && pm->runtime_suspend
+            && !pci_dev->state_saved && pci_dev->current_state != PCI_D0
             && pci_dev->current_state != PCI_UNKNOWN) {
                 WARN_ONCE(pci_dev->current_state != prev,
                         "PCI PM: State of device not saved by %pF\n",
@@ -1292,7 +1291,7 @@ static int pci_pm_runtime_suspend(struct device *dev)
 
 static int pci_pm_runtime_resume(struct device *dev)
 {
-        int rc;
+        int rc = 0;
         struct pci_dev *pci_dev = to_pci_dev(dev);
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
@@ -1306,14 +1305,12 @@ static int pci_pm_runtime_resume(struct device *dev)
         if (!pci_dev->driver)
                 return 0;
 
-        if (!pm || !pm->runtime_resume)
-                return -ENOSYS;
-
         pci_fixup_device(pci_fixup_resume_early, pci_dev);
         pci_enable_wake(pci_dev, PCI_D0, false);
         pci_fixup_device(pci_fixup_resume, pci_dev);
 
-        rc = pm->runtime_resume(dev);
+        if (pm && pm->runtime_resume)
+                rc = pm->runtime_resume(dev);
 
         pci_dev->runtime_d3cold = false;
 
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 662b7457db23..224d88634115 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -2,6 +2,8 @@
 #ifndef DRIVERS_PCI_H
 #define DRIVERS_PCI_H
 
+#include <linux/pci.h>
+
 #define PCI_FIND_CAP_TTL        48
 
 #define PCI_VSEC_ID_INTEL_TBT   0x1234  /* Thunderbolt */
diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
index dcb29cb76dc6..2330ebf6df72 100644
--- a/drivers/pci/pcie/aspm.c
+++ b/drivers/pci/pcie/aspm.c
@@ -53,8 +53,6 @@ struct pcie_link_state {
         struct pcie_link_state *root;   /* pointer to the root port link */
         struct pcie_link_state *parent; /* pointer to the parent Link state */
         struct list_head sibling;       /* node in link_list */
-        struct list_head children;      /* list of child link states */
-        struct list_head link;          /* node in parent's children list */
 
         /* ASPM state */
         u32 aspm_support:7;             /* Supported ASPM state */
@@ -850,8 +848,6 @@ static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev)
                 return NULL;
 
         INIT_LIST_HEAD(&link->sibling);
-        INIT_LIST_HEAD(&link->children);
-        INIT_LIST_HEAD(&link->link);
         link->pdev = pdev;
         link->downstream = pci_function_0(pdev->subordinate);
 
@@ -877,7 +873,6 @@ static struct pcie_link_state *alloc_pcie_link_state(struct pci_dev *pdev)
 
                 link->parent = parent;
                 link->root = link->parent->root;
-                list_add(&link->link, &parent->children);
         }
 
         list_add(&link->sibling, &link_list);
@@ -1001,7 +996,6 @@ void pcie_aspm_exit_link_state(struct pci_dev *pdev)
         /* All functions are removed, so just disable ASPM for the link */
         pcie_config_aspm_link(link, 0);
         list_del(&link->sibling);
-        list_del(&link->link);
         /* Clock PM is for endpoint device */
         free_link_state(link);
 
diff --git a/drivers/pci/pcie/portdrv.h b/drivers/pci/pcie/portdrv.h
index e495f04394d0..fbbf00b0992e 100644
--- a/drivers/pci/pcie/portdrv.h
+++ b/drivers/pci/pcie/portdrv.h
@@ -71,19 +71,19 @@ static inline void *get_service_data(struct pcie_device *dev)
 
 struct pcie_port_service_driver {
         const char *name;
-        int (*probe) (struct pcie_device *dev);
-        void (*remove) (struct pcie_device *dev);
-        int (*suspend) (struct pcie_device *dev);
-        int (*resume_noirq) (struct pcie_device *dev);
-        int (*resume) (struct pcie_device *dev);
-        int (*runtime_suspend) (struct pcie_device *dev);
-        int (*runtime_resume) (struct pcie_device *dev);
+        int (*probe)(struct pcie_device *dev);
+        void (*remove)(struct pcie_device *dev);
+        int (*suspend)(struct pcie_device *dev);
+        int (*resume_noirq)(struct pcie_device *dev);
+        int (*resume)(struct pcie_device *dev);
+        int (*runtime_suspend)(struct pcie_device *dev);
+        int (*runtime_resume)(struct pcie_device *dev);
 
         /* Device driver may resume normal operations */
         void (*error_resume)(struct pci_dev *dev);
 
         /* Link Reset Capability - AER service driver specific */
-        pci_ers_result_t (*reset_link) (struct pci_dev *dev);
+        pci_ers_result_t (*reset_link)(struct pci_dev *dev);
 
         int port_type;  /* Type of the port this driver can handle */
         u32 service;    /* Port service this device represents */
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 4700d24e5d55..b0a413f3f7ca 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -619,6 +619,30 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_NL_USB,
                 quirk_amd_nl_class);
 
 /*
+ * Synopsys USB 3.x host HAPS platform has a class code of
+ * PCI_CLASS_SERIAL_USB_XHCI, and xhci driver can claim it.  However, these
+ * devices should use dwc3-haps driver.  Change these devices' class code to
+ * PCI_CLASS_SERIAL_USB_DEVICE to prevent the xhci-pci driver from claiming
+ * them.
+ */
+static void quirk_synopsys_haps(struct pci_dev *pdev)
+{
+        u32 class = pdev->class;
+
+        switch (pdev->device) {
+        case PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3:
+        case PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI:
+        case PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31:
+                pdev->class = PCI_CLASS_SERIAL_USB_DEVICE;
+                pci_info(pdev, "PCI class overridden (%#08x -> %#08x) so dwc3 driver can claim this instead of xhci\n",
+                         class, pdev->class);
+                break;
+        }
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SYNOPSYS, PCI_ANY_ID,
+                         quirk_synopsys_haps);
+
+/*
  * Let's make the southbridge information explicit instead of having to
  * worry about people probing the ACPI areas, for example.. (Yes, it
  * happens, and if you read the wrong ACPI register it will put the machine
diff --git a/drivers/pci/switch/switchtec.c b/drivers/pci/switch/switchtec.c
index 54a8b30dda38..6c5536d3d42a 100644
--- a/drivers/pci/switch/switchtec.c
+++ b/drivers/pci/switch/switchtec.c
@@ -13,7 +13,7 @@
 #include <linux/uaccess.h>
 #include <linux/poll.h>
 #include <linux/wait.h>
-
+#include <linux/io-64-nonatomic-lo-hi.h>
 #include <linux/nospec.h>
 
 MODULE_DESCRIPTION("Microsemi Switchtec(tm) PCIe Management Driver");
@@ -25,6 +25,11 @@ static int max_devices = 16;
 module_param(max_devices, int, 0644);
 MODULE_PARM_DESC(max_devices, "max number of switchtec device instances");
 
+static bool use_dma_mrpc = 1;
+module_param(use_dma_mrpc, bool, 0644);
+MODULE_PARM_DESC(use_dma_mrpc,
+                 "Enable the use of the DMA MRPC feature");
+
 static dev_t switchtec_devt;
 static DEFINE_IDA(switchtec_minor_ida);
 
@@ -113,6 +118,19 @@ static void stuser_set_state(struct switchtec_user *stuser,
 
 static void mrpc_complete_cmd(struct switchtec_dev *stdev);
 
+static void flush_wc_buf(struct switchtec_dev *stdev)
+{
+        struct ntb_dbmsg_regs __iomem *mmio_dbmsg;
+
+        /*
+         * odb (outbound doorbell) register is processed by low latency
+         * hardware and w/o side effect
+         */
+        mmio_dbmsg = (void __iomem *)stdev->mmio_ntb +
+                SWITCHTEC_NTB_REG_DBMSG_OFFSET;
+        ioread32(&mmio_dbmsg->odb);
+}
+
 static void mrpc_cmd_submit(struct switchtec_dev *stdev)
 {
         /* requires the mrpc_mutex to already be held when called */
@@ -128,16 +146,18 @@ static void mrpc_cmd_submit(struct switchtec_dev *stdev)
         stuser = list_entry(stdev->mrpc_queue.next, struct switchtec_user,
                             list);
 
+        if (stdev->dma_mrpc) {
+                stdev->dma_mrpc->status = SWITCHTEC_MRPC_STATUS_INPROGRESS;
+                memset(stdev->dma_mrpc->data, 0xFF, SWITCHTEC_MRPC_PAYLOAD_SIZE);
+        }
+
         stuser_set_state(stuser, MRPC_RUNNING);
         stdev->mrpc_busy = 1;
         memcpy_toio(&stdev->mmio_mrpc->input_data,
                     stuser->data, stuser->data_len);
+        flush_wc_buf(stdev);
         iowrite32(stuser->cmd, &stdev->mmio_mrpc->cmd);
 
-        stuser->status = ioread32(&stdev->mmio_mrpc->status);
-        if (stuser->status != SWITCHTEC_MRPC_STATUS_INPROGRESS)
-                mrpc_complete_cmd(stdev);
-
         schedule_delayed_work(&stdev->mrpc_timeout,
                               msecs_to_jiffies(500));
 }
@@ -170,7 +190,11 @@ static void mrpc_complete_cmd(struct switchtec_dev *stdev)
         stuser = list_entry(stdev->mrpc_queue.next, struct switchtec_user,
                             list);
 
-        stuser->status = ioread32(&stdev->mmio_mrpc->status);
+        if (stdev->dma_mrpc)
+                stuser->status = stdev->dma_mrpc->status;
+        else
+                stuser->status = ioread32(&stdev->mmio_mrpc->status);
+
         if (stuser->status == SWITCHTEC_MRPC_STATUS_INPROGRESS)
                 return;
 
@@ -180,13 +204,19 @@ static void mrpc_complete_cmd(struct switchtec_dev *stdev)
         if (stuser->status != SWITCHTEC_MRPC_STATUS_DONE)
                 goto out;
 
-        stuser->return_code = ioread32(&stdev->mmio_mrpc->ret_value);
+        if (stdev->dma_mrpc)
+                stuser->return_code = stdev->dma_mrpc->rtn_code;
+        else
+                stuser->return_code = ioread32(&stdev->mmio_mrpc->ret_value);
         if (stuser->return_code != 0)
                 goto out;
 
-        memcpy_fromio(stuser->data, &stdev->mmio_mrpc->output_data,
-                      stuser->read_len);
-
+        if (stdev->dma_mrpc)
+                memcpy(stuser->data, &stdev->dma_mrpc->data,
+                              stuser->read_len);
+        else
+                memcpy_fromio(stuser->data, &stdev->mmio_mrpc->output_data,
+                              stuser->read_len);
 out:
         complete_all(&stuser->comp);
         list_del_init(&stuser->list);
@@ -221,7 +251,10 @@ static void mrpc_timeout_work(struct work_struct *work)
 
         mutex_lock(&stdev->mrpc_mutex);
 
-        status = ioread32(&stdev->mmio_mrpc->status);
+        if (stdev->dma_mrpc)
+                status = stdev->dma_mrpc->status;
+        else
+                status = ioread32(&stdev->mmio_mrpc->status);
         if (status == SWITCHTEC_MRPC_STATUS_INPROGRESS) {
                 schedule_delayed_work(&stdev->mrpc_timeout,
                                       msecs_to_jiffies(500));
@@ -229,7 +262,6 @@ static void mrpc_timeout_work(struct work_struct *work)
         }
 
         mrpc_complete_cmd(stdev);
-
 out:
         mutex_unlock(&stdev->mrpc_mutex);
 }
@@ -800,6 +832,7 @@ static int ioctl_event_ctl(struct switchtec_dev *stdev,
 {
         int ret;
         int nr_idxs;
+        unsigned int event_flags;
         struct switchtec_ioctl_event_ctl ctl;
 
         if (copy_from_user(&ctl, uctl, sizeof(ctl)))
@@ -821,7 +854,9 @@ static int ioctl_event_ctl(struct switchtec_dev *stdev,
                 else
                         return -EINVAL;
 
+                event_flags = ctl.flags;
                 for (ctl.index = 0; ctl.index < nr_idxs; ctl.index++) {
+                        ctl.flags = event_flags;
                         ret = event_ctl(stdev, &ctl);
                         if (ret < 0)
                                 return ret;
@@ -1017,10 +1052,24 @@ static void enable_link_state_events(struct switchtec_dev *stdev)
         }
 }
 
+static void enable_dma_mrpc(struct switchtec_dev *stdev)
+{
+        writeq(stdev->dma_mrpc_dma_addr, &stdev->mmio_mrpc->dma_addr);
+        flush_wc_buf(stdev);
+        iowrite32(SWITCHTEC_DMA_MRPC_EN, &stdev->mmio_mrpc->dma_en);
+}
+
 static void stdev_release(struct device *dev)
 {
         struct switchtec_dev *stdev = to_stdev(dev);
 
+        if (stdev->dma_mrpc) {
+                iowrite32(0, &stdev->mmio_mrpc->dma_en);
+                flush_wc_buf(stdev);
+                writeq(0, &stdev->mmio_mrpc->dma_addr);
+                dma_free_coherent(&stdev->pdev->dev, sizeof(*stdev->dma_mrpc),
+                                stdev->dma_mrpc, stdev->dma_mrpc_dma_addr);
+        }
         kfree(stdev);
 }
 
@@ -1176,10 +1225,27 @@ static irqreturn_t switchtec_event_isr(int irq, void *dev)
         return ret;
 }
 
+
+static irqreturn_t switchtec_dma_mrpc_isr(int irq, void *dev)
+{
+        struct switchtec_dev *stdev = dev;
+        irqreturn_t ret = IRQ_NONE;
+
+        iowrite32(SWITCHTEC_EVENT_CLEAR |
+                  SWITCHTEC_EVENT_EN_IRQ,
+                  &stdev->mmio_part_cfg->mrpc_comp_hdr);
+        schedule_work(&stdev->mrpc_work);
+
+        ret = IRQ_HANDLED;
+        return ret;
+}
+
 static int switchtec_init_isr(struct switchtec_dev *stdev)
 {
         int nvecs;
         int event_irq;
+        int dma_mrpc_irq;
+        int rc;
 
         nvecs = pci_alloc_irq_vectors(stdev->pdev, 1, 4,
                                       PCI_IRQ_MSIX | PCI_IRQ_MSI);
@@ -1194,9 +1260,29 @@ static int switchtec_init_isr(struct switchtec_dev *stdev)
         if (event_irq < 0)
                 return event_irq;
 
-        return devm_request_irq(&stdev->pdev->dev, event_irq,
+        rc = devm_request_irq(&stdev->pdev->dev, event_irq,
                                 switchtec_event_isr, 0,
                                 KBUILD_MODNAME, stdev);
+
+        if (rc)
+                return rc;
+
+        if (!stdev->dma_mrpc)
+                return rc;
+
+        dma_mrpc_irq = ioread32(&stdev->mmio_mrpc->dma_vector);
+        if (dma_mrpc_irq < 0 || dma_mrpc_irq >= nvecs)
+                return -EFAULT;
+
+        dma_mrpc_irq  = pci_irq_vector(stdev->pdev, dma_mrpc_irq);
+        if (dma_mrpc_irq < 0)
+                return dma_mrpc_irq;
+
+        rc = devm_request_irq(&stdev->pdev->dev, dma_mrpc_irq,
+                                switchtec_dma_mrpc_isr, 0,
+                                KBUILD_MODNAME, stdev);
+
+        return rc;
 }
 
 static void init_pff(struct switchtec_dev *stdev)
@@ -1232,19 +1318,38 @@ static int switchtec_init_pci(struct switchtec_dev *stdev,
                               struct pci_dev *pdev)
 {
         int rc;
+        void __iomem *map;
+        unsigned long res_start, res_len;
 
         rc = pcim_enable_device(pdev);
         if (rc)
                 return rc;
 
-        rc = pcim_iomap_regions(pdev, 0x1, KBUILD_MODNAME);
+        rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
         if (rc)
                 return rc;
 
         pci_set_master(pdev);
 
-        stdev->mmio = pcim_iomap_table(pdev)[0];
-        stdev->mmio_mrpc = stdev->mmio + SWITCHTEC_GAS_MRPC_OFFSET;
+        res_start = pci_resource_start(pdev, 0);
+        res_len = pci_resource_len(pdev, 0);
+
+        if (!devm_request_mem_region(&pdev->dev, res_start,
+                                     res_len, KBUILD_MODNAME))
+                return -EBUSY;
+
+        stdev->mmio_mrpc = devm_ioremap_wc(&pdev->dev, res_start,
+                                           SWITCHTEC_GAS_TOP_CFG_OFFSET);
+        if (!stdev->mmio_mrpc)
+                return -ENOMEM;
+
+        map = devm_ioremap(&pdev->dev,
+                           res_start + SWITCHTEC_GAS_TOP_CFG_OFFSET,
+                           res_len - SWITCHTEC_GAS_TOP_CFG_OFFSET);
+        if (!map)
+                return -ENOMEM;
+
+        stdev->mmio = map - SWITCHTEC_GAS_TOP_CFG_OFFSET;
         stdev->mmio_sw_event = stdev->mmio + SWITCHTEC_GAS_SW_EVENT_OFFSET;
         stdev->mmio_sys_info = stdev->mmio + SWITCHTEC_GAS_SYS_INFO_OFFSET;
         stdev->mmio_flash_info = stdev->mmio + SWITCHTEC_GAS_FLASH_INFO_OFFSET;
@@ -1262,6 +1367,19 @@ static int switchtec_init_pci(struct switchtec_dev *stdev,
 
         pci_set_drvdata(pdev, stdev);
 
+        if (!use_dma_mrpc)
+                return 0;
+
+        if (ioread32(&stdev->mmio_mrpc->dma_ver) == 0)
+                return 0;
+
+        stdev->dma_mrpc = dma_zalloc_coherent(&stdev->pdev->dev,
+                                              sizeof(*stdev->dma_mrpc),
+                                              &stdev->dma_mrpc_dma_addr,
+                                              GFP_KERNEL);
+        if (stdev->dma_mrpc == NULL)
+                return -ENOMEM;
+
         return 0;
 }
 
@@ -1293,6 +1411,9 @@ static int switchtec_pci_probe(struct pci_dev *pdev,
                   &stdev->mmio_part_cfg->mrpc_comp_hdr);
         enable_link_state_events(stdev);
 
+        if (stdev->dma_mrpc)
+                enable_dma_mrpc(stdev);
+
         rc = cdev_device_add(&stdev->cdev, &stdev->dev);
         if (rc)
                 goto err_devadd;
@@ -1318,7 +1439,6 @@ static void switchtec_pci_remove(struct pci_dev *pdev)
         cdev_device_del(&stdev->cdev, &stdev->dev);
         ida_simple_remove(&switchtec_minor_ida, MINOR(stdev->dev.devt));
         dev_info(&stdev->dev, "unregistered.\n");
-
         stdev_kill(stdev);
         put_device(&stdev->dev);
 }
diff --git a/drivers/usb/dwc3/dwc3-haps.c b/drivers/usb/dwc3/dwc3-haps.c
index c9cc33881bef..02d57d98ef9b 100644
--- a/drivers/usb/dwc3/dwc3-haps.c
+++ b/drivers/usb/dwc3/dwc3-haps.c
@@ -15,10 +15,6 @@
 #include <linux/platform_device.h>
 #include <linux/property.h>
 
-#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3         0xabcd
-#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI     0xabce
-#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31        0xabcf
-
 /**
  * struct dwc3_haps - Driver private structure
  * @dwc3: child dwc3 platform_device
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 11c71c4ecf75..8e3c646bc15c 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -405,6 +405,7 @@ struct pci_dev {
         unsigned int    non_compliant_bars:1;   /* Broken BARs; ignore them */
         unsigned int    is_probed:1;            /* Device probing in progress */
         unsigned int    link_active_reporting:1;/* Device capable of reporting link active */
+        unsigned int    no_vf_scan:1;           /* Don't scan for VFs after IOV enablement */
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
@@ -764,9 +765,9 @@ struct pci_driver {
         int  (*suspend)(struct pci_dev *dev, pm_message_t state);       /* Device suspended */
         int  (*suspend_late)(struct pci_dev *dev, pm_message_t state);
         int  (*resume_early)(struct pci_dev *dev);
-        int  (*resume) (struct pci_dev *dev);   /* Device woken up */
-        void (*shutdown) (struct pci_dev *dev);
-        int  (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* On PF */
+        int  (*resume)(struct pci_dev *dev);    /* Device woken up */
+        void (*shutdown)(struct pci_dev *dev);
+        int  (*sriov_configure)(struct pci_dev *dev, int num_vfs); /* On PF */
         const struct pci_error_handlers *err_handler;
         const struct attribute_group **groups;
         struct device_driver    driver;
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 69f0abe1ba1a..25db0c1586ea 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2358,6 +2358,9 @@
 #define PCI_DEVICE_ID_CENATEK_IDE       0x0001
 
 #define PCI_VENDOR_ID_SYNOPSYS          0x16c3
+#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3         0xabcd
+#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3_AXI     0xabce
+#define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB31        0xabcf
 
 #define PCI_VENDOR_ID_VITESSE           0x1725
 #define PCI_DEVICE_ID_VITESSE_VSC7174   0x7174
diff --git a/include/linux/switchtec.h b/include/linux/switchtec.h
index ab400af6f0ce..eee0412bdf4b 100644
--- a/include/linux/switchtec.h
+++ b/include/linux/switchtec.h
@@ -29,6 +29,7 @@
 #define SWITCHTEC_EVENT_EN_IRQ   BIT(3)
 #define SWITCHTEC_EVENT_FATAL    BIT(4)
 
+#define SWITCHTEC_DMA_MRPC_EN   BIT(0)
 enum {
         SWITCHTEC_GAS_MRPC_OFFSET       = 0x0000,
         SWITCHTEC_GAS_TOP_CFG_OFFSET    = 0x1000,
@@ -46,6 +47,10 @@ struct mrpc_regs {
         u32 cmd;
         u32 status;
         u32 ret_value;
+        u32 dma_en;
+        u64 dma_addr;
+        u32 dma_vector;
+        u32 dma_ver;
 } __packed;
 
 enum mrpc_status {
@@ -342,6 +347,14 @@ struct pff_csr_regs {
 
 struct switchtec_ntb;
 
+struct dma_mrpc_output {
+        u32 status;
+        u32 cmd_id;
+        u32 rtn_code;
+        u32 output_size;
+        u8 data[SWITCHTEC_MRPC_PAYLOAD_SIZE];
+};
+
 struct switchtec_dev {
         struct pci_dev *pdev;
         struct device dev;
@@ -381,6 +394,9 @@ struct switchtec_dev {
         u8 link_event_count[SWITCHTEC_MAX_PFF_CSR];
 
         struct switchtec_ntb *sndev;
+
+        struct dma_mrpc_output *dma_mrpc;
+        dma_addr_t dma_mrpc_dma_addr;
 };
 
 static inline struct switchtec_dev *to_stdev(struct device *dev)