Merge tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc

Pull ARM SoC driver updates from Arnd Bergmann:
 "As usual, the drivers/tee and drivers/reset subsystems get merged
  here, with the expected set of smaller updates and some new hardware
  support. The tee subsystem now supports device drivers to be attached
  to a tee, the first example here is a random number driver with its
  implementation in the secure world.

  Three new power domain drivers get added for specific chip families:
   - Broadcom BCM283x chips (used in Raspberry Pi)
   - Qualcomm Snapdragon phone chips
   - Xilinx ZynqMP FPGA SoCs

  One new driver is added to talk to the BPMP firmware on NVIDIA
  Tegra210

  Existing drivers are extended for new SoC variants from NXP, NVIDIA,
  Amlogic and Qualcomm"

* tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc: (113 commits)
  tee: optee: update optee_msg.h and optee_smc.h to dual license
  tee: add cancellation support to client interface
  dpaa2-eth: configure the cache stashing amount on a queue
  soc: fsl: dpio: configure cache stashing destination
  soc: fsl: dpio: enable frame data cache stashing per software portal
  soc: fsl: guts: make fsl_guts_get_svr() static
  hwrng: make symbol 'optee_rng_id_table' static
  tee: optee: Fix unsigned comparison with less than zero
  hwrng: Fix unsigned comparison with less than zero
  tee: fix possible error pointer ctx dereferencing
  hwrng: optee: Initialize some structs using memset instead of braces
  tee: optee: Initialize some structs using memset instead of braces
  soc: fsl: dpio: fix memory leak of a struct qbman on error exit path
  clk: tegra: dfll: Make symbol 'tegra210_cpu_cvb_tables' static
  soc: qcom: llcc-slice: Fix typos
  qcom: soc: llcc-slice: Consolidate some code
  qcom: soc: llcc-slice: Clear the global drv_data pointer on error
  drivers: soc: xilinx: Add ZynqMP power domain driver
  firmware: xilinx: Add APIs to control node status/power
  dt-bindings: power: Add ZynqMP power domain bindings
  ...

11 files changed, 954 insertions, 245 deletions

diff --git a/drivers/firmware/imx/misc.c b/drivers/firmware/imx/misc.c
index 97f5424dbac9..4b56a587dacd 100644
--- a/drivers/firmware/imx/misc.c
+++ b/drivers/firmware/imx/misc.c
@@ -18,6 +18,14 @@ struct imx_sc_msg_req_misc_set_ctrl {
         u16 resource;
 } __packed;
 
+struct imx_sc_msg_req_cpu_start {
+        struct imx_sc_rpc_msg hdr;
+        u32 address_hi;
+        u32 address_lo;
+        u16 resource;
+        u8 enable;
+} __packed;
+
 struct imx_sc_msg_req_misc_get_ctrl {
         struct imx_sc_rpc_msg hdr;
         u32 ctrl;
@@ -97,3 +105,33 @@ int imx_sc_misc_get_control(struct imx_sc_ipc *ipc, u32 resource,
         return 0;
 }
 EXPORT_SYMBOL(imx_sc_misc_get_control);
+
+/*
+ * This function starts/stops a CPU identified by @resource
+ *
+ * @param[in]     ipc         IPC handle
+ * @param[in]     resource    resource the control is associated with
+ * @param[in]     enable      true for start, false for stop
+ * @param[in]     phys_addr   initial instruction address to be executed
+ *
+ * @return Returns 0 for success and < 0 for errors.
+ */
+int imx_sc_pm_cpu_start(struct imx_sc_ipc *ipc, u32 resource,
+                        bool enable, u64 phys_addr)
+{
+        struct imx_sc_msg_req_cpu_start msg;
+        struct imx_sc_rpc_msg *hdr = &msg.hdr;
+
+        hdr->ver = IMX_SC_RPC_VERSION;
+        hdr->svc = IMX_SC_RPC_SVC_PM;
+        hdr->func = IMX_SC_PM_FUNC_CPU_START;
+        hdr->size = 4;
+
+        msg.address_hi = phys_addr >> 32;
+        msg.address_lo = phys_addr;
+        msg.resource = resource;
+        msg.enable = enable;
+
+        return imx_scu_call_rpc(ipc, &msg, true);
+}
+EXPORT_SYMBOL(imx_sc_pm_cpu_start);
diff --git a/drivers/firmware/imx/scu-pd.c b/drivers/firmware/imx/scu-pd.c
index 407245f2efd0..39a94c7177fc 100644
--- a/drivers/firmware/imx/scu-pd.c
+++ b/drivers/firmware/imx/scu-pd.c
@@ -322,6 +322,7 @@ static int imx_sc_pd_probe(struct platform_device *pdev)
 
 static const struct of_device_id imx_sc_pd_match[] = {
         { .compatible = "fsl,imx8qxp-scu-pd", &imx8qxp_scu_pd},
+        { .compatible = "fsl,scu-pd", &imx8qxp_scu_pd},
         { /* sentinel */ }
 };
 
diff --git a/drivers/firmware/raspberrypi.c b/drivers/firmware/raspberrypi.c
index a13558154ac3..61be15d9df7d 100644
--- a/drivers/firmware/raspberrypi.c
+++ b/drivers/firmware/raspberrypi.c
@@ -238,6 +238,16 @@ static int rpi_firmware_probe(struct platform_device *pdev)
         return 0;
 }
 
+static void rpi_firmware_shutdown(struct platform_device *pdev)
+{
+        struct rpi_firmware *fw = platform_get_drvdata(pdev);
+
+        if (!fw)
+                return;
+
+        rpi_firmware_property(fw, RPI_FIRMWARE_NOTIFY_REBOOT, NULL, 0);
+}
+
 static int rpi_firmware_remove(struct platform_device *pdev)
 {
         struct rpi_firmware *fw = platform_get_drvdata(pdev);
@@ -278,6 +288,7 @@ static struct platform_driver rpi_firmware_driver = {
                 .of_match_table = rpi_firmware_of_match,
         },
         .probe          = rpi_firmware_probe,
+        .shutdown       = rpi_firmware_shutdown,
         .remove         = rpi_firmware_remove,
 };
 module_platform_driver(rpi_firmware_driver);
diff --git a/drivers/firmware/tegra/Makefile b/drivers/firmware/tegra/Makefile
index 1b826dcca719..676b01caff05 100644
--- a/drivers/firmware/tegra/Makefile
+++ b/drivers/firmware/tegra/Makefile
@@ -1,4 +1,7 @@
 tegra-bpmp-y                    = bpmp.o
+tegra-bpmp-$(CONFIG_ARCH_TEGRA_210_SOC) += bpmp-tegra210.o
+tegra-bpmp-$(CONFIG_ARCH_TEGRA_186_SOC) += bpmp-tegra186.o
+tegra-bpmp-$(CONFIG_ARCH_TEGRA_194_SOC) += bpmp-tegra186.o
 tegra-bpmp-$(CONFIG_DEBUG_FS)   += bpmp-debugfs.o
 obj-$(CONFIG_TEGRA_BPMP)        += tegra-bpmp.o
 obj-$(CONFIG_TEGRA_IVC)         += ivc.o
diff --git a/drivers/firmware/tegra/bpmp-private.h b/drivers/firmware/tegra/bpmp-private.h
new file mode 100644
index 000000000000..54d560c48398
--- /dev/null
+++ b/drivers/firmware/tegra/bpmp-private.h
@@ -0,0 +1,34 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2018, NVIDIA CORPORATION.
+ */
+
+#ifndef __FIRMWARE_TEGRA_BPMP_PRIVATE_H
+#define __FIRMWARE_TEGRA_BPMP_PRIVATE_H
+
+#include <soc/tegra/bpmp.h>
+
+struct tegra_bpmp_ops {
+        int (*init)(struct tegra_bpmp *bpmp);
+        void (*deinit)(struct tegra_bpmp *bpmp);
+        bool (*is_response_ready)(struct tegra_bpmp_channel *channel);
+        bool (*is_request_ready)(struct tegra_bpmp_channel *channel);
+        int (*ack_response)(struct tegra_bpmp_channel *channel);
+        int (*ack_request)(struct tegra_bpmp_channel *channel);
+        bool (*is_response_channel_free)(struct tegra_bpmp_channel *channel);
+        bool (*is_request_channel_free)(struct tegra_bpmp_channel *channel);
+        int (*post_response)(struct tegra_bpmp_channel *channel);
+        int (*post_request)(struct tegra_bpmp_channel *channel);
+        int (*ring_doorbell)(struct tegra_bpmp *bpmp);
+        int (*resume)(struct tegra_bpmp *bpmp);
+};
+
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
+    IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
+extern const struct tegra_bpmp_ops tegra186_bpmp_ops;
+#endif
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
+extern const struct tegra_bpmp_ops tegra210_bpmp_ops;
+#endif
+
+#endif
diff --git a/drivers/firmware/tegra/bpmp-tegra186.c b/drivers/firmware/tegra/bpmp-tegra186.c
new file mode 100644
index 000000000000..ea308751635f
--- /dev/null
+++ b/drivers/firmware/tegra/bpmp-tegra186.c
@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018, NVIDIA CORPORATION.
+ */
+
+#include <linux/genalloc.h>
+#include <linux/mailbox_client.h>
+#include <linux/platform_device.h>
+
+#include <soc/tegra/bpmp.h>
+#include <soc/tegra/bpmp-abi.h>
+#include <soc/tegra/ivc.h>
+
+#include "bpmp-private.h"
+
+struct tegra186_bpmp {
+        struct tegra_bpmp *parent;
+
+        struct {
+                struct gen_pool *pool;
+                dma_addr_t phys;
+                void *virt;
+        } tx, rx;
+
+        struct {
+                struct mbox_client client;
+                struct mbox_chan *channel;
+        } mbox;
+};
+
+static inline struct tegra_bpmp *
+mbox_client_to_bpmp(struct mbox_client *client)
+{
+        struct tegra186_bpmp *priv;
+
+        priv = container_of(client, struct tegra186_bpmp, mbox.client);
+
+        return priv->parent;
+}
+
+static bool tegra186_bpmp_is_message_ready(struct tegra_bpmp_channel *channel)
+{
+        void *frame;
+
+        frame = tegra_ivc_read_get_next_frame(channel->ivc);
+        if (IS_ERR(frame)) {
+                channel->ib = NULL;
+                return false;
+        }
+
+        channel->ib = frame;
+
+        return true;
+}
+
+static bool tegra186_bpmp_is_channel_free(struct tegra_bpmp_channel *channel)
+{
+        void *frame;
+
+        frame = tegra_ivc_write_get_next_frame(channel->ivc);
+        if (IS_ERR(frame)) {
+                channel->ob = NULL;
+                return false;
+        }
+
+        channel->ob = frame;
+
+        return true;
+}
+
+static int tegra186_bpmp_ack_message(struct tegra_bpmp_channel *channel)
+{
+        return tegra_ivc_read_advance(channel->ivc);
+}
+
+static int tegra186_bpmp_post_message(struct tegra_bpmp_channel *channel)
+{
+        return tegra_ivc_write_advance(channel->ivc);
+}
+
+static int tegra186_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
+{
+        struct tegra186_bpmp *priv = bpmp->priv;
+        int err;
+
+        err = mbox_send_message(priv->mbox.channel, NULL);
+        if (err < 0)
+                return err;
+
+        mbox_client_txdone(priv->mbox.channel, 0);
+
+        return 0;
+}
+
+static void tegra186_bpmp_ivc_notify(struct tegra_ivc *ivc, void *data)
+{
+        struct tegra_bpmp *bpmp = data;
+        struct tegra186_bpmp *priv = bpmp->priv;
+
+        if (WARN_ON(priv->mbox.channel == NULL))
+                return;
+
+        tegra186_bpmp_ring_doorbell(bpmp);
+}
+
+static int tegra186_bpmp_channel_init(struct tegra_bpmp_channel *channel,
+                                      struct tegra_bpmp *bpmp,
+                                      unsigned int index)
+{
+        struct tegra186_bpmp *priv = bpmp->priv;
+        size_t message_size, queue_size;
+        unsigned int offset;
+        int err;
+
+        channel->ivc = devm_kzalloc(bpmp->dev, sizeof(*channel->ivc),
+                                    GFP_KERNEL);
+        if (!channel->ivc)
+                return -ENOMEM;
+
+        message_size = tegra_ivc_align(MSG_MIN_SZ);
+        queue_size = tegra_ivc_total_queue_size(message_size);
+        offset = queue_size * index;
+
+        err = tegra_ivc_init(channel->ivc, NULL,
+                             priv->rx.virt + offset, priv->rx.phys + offset,
+                             priv->tx.virt + offset, priv->tx.phys + offset,
+                             1, message_size, tegra186_bpmp_ivc_notify,
+                             bpmp);
+        if (err < 0) {
+                dev_err(bpmp->dev, "failed to setup IVC for channel %u: %d\n",
+                        index, err);
+                return err;
+        }
+
+        init_completion(&channel->completion);
+        channel->bpmp = bpmp;
+
+        return 0;
+}
+
+static void tegra186_bpmp_channel_reset(struct tegra_bpmp_channel *channel)
+{
+        /* reset the channel state */
+        tegra_ivc_reset(channel->ivc);
+
+        /* sync the channel state with BPMP */
+        while (tegra_ivc_notified(channel->ivc))
+                ;
+}
+
+static void tegra186_bpmp_channel_cleanup(struct tegra_bpmp_channel *channel)
+{
+        tegra_ivc_cleanup(channel->ivc);
+}
+
+static void mbox_handle_rx(struct mbox_client *client, void *data)
+{
+        struct tegra_bpmp *bpmp = mbox_client_to_bpmp(client);
+
+        tegra_bpmp_handle_rx(bpmp);
+}
+
+static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
+{
+        struct tegra186_bpmp *priv;
+        unsigned int i;
+        int err;
+
+        priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        bpmp->priv = priv;
+        priv->parent = bpmp;
+
+        priv->tx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 0);
+        if (!priv->tx.pool) {
+                dev_err(bpmp->dev, "TX shmem pool not found\n");
+                return -ENOMEM;
+        }
+
+        priv->tx.virt = gen_pool_dma_alloc(priv->tx.pool, 4096, &priv->tx.phys);
+        if (!priv->tx.virt) {
+                dev_err(bpmp->dev, "failed to allocate from TX pool\n");
+                return -ENOMEM;
+        }
+
+        priv->rx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 1);
+        if (!priv->rx.pool) {
+                dev_err(bpmp->dev, "RX shmem pool not found\n");
+                err = -ENOMEM;
+                goto free_tx;
+        }
+
+        priv->rx.virt = gen_pool_dma_alloc(priv->rx.pool, 4096, &priv->rx.phys);
+        if (!priv->rx.virt) {
+                dev_err(bpmp->dev, "failed to allocate from RX pool\n");
+                err = -ENOMEM;
+                goto free_tx;
+        }
+
+        err = tegra186_bpmp_channel_init(bpmp->tx_channel, bpmp,
+                                         bpmp->soc->channels.cpu_tx.offset);
+        if (err < 0)
+                goto free_rx;
+
+        err = tegra186_bpmp_channel_init(bpmp->rx_channel, bpmp,
+                                         bpmp->soc->channels.cpu_rx.offset);
+        if (err < 0)
+                goto cleanup_tx_channel;
+
+        for (i = 0; i < bpmp->threaded.count; i++) {
+                unsigned int index = bpmp->soc->channels.thread.offset + i;
+
+                err = tegra186_bpmp_channel_init(&bpmp->threaded_channels[i],
+                                                 bpmp, index);
+                if (err < 0)
+                        goto cleanup_channels;
+        }
+
+        /* mbox registration */
+        priv->mbox.client.dev = bpmp->dev;
+        priv->mbox.client.rx_callback = mbox_handle_rx;
+        priv->mbox.client.tx_block = false;
+        priv->mbox.client.knows_txdone = false;
+
+        priv->mbox.channel = mbox_request_channel(&priv->mbox.client, 0);
+        if (IS_ERR(priv->mbox.channel)) {
+                err = PTR_ERR(priv->mbox.channel);
+                dev_err(bpmp->dev, "failed to get HSP mailbox: %d\n", err);
+                goto cleanup_channels;
+        }
+
+        tegra186_bpmp_channel_reset(bpmp->tx_channel);
+        tegra186_bpmp_channel_reset(bpmp->rx_channel);
+
+        for (i = 0; i < bpmp->threaded.count; i++)
+                tegra186_bpmp_channel_reset(&bpmp->threaded_channels[i]);
+
+        return 0;
+
+cleanup_channels:
+        for (i = 0; i < bpmp->threaded.count; i++) {
+                if (!bpmp->threaded_channels[i].bpmp)
+                        continue;
+
+                tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
+        }
+
+        tegra186_bpmp_channel_cleanup(bpmp->rx_channel);
+cleanup_tx_channel:
+        tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
+free_rx:
+        gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.virt, 4096);
+free_tx:
+        gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.virt, 4096);
+
+        return err;
+}
+
+static void tegra186_bpmp_deinit(struct tegra_bpmp *bpmp)
+{
+        struct tegra186_bpmp *priv = bpmp->priv;
+        unsigned int i;
+
+        mbox_free_channel(priv->mbox.channel);
+
+        for (i = 0; i < bpmp->threaded.count; i++)
+                tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
+
+        tegra186_bpmp_channel_cleanup(bpmp->rx_channel);
+        tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
+
+        gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.virt, 4096);
+        gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.virt, 4096);
+}
+
+static int tegra186_bpmp_resume(struct tegra_bpmp *bpmp)
+{
+        unsigned int i;
+
+        /* reset message channels */
+        tegra186_bpmp_channel_reset(bpmp->tx_channel);
+        tegra186_bpmp_channel_reset(bpmp->rx_channel);
+
+        for (i = 0; i < bpmp->threaded.count; i++)
+                tegra186_bpmp_channel_reset(&bpmp->threaded_channels[i]);
+
+        return 0;
+}
+
+const struct tegra_bpmp_ops tegra186_bpmp_ops = {
+        .init = tegra186_bpmp_init,
+        .deinit = tegra186_bpmp_deinit,
+        .is_response_ready = tegra186_bpmp_is_message_ready,
+        .is_request_ready = tegra186_bpmp_is_message_ready,
+        .ack_response = tegra186_bpmp_ack_message,
+        .ack_request = tegra186_bpmp_ack_message,
+        .is_response_channel_free = tegra186_bpmp_is_channel_free,
+        .is_request_channel_free = tegra186_bpmp_is_channel_free,
+        .post_response = tegra186_bpmp_post_message,
+        .post_request = tegra186_bpmp_post_message,
+        .ring_doorbell = tegra186_bpmp_ring_doorbell,
+        .resume = tegra186_bpmp_resume,
+};
diff --git a/drivers/firmware/tegra/bpmp-tegra210.c b/drivers/firmware/tegra/bpmp-tegra210.c
new file mode 100644
index 000000000000..ae15940a078e
--- /dev/null
+++ b/drivers/firmware/tegra/bpmp-tegra210.c
@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018, NVIDIA CORPORATION.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+
+#include <soc/tegra/bpmp.h>
+
+#include "bpmp-private.h"
+
+#define TRIGGER_OFFSET          0x000
+#define RESULT_OFFSET(id)       (0xc00 + id * 4)
+#define TRIGGER_ID_SHIFT        16
+#define TRIGGER_CMD_GET         4
+
+#define STA_OFFSET              0
+#define SET_OFFSET              4
+#define CLR_OFFSET              8
+
+#define CH_MASK(ch)     (0x3 << ((ch) * 2))
+#define SL_SIGL(ch)     (0x0 << ((ch) * 2))
+#define SL_QUED(ch)     (0x1 << ((ch) * 2))
+#define MA_FREE(ch)     (0x2 << ((ch) * 2))
+#define MA_ACKD(ch)     (0x3 << ((ch) * 2))
+
+struct tegra210_bpmp {
+        void __iomem *atomics;
+        void __iomem *arb_sema;
+        struct irq_data *tx_irq_data;
+};
+
+static u32 bpmp_channel_status(struct tegra_bpmp *bpmp, unsigned int index)
+{
+        struct tegra210_bpmp *priv = bpmp->priv;
+
+        return __raw_readl(priv->arb_sema + STA_OFFSET) & CH_MASK(index);
+}
+
+static bool tegra210_bpmp_is_response_ready(struct tegra_bpmp_channel *channel)
+{
+        unsigned int index = channel->index;
+
+        return bpmp_channel_status(channel->bpmp, index) == MA_ACKD(index);
+}
+
+static bool tegra210_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)
+{
+        unsigned int index = channel->index;
+
+        return bpmp_channel_status(channel->bpmp, index) == SL_SIGL(index);
+}
+
+static bool
+tegra210_bpmp_is_request_channel_free(struct tegra_bpmp_channel *channel)
+{
+        unsigned int index = channel->index;
+
+        return bpmp_channel_status(channel->bpmp, index) == MA_FREE(index);
+}
+
+static bool
+tegra210_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)
+{
+        unsigned int index = channel->index;
+
+        return bpmp_channel_status(channel->bpmp, index) == SL_QUED(index);
+}
+
+static int tegra210_bpmp_post_request(struct tegra_bpmp_channel *channel)
+{
+        struct tegra210_bpmp *priv = channel->bpmp->priv;
+
+        __raw_writel(CH_MASK(channel->index), priv->arb_sema + CLR_OFFSET);
+
+        return 0;
+}
+
+static int tegra210_bpmp_post_response(struct tegra_bpmp_channel *channel)
+{
+        struct tegra210_bpmp *priv = channel->bpmp->priv;
+
+        __raw_writel(MA_ACKD(channel->index), priv->arb_sema + SET_OFFSET);
+
+        return 0;
+}
+
+static int tegra210_bpmp_ack_response(struct tegra_bpmp_channel *channel)
+{
+        struct tegra210_bpmp *priv = channel->bpmp->priv;
+
+        __raw_writel(MA_ACKD(channel->index) ^ MA_FREE(channel->index),
+                     priv->arb_sema + CLR_OFFSET);
+
+        return 0;
+}
+
+static int tegra210_bpmp_ack_request(struct tegra_bpmp_channel *channel)
+{
+        struct tegra210_bpmp *priv = channel->bpmp->priv;
+
+        __raw_writel(SL_QUED(channel->index), priv->arb_sema + SET_OFFSET);
+
+        return 0;
+}
+
+static int tegra210_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
+{
+        struct tegra210_bpmp *priv = bpmp->priv;
+        struct irq_data *irq_data = priv->tx_irq_data;
+
+        /*
+         * Tegra Legacy Interrupt Controller (LIC) is used to notify BPMP of
+         * available messages
+         */
+        if (irq_data->chip->irq_retrigger)
+                return irq_data->chip->irq_retrigger(irq_data);
+
+        return -EINVAL;
+}
+
+static irqreturn_t rx_irq(int irq, void *data)
+{
+        struct tegra_bpmp *bpmp = data;
+
+        tegra_bpmp_handle_rx(bpmp);
+
+        return IRQ_HANDLED;
+}
+
+static int tegra210_bpmp_channel_init(struct tegra_bpmp_channel *channel,
+                                      struct tegra_bpmp *bpmp,
+                                      unsigned int index)
+{
+        struct tegra210_bpmp *priv = bpmp->priv;
+        u32 address;
+        void *p;
+
+        /* Retrieve channel base address from BPMP */
+        writel(index << TRIGGER_ID_SHIFT | TRIGGER_CMD_GET,
+               priv->atomics + TRIGGER_OFFSET);
+        address = readl(priv->atomics + RESULT_OFFSET(index));
+
+        p = devm_ioremap(bpmp->dev, address, 0x80);
+        if (!p)
+                return -ENOMEM;
+
+        channel->ib = p;
+        channel->ob = p;
+        channel->index = index;
+        init_completion(&channel->completion);
+        channel->bpmp = bpmp;
+
+        return 0;
+}
+
+static int tegra210_bpmp_init(struct tegra_bpmp *bpmp)
+{
+        struct platform_device *pdev = to_platform_device(bpmp->dev);
+        struct tegra210_bpmp *priv;
+        struct resource *res;
+        unsigned int i;
+        int err;
+
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        bpmp->priv = priv;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        priv->atomics = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(priv->atomics))
+                return PTR_ERR(priv->atomics);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        priv->arb_sema = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(priv->arb_sema))
+                return PTR_ERR(priv->arb_sema);
+
+        err = tegra210_bpmp_channel_init(bpmp->tx_channel, bpmp,
+                                         bpmp->soc->channels.cpu_tx.offset);
+        if (err < 0)
+                return err;
+
+        err = tegra210_bpmp_channel_init(bpmp->rx_channel, bpmp,
+                                         bpmp->soc->channels.cpu_rx.offset);
+        if (err < 0)
+                return err;
+
+        for (i = 0; i < bpmp->threaded.count; i++) {
+                unsigned int index = bpmp->soc->channels.thread.offset + i;
+
+                err = tegra210_bpmp_channel_init(&bpmp->threaded_channels[i],
+                                                 bpmp, index);
+                if (err < 0)
+                        return err;
+        }
+
+        err = platform_get_irq_byname(pdev, "tx");
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed to get TX IRQ: %d\n", err);
+                return err;
+        }
+
+        priv->tx_irq_data = irq_get_irq_data(err);
+        if (!priv->tx_irq_data) {
+                dev_err(&pdev->dev, "failed to get IRQ data for TX IRQ\n");
+                return err;
+        }
+
+        err = platform_get_irq_byname(pdev, "rx");
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed to get rx IRQ: %d\n", err);
+                return err;
+        }
+
+        err = devm_request_irq(&pdev->dev, err, rx_irq,
+                               IRQF_NO_SUSPEND, dev_name(&pdev->dev), bpmp);
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
+                return err;
+        }
+
+        return 0;
+}
+
+const struct tegra_bpmp_ops tegra210_bpmp_ops = {
+        .init = tegra210_bpmp_init,
+        .is_response_ready = tegra210_bpmp_is_response_ready,
+        .is_request_ready = tegra210_bpmp_is_request_ready,
+        .ack_response = tegra210_bpmp_ack_response,
+        .ack_request = tegra210_bpmp_ack_request,
+        .is_response_channel_free = tegra210_bpmp_is_response_channel_free,
+        .is_request_channel_free = tegra210_bpmp_is_request_channel_free,
+        .post_response = tegra210_bpmp_post_response,
+        .post_request = tegra210_bpmp_post_request,
+        .ring_doorbell = tegra210_bpmp_ring_doorbell,
+};
diff --git a/drivers/firmware/tegra/bpmp.c b/drivers/firmware/tegra/bpmp.c
index 689478b92bce..dd775e8ba5a0 100644
--- a/drivers/firmware/tegra/bpmp.c
+++ b/drivers/firmware/tegra/bpmp.c
@@ -26,6 +26,8 @@
 #include <soc/tegra/bpmp-abi.h>
 #include <soc/tegra/ivc.h>
 
+#include "bpmp-private.h"
+
 #define MSG_ACK         BIT(0)
 #define MSG_RING        BIT(1)
 #define TAG_SZ          32
@@ -36,6 +38,14 @@ mbox_client_to_bpmp(struct mbox_client *client)
         return container_of(client, struct tegra_bpmp, mbox.client);
 }
 
+static inline const struct tegra_bpmp_ops *
+channel_to_ops(struct tegra_bpmp_channel *channel)
+{
+        struct tegra_bpmp *bpmp = channel->bpmp;
+
+        return bpmp->soc->ops;
+}
+
 struct tegra_bpmp *tegra_bpmp_get(struct device *dev)
 {
         struct platform_device *pdev;
@@ -96,22 +106,21 @@ static bool tegra_bpmp_message_valid(const struct tegra_bpmp_message *msg)
                (msg->rx.size == 0 || msg->rx.data);
 }
 
-static bool tegra_bpmp_master_acked(struct tegra_bpmp_channel *channel)
+static bool tegra_bpmp_is_response_ready(struct tegra_bpmp_channel *channel)
 {
-        void *frame;
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
 
-        frame = tegra_ivc_read_get_next_frame(channel->ivc);
-        if (IS_ERR(frame)) {
-                channel->ib = NULL;
-                return false;
-        }
+        return ops->is_response_ready(channel);
+}
 
-        channel->ib = frame;
+static bool tegra_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)
+{
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
 
-        return true;
+        return ops->is_request_ready(channel);
 }
 
-static int tegra_bpmp_wait_ack(struct tegra_bpmp_channel *channel)
+static int tegra_bpmp_wait_response(struct tegra_bpmp_channel *channel)
 {
         unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;
         ktime_t end;
@@ -119,29 +128,45 @@ static int tegra_bpmp_wait_ack(struct tegra_bpmp_channel *channel)
         end = ktime_add_us(ktime_get(), timeout);
 
         do {
-                if (tegra_bpmp_master_acked(channel))
+                if (tegra_bpmp_is_response_ready(channel))
                         return 0;
         } while (ktime_before(ktime_get(), end));
 
         return -ETIMEDOUT;
 }
 
-static bool tegra_bpmp_master_free(struct tegra_bpmp_channel *channel)
+static int tegra_bpmp_ack_response(struct tegra_bpmp_channel *channel)
 {
-        void *frame;
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
 
-        frame = tegra_ivc_write_get_next_frame(channel->ivc);
-        if (IS_ERR(frame)) {
-                channel->ob = NULL;
-                return false;
-        }
+        return ops->ack_response(channel);
+}
 
-        channel->ob = frame;
+static int tegra_bpmp_ack_request(struct tegra_bpmp_channel *channel)
+{
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
 
-        return true;
+        return ops->ack_request(channel);
 }
 
-static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
+static bool
+tegra_bpmp_is_request_channel_free(struct tegra_bpmp_channel *channel)
+{
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->is_request_channel_free(channel);
+}
+
+static bool
+tegra_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)
+{
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->is_response_channel_free(channel);
+}
+
+static int
+tegra_bpmp_wait_request_channel_free(struct tegra_bpmp_channel *channel)
 {
         unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;
         ktime_t start, now;
@@ -149,7 +174,7 @@ static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
         start = ns_to_ktime(local_clock());
 
         do {
-                if (tegra_bpmp_master_free(channel))
+                if (tegra_bpmp_is_request_channel_free(channel))
                         return 0;
 
                 now = ns_to_ktime(local_clock());
@@ -158,6 +183,25 @@ static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
         return -ETIMEDOUT;
 }
 
+static int tegra_bpmp_post_request(struct tegra_bpmp_channel *channel)
+{
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->post_request(channel);
+}
+
+static int tegra_bpmp_post_response(struct tegra_bpmp_channel *channel)
+{
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->post_response(channel);
+}
+
+static int tegra_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
+{
+        return bpmp->soc->ops->ring_doorbell(bpmp);
+}
+
 static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
                                          void *data, size_t size, int *ret)
 {
@@ -166,7 +210,7 @@ static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
         if (data && size > 0)
                 memcpy(data, channel->ib->data, size);
 
-        err = tegra_ivc_read_advance(channel->ivc);
+        err = tegra_bpmp_ack_response(channel);
         if (err < 0)
                 return err;
 
@@ -210,7 +254,7 @@ static ssize_t __tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,
         if (data && size > 0)
                 memcpy(channel->ob->data, data, size);
 
-        return tegra_ivc_write_advance(channel->ivc);
+        return tegra_bpmp_post_request(channel);
 }
 
 static struct tegra_bpmp_channel *
@@ -238,7 +282,7 @@ tegra_bpmp_write_threaded(struct tegra_bpmp *bpmp, unsigned int mrq,
 
         channel = &bpmp->threaded_channels[index];
 
-        if (!tegra_bpmp_master_free(channel)) {
+        if (!tegra_bpmp_is_request_channel_free(channel)) {
                 err = -EBUSY;
                 goto unlock;
         }
@@ -270,7 +314,7 @@ static ssize_t tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,
 {
         int err;
 
-        err = tegra_bpmp_wait_master_free(channel);
+        err = tegra_bpmp_wait_request_channel_free(channel);
         if (err < 0)
                 return err;
 
@@ -302,13 +346,11 @@ int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,
 
         spin_unlock(&bpmp->atomic_tx_lock);
 
-        err = mbox_send_message(bpmp->mbox.channel, NULL);
+        err = tegra_bpmp_ring_doorbell(bpmp);
         if (err < 0)
                 return err;
 
-        mbox_client_txdone(bpmp->mbox.channel, 0);
-
-        err = tegra_bpmp_wait_ack(channel);
+        err = tegra_bpmp_wait_response(channel);
         if (err < 0)
                 return err;
 
@@ -335,12 +377,10 @@ int tegra_bpmp_transfer(struct tegra_bpmp *bpmp,
         if (IS_ERR(channel))
                 return PTR_ERR(channel);
 
-        err = mbox_send_message(bpmp->mbox.channel, NULL);
+        err = tegra_bpmp_ring_doorbell(bpmp);
         if (err < 0)
                 return err;
 
-        mbox_client_txdone(bpmp->mbox.channel, 0);
-
         timeout = usecs_to_jiffies(bpmp->soc->channels.thread.timeout);
 
         err = wait_for_completion_timeout(&channel->completion, timeout);
@@ -369,38 +409,34 @@ void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,
 {
         unsigned long flags = channel->ib->flags;
         struct tegra_bpmp *bpmp = channel->bpmp;
-        struct tegra_bpmp_mb_data *frame;
         int err;
 
         if (WARN_ON(size > MSG_DATA_MIN_SZ))
                 return;
 
-        err = tegra_ivc_read_advance(channel->ivc);
+        err = tegra_bpmp_ack_request(channel);
         if (WARN_ON(err < 0))
                 return;
 
         if ((flags & MSG_ACK) == 0)
                 return;
 
-        frame = tegra_ivc_write_get_next_frame(channel->ivc);
-        if (WARN_ON(IS_ERR(frame)))
+        if (WARN_ON(!tegra_bpmp_is_response_channel_free(channel)))
                 return;
 
-        frame->code = code;
+        channel->ob->code = code;
 
         if (data && size > 0)
-                memcpy(frame->data, data, size);
+                memcpy(channel->ob->data, data, size);
 
-        err = tegra_ivc_write_advance(channel->ivc);
+        err = tegra_bpmp_post_response(channel);
         if (WARN_ON(err < 0))
                 return;
 
         if (flags & MSG_RING) {
-                err = mbox_send_message(bpmp->mbox.channel, NULL);
+                err = tegra_bpmp_ring_doorbell(bpmp);
                 if (WARN_ON(err < 0))
                         return;
-
-                mbox_client_txdone(bpmp->mbox.channel, 0);
         }
 }
 EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return);
@@ -627,9 +663,8 @@ static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel)
         complete(&channel->completion);
 }
 
-static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
+void tegra_bpmp_handle_rx(struct tegra_bpmp *bpmp)
 {
-        struct tegra_bpmp *bpmp = mbox_client_to_bpmp(client);
         struct tegra_bpmp_channel *channel;
         unsigned int i, count;
         unsigned long *busy;
@@ -638,7 +673,7 @@ static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
         count = bpmp->soc->channels.thread.count;
         busy = bpmp->threaded.busy;
 
-        if (tegra_bpmp_master_acked(channel))
+        if (tegra_bpmp_is_request_ready(channel))
                 tegra_bpmp_handle_mrq(bpmp, channel->ib->code, channel);
 
         spin_lock(&bpmp->lock);
@@ -648,7 +683,7 @@ static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
 
                 channel = &bpmp->threaded_channels[i];
 
-                if (tegra_bpmp_master_acked(channel)) {
+                if (tegra_bpmp_is_response_ready(channel)) {
                         tegra_bpmp_channel_signal(channel);
                         clear_bit(i, busy);
                 }
@@ -657,74 +692,9 @@ static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
         spin_unlock(&bpmp->lock);
 }
 
-static void tegra_bpmp_ivc_notify(struct tegra_ivc *ivc, void *data)
-{
-        struct tegra_bpmp *bpmp = data;
-        int err;
-
-        if (WARN_ON(bpmp->mbox.channel == NULL))
-                return;
-
-        err = mbox_send_message(bpmp->mbox.channel, NULL);
-        if (err < 0)
-                return;
-
-        mbox_client_txdone(bpmp->mbox.channel, 0);
-}
-
-static int tegra_bpmp_channel_init(struct tegra_bpmp_channel *channel,
-                                   struct tegra_bpmp *bpmp,
-                                   unsigned int index)
-{
-        size_t message_size, queue_size;
-        unsigned int offset;
-        int err;
-
-        channel->ivc = devm_kzalloc(bpmp->dev, sizeof(*channel->ivc),
-                                    GFP_KERNEL);
-        if (!channel->ivc)
-                return -ENOMEM;
-
-        message_size = tegra_ivc_align(MSG_MIN_SZ);
-        queue_size = tegra_ivc_total_queue_size(message_size);
-        offset = queue_size * index;
-
-        err = tegra_ivc_init(channel->ivc, NULL,
-                             bpmp->rx.virt + offset, bpmp->rx.phys + offset,
-                             bpmp->tx.virt + offset, bpmp->tx.phys + offset,
-                             1, message_size, tegra_bpmp_ivc_notify,
-                             bpmp);
-        if (err < 0) {
-                dev_err(bpmp->dev, "failed to setup IVC for channel %u: %d\n",
-                        index, err);
-                return err;
-        }
-
-        init_completion(&channel->completion);
-        channel->bpmp = bpmp;
-
-        return 0;
-}
-
-static void tegra_bpmp_channel_reset(struct tegra_bpmp_channel *channel)
-{
-        /* reset the channel state */
-        tegra_ivc_reset(channel->ivc);
-
-        /* sync the channel state with BPMP */
-        while (tegra_ivc_notified(channel->ivc))
-                ;
-}
-
-static void tegra_bpmp_channel_cleanup(struct tegra_bpmp_channel *channel)
-{
-        tegra_ivc_cleanup(channel->ivc);
-}
-
 static int tegra_bpmp_probe(struct platform_device *pdev)
 {
         struct tegra_bpmp *bpmp;
-        unsigned int i;
         char tag[TAG_SZ];
         size_t size;
         int err;
@@ -736,32 +706,6 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
         bpmp->soc = of_device_get_match_data(&pdev->dev);
         bpmp->dev = &pdev->dev;
 
-        bpmp->tx.pool = of_gen_pool_get(pdev->dev.of_node, "shmem", 0);
-        if (!bpmp->tx.pool) {
-                dev_err(&pdev->dev, "TX shmem pool not found\n");
-                return -ENOMEM;
-        }
-
-        bpmp->tx.virt = gen_pool_dma_alloc(bpmp->tx.pool, 4096, &bpmp->tx.phys);
-        if (!bpmp->tx.virt) {
-                dev_err(&pdev->dev, "failed to allocate from TX pool\n");
-                return -ENOMEM;
-        }
-
-        bpmp->rx.pool = of_gen_pool_get(pdev->dev.of_node, "shmem", 1);
-        if (!bpmp->rx.pool) {
-                dev_err(&pdev->dev, "RX shmem pool not found\n");
-                err = -ENOMEM;
-                goto free_tx;
-        }
-
-        bpmp->rx.virt = gen_pool_dma_alloc(bpmp->rx.pool, 4096, &bpmp->rx.phys);
-        if (!bpmp->rx.virt) {
-                dev_err(&pdev->dev, "failed to allocate from RX pool\n");
-                err = -ENOMEM;
-                goto free_tx;
-        }
-
         INIT_LIST_HEAD(&bpmp->mrqs);
         spin_lock_init(&bpmp->lock);
 
@@ -771,81 +715,38 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
         size = BITS_TO_LONGS(bpmp->threaded.count) * sizeof(long);
 
         bpmp->threaded.allocated = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
-        if (!bpmp->threaded.allocated) {
-                err = -ENOMEM;
-                goto free_rx;
-        }
+        if (!bpmp->threaded.allocated)
+                return -ENOMEM;
 
         bpmp->threaded.busy = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
-        if (!bpmp->threaded.busy) {
-                err = -ENOMEM;
-                goto free_rx;
-        }
+        if (!bpmp->threaded.busy)
+                return -ENOMEM;
 
         spin_lock_init(&bpmp->atomic_tx_lock);
         bpmp->tx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->tx_channel),
                                         GFP_KERNEL);
-        if (!bpmp->tx_channel) {
-                err = -ENOMEM;
-                goto free_rx;
-        }
+        if (!bpmp->tx_channel)
+                return -ENOMEM;
 
         bpmp->rx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->rx_channel),
                                         GFP_KERNEL);
-        if (!bpmp->rx_channel) {
-                err = -ENOMEM;
-                goto free_rx;
-        }
+        if (!bpmp->rx_channel)
+                return -ENOMEM;
 
         bpmp->threaded_channels = devm_kcalloc(&pdev->dev, bpmp->threaded.count,
                                                sizeof(*bpmp->threaded_channels),
                                                GFP_KERNEL);
-        if (!bpmp->threaded_channels) {
-                err = -ENOMEM;
-                goto free_rx;
-        }
-
-        err = tegra_bpmp_channel_init(bpmp->tx_channel, bpmp,
-                                      bpmp->soc->channels.cpu_tx.offset);
-        if (err < 0)
-                goto free_rx;
+        if (!bpmp->threaded_channels)
+                return -ENOMEM;
 
-        err = tegra_bpmp_channel_init(bpmp->rx_channel, bpmp,
-                                      bpmp->soc->channels.cpu_rx.offset);
+        err = bpmp->soc->ops->init(bpmp);
         if (err < 0)
-                goto cleanup_tx_channel;
-
-        for (i = 0; i < bpmp->threaded.count; i++) {
-                err = tegra_bpmp_channel_init(
-                        &bpmp->threaded_channels[i], bpmp,
-                        bpmp->soc->channels.thread.offset + i);
-                if (err < 0)
-                        goto cleanup_threaded_channels;
-        }
-
-        /* mbox registration */
-        bpmp->mbox.client.dev = &pdev->dev;
-        bpmp->mbox.client.rx_callback = tegra_bpmp_handle_rx;
-        bpmp->mbox.client.tx_block = false;
-        bpmp->mbox.client.knows_txdone = false;
-
-        bpmp->mbox.channel = mbox_request_channel(&bpmp->mbox.client, 0);
-        if (IS_ERR(bpmp->mbox.channel)) {
-                err = PTR_ERR(bpmp->mbox.channel);
-                dev_err(&pdev->dev, "failed to get HSP mailbox: %d\n", err);
-                goto cleanup_threaded_channels;
-        }
-
-        /* reset message channels */
-        tegra_bpmp_channel_reset(bpmp->tx_channel);
-        tegra_bpmp_channel_reset(bpmp->rx_channel);
-        for (i = 0; i < bpmp->threaded.count; i++)
-                tegra_bpmp_channel_reset(&bpmp->threaded_channels[i]);
+                return err;
 
         err = tegra_bpmp_request_mrq(bpmp, MRQ_PING,
                                      tegra_bpmp_mrq_handle_ping, bpmp);
         if (err < 0)
-                goto free_mbox;
+                goto deinit;
 
         err = tegra_bpmp_ping(bpmp);
         if (err < 0) {
@@ -867,17 +768,23 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
         if (err < 0)
                 goto free_mrq;
 
-        err = tegra_bpmp_init_clocks(bpmp);
-        if (err < 0)
-                goto free_mrq;
+        if (of_find_property(pdev->dev.of_node, "#clock-cells", NULL)) {
+                err = tegra_bpmp_init_clocks(bpmp);
+                if (err < 0)
+                        goto free_mrq;
+        }
 
-        err = tegra_bpmp_init_resets(bpmp);
-        if (err < 0)
-                goto free_mrq;
+        if (of_find_property(pdev->dev.of_node, "#reset-cells", NULL)) {
+                err = tegra_bpmp_init_resets(bpmp);
+                if (err < 0)
+                        goto free_mrq;
+        }
 
-        err = tegra_bpmp_init_powergates(bpmp);
-        if (err < 0)
-                goto free_mrq;
+        if (of_find_property(pdev->dev.of_node, "#power-domain-cells", NULL)) {
+                err = tegra_bpmp_init_powergates(bpmp);
+                if (err < 0)
+                        goto free_mrq;
+        }
 
         err = tegra_bpmp_init_debugfs(bpmp);
         if (err < 0)
@@ -887,41 +794,27 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
 
 free_mrq:
         tegra_bpmp_free_mrq(bpmp, MRQ_PING, bpmp);
-free_mbox:
-        mbox_free_channel(bpmp->mbox.channel);
-cleanup_threaded_channels:
-        for (i = 0; i < bpmp->threaded.count; i++) {
-                if (bpmp->threaded_channels[i].bpmp)
-                        tegra_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
-        }
+deinit:
+        if (bpmp->soc->ops->deinit)
+                bpmp->soc->ops->deinit(bpmp);
 
-        tegra_bpmp_channel_cleanup(bpmp->rx_channel);
-cleanup_tx_channel:
-        tegra_bpmp_channel_cleanup(bpmp->tx_channel);
-free_rx:
-        gen_pool_free(bpmp->rx.pool, (unsigned long)bpmp->rx.virt, 4096);
-free_tx:
-        gen_pool_free(bpmp->tx.pool, (unsigned long)bpmp->tx.virt, 4096);
         return err;
 }
 
 static int __maybe_unused tegra_bpmp_resume(struct device *dev)
 {
         struct tegra_bpmp *bpmp = dev_get_drvdata(dev);
-        unsigned int i;
-
-        /* reset message channels */
-        tegra_bpmp_channel_reset(bpmp->tx_channel);
-        tegra_bpmp_channel_reset(bpmp->rx_channel);
-
-        for (i = 0; i < bpmp->threaded.count; i++)
-                tegra_bpmp_channel_reset(&bpmp->threaded_channels[i]);
 
-        return 0;
+        if (bpmp->soc->ops->resume)
+                return bpmp->soc->ops->resume(bpmp);
+        else
+                return 0;
 }
 
 static SIMPLE_DEV_PM_OPS(tegra_bpmp_pm_ops, NULL, tegra_bpmp_resume);
 
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
+    IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
 static const struct tegra_bpmp_soc tegra186_soc = {
         .channels = {
                 .cpu_tx = {
@@ -938,11 +831,42 @@ static const struct tegra_bpmp_soc tegra186_soc = {
                         .timeout = 0,
                 },
         },
+        .ops = &tegra186_bpmp_ops,
         .num_resets = 193,
 };
+#endif
+
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
+static const struct tegra_bpmp_soc tegra210_soc = {
+        .channels = {
+                .cpu_tx = {
+                        .offset = 0,
+                        .count = 1,
+                        .timeout = 60 * USEC_PER_SEC,
+                },
+                .thread = {
+                        .offset = 4,
+                        .count = 1,
+                        .timeout = 600 * USEC_PER_SEC,
+                },
+                .cpu_rx = {
+                        .offset = 8,
+                        .count = 1,
+                        .timeout = 0,
+                },
+        },
+        .ops = &tegra210_bpmp_ops,
+};
+#endif
 
 static const struct of_device_id tegra_bpmp_match[] = {
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
+    IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
         { .compatible = "nvidia,tegra186-bpmp", .data = &tegra186_soc },
+#endif
+#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
+        { .compatible = "nvidia,tegra210-bpmp", .data = &tegra210_soc },
+#endif
         { }
 };
 
diff --git a/drivers/firmware/ti_sci.c b/drivers/firmware/ti_sci.c
index 69ed1464175c..3fbbb61012c4 100644
--- a/drivers/firmware/ti_sci.c
+++ b/drivers/firmware/ti_sci.c
@@ -146,25 +146,8 @@ static int ti_sci_debug_show(struct seq_file *s, void *unused)
         return 0;
 }
 
-/**
- * ti_sci_debug_open() - debug file open
- * @inode:      inode pointer
- * @file:       file pointer
- *
- * Return: result of single_open
- */
-static int ti_sci_debug_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, ti_sci_debug_show, inode->i_private);
-}
-
-/* log file operations */
-static const struct file_operations ti_sci_debug_fops = {
-        .open = ti_sci_debug_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
+/* Provide the log file operations interface*/
+DEFINE_SHOW_ATTRIBUTE(ti_sci_debug);
 
 /**
  * ti_sci_debugfs_create() - Create log debug file
diff --git a/drivers/firmware/xilinx/Kconfig b/drivers/firmware/xilinx/Kconfig
index 8f44b9cd295a..bd33bbf70daf 100644
--- a/drivers/firmware/xilinx/Kconfig
+++ b/drivers/firmware/xilinx/Kconfig
@@ -6,6 +6,7 @@ menu "Zynq MPSoC Firmware Drivers"
 
 config ZYNQMP_FIRMWARE
         bool "Enable Xilinx Zynq MPSoC firmware interface"
+        select MFD_CORE
         help
           Firmware interface driver is used by different
           drivers to communicate with the firmware for
diff --git a/drivers/firmware/xilinx/zynqmp.c b/drivers/firmware/xilinx/zynqmp.c
index 9a1c72a9280f..98f936125643 100644
--- a/drivers/firmware/xilinx/zynqmp.c
+++ b/drivers/firmware/xilinx/zynqmp.c
@@ -14,6 +14,7 @@
 #include <linux/compiler.h>
 #include <linux/device.h>
 #include <linux/init.h>
+#include <linux/mfd/core.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
@@ -23,6 +24,12 @@
 #include <linux/firmware/xlnx-zynqmp.h>
 #include "zynqmp-debug.h"
 
+static const struct mfd_cell firmware_devs[] = {
+        {
+                .name = "zynqmp_power_controller",
+        },
+};
+
 /**
  * zynqmp_pm_ret_code() - Convert PMU-FW error codes to Linux error codes
  * @ret_status:         PMUFW return code
@@ -187,6 +194,29 @@ static int zynqmp_pm_get_api_version(u32 *version)
 }
 
 /**
+ * zynqmp_pm_get_chipid - Get silicon ID registers
+ * @idcode:     IDCODE register
+ * @version:    version register
+ *
+ * Return:      Returns the status of the operation and the idcode and version
+ *              registers in @idcode and @version.
+ */
+static int zynqmp_pm_get_chipid(u32 *idcode, u32 *version)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        if (!idcode || !version)
+                return -EINVAL;
+
+        ret = zynqmp_pm_invoke_fn(PM_GET_CHIPID, 0, 0, 0, 0, ret_payload);
+        *idcode = ret_payload[1];
+        *version = ret_payload[2];
+
+        return ret;
+}
+
+/**
  * zynqmp_pm_get_trustzone_version() - Get secure trustzone firmware version
  * @version:    Returned version value
  *
@@ -469,8 +499,129 @@ static int zynqmp_pm_ioctl(u32 node_id, u32 ioctl_id, u32 arg1, u32 arg2,
                                    arg1, arg2, out);
 }
 
+/**
+ * zynqmp_pm_reset_assert - Request setting of reset (1 - assert, 0 - release)
+ * @reset:              Reset to be configured
+ * @assert_flag:        Flag stating should reset be asserted (1) or
+ *                      released (0)
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_reset_assert(const enum zynqmp_pm_reset reset,
+                                  const enum zynqmp_pm_reset_action assert_flag)
+{
+        return zynqmp_pm_invoke_fn(PM_RESET_ASSERT, reset, assert_flag,
+                                   0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_reset_get_status - Get status of the reset
+ * @reset:      Reset whose status should be returned
+ * @status:     Returned status
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_reset_get_status(const enum zynqmp_pm_reset reset,
+                                      u32 *status)
+{
+        u32 ret_payload[PAYLOAD_ARG_CNT];
+        int ret;
+
+        if (!status)
+                return -EINVAL;
+
+        ret = zynqmp_pm_invoke_fn(PM_RESET_GET_STATUS, reset, 0,
+                                  0, 0, ret_payload);
+        *status = ret_payload[1];
+
+        return ret;
+}
+
+/**
+ * zynqmp_pm_init_finalize() - PM call to inform firmware that the caller
+ *                             master has initialized its own power management
+ *
+ * This API function is to be used for notify the power management controller
+ * about the completed power management initialization.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_init_finalize(void)
+{
+        return zynqmp_pm_invoke_fn(PM_PM_INIT_FINALIZE, 0, 0, 0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_set_suspend_mode() - Set system suspend mode
+ * @mode:       Mode to set for system suspend
+ *
+ * This API function is used to set mode of system suspend.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_set_suspend_mode(u32 mode)
+{
+        return zynqmp_pm_invoke_fn(PM_SET_SUSPEND_MODE, mode, 0, 0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_request_node() - Request a node with specific capabilities
+ * @node:               Node ID of the slave
+ * @capabilities:       Requested capabilities of the slave
+ * @qos:                Quality of service (not supported)
+ * @ack:                Flag to specify whether acknowledge is requested
+ *
+ * This function is used by master to request particular node from firmware.
+ * Every master must request node before using it.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_request_node(const u32 node, const u32 capabilities,
+                                  const u32 qos,
+                                  const enum zynqmp_pm_request_ack ack)
+{
+        return zynqmp_pm_invoke_fn(PM_REQUEST_NODE, node, capabilities,
+                                   qos, ack, NULL);
+}
+
+/**
+ * zynqmp_pm_release_node() - Release a node
+ * @node:       Node ID of the slave
+ *
+ * This function is used by master to inform firmware that master
+ * has released node. Once released, master must not use that node
+ * without re-request.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_release_node(const u32 node)
+{
+        return zynqmp_pm_invoke_fn(PM_RELEASE_NODE, node, 0, 0, 0, NULL);
+}
+
+/**
+ * zynqmp_pm_set_requirement() - PM call to set requirement for PM slaves
+ * @node:               Node ID of the slave
+ * @capabilities:       Requested capabilities of the slave
+ * @qos:                Quality of service (not supported)
+ * @ack:                Flag to specify whether acknowledge is requested
+ *
+ * This API function is to be used for slaves a PU already has requested
+ * to change its capabilities.
+ *
+ * Return: Returns status, either success or error+reason
+ */
+static int zynqmp_pm_set_requirement(const u32 node, const u32 capabilities,
+                                     const u32 qos,
+                                     const enum zynqmp_pm_request_ack ack)
+{
+        return zynqmp_pm_invoke_fn(PM_SET_REQUIREMENT, node, capabilities,
+                                   qos, ack, NULL);
+}
+
 static const struct zynqmp_eemi_ops eemi_ops = {
         .get_api_version = zynqmp_pm_get_api_version,
+        .get_chipid = zynqmp_pm_get_chipid,
         .query_data = zynqmp_pm_query_data,
         .clock_enable = zynqmp_pm_clock_enable,
         .clock_disable = zynqmp_pm_clock_disable,
@@ -482,6 +633,13 @@ static const struct zynqmp_eemi_ops eemi_ops = {
         .clock_setparent = zynqmp_pm_clock_setparent,
         .clock_getparent = zynqmp_pm_clock_getparent,
         .ioctl = zynqmp_pm_ioctl,
+        .reset_assert = zynqmp_pm_reset_assert,
+        .reset_get_status = zynqmp_pm_reset_get_status,
+        .init_finalize = zynqmp_pm_init_finalize,
+        .set_suspend_mode = zynqmp_pm_set_suspend_mode,
+        .request_node = zynqmp_pm_request_node,
+        .release_node = zynqmp_pm_release_node,
+        .set_requirement = zynqmp_pm_set_requirement,
 };
 
 /**
@@ -538,11 +696,19 @@ static int zynqmp_firmware_probe(struct platform_device *pdev)
 
         zynqmp_pm_api_debugfs_init();
 
+        ret = mfd_add_devices(&pdev->dev, PLATFORM_DEVID_NONE, firmware_devs,
+                              ARRAY_SIZE(firmware_devs), NULL, 0, NULL);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add MFD devices %d\n", ret);
+                return ret;
+        }
+
         return of_platform_populate(dev->of_node, NULL, NULL, dev);
 }
 
 static int zynqmp_firmware_remove(struct platform_device *pdev)
 {
+        mfd_remove_devices(&pdev->dev);
         zynqmp_pm_api_debugfs_exit();
 
         return 0;