drivers/net/ipa/ipa_mem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
   4  * Copyright (C) 2019-2020 Linaro Ltd.
   5  */
   6
   7 #include <linux/types.h>
   8 #include <linux/bitfield.h>
   9 #include <linux/bug.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/io.h>
  12
  13 #include "ipa.h"
  14 #include "ipa_reg.h"
  15 #include "ipa_cmd.h"
  16 #include "ipa_mem.h"
  17 #include "ipa_data.h"
  18 #include "ipa_table.h"
  19 #include "gsi_trans.h"
  20
  21 /* "Canary" value placed between memory regions to detect overflow */
  22 #define IPA_MEM_CANARY_VAL              cpu_to_le32(0xdeadbeef)
  23
  24 /* Add an immediate command to a transaction that zeroes a memory region */
  25 static void
  26 ipa_mem_zero_region_add(struct gsi_trans *trans, const struct ipa_mem *mem)
  27 {
  28         struct ipa *ipa = container_of(trans->gsi, struct ipa, gsi);
  29         dma_addr_t addr = ipa->zero_addr;
  30
  31         if (!mem->size)
  32                 return;
  33
  34         ipa_cmd_dma_shared_mem_add(trans, mem->offset, mem->size, addr, true);
  35 }
  36
  37 /**
  38  * ipa_mem_setup() - Set up IPA AP and modem shared memory areas
  39  *
  40  * Set up the shared memory regions in IPA local memory.  This involves
  41  * zero-filling memory regions, and in the case of header memory, telling
  42  * the IPA where it's located.
  43  *
  44  * This function performs the initial setup of this memory.  If the modem
  45  * crashes, its regions are re-zeroed in ipa_mem_zero_modem().
  46  *
  47  * The AP informs the modem where its portions of memory are located
  48  * in a QMI exchange that occurs at modem startup.
  49  *
  50  * @Return:     0 if successful, or a negative error code
  51  */
  52 int ipa_mem_setup(struct ipa *ipa)
  53 {
  54         dma_addr_t addr = ipa->zero_addr;
  55         struct gsi_trans *trans;
  56         u32 offset;
  57         u16 size;
  58
  59         /* Get a transaction to define the header memory region and to zero
  60          * the processing context and modem memory regions.
  61          */
  62         trans = ipa_cmd_trans_alloc(ipa, 4);
  63         if (!trans) {
  64                 dev_err(&ipa->pdev->dev, "no transaction for memory setup\n");
  65                 return -EBUSY;
  66         }
  67
  68         /* Initialize IPA-local header memory.  The modem and AP header
  69          * regions are contiguous, and initialized together.
  70          */
  71         offset = ipa->mem[IPA_MEM_MODEM_HEADER].offset;
  72         size = ipa->mem[IPA_MEM_MODEM_HEADER].size;
  73         size += ipa->mem[IPA_MEM_AP_HEADER].size;
  74
  75         ipa_cmd_hdr_init_local_add(trans, offset, size, addr);
  76
  77         ipa_mem_zero_region_add(trans, &ipa->mem[IPA_MEM_MODEM_PROC_CTX]);
  78
  79         ipa_mem_zero_region_add(trans, &ipa->mem[IPA_MEM_AP_PROC_CTX]);
  80
  81         ipa_mem_zero_region_add(trans, &ipa->mem[IPA_MEM_MODEM]);
  82
  83         gsi_trans_commit_wait(trans);
  84
  85         /* Tell the hardware where the processing context area is located */
  86         iowrite32(ipa->mem_offset + offset,
  87                   ipa->reg_virt + IPA_REG_LOCAL_PKT_PROC_CNTXT_BASE_OFFSET);
  88
  89         return 0;
  90 }
  91
  92 void ipa_mem_teardown(struct ipa *ipa)
  93 {
  94         /* Nothing to do */
  95 }
  96
  97 #ifdef IPA_VALIDATE
  98
  99 static bool ipa_mem_valid(struct ipa *ipa, enum ipa_mem_id mem_id)
 100 {
 101         const struct ipa_mem *mem = &ipa->mem[mem_id];
 102         struct device *dev = &ipa->pdev->dev;
 103         u16 size_multiple;
 104
 105         /* Other than modem memory, sizes must be a multiple of 8 */
 106         size_multiple = mem_id == IPA_MEM_MODEM ? 4 : 8;
 107         if (mem->size % size_multiple)
 108                 dev_err(dev, "region %u size not a multiple of %u bytes\n",
 109                         mem_id, size_multiple);
 110         else if (mem->offset % 8)
 111                 dev_err(dev, "region %u offset not 8-byte aligned\n", mem_id);
 112         else if (mem->offset < mem->canary_count * sizeof(__le32))
 113                 dev_err(dev, "region %u offset too small for %hu canaries\n",
 114                         mem_id, mem->canary_count);
 115         else if (mem->offset + mem->size > ipa->mem_size)
 116                 dev_err(dev, "region %u ends beyond memory limit (0x%08x)\n",
 117                         mem_id, ipa->mem_size);
 118         else
 119                 return true;
 120
 121         return false;
 122 }
 123
 124 #else /* !IPA_VALIDATE */
 125
 126 static bool ipa_mem_valid(struct ipa *ipa, enum ipa_mem_id mem_id)
 127 {
 128         return true;
 129 }
 130
 131 #endif /*! IPA_VALIDATE */
 132
 133 /**
 134  * ipa_mem_config() - Configure IPA shared memory
 135  *
 136  * @Return:     0 if successful, or a negative error code
 137  */
 138 int ipa_mem_config(struct ipa *ipa)
 139 {
 140         struct device *dev = &ipa->pdev->dev;
 141         enum ipa_mem_id mem_id;
 142         dma_addr_t addr;
 143         u32 mem_size;
 144         void *virt;
 145         u32 val;
 146
 147         /* Check the advertised location and size of the shared memory area */
 148         val = ioread32(ipa->reg_virt + IPA_REG_SHARED_MEM_SIZE_OFFSET);
 149
 150         /* The fields in the register are in 8 byte units */
 151         ipa->mem_offset = 8 * u32_get_bits(val, SHARED_MEM_BADDR_FMASK);
 152         /* Make sure the end is within the region's mapped space */
 153         mem_size = 8 * u32_get_bits(val, SHARED_MEM_SIZE_FMASK);
 154
 155         /* If the sizes don't match, issue a warning */
 156         if (ipa->mem_offset + mem_size > ipa->mem_size) {
 157                 dev_warn(dev, "ignoring larger reported memory size: 0x%08x\n",
 158                         mem_size);
 159         } else if (ipa->mem_offset + mem_size < ipa->mem_size) {
 160                 dev_warn(dev, "limiting IPA memory size to 0x%08x\n",
 161                          mem_size);
 162                 ipa->mem_size = mem_size;
 163         }
 164
 165         /* Prealloc DMA memory for zeroing regions */
 166         virt = dma_alloc_coherent(dev, IPA_MEM_MAX, &addr, GFP_KERNEL);
 167         if (!virt)
 168                 return -ENOMEM;
 169         ipa->zero_addr = addr;
 170         ipa->zero_virt = virt;
 171         ipa->zero_size = IPA_MEM_MAX;
 172
 173         /* Verify each defined memory region is valid, and if indicated
 174          * for the region, write "canary" values in the space prior to
 175          * the region's base address.
 176          */
 177         for (mem_id = 0; mem_id < IPA_MEM_COUNT; mem_id++) {
 178                 const struct ipa_mem *mem = &ipa->mem[mem_id];
 179                 u16 canary_count;
 180                 __le32 *canary;
 181
 182                 /* Validate all regions (even undefined ones) */
 183                 if (!ipa_mem_valid(ipa, mem_id))
 184                         goto err_dma_free;
 185
 186                 /* Skip over undefined regions */
 187                 if (!mem->offset && !mem->size)
 188                         continue;
 189
 190                 canary_count = mem->canary_count;
 191                 if (!canary_count)
 192                         continue;
 193
 194                 /* Write canary values in the space before the region */
 195                 canary = ipa->mem_virt + ipa->mem_offset + mem->offset;
 196                 do
 197                         *--canary = IPA_MEM_CANARY_VAL;
 198                 while (--canary_count);
 199         }
 200
 201         /* Make sure filter and route table memory regions are valid */
 202         if (!ipa_table_valid(ipa))
 203                 goto err_dma_free;
 204
 205         /* Validate memory-related properties relevant to immediate commands */
 206         if (!ipa_cmd_data_valid(ipa))
 207                 goto err_dma_free;
 208
 209         /* Verify the microcontroller ring alignment (0 is OK too) */
 210         if (ipa->mem[IPA_MEM_UC_EVENT_RING].offset % 1024) {
 211                 dev_err(dev, "microcontroller ring not 1024-byte aligned\n");
 212                 goto err_dma_free;
 213         }
 214
 215         return 0;
 216
 217 err_dma_free:
 218         dma_free_coherent(dev, IPA_MEM_MAX, ipa->zero_virt, ipa->zero_addr);
 219
 220         return -EINVAL;
 221 }
 222
 223 /* Inverse of ipa_mem_config() */
 224 void ipa_mem_deconfig(struct ipa *ipa)
 225 {
 226         struct device *dev = &ipa->pdev->dev;
 227
 228         dma_free_coherent(dev, ipa->zero_size, ipa->zero_virt, ipa->zero_addr);
 229         ipa->zero_size = 0;
 230         ipa->zero_virt = NULL;
 231         ipa->zero_addr = 0;
 232 }
 233
 234 /**
 235  * ipa_mem_zero_modem() - Zero IPA-local memory regions owned by the modem
 236  *
 237  * Zero regions of IPA-local memory used by the modem.  These are configured
 238  * (and initially zeroed) by ipa_mem_setup(), but if the modem crashes and
 239  * restarts via SSR we need to re-initialize them.  A QMI message tells the
 240  * modem where to find regions of IPA local memory it needs to know about
 241  * (these included).
 242  */
 243 int ipa_mem_zero_modem(struct ipa *ipa)
 244 {
 245         struct gsi_trans *trans;
 246
 247         /* Get a transaction to zero the modem memory, modem header,
 248          * and modem processing context regions.
 249          */
 250         trans = ipa_cmd_trans_alloc(ipa, 3);
 251         if (!trans) {
 252                 dev_err(&ipa->pdev->dev,
 253                         "no transaction to zero modem memory\n");
 254                 return -EBUSY;
 255         }
 256
 257         ipa_mem_zero_region_add(trans, &ipa->mem[IPA_MEM_MODEM_HEADER]);
 258
 259         ipa_mem_zero_region_add(trans, &ipa->mem[IPA_MEM_MODEM_PROC_CTX]);
 260
 261         ipa_mem_zero_region_add(trans, &ipa->mem[IPA_MEM_MODEM]);
 262
 263         gsi_trans_commit_wait(trans);
 264
 265         return 0;
 266 }
 267
 268 /* Perform memory region-related initialization */
 269 int ipa_mem_init(struct ipa *ipa, u32 count, const struct ipa_mem *mem)
 270 {
 271         struct device *dev = &ipa->pdev->dev;
 272         struct resource *res;
 273         int ret;
 274
 275         if (count > IPA_MEM_COUNT) {
 276                 dev_err(dev, "to many memory regions (%u > %u)\n",
 277                         count, IPA_MEM_COUNT);
 278                 return -EINVAL;
 279         }
 280
 281         ret = dma_set_mask_and_coherent(&ipa->pdev->dev, DMA_BIT_MASK(64));
 282         if (ret) {
 283                 dev_err(dev, "error %d setting DMA mask\n", ret);
 284                 return ret;
 285         }
 286
 287         res = platform_get_resource_byname(ipa->pdev, IORESOURCE_MEM,
 288                                            "ipa-shared");
 289         if (!res) {
 290                 dev_err(dev,
 291                         "DT error getting \"ipa-shared\" memory property\n");
 292                 return -ENODEV;
 293         }
 294
 295         ipa->mem_virt = memremap(res->start, resource_size(res), MEMREMAP_WC);
 296         if (!ipa->mem_virt) {
 297                 dev_err(dev, "unable to remap \"ipa-shared\" memory\n");
 298                 return -ENOMEM;
 299         }
 300
 301         ipa->mem_addr = res->start;
 302         ipa->mem_size = resource_size(res);
 303
 304         /* The ipa->mem[] array is indexed by enum ipa_mem_id values */
 305         ipa->mem = mem;
 306
 307         return 0;
 308 }
 309
 310 /* Inverse of ipa_mem_init() */
 311 void ipa_mem_exit(struct ipa *ipa)
 312 {
 313         memunmap(ipa->mem_virt);
 314 }