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-2021 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/iommu.h>
  12 #include <linux/io.h>
  13 #include <linux/soc/qcom/smem.h>
  14
  15 #include "ipa.h"
  16 #include "ipa_reg.h"
  17 #include "ipa_data.h"
  18 #include "ipa_cmd.h"
  19 #include "ipa_mem.h"
  20 #include "ipa_table.h"
  21 #include "gsi_trans.h"
  22
  23 /* "Canary" value placed between memory regions to detect overflow */
  24 #define IPA_MEM_CANARY_VAL              cpu_to_le32(0xdeadbeef)
  25
  26 /* SMEM host id representing the modem. */
  27 #define QCOM_SMEM_HOST_MODEM    1
  28
  29 const struct ipa_mem *ipa_mem_find(struct ipa *ipa, enum ipa_mem_id mem_id)
  30 {
  31         u32 i;
  32
  33         for (i = 0; i < ipa->mem_count; i++) {
  34                 const struct ipa_mem *mem = &ipa->mem[i];
  35
  36                 if (mem->id == mem_id)
  37                         return mem;
  38         }
  39
  40         return NULL;
  41 }
  42
  43 /* Add an immediate command to a transaction that zeroes a memory region */
  44 static void
  45 ipa_mem_zero_region_add(struct gsi_trans *trans, enum ipa_mem_id mem_id)
  46 {
  47         struct ipa *ipa = container_of(trans->gsi, struct ipa, gsi);
  48         const struct ipa_mem *mem = ipa_mem_find(ipa, mem_id);
  49         dma_addr_t addr = ipa->zero_addr;
  50
  51         if (!mem->size)
  52                 return;
  53
  54         ipa_cmd_dma_shared_mem_add(trans, mem->offset, mem->size, addr, true);
  55 }
  56
  57 /**
  58  * ipa_mem_setup() - Set up IPA AP and modem shared memory areas
  59  * @ipa:        IPA pointer
  60  *
  61  * Set up the shared memory regions in IPA local memory.  This involves
  62  * zero-filling memory regions, and in the case of header memory, telling
  63  * the IPA where it's located.
  64  *
  65  * This function performs the initial setup of this memory.  If the modem
  66  * crashes, its regions are re-zeroed in ipa_mem_zero_modem().
  67  *
  68  * The AP informs the modem where its portions of memory are located
  69  * in a QMI exchange that occurs at modem startup.
  70  *
  71  * There is no need for a matching ipa_mem_teardown() function.
  72  *
  73  * Return:      0 if successful, or a negative error code
  74  */
  75 int ipa_mem_setup(struct ipa *ipa)
  76 {
  77         dma_addr_t addr = ipa->zero_addr;
  78         const struct ipa_mem *mem;
  79         struct gsi_trans *trans;
  80         u32 offset;
  81         u16 size;
  82         u32 val;
  83
  84         /* Get a transaction to define the header memory region and to zero
  85          * the processing context and modem memory regions.
  86          */
  87         trans = ipa_cmd_trans_alloc(ipa, 4);
  88         if (!trans) {
  89                 dev_err(&ipa->pdev->dev, "no transaction for memory setup\n");
  90                 return -EBUSY;
  91         }
  92
  93         /* Initialize IPA-local header memory.  The AP header region, if
  94          * present, is contiguous with and follows the modem header region,
  95          * and they are initialized together.
  96          */
  97         mem = ipa_mem_find(ipa, IPA_MEM_MODEM_HEADER);
  98         offset = mem->offset;
  99         size = mem->size;
 100         mem = ipa_mem_find(ipa, IPA_MEM_AP_HEADER);
 101         if (mem)
 102                 size += mem->size;
 103
 104         ipa_cmd_hdr_init_local_add(trans, offset, size, addr);
 105
 106         ipa_mem_zero_region_add(trans, IPA_MEM_MODEM_PROC_CTX);
 107         ipa_mem_zero_region_add(trans, IPA_MEM_AP_PROC_CTX);
 108         ipa_mem_zero_region_add(trans, IPA_MEM_MODEM);
 109
 110         gsi_trans_commit_wait(trans);
 111
 112         /* Tell the hardware where the processing context area is located */
 113         mem = ipa_mem_find(ipa, IPA_MEM_MODEM_PROC_CTX);
 114         offset = ipa->mem_offset + mem->offset;
 115         val = proc_cntxt_base_addr_encoded(ipa->version, offset);
 116         iowrite32(val, ipa->reg_virt + IPA_REG_LOCAL_PKT_PROC_CNTXT_OFFSET);
 117
 118         return 0;
 119 }
 120
 121 /* Is the given memory region ID is valid for the current IPA version? */
 122 static bool ipa_mem_id_valid(struct ipa *ipa, enum ipa_mem_id mem_id)
 123 {
 124         enum ipa_version version = ipa->version;
 125
 126         switch (mem_id) {
 127         case IPA_MEM_UC_SHARED:
 128         case IPA_MEM_UC_INFO:
 129         case IPA_MEM_V4_FILTER_HASHED:
 130         case IPA_MEM_V4_FILTER:
 131         case IPA_MEM_V6_FILTER_HASHED:
 132         case IPA_MEM_V6_FILTER:
 133         case IPA_MEM_V4_ROUTE_HASHED:
 134         case IPA_MEM_V4_ROUTE:
 135         case IPA_MEM_V6_ROUTE_HASHED:
 136         case IPA_MEM_V6_ROUTE:
 137         case IPA_MEM_MODEM_HEADER:
 138         case IPA_MEM_AP_HEADER:
 139         case IPA_MEM_MODEM_PROC_CTX:
 140         case IPA_MEM_AP_PROC_CTX:
 141         case IPA_MEM_MODEM:
 142         case IPA_MEM_UC_EVENT_RING:
 143         case IPA_MEM_PDN_CONFIG:
 144         case IPA_MEM_STATS_QUOTA_MODEM:
 145         case IPA_MEM_STATS_QUOTA_AP:
 146         case IPA_MEM_END_MARKER:        /* pseudo region */
 147                 break;
 148
 149         case IPA_MEM_STATS_TETHERING:
 150         case IPA_MEM_STATS_DROP:
 151                 if (version < IPA_VERSION_4_0)
 152                         return false;
 153                 break;
 154
 155         case IPA_MEM_STATS_V4_FILTER:
 156         case IPA_MEM_STATS_V6_FILTER:
 157         case IPA_MEM_STATS_V4_ROUTE:
 158         case IPA_MEM_STATS_V6_ROUTE:
 159                 if (version < IPA_VERSION_4_0 || version > IPA_VERSION_4_2)
 160                         return false;
 161                 break;
 162
 163         case IPA_MEM_NAT_TABLE:
 164         case IPA_MEM_STATS_FILTER_ROUTE:
 165                 if (version < IPA_VERSION_4_5)
 166                         return false;
 167                 break;
 168
 169         default:
 170                 return false;
 171         }
 172
 173         return true;
 174 }
 175
 176 /* Must the given memory region be present in the configuration? */
 177 static bool ipa_mem_id_required(struct ipa *ipa, enum ipa_mem_id mem_id)
 178 {
 179         switch (mem_id) {
 180         case IPA_MEM_UC_SHARED:
 181         case IPA_MEM_UC_INFO:
 182         case IPA_MEM_V4_FILTER_HASHED:
 183         case IPA_MEM_V4_FILTER:
 184         case IPA_MEM_V6_FILTER_HASHED:
 185         case IPA_MEM_V6_FILTER:
 186         case IPA_MEM_V4_ROUTE_HASHED:
 187         case IPA_MEM_V4_ROUTE:
 188         case IPA_MEM_V6_ROUTE_HASHED:
 189         case IPA_MEM_V6_ROUTE:
 190         case IPA_MEM_MODEM_HEADER:
 191         case IPA_MEM_MODEM_PROC_CTX:
 192         case IPA_MEM_AP_PROC_CTX:
 193         case IPA_MEM_MODEM:
 194                 return true;
 195
 196         case IPA_MEM_PDN_CONFIG:
 197         case IPA_MEM_STATS_QUOTA_MODEM:
 198         case IPA_MEM_STATS_TETHERING:
 199                 return ipa->version >= IPA_VERSION_4_0;
 200
 201         default:
 202                 return false;           /* Anything else is optional */
 203         }
 204 }
 205
 206 static bool ipa_mem_valid_one(struct ipa *ipa, const struct ipa_mem *mem)
 207 {
 208         struct device *dev = &ipa->pdev->dev;
 209         enum ipa_mem_id mem_id = mem->id;
 210         u16 size_multiple;
 211
 212         /* Make sure the memory region is valid for this version of IPA */
 213         if (!ipa_mem_id_valid(ipa, mem_id)) {
 214                 dev_err(dev, "region id %u not valid\n", mem_id);
 215                 return false;
 216         }
 217
 218         if (!mem->size && !mem->canary_count) {
 219                 dev_err(dev, "empty memory region %u\n", mem_id);
 220                 return false;
 221         }
 222
 223         /* Other than modem memory, sizes must be a multiple of 8 */
 224         size_multiple = mem_id == IPA_MEM_MODEM ? 4 : 8;
 225         if (mem->size % size_multiple)
 226                 dev_err(dev, "region %u size not a multiple of %u bytes\n",
 227                         mem_id, size_multiple);
 228         else if (mem->offset % 8)
 229                 dev_err(dev, "region %u offset not 8-byte aligned\n", mem_id);
 230         else if (mem->offset < mem->canary_count * sizeof(__le32))
 231                 dev_err(dev, "region %u offset too small for %hu canaries\n",
 232                         mem_id, mem->canary_count);
 233         else if (mem_id == IPA_MEM_END_MARKER && mem->size)
 234                 dev_err(dev, "non-zero end marker region size\n");
 235         else
 236                 return true;
 237
 238         return false;
 239 }
 240
 241 /* Verify each defined memory region is valid. */
 242 static bool ipa_mem_valid(struct ipa *ipa, const struct ipa_mem_data *mem_data)
 243 {
 244         DECLARE_BITMAP(regions, IPA_MEM_COUNT) = { };
 245         struct device *dev = &ipa->pdev->dev;
 246         enum ipa_mem_id mem_id;
 247         u32 i;
 248
 249         if (mem_data->local_count > IPA_MEM_COUNT) {
 250                 dev_err(dev, "too many memory regions (%u > %u)\n",
 251                         mem_data->local_count, IPA_MEM_COUNT);
 252                 return false;
 253         }
 254
 255         for (i = 0; i < mem_data->local_count; i++) {
 256                 const struct ipa_mem *mem = &mem_data->local[i];
 257
 258                 if (__test_and_set_bit(mem->id, regions)) {
 259                         dev_err(dev, "duplicate memory region %u\n", mem->id);
 260                         return false;
 261                 }
 262
 263                 /* Defined regions have non-zero size and/or canary count */
 264                 if (!ipa_mem_valid_one(ipa, mem))
 265                         return false;
 266         }
 267
 268         /* Now see if any required regions are not defined */
 269         for_each_clear_bit(mem_id, regions, IPA_MEM_COUNT) {
 270                 if (ipa_mem_id_required(ipa, mem_id))
 271                         dev_err(dev, "required memory region %u missing\n",
 272                                 mem_id);
 273         }
 274
 275         return true;
 276 }
 277
 278 /* Do all memory regions fit within the IPA local memory? */
 279 static bool ipa_mem_size_valid(struct ipa *ipa)
 280 {
 281         struct device *dev = &ipa->pdev->dev;
 282         u32 limit = ipa->mem_size;
 283         u32 i;
 284
 285         for (i = 0; i < ipa->mem_count; i++) {
 286                 const struct ipa_mem *mem = &ipa->mem[i];
 287
 288                 if (mem->offset + mem->size <= limit)
 289                         continue;
 290
 291                 dev_err(dev, "region %u ends beyond memory limit (0x%08x)\n",
 292                         mem->id, limit);
 293
 294                 return false;
 295         }
 296
 297         return true;
 298 }
 299
 300 /**
 301  * ipa_mem_config() - Configure IPA shared memory
 302  * @ipa:        IPA pointer
 303  *
 304  * Return:      0 if successful, or a negative error code
 305  */
 306 int ipa_mem_config(struct ipa *ipa)
 307 {
 308         struct device *dev = &ipa->pdev->dev;
 309         const struct ipa_mem *mem;
 310         dma_addr_t addr;
 311         u32 mem_size;
 312         void *virt;
 313         u32 val;
 314         u32 i;
 315
 316         /* Check the advertised location and size of the shared memory area */
 317         val = ioread32(ipa->reg_virt + IPA_REG_SHARED_MEM_SIZE_OFFSET);
 318
 319         /* The fields in the register are in 8 byte units */
 320         ipa->mem_offset = 8 * u32_get_bits(val, SHARED_MEM_BADDR_FMASK);
 321         /* Make sure the end is within the region's mapped space */
 322         mem_size = 8 * u32_get_bits(val, SHARED_MEM_SIZE_FMASK);
 323
 324         /* If the sizes don't match, issue a warning */
 325         if (ipa->mem_offset + mem_size < ipa->mem_size) {
 326                 dev_warn(dev, "limiting IPA memory size to 0x%08x\n",
 327                          mem_size);
 328                 ipa->mem_size = mem_size;
 329         } else if (ipa->mem_offset + mem_size > ipa->mem_size) {
 330                 dev_dbg(dev, "ignoring larger reported memory size: 0x%08x\n",
 331                         mem_size);
 332         }
 333
 334         /* We know our memory size; make sure regions are all in range */
 335         if (!ipa_mem_size_valid(ipa))
 336                 return -EINVAL;
 337
 338         /* Prealloc DMA memory for zeroing regions */
 339         virt = dma_alloc_coherent(dev, IPA_MEM_MAX, &addr, GFP_KERNEL);
 340         if (!virt)
 341                 return -ENOMEM;
 342         ipa->zero_addr = addr;
 343         ipa->zero_virt = virt;
 344         ipa->zero_size = IPA_MEM_MAX;
 345
 346         /* For each defined region, write "canary" values in the
 347          * space prior to the region's base address if indicated.
 348          */
 349         for (i = 0; i < ipa->mem_count; i++) {
 350                 u16 canary_count = ipa->mem[i].canary_count;
 351                 __le32 *canary;
 352
 353                 if (!canary_count)
 354                         continue;
 355
 356                 /* Write canary values in the space before the region */
 357                 canary = ipa->mem_virt + ipa->mem_offset + ipa->mem[i].offset;
 358                 do
 359                         *--canary = IPA_MEM_CANARY_VAL;
 360                 while (--canary_count);
 361         }
 362
 363         /* Make sure filter and route table memory regions are valid */
 364         if (!ipa_table_valid(ipa))
 365                 goto err_dma_free;
 366
 367         /* Validate memory-related properties relevant to immediate commands */
 368         if (!ipa_cmd_data_valid(ipa))
 369                 goto err_dma_free;
 370
 371         /* Verify the microcontroller ring alignment (if defined) */
 372         mem = ipa_mem_find(ipa, IPA_MEM_UC_EVENT_RING);
 373         if (mem && mem->offset % 1024) {
 374                 dev_err(dev, "microcontroller ring not 1024-byte aligned\n");
 375                 goto err_dma_free;
 376         }
 377
 378         return 0;
 379
 380 err_dma_free:
 381         dma_free_coherent(dev, IPA_MEM_MAX, ipa->zero_virt, ipa->zero_addr);
 382
 383         return -EINVAL;
 384 }
 385
 386 /* Inverse of ipa_mem_config() */
 387 void ipa_mem_deconfig(struct ipa *ipa)
 388 {
 389         struct device *dev = &ipa->pdev->dev;
 390
 391         dma_free_coherent(dev, ipa->zero_size, ipa->zero_virt, ipa->zero_addr);
 392         ipa->zero_size = 0;
 393         ipa->zero_virt = NULL;
 394         ipa->zero_addr = 0;
 395 }
 396
 397 /**
 398  * ipa_mem_zero_modem() - Zero IPA-local memory regions owned by the modem
 399  * @ipa:        IPA pointer
 400  *
 401  * Zero regions of IPA-local memory used by the modem.  These are configured
 402  * (and initially zeroed) by ipa_mem_setup(), but if the modem crashes and
 403  * restarts via SSR we need to re-initialize them.  A QMI message tells the
 404  * modem where to find regions of IPA local memory it needs to know about
 405  * (these included).
 406  */
 407 int ipa_mem_zero_modem(struct ipa *ipa)
 408 {
 409         struct gsi_trans *trans;
 410
 411         /* Get a transaction to zero the modem memory, modem header,
 412          * and modem processing context regions.
 413          */
 414         trans = ipa_cmd_trans_alloc(ipa, 3);
 415         if (!trans) {
 416                 dev_err(&ipa->pdev->dev,
 417                         "no transaction to zero modem memory\n");
 418                 return -EBUSY;
 419         }
 420
 421         ipa_mem_zero_region_add(trans, IPA_MEM_MODEM_HEADER);
 422         ipa_mem_zero_region_add(trans, IPA_MEM_MODEM_PROC_CTX);
 423         ipa_mem_zero_region_add(trans, IPA_MEM_MODEM);
 424
 425         gsi_trans_commit_wait(trans);
 426
 427         return 0;
 428 }
 429
 430 /**
 431  * ipa_imem_init() - Initialize IMEM memory used by the IPA
 432  * @ipa:        IPA pointer
 433  * @addr:       Physical address of the IPA region in IMEM
 434  * @size:       Size (bytes) of the IPA region in IMEM
 435  *
 436  * IMEM is a block of shared memory separate from system DRAM, and
 437  * a portion of this memory is available for the IPA to use.  The
 438  * modem accesses this memory directly, but the IPA accesses it
 439  * via the IOMMU, using the AP's credentials.
 440  *
 441  * If this region exists (size > 0) we map it for read/write access
 442  * through the IOMMU using the IPA device.
 443  *
 444  * Note: @addr and @size are not guaranteed to be page-aligned.
 445  */
 446 static int ipa_imem_init(struct ipa *ipa, unsigned long addr, size_t size)
 447 {
 448         struct device *dev = &ipa->pdev->dev;
 449         struct iommu_domain *domain;
 450         unsigned long iova;
 451         phys_addr_t phys;
 452         int ret;
 453
 454         if (!size)
 455                 return 0;       /* IMEM memory not used */
 456
 457         domain = iommu_get_domain_for_dev(dev);
 458         if (!domain) {
 459                 dev_err(dev, "no IOMMU domain found for IMEM\n");
 460                 return -EINVAL;
 461         }
 462
 463         /* Align the address down and the size up to page boundaries */
 464         phys = addr & PAGE_MASK;
 465         size = PAGE_ALIGN(size + addr - phys);
 466         iova = phys;    /* We just want a direct mapping */
 467
 468         ret = iommu_map(domain, iova, phys, size, IOMMU_READ | IOMMU_WRITE);
 469         if (ret)
 470                 return ret;
 471
 472         ipa->imem_iova = iova;
 473         ipa->imem_size = size;
 474
 475         return 0;
 476 }
 477
 478 static void ipa_imem_exit(struct ipa *ipa)
 479 {
 480         struct iommu_domain *domain;
 481         struct device *dev;
 482
 483         if (!ipa->imem_size)
 484                 return;
 485
 486         dev = &ipa->pdev->dev;
 487         domain = iommu_get_domain_for_dev(dev);
 488         if (domain) {
 489                 size_t size;
 490
 491                 size = iommu_unmap(domain, ipa->imem_iova, ipa->imem_size);
 492                 if (size != ipa->imem_size)
 493                         dev_warn(dev, "unmapped %zu IMEM bytes, expected %zu\n",
 494                                  size, ipa->imem_size);
 495         } else {
 496                 dev_err(dev, "couldn't get IPA IOMMU domain for IMEM\n");
 497         }
 498
 499         ipa->imem_size = 0;
 500         ipa->imem_iova = 0;
 501 }
 502
 503 /**
 504  * ipa_smem_init() - Initialize SMEM memory used by the IPA
 505  * @ipa:        IPA pointer
 506  * @item:       Item ID of SMEM memory
 507  * @size:       Size (bytes) of SMEM memory region
 508  *
 509  * SMEM is a managed block of shared DRAM, from which numbered "items"
 510  * can be allocated.  One item is designated for use by the IPA.
 511  *
 512  * The modem accesses SMEM memory directly, but the IPA accesses it
 513  * via the IOMMU, using the AP's credentials.
 514  *
 515  * If size provided is non-zero, we allocate it and map it for
 516  * access through the IOMMU.
 517  *
 518  * Note: @size and the item address are is not guaranteed to be page-aligned.
 519  */
 520 static int ipa_smem_init(struct ipa *ipa, u32 item, size_t size)
 521 {
 522         struct device *dev = &ipa->pdev->dev;
 523         struct iommu_domain *domain;
 524         unsigned long iova;
 525         phys_addr_t phys;
 526         phys_addr_t addr;
 527         size_t actual;
 528         void *virt;
 529         int ret;
 530
 531         if (!size)
 532                 return 0;       /* SMEM memory not used */
 533
 534         /* SMEM is memory shared between the AP and another system entity
 535          * (in this case, the modem).  An allocation from SMEM is persistent
 536          * until the AP reboots; there is no way to free an allocated SMEM
 537          * region.  Allocation only reserves the space; to use it you need
 538          * to "get" a pointer it (this does not imply reference counting).
 539          * The item might have already been allocated, in which case we
 540          * use it unless the size isn't what we expect.
 541          */
 542         ret = qcom_smem_alloc(QCOM_SMEM_HOST_MODEM, item, size);
 543         if (ret && ret != -EEXIST) {
 544                 dev_err(dev, "error %d allocating size %zu SMEM item %u\n",
 545                         ret, size, item);
 546                 return ret;
 547         }
 548
 549         /* Now get the address of the SMEM memory region */
 550         virt = qcom_smem_get(QCOM_SMEM_HOST_MODEM, item, &actual);
 551         if (IS_ERR(virt)) {
 552                 ret = PTR_ERR(virt);
 553                 dev_err(dev, "error %d getting SMEM item %u\n", ret, item);
 554                 return ret;
 555         }
 556
 557         /* In case the region was already allocated, verify the size */
 558         if (ret && actual != size) {
 559                 dev_err(dev, "SMEM item %u has size %zu, expected %zu\n",
 560                         item, actual, size);
 561                 return -EINVAL;
 562         }
 563
 564         domain = iommu_get_domain_for_dev(dev);
 565         if (!domain) {
 566                 dev_err(dev, "no IOMMU domain found for SMEM\n");
 567                 return -EINVAL;
 568         }
 569
 570         /* Align the address down and the size up to a page boundary */
 571         addr = qcom_smem_virt_to_phys(virt);
 572         phys = addr & PAGE_MASK;
 573         size = PAGE_ALIGN(size + addr - phys);
 574         iova = phys;    /* We just want a direct mapping */
 575
 576         ret = iommu_map(domain, iova, phys, size, IOMMU_READ | IOMMU_WRITE);
 577         if (ret)
 578                 return ret;
 579
 580         ipa->smem_iova = iova;
 581         ipa->smem_size = size;
 582
 583         return 0;
 584 }
 585
 586 static void ipa_smem_exit(struct ipa *ipa)
 587 {
 588         struct device *dev = &ipa->pdev->dev;
 589         struct iommu_domain *domain;
 590
 591         domain = iommu_get_domain_for_dev(dev);
 592         if (domain) {
 593                 size_t size;
 594
 595                 size = iommu_unmap(domain, ipa->smem_iova, ipa->smem_size);
 596                 if (size != ipa->smem_size)
 597                         dev_warn(dev, "unmapped %zu SMEM bytes, expected %zu\n",
 598                                  size, ipa->smem_size);
 599
 600         } else {
 601                 dev_err(dev, "couldn't get IPA IOMMU domain for SMEM\n");
 602         }
 603
 604         ipa->smem_size = 0;
 605         ipa->smem_iova = 0;
 606 }
 607
 608 /* Perform memory region-related initialization */
 609 int ipa_mem_init(struct ipa *ipa, const struct ipa_mem_data *mem_data)
 610 {
 611         struct device *dev = &ipa->pdev->dev;
 612         struct resource *res;
 613         int ret;
 614
 615         /* Make sure the set of defined memory regions is valid */
 616         if (!ipa_mem_valid(ipa, mem_data))
 617                 return -EINVAL;
 618
 619         ipa->mem_count = mem_data->local_count;
 620         ipa->mem = mem_data->local;
 621
 622         ret = dma_set_mask_and_coherent(&ipa->pdev->dev, DMA_BIT_MASK(64));
 623         if (ret) {
 624                 dev_err(dev, "error %d setting DMA mask\n", ret);
 625                 return ret;
 626         }
 627
 628         res = platform_get_resource_byname(ipa->pdev, IORESOURCE_MEM,
 629                                            "ipa-shared");
 630         if (!res) {
 631                 dev_err(dev,
 632                         "DT error getting \"ipa-shared\" memory property\n");
 633                 return -ENODEV;
 634         }
 635
 636         ipa->mem_virt = memremap(res->start, resource_size(res), MEMREMAP_WC);
 637         if (!ipa->mem_virt) {
 638                 dev_err(dev, "unable to remap \"ipa-shared\" memory\n");
 639                 return -ENOMEM;
 640         }
 641
 642         ipa->mem_addr = res->start;
 643         ipa->mem_size = resource_size(res);
 644
 645         ret = ipa_imem_init(ipa, mem_data->imem_addr, mem_data->imem_size);
 646         if (ret)
 647                 goto err_unmap;
 648
 649         ret = ipa_smem_init(ipa, mem_data->smem_id, mem_data->smem_size);
 650         if (ret)
 651                 goto err_imem_exit;
 652
 653         return 0;
 654
 655 err_imem_exit:
 656         ipa_imem_exit(ipa);
 657 err_unmap:
 658         memunmap(ipa->mem_virt);
 659
 660         return ret;
 661 }
 662
 663 /* Inverse of ipa_mem_init() */
 664 void ipa_mem_exit(struct ipa *ipa)
 665 {
 666         ipa_smem_exit(ipa);
 667         ipa_imem_exit(ipa);
 668         memunmap(ipa->mem_virt);
 669 }