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 
ipa_mem_find(struct ipa * ipa,enum ipa_mem_id mem_id)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
ipa_mem_zero_region_add(struct gsi_trans * trans,enum ipa_mem_id mem_id)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  */
ipa_mem_setup(struct ipa * ipa)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? */
ipa_mem_id_valid(struct ipa * ipa,enum ipa_mem_id mem_id)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? */
ipa_mem_id_required(struct ipa * ipa,enum ipa_mem_id mem_id)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 
ipa_mem_valid_one(struct ipa * ipa,const struct ipa_mem * mem)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. */
ipa_mem_valid(struct ipa * ipa,const struct ipa_mem_data * mem_data)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? */
ipa_mem_size_valid(struct ipa * ipa)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  */
ipa_mem_config(struct ipa * ipa)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() */
ipa_mem_deconfig(struct ipa * ipa)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  */
ipa_mem_zero_modem(struct ipa * ipa)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  */
ipa_imem_init(struct ipa * ipa,unsigned long addr,size_t size)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 
ipa_imem_exit(struct ipa * ipa)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  */
ipa_smem_init(struct ipa * ipa,u32 item,size_t size)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 
ipa_smem_exit(struct ipa * ipa)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 */
ipa_mem_init(struct ipa * ipa,const struct ipa_mem_data * mem_data)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() */
ipa_mem_exit(struct ipa * ipa)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 }
670