net: ipa: define SMEM memory region for IPA

Arrange to use an item from SMEM memory for IPA.  SMEM item number
497 is designated to be used by the IPA.  Specify the item ID and
size of the region in platform configuration data.  Allocate and get
a pointer to this region from ipa_mem_init().  The memory must be
mapped for access through an SMMU.

Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ipa/ipa.h b/drivers/net/ipa/ipa.h
index 32f6dfafdb05fd82b003f0523e95837195f51e28..b10a853929525e47f6be21ce869cc37d0204f759 100644 (file)
--- a/drivers/net/ipa/ipa.h
+++ b/drivers/net/ipa/ipa.h
@@ -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;

diff --git a/drivers/net/ipa/ipa_data-sc7180.c b/drivers/net/ipa/ipa_data-sc7180.c
index e9007d151c68ab2f3433b0d03c83ab5896f96650..43faa35ae726b28aa99ec2434ec78d249086406b 100644 (file)
--- a/drivers/net/ipa/ipa_data-sc7180.c
+++ b/drivers/net/ipa/ipa_data-sc7180.c
@@ -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. */

diff --git a/drivers/net/ipa/ipa_data-sdm845.c b/drivers/net/ipa/ipa_data-sdm845.c
index c0e207085550fe89f7940a53e6313aefa150b90b..f7ba85717edf5b4690c07e2c5ea0489db0969baa 100644 (file)
--- a/drivers/net/ipa/ipa_data-sdm845.c
+++ b/drivers/net/ipa/ipa_data-sdm845.c
@@ -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. */

diff --git a/drivers/net/ipa/ipa_data.h b/drivers/net/ipa/ipa_data.h
index 69957af56ccd23590b1c2d1ca1ebc6a605b58f23..16dfd74717b15d971d9c6240a2262c19c4b542f6 100644 (file)
--- a/drivers/net/ipa/ipa_data.h
+++ b/drivers/net/ipa/ipa_data.h
@@ -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;
 };
 
 /**

diff --git a/drivers/net/ipa/ipa_mem.c b/drivers/net/ipa/ipa_mem.c
index 3c0916597fe12a13d3a8eb0cf508000d313ebc29..aa8f6b0f3d500f7e64d54f18f0474a80893f9880 100644 (file)
--- a/drivers/net/ipa/ipa_mem.c
+++ b/drivers/net/ipa/ipa_mem.c
@@ -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);
 }