firmware: tegra: Refactor BPMP driver

Split BPMP driver into common and chip specific parts to facilitate
adding support for previous and future Tegra chips that are using BPMP
as co-processor.

Signed-off-by: Timo Alho <talho@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Thierry Reding <treding@nvidia.com>

4 files changed, 394 insertions, 202 deletions

diff --git a/drivers/firmware/tegra/Makefile b/drivers/firmware/tegra/Makefile
index 1b826dcca719..559355674bca 100644
--- a/drivers/firmware/tegra/Makefile
+++ b/drivers/firmware/tegra/Makefile
@@ -1,4 +1,5 @@
 tegra-bpmp-y                    = bpmp.o
+tegra-bpmp-$(CONFIG_ARCH_TEGRA_186_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..6fb10f1cfb8f
--- /dev/null
+++ b/drivers/firmware/tegra/bpmp-private.h
@@ -0,0 +1,28 @@
+/* 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);
+};
+
+extern const struct tegra_bpmp_ops tegra186_bpmp_ops;
+
+#endif
diff --git a/drivers/firmware/tegra/bpmp-tegra186.c b/drivers/firmware/tegra/bpmp-tegra186.c
new file mode 100644
index 000000000000..89bb32b97345
--- /dev/null
+++ b/drivers/firmware/tegra/bpmp-tegra186.c
@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018, NVIDIA CORPORATION.
+ */
+
+#include <linux/clk/tegra.h>
+#include <linux/genalloc.h>
+#include <linux/mailbox_client.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/semaphore.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.c b/drivers/firmware/tegra/bpmp.c
index e7fd68ebedd0..2b498deacdbc 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;
@@ -98,22 +108,16 @@ static bool tegra_bpmp_message_valid(const struct tegra_bpmp_message *msg)
 
 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;
-        }
-
-        channel->ib = frame;
-
-        return true;
+        return ops->is_response_ready(channel);
 }
 
 static bool tegra_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)
 {
-        return tegra_bpmp_is_response_ready(channel);
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->is_request_ready(channel);
 }
 
 static int tegra_bpmp_wait_response(struct tegra_bpmp_channel *channel)
@@ -133,34 +137,32 @@ static int tegra_bpmp_wait_response(struct tegra_bpmp_channel *channel)
 
 static int tegra_bpmp_ack_response(struct tegra_bpmp_channel *channel)
 {
-        return tegra_ivc_read_advance(channel->ivc);
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->ack_response(channel);
 }
 
 static int tegra_bpmp_ack_request(struct tegra_bpmp_channel *channel)
 {
-        return tegra_ivc_read_advance(channel->ivc);
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->ack_request(channel);
 }
 
 static bool
 tegra_bpmp_is_request_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;
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
 
-        return true;
+        return ops->is_request_channel_free(channel);
 }
 
 static bool
 tegra_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)
 {
-        return tegra_bpmp_is_request_channel_free(channel);
+        const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
+
+        return ops->is_response_channel_free(channel);
 }
 
 static int
@@ -183,28 +185,21 @@ tegra_bpmp_wait_request_channel_free(struct tegra_bpmp_channel *channel)
 
 static int tegra_bpmp_post_request(struct tegra_bpmp_channel *channel)
 {
-        return tegra_ivc_write_advance(channel->ivc);
+        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)
 {
-        return tegra_ivc_write_advance(channel->ivc);
+        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)
 {
-        int err;
-
-        if (WARN_ON(bpmp->mbox.channel == NULL))
-                return -EINVAL;
-
-        err = mbox_send_message(bpmp->mbox.channel, NULL);
-        if (err < 0)
-                return err;
-
-        mbox_client_txdone(bpmp->mbox.channel, 0);
-
-        return 0;
+        return bpmp->soc->ops->ring_doorbell(bpmp);
 }
 
 static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
@@ -668,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;
@@ -698,66 +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;
-
-        WARN_ON(tegra_bpmp_ring_doorbell(bpmp));
-}
-
-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;
@@ -769,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);
 
@@ -804,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) {
@@ -920,37 +788,21 @@ 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);
@@ -971,6 +823,7 @@ static const struct tegra_bpmp_soc tegra186_soc = {
                         .timeout = 0,
                 },
         },
+        .ops = &tegra186_bpmp_ops,
         .num_resets = 193,
 };