net: ipa: define SMEM memory region for IPA (a0036bb4) · Commits · 戴 / test

drivers/net/ipa/ipa.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,8 @@ struct ipa_interrupt;
		* @mem: Array of IPA-local memory region descriptors
		* @imem_iova: I/O virtual address of IPA region in IMEM
		* @imem_size; Size of IMEM region
		* @smem_iova: I/O virtual address of IPA region in SMEM
		* @smem_size; Size of SMEM region
		* @zero_addr: DMA address of preallocated zero-filled memory
		* @zero_virt: Virtual address of preallocated zero-filled memory
		* @zero_size: Size (bytes) of preallocated zero-filled memory
		@@ -93,6 +95,9 @@ struct ipa {
		unsigned long imem_iova;
		size_t imem_size;

		unsigned long smem_iova;
		size_t smem_size;

		dma_addr_t zero_addr;
		void *zero_virt;
		size_t zero_size;

drivers/net/ipa/ipa_data-sc7180.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -301,6 +301,8 @@ static struct ipa_mem_data ipa_mem_data = {
		.local = ipa_mem_local_data,
		.imem_addr = 0x146a8000,
		.imem_size = 0x00002000,
		.smem_id = 497,
		.smem_size = 0x00002000,
		};

		/* Configuration data for the SC7180 SoC. */

drivers/net/ipa/ipa_data-sdm845.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -323,6 +323,8 @@ static struct ipa_mem_data ipa_mem_data = {
		.local = ipa_mem_local_data,
		.imem_addr = 0x146bd000,
		.imem_size = 0x00002000,
		.smem_id = 497,
		.smem_size = 0x00002000,
		};

		/* Configuration data for the SDM845 SoC. */

drivers/net/ipa/ipa_data.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -250,12 +250,16 @@ struct ipa_resource_data {
		* @local: array of IPA-local memory region descriptors
		* @imem_addr: physical address of IPA region within IMEM
		* @imem_size: size in bytes of IPA IMEM region
		* @smem_id: item identifier for IPA region within SMEM memory
		* @imem_size: size in bytes of the IPA SMEM region
		*/
		struct ipa_mem_data {
		u32 local_count;
		const struct ipa_mem *local;
		u32 imem_addr;
		u32 imem_size;
		u32 smem_id;
		u32 smem_size;
		};

		/**

drivers/net/ipa/ipa_mem.c

+116 −0

Original line number	Diff line number	Diff line
		@@ -10,6 +10,7 @@
		#include <linux/dma-mapping.h>
		#include <linux/iommu.h>
		#include <linux/io.h>
		#include <linux/soc/qcom/smem.h>

		#include "ipa.h"
		#include "ipa_reg.h"
		@@ -23,6 +24,9 @@
		/* "Canary" value placed between memory regions to detect overflow */
		#define IPA_MEM_CANARY_VAL cpu_to_le32(0xdeadbeef)

		/* SMEM host id representing the modem. */
		#define QCOM_SMEM_HOST_MODEM 1

		/* Add an immediate command to a transaction that zeroes a memory region */
		static void
		ipa_mem_zero_region_add(struct gsi_trans trans, const struct ipa_mem mem)
		@@ -340,6 +344,111 @@ static void ipa_imem_exit(struct ipa *ipa)
		ipa->imem_iova = 0;
		}

		/**
		* ipa_smem_init() - Initialize SMEM memory used by the IPA
		* @ipa: IPA pointer
		* @item: Item ID of SMEM memory
		* @size: Size (bytes) of SMEM memory region
		*
		* SMEM is a managed block of shared DRAM, from which numbered "items"
		* can be allocated. One item is designated for use by the IPA.
		*
		* The modem accesses SMEM memory directly, but the IPA accesses it
		* via the IOMMU, using the AP's credentials.
		*
		* If size provided is non-zero, we allocate it and map it for
		* access through the IOMMU.
		*
		* Note: @size and the item address are is not guaranteed to be page-aligned.
		*/
		static int ipa_smem_init(struct ipa *ipa, u32 item, size_t size)
		{
		struct device *dev = &ipa->pdev->dev;
		struct iommu_domain *domain;
		unsigned long iova;
		phys_addr_t phys;
		phys_addr_t addr;
		size_t actual;
		void *virt;
		int ret;

		if (!size)
		return 0; /* SMEM memory not used */

		/* SMEM is memory shared between the AP and another system entity
		* (in this case, the modem). An allocation from SMEM is persistent
		* until the AP reboots; there is no way to free an allocated SMEM
		* region. Allocation only reserves the space; to use it you need
		* to "get" a pointer it (this implies no reference counting).
		* The item might have already been allocated, in which case we
		* use it unless the size isn't what we expect.
		*/
		ret = qcom_smem_alloc(QCOM_SMEM_HOST_MODEM, item, size);
		if (ret && ret != -EEXIST) {
		dev_err(dev, "error %d allocating size %zu SMEM item %u\n",
		ret, size, item);
		return ret;
		}

		/* Now get the address of the SMEM memory region */
		virt = qcom_smem_get(QCOM_SMEM_HOST_MODEM, item, &actual);
		if (IS_ERR(virt)) {
		ret = PTR_ERR(virt);
		dev_err(dev, "error %d getting SMEM item %u\n", ret, item);
		return ret;
		}

		/* In case the region was already allocated, verify the size */
		if (ret && actual != size) {
		dev_err(dev, "SMEM item %u has size %zu, expected %zu\n",
		item, actual, size);
		return -EINVAL;
		}

		domain = iommu_get_domain_for_dev(dev);
		if (!domain) {
		dev_err(dev, "no IOMMU domain found for SMEM\n");
		return -EINVAL;
		}

		/* Align the address down and the size up to a page boundary */
		addr = qcom_smem_virt_to_phys(virt) & PAGE_MASK;
		phys = addr & PAGE_MASK;
		size = PAGE_ALIGN(size + addr - phys);
		iova = phys; /* We just want a direct mapping */

		ret = iommu_map(domain, iova, phys, size, IOMMU_READ \| IOMMU_WRITE);
		if (ret)
		return ret;

		ipa->smem_iova = iova;
		ipa->smem_size = size;

		return 0;
		}

		static void ipa_smem_exit(struct ipa *ipa)
		{
		struct device *dev = &ipa->pdev->dev;
		struct iommu_domain *domain;

		domain = iommu_get_domain_for_dev(dev);
		if (domain) {
		size_t size;

		size = iommu_unmap(domain, ipa->smem_iova, ipa->smem_size);
		if (size != ipa->smem_size)
		dev_warn(dev, "unmapped %zu SMEM bytes, expected %lu\n",
		size, ipa->smem_size);

		} else {
		dev_err(dev, "couldn't get IPA IOMMU domain for SMEM\n");
		}

		ipa->smem_size = 0;
		ipa->smem_iova = 0;
		}

		/* Perform memory region-related initialization */
		int ipa_mem_init(struct ipa ipa, const struct ipa_mem_data mem_data)
		{
		@@ -383,8 +492,14 @@ int ipa_mem_init(struct ipa ipa, const struct ipa_mem_data mem_data)
		if (ret)
		goto err_unmap;

		ret = ipa_smem_init(ipa, mem_data->smem_id, mem_data->smem_size);
		if (ret)
		goto err_imem_exit;

		return 0;

		err_imem_exit:
		ipa_imem_exit(ipa);
		err_unmap:
		memunmap(ipa->mem_virt);

		@@ -394,6 +509,7 @@ err_unmap:
		/* Inverse of ipa_mem_init() */
		void ipa_mem_exit(struct ipa *ipa)
		{
		ipa_smem_exit(ipa);
		ipa_imem_exit(ipa);
		memunmap(ipa->mem_virt);
		}

Admin message