firmware: tegra: bpmp: Add support for DRAM MRQ GSCs

Implement support for DRAM MRQ GSCs.

Signed-off-by: Peter De Schrijver <pdeschrijver@nvidia.com>
[treding@nvidia.com: drop unnecessary discrimination enum]
Signed-off-by: Thierry Reding <treding@nvidia.com>

diff --git a/drivers/firmware/tegra/bpmp-tegra186.c b/drivers/firmware/tegra/bpmp-tegra186.c
index 2e26199..6f0d051 100644 (file)
--- a/drivers/firmware/tegra/bpmp-tegra186.c
+++ b/drivers/firmware/tegra/bpmp-tegra186.c
@@ -4,7 +4,9 @@
  */
 
 #include <linux/genalloc.h>
+#include <linux/io.h>
 #include <linux/mailbox_client.h>
+#include <linux/of_address.h>
 #include <linux/platform_device.h>
 
 #include <soc/tegra/bpmp.h>
@@ -18,7 +20,10 @@ struct tegra186_bpmp {
 
        struct {
                struct gen_pool *pool;
-               void __iomem *virt;
+               union {
+                       void __iomem *sram;
+                       void *dram;
+               };
                dma_addr_t phys;
        } tx, rx;
 
@@ -118,8 +123,13 @@ static int tegra186_bpmp_channel_init(struct tegra_bpmp_channel *channel,
        queue_size = tegra_ivc_total_queue_size(message_size);
        offset = queue_size * index;
 
-       iosys_map_set_vaddr_iomem(&rx, priv->rx.virt + offset);
-       iosys_map_set_vaddr_iomem(&tx, priv->tx.virt + offset);
+       if (priv->rx.pool) {
+               iosys_map_set_vaddr_iomem(&rx, priv->rx.sram + offset);
+               iosys_map_set_vaddr_iomem(&tx, priv->tx.sram + offset);
+       } else {
+               iosys_map_set_vaddr(&rx, priv->rx.dram + offset);
+               iosys_map_set_vaddr(&tx, priv->tx.dram + offset);
+       }
 
        err = tegra_ivc_init(channel->ivc, NULL, &rx, priv->rx.phys + offset, &tx,
                             priv->tx.phys + offset, 1, message_size, tegra186_bpmp_ivc_notify,
@@ -158,18 +168,72 @@ static void mbox_handle_rx(struct mbox_client *client, void *data)
        tegra_bpmp_handle_rx(bpmp);
 }
 
-static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
+static void tegra186_bpmp_teardown_channels(struct tegra_bpmp *bpmp)
 {
-       struct tegra186_bpmp *priv;
+       struct tegra186_bpmp *priv = bpmp->priv;
        unsigned int i;
+
+       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);
+       tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
+
+       if (priv->tx.pool) {
+               gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.sram, 4096);
+               gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.sram, 4096);
+       }
+}
+
+static int tegra186_bpmp_dram_init(struct tegra_bpmp *bpmp)
+{
+       struct tegra186_bpmp *priv = bpmp->priv;
+       struct device_node *np;
+       struct resource res;
+       size_t size;
        int err;
 
-       priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
+       np = of_parse_phandle(bpmp->dev->of_node, "memory-region", 0);
+       if (!np)
+               return -ENODEV;
 
-       bpmp->priv = priv;
-       priv->parent = bpmp;
+       err = of_address_to_resource(np, 0, &res);
+       if (err < 0) {
+               dev_warn(bpmp->dev, "failed to parse memory region: %d\n", err);
+               return err;
+       }
+
+       size = resource_size(&res);
+
+       if (size < SZ_8K) {
+               dev_warn(bpmp->dev, "DRAM region must be larger than 8 KiB\n");
+               return -EINVAL;
+       }
+
+       priv->tx.phys = res.start;
+       priv->rx.phys = res.start + SZ_4K;
+
+       priv->tx.dram = devm_memremap(bpmp->dev, priv->tx.phys, size,
+                                     MEMREMAP_WC);
+       if (IS_ERR(priv->tx.dram)) {
+               err = PTR_ERR(priv->tx.dram);
+               dev_warn(bpmp->dev, "failed to map DRAM region: %d\n", err);
+               return err;
+       }
+
+       priv->rx.dram = priv->tx.dram + SZ_4K;
+
+       return 0;
+}
+
+static int tegra186_bpmp_sram_init(struct tegra_bpmp *bpmp)
+{
+       struct tegra186_bpmp *priv = bpmp->priv;
+       int err;
 
        priv->tx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 0);
        if (!priv->tx.pool) {
@@ -177,8 +241,9 @@ static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
                return -EPROBE_DEFER;
        }
 
-       priv->tx.virt = (void __iomem *)gen_pool_dma_alloc(priv->tx.pool, 4096, &priv->tx.phys);
-       if (!priv->tx.virt) {
+       priv->tx.sram = (void __iomem *)gen_pool_dma_alloc(priv->tx.pool, 4096,
+                                                          &priv->tx.phys);
+       if (!priv->tx.sram) {
                dev_err(bpmp->dev, "failed to allocate from TX pool\n");
                return -ENOMEM;
        }
@@ -190,22 +255,45 @@ static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
                goto free_tx;
        }
 
-       priv->rx.virt = (void __iomem *)gen_pool_dma_alloc(priv->rx.pool, 4096, &priv->rx.phys);
-       if (!priv->rx.virt) {
+       priv->rx.sram = (void __iomem *)gen_pool_dma_alloc(priv->rx.pool, 4096,
+                                                          &priv->rx.phys);
+       if (!priv->rx.sram) {
                dev_err(bpmp->dev, "failed to allocate from RX pool\n");
                err = -ENOMEM;
                goto free_tx;
        }
 
+       return 0;
+
+free_tx:
+       gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.sram, 4096);
+
+       return err;
+}
+
+static int tegra186_bpmp_setup_channels(struct tegra_bpmp *bpmp)
+{
+       unsigned int i;
+       int err;
+
+       err = tegra186_bpmp_dram_init(bpmp);
+       if (err == -ENODEV) {
+               err = tegra186_bpmp_sram_init(bpmp);
+               if (err < 0)
+                       return err;
+       }
+
        err = tegra186_bpmp_channel_init(bpmp->tx_channel, bpmp,
                                         bpmp->soc->channels.cpu_tx.offset);
        if (err < 0)
-               goto free_rx;
+               return err;
 
        err = tegra186_bpmp_channel_init(bpmp->rx_channel, bpmp,
                                         bpmp->soc->channels.cpu_rx.offset);
-       if (err < 0)
-               goto cleanup_tx_channel;
+       if (err < 0) {
+               tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
+               return err;
+       }
 
        for (i = 0; i < bpmp->threaded.count; i++) {
                unsigned int index = bpmp->soc->channels.thread.offset + i;
@@ -213,9 +301,43 @@ static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
                err = tegra186_bpmp_channel_init(&bpmp->threaded_channels[i],
                                                 bpmp, index);
                if (err < 0)
-                       goto cleanup_channels;
+                       break;
        }
 
+       if (err < 0)
+               tegra186_bpmp_teardown_channels(bpmp);
+
+       return err;
+}
+
+static void tegra186_bpmp_reset_channels(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]);
+}
+
+static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
+{
+       struct tegra186_bpmp *priv;
+       int err;
+
+       priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->parent = bpmp;
+       bpmp->priv = priv;
+
+       err = tegra186_bpmp_setup_channels(bpmp);
+       if (err < 0)
+               return err;
+
        /* mbox registration */
        priv->mbox.client.dev = bpmp->dev;
        priv->mbox.client.rx_callback = mbox_handle_rx;
@@ -226,63 +348,27 @@ static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
        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_teardown_channels(bpmp);
+               return err;
        }
 
-       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]);
+       tegra186_bpmp_reset_channels(bpmp);
 
        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);
+       tegra186_bpmp_teardown_channels(bpmp);
 }
 
 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]);
+       tegra186_bpmp_reset_channels(bpmp);
 
        return 0;
 }

diff --git a/drivers/firmware/tegra/bpmp.c b/drivers/firmware/tegra/bpmp.c
index 8b5e5da..17bd359 100644 (file)
--- a/drivers/firmware/tegra/bpmp.c
+++ b/drivers/firmware/tegra/bpmp.c
@@ -735,6 +735,8 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
        if (!bpmp->threaded_channels)
                return -ENOMEM;
 
+       platform_set_drvdata(pdev, bpmp);
+
        err = bpmp->soc->ops->init(bpmp);
        if (err < 0)
                return err;
@@ -758,8 +760,6 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
 
        dev_info(&pdev->dev, "firmware: %.*s\n", (int)sizeof(tag), tag);
 
-       platform_set_drvdata(pdev, bpmp);
-
        err = of_platform_default_populate(pdev->dev.of_node, NULL, &pdev->dev);
        if (err < 0)
                goto free_mrq;