Unverified Commit b161ec3d authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

Merge tag 'tegra-for-6.5-firmware' of... 

Merge tag 'tegra-for-6.5-firmware' of git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux into soc/drivers

firmware: tegra: Changes for v6.5-rc1

This adds support for using system memory as shared memory between the
CPU and the BPMP, which will be needed for Tegra264 support.

* tag 'tegra-for-6.5-firmware' of git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux:
  firmware: tegra: bpmp: Add support for DRAM MRQ GSCs

Link: https://lore.kernel.org/r/20230609193620.2275240-2-thierry.reding@gmail.com


Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
parents bc889e87 2abd484c

drivers/firmware/tegra/bpmp-tegra186.c

+145 −59
Original line number Diff line number Diff line
@@ -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,76 +301,74 @@ 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;

	}



	/* 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;

	if (err < 0)

		tegra186_bpmp_teardown_channels(bpmp);



	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;

	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]);

}



	return 0;

static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)

{

	struct tegra186_bpmp *priv;

	int err;



cleanup_channels:

	for (i = 0; i < bpmp->threaded.count; i++) {

		if (!bpmp->threaded_channels[i].bpmp)

			continue;

	priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



		tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);

	}

	priv->parent = bpmp;

	bpmp->priv = priv;



	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);

	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;

	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);

		tegra186_bpmp_teardown_channels(bpmp);

		return err;

	}



	tegra186_bpmp_reset_channels(bpmp);



	return 0;

}



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;

}

drivers/firmware/tegra/bpmp.c

+2 −2
Original line number Diff line number Diff line
@@ -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;