xtensa: move to use system cache API support for coherency

Remove custom implementation and use system cache interface instead.

Signed-off-by: Anas Nashif <[email protected]>

arch/xtensa/core/mem_manage.c

@@ -8,11 +8,12 @@
 #include <zephyr/arch/xtensa/arch.h>
 #include <zephyr/arch/xtensa/cache.h>
 #include <zephyr/kernel/mm.h>
+#include <zephyr/cache.h>
 
 __weak bool sys_mm_is_phys_addr_in_range(uintptr_t phys)
 {
 	bool valid;
-	uintptr_t cached = (uintptr_t)arch_xtensa_cached_ptr((void *)phys);
+	uintptr_t cached = (uintptr_t)sys_cache_cached_ptr_get((void *)phys);
 
 	valid = ((phys >= CONFIG_SRAM_BASE_ADDRESS) &&
 		 (phys < (CONFIG_SRAM_BASE_ADDRESS + (CONFIG_SRAM_SIZE * 1024UL))));
@@ -28,7 +29,7 @@ __weak bool sys_mm_is_virt_addr_in_range(void *virt)
 	bool valid;
 	uintptr_t addr = (uintptr_t)virt;
 
-	uintptr_t cached = (uintptr_t)arch_xtensa_cached_ptr(virt);
+	uintptr_t cached = (uintptr_t)sys_cache_cached_ptr_get(virt);
 
 	valid = ((addr >= CONFIG_KERNEL_VM_BASE) &&
 		 (addr < (CONFIG_KERNEL_VM_BASE + CONFIG_KERNEL_VM_SIZE)));

arch/xtensa/core/ptables.c

@@ -255,13 +255,13 @@ static void map_memory(const uint32_t start, const uint32_t end,
 	map_memory_range(start, end, attrs, shared);
 
 #ifdef CONFIG_XTENSA_MMU_DOUBLE_MAP
-	if (arch_xtensa_is_ptr_uncached((void *)start)) {
-		map_memory_range(POINTER_TO_UINT(z_soc_cached_ptr((void *)start)),
-			POINTER_TO_UINT(z_soc_cached_ptr((void *)end)),
+	if (sys_cache_is_ptr_uncached((void *)start)) {
+		map_memory_range(POINTER_TO_UINT(sys_cache_cached_ptr_get((void *)start)),
+			POINTER_TO_UINT(sys_cache_cached_ptr_get((void *)end)),
 			attrs | XTENSA_MMU_CACHED_WB, shared);
-	} else if (arch_xtensa_is_ptr_cached((void *)start)) {
-		map_memory_range(POINTER_TO_UINT(z_soc_uncached_ptr((void *)start)),
-			POINTER_TO_UINT(z_soc_uncached_ptr((void *)end)), attrs, shared);
+	} else if (sys_cache_is_ptr_cached((void *)start)) {
+		map_memory_range(POINTER_TO_UINT(sys_cache_uncached_ptr_get((void *)start)),
+			POINTER_TO_UINT(sys_cache_uncached_ptr_get((void *)end)), attrs, shared);
 	}
 #endif
 }
@@ -413,19 +413,19 @@ static inline void __arch_mem_map(void *va, uintptr_t pa, uint32_t xtensa_flags,
 	uint32_t flags, flags_uc;
 
 	if (IS_ENABLED(CONFIG_XTENSA_MMU_DOUBLE_MAP)) {
-		if (arch_xtensa_is_ptr_cached(va)) {
+		if (sys_cache_is_ptr_cached(va)) {
 			vaddr = va;
-			vaddr_uc = arch_xtensa_uncached_ptr(va);
+			vaddr_uc = sys_cache_uncached_ptr_get(va);
 		} else {
-			vaddr = arch_xtensa_cached_ptr(va);
+			vaddr = sys_cache_cached_ptr_get(va);
 			vaddr_uc = va;
 		}
 
-		if (arch_xtensa_is_ptr_cached((void *)pa)) {
+		if (sys_cache_is_ptr_cached((void *)pa)) {
 			paddr = pa;
-			paddr_uc = (uintptr_t)arch_xtensa_uncached_ptr((void *)pa);
+			paddr_uc = (uintptr_t)sys_cache_uncached_ptr_get((void *)pa);
 		} else {
-			paddr = (uintptr_t)arch_xtensa_cached_ptr((void *)pa);
+			paddr = (uintptr_t)sys_cache_cached_ptr_get((void *)pa);
 			paddr_uc = pa;
 		}
 
@@ -588,11 +588,11 @@ static inline void __arch_mem_unmap(void *va)
 	void *vaddr, *vaddr_uc;
 
 	if (IS_ENABLED(CONFIG_XTENSA_MMU_DOUBLE_MAP)) {
-		if (arch_xtensa_is_ptr_cached(va)) {
+		if (sys_cache_is_ptr_cached(va)) {
 			vaddr = va;
-			vaddr_uc = arch_xtensa_uncached_ptr(va);
+			vaddr_uc = sys_cache_uncached_ptr_get(va);
 		} else {
-			vaddr = arch_xtensa_cached_ptr(va);
+			vaddr = sys_cache_cached_ptr_get(va);
 			vaddr_uc = va;
 		}
 	} else {
@@ -866,11 +866,11 @@ static inline int update_region(uint32_t *ptables, uintptr_t start,
 	uintptr_t va, va_uc;
 	uint32_t new_flags, new_flags_uc;
 
-	if (arch_xtensa_is_ptr_cached((void *)start)) {
+	if (sys_cache_is_ptr_cached((void *)start)) {
 		va = start;
-		va_uc = (uintptr_t)arch_xtensa_uncached_ptr((void *)start);
+		va_uc = (uintptr_t)sys_cache_uncached_ptr_get((void *)start);
 	} else {
-		va = (uintptr_t)arch_xtensa_cached_ptr((void *)start);
+		va = (uintptr_t)sys_cache_cached_ptr_get((void *)start);
 		va_uc = start;
 	}
 

drivers/console/winstream_console.c

@@ -8,10 +8,10 @@
 #include <zephyr/kernel.h>
 #include <zephyr/sys/winstream.h>
 #include <zephyr/devicetree.h>
+#include <zephyr/cache.h>
 
 #include <adsp_memory.h>
 #include <mem_window.h>
-#include <soc.h>
 
 struct k_spinlock trace_lock;
 
@@ -78,7 +78,7 @@ static int winstream_console_init(void)
 	}
 	const struct mem_win_config *config = dev->config;
 	void *buf =
-		arch_xtensa_uncached_ptr((__sparse_force void __sparse_cache *)config->mem_base);
+		sys_cache_uncached_ptr_get((__sparse_force void __sparse_cache *)config->mem_base);
 
 	winstream = sys_winstream_init(buf, config->size);
 	winstream_console_hook_install();

drivers/ipm/ipm_cavs_host.c

@@ -7,6 +7,7 @@
 #include <adsp_shim.h>
 #include <intel_adsp_ipc.h>
 #include <mem_window.h>
+#include <zephyr/cache.h>
 
 /* Matches SOF_IPC_MSG_MAX_SIZE, though in practice nothing anywhere
  * near that big is ever sent.  Should maybe consider making this a
@@ -49,8 +50,9 @@ static int send(const struct device *dev, int wait, uint32_t id,
 		return -ENODEV;
 	}
 	const struct mem_win_config *mw0_config = mw0->config;
-	uint32_t *buf = (uint32_t *)arch_xtensa_uncached_ptr((void *)((uint32_t)mw0_config->mem_base
-		+ CONFIG_IPM_CAVS_HOST_OUTBOX_OFFSET));
+	uint32_t *buf = (uint32_t *)sys_cache_uncached_ptr_get(
+			(void *)((uint32_t)mw0_config->mem_base
+			+ CONFIG_IPM_CAVS_HOST_OUTBOX_OFFSET));
 
 	if (!intel_adsp_ipc_is_complete(INTEL_ADSP_IPC_HOST_DEV)) {
 		return -EBUSY;
@@ -108,7 +110,7 @@ static bool ipc_handler(const struct device *dev, void *arg,
 		return -ENODEV;
 	}
 	const struct mem_win_config *mw1_config = mw1->config;
-	uint32_t *msg = arch_xtensa_uncached_ptr((void *)mw1_config->mem_base);
+	uint32_t *msg = sys_cache_uncached_ptr_get((void *)mw1_config->mem_base);
 
 	/* We play tricks to leave one word available before the
 	 * beginning of the SRAM window, this way the host can see the

drivers/mm/mm_drv_intel_adsp_mtl_tlb.c

@@ -16,7 +16,7 @@
  * Note that all passed in addresses should be in cached range
  * (aka cached addresses). Due to the need to calculate TLB
  * indexes, virtual addresses will be converted internally to
- * cached one via z_soc_cached_ptr(). However, physical addresses
+ * cached one via sys_cache_cached_ptr_get(). However, physical addresses
  * are untouched.
  */
 
@@ -183,8 +183,8 @@ int sys_mm_drv_map_page(void *virt, uintptr_t phys, uint32_t flags)
 	 * the cached physical address is needed to perform
 	 * bound check.
 	 */
-	uintptr_t pa = POINTER_TO_UINT(z_soc_cached_ptr(UINT_TO_POINTER(phys)));
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t pa = POINTER_TO_UINT(sys_cache_cached_ptr_get(UINT_TO_POINTER(phys)));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	ARG_UNUSED(flags);
 
@@ -215,7 +215,7 @@ int sys_mm_drv_map_page(void *virt, uintptr_t phys, uint32_t flags)
 				 "unable to assign free phys page %d\n", ret);
 			goto out;
 		}
-		pa = POINTER_TO_UINT(z_soc_cached_ptr(phys_block_ptr));
+		pa = POINTER_TO_UINT(sys_cache_cached_ptr_get(phys_block_ptr));
 	}
 
 	/* Check bounds of physical address space */
@@ -296,7 +296,7 @@ int sys_mm_drv_map_region(void *virt, uintptr_t phys,
 		goto out;
 	}
 
-	va = (__sparse_force uint8_t *)z_soc_cached_ptr(virt);
+	va = (__sparse_force uint8_t *)sys_cache_cached_ptr_get(virt);
 	pa = phys;
 
 	key = k_spin_lock(&sys_mm_drv_common_lock);
@@ -324,7 +324,7 @@ int sys_mm_drv_map_region(void *virt, uintptr_t phys,
 int sys_mm_drv_map_array(void *virt, uintptr_t *phys,
 			 size_t cnt, uint32_t flags)
 {
-	void *va = (__sparse_force void *)z_soc_cached_ptr(virt);
+	void *va = (__sparse_force void *)sys_cache_cached_ptr_get(virt);
 
 	return sys_mm_drv_simple_map_array(va, phys, cnt, flags);
 }
@@ -339,7 +339,7 @@ int sys_mm_drv_unmap_page(void *virt)
 	int ret = 0;
 
 	/* Use cached virtual address */
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	/* Check bounds of virtual address space */
 	CHECKIF((va < UNUSED_L2_START_ALIGNED) ||
@@ -396,7 +396,7 @@ int sys_mm_drv_unmap_page(void *virt)
 
 int sys_mm_drv_unmap_region(void *virt, size_t size)
 {
-	void *va = (__sparse_force void *)z_soc_cached_ptr(virt);
+	void *va = (__sparse_force void *)sys_cache_cached_ptr_get(virt);
 
 	return sys_mm_drv_simple_unmap_region(va, size);
 }
@@ -408,7 +408,7 @@ int sys_mm_drv_page_phys_get(void *virt, uintptr_t *phys)
 	int ret = 0;
 
 	/* Use cached address */
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	CHECKIF(!sys_mm_drv_is_addr_aligned(va)) {
 		ret = -EINVAL;
@@ -449,7 +449,7 @@ int sys_mm_drv_page_flag_get(void *virt, uint32_t *flags)
 	uint16_t ent;
 
 	/* Use cached address */
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	CHECKIF(!sys_mm_drv_is_addr_aligned(va)) {
 		ret = -EINVAL;
@@ -487,8 +487,8 @@ int sys_mm_drv_page_flag_get(void *virt, uint32_t *flags)
 int sys_mm_drv_remap_region(void *virt_old, size_t size,
 			    void *virt_new)
 {
-	void *va_new = (__sparse_force void *)z_soc_cached_ptr(virt_new);
-	void *va_old = (__sparse_force void *)z_soc_cached_ptr(virt_old);
+	void *va_new = (__sparse_force void *)sys_cache_cached_ptr_get(virt_new);
+	void *va_old = (__sparse_force void *)sys_cache_cached_ptr_get(virt_old);
 
 	return sys_mm_drv_simple_remap_region(va_old, size, va_new);
 }
@@ -500,8 +500,8 @@ int sys_mm_drv_move_region(void *virt_old, size_t size, void *virt_new,
 	size_t offset;
 	int ret = 0;
 
-	virt_new = (__sparse_force void *)z_soc_cached_ptr(virt_new);
-	virt_old = (__sparse_force void *)z_soc_cached_ptr(virt_old);
+	virt_new = (__sparse_force void *)sys_cache_cached_ptr_get(virt_new);
+	virt_old = (__sparse_force void *)sys_cache_cached_ptr_get(virt_old);
 
 	CHECKIF(!sys_mm_drv_is_virt_addr_aligned(virt_old) ||
 		!sys_mm_drv_is_virt_addr_aligned(virt_new) ||
@@ -598,8 +598,8 @@ int sys_mm_drv_move_array(void *virt_old, size_t size, void *virt_new,
 {
 	int ret;
 
-	void *va_new = (__sparse_force void *)z_soc_cached_ptr(virt_new);
-	void *va_old = (__sparse_force void *)z_soc_cached_ptr(virt_old);
+	void *va_new = (__sparse_force void *)sys_cache_cached_ptr_get(virt_new);
+	void *va_old = (__sparse_force void *)sys_cache_cached_ptr_get(virt_old);
 
 	ret = sys_mm_drv_simple_move_array(va_old, size, va_new,
 					    phys_new, phys_cnt);
@@ -783,7 +783,7 @@ __imr void adsp_mm_restore_context(void *storage_buffer)
 
 	while (phys_addr != 0) {
 		uint32_t phys_addr_uncached =
-				POINTER_TO_UINT(z_soc_uncached_ptr(
+				POINTER_TO_UINT(sys_cache_uncached_ptr_get(
 					(void __sparse_cache *)UINT_TO_POINTER(phys_addr)));
 		uint32_t phys_offset = phys_addr - L2_SRAM_BASE;
 		uint32_t bank_idx = (phys_offset / SRAM_BANK_SIZE);

drivers/mm/mm_drv_intel_adsp_tlb.c

@@ -16,7 +16,7 @@
  * Note that all passed in addresses should be in cached range
  * (aka cached addresses). Due to the need to calculate TLB
  * indexes, virtual addresses will be converted internally to
- * cached one via z_soc_cached_ptr(). However, physical addresses
+ * cached one via sys_cache_cached_ptr_get(). However, physical addresses
  * are untouched.
  */
 
@@ -32,7 +32,6 @@
 #include <zephyr/debug/sparse.h>
 #include <zephyr/cache.h>
 
-#include <soc.h>
 #include <adsp_memory.h>
 
 #include <zephyr/drivers/mm/system_mm.h>
@@ -80,8 +79,8 @@ int sys_mm_drv_map_page(void *virt, uintptr_t phys, uint32_t flags)
 	 * the cached physical address is needed to perform
 	 * bound check.
 	 */
-	uintptr_t pa = POINTER_TO_UINT(z_soc_cached_ptr(UINT_TO_POINTER(phys)));
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t pa = POINTER_TO_UINT(sys_cache_cached_ptr_get(UINT_TO_POINTER(phys)));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	ARG_UNUSED(flags);
 
@@ -145,15 +144,15 @@ int sys_mm_drv_map_page(void *virt, uintptr_t phys, uint32_t flags)
 int sys_mm_drv_map_region(void *virt, uintptr_t phys,
 			  size_t size, uint32_t flags)
 {
-	void *va = (__sparse_force void *)z_soc_cached_ptr(virt);
+	void *va = (__sparse_force void *)sys_cache_cached_ptr_get(virt);
 
 	return sys_mm_drv_simple_map_region(va, phys, size, flags);
 }
 
 int sys_mm_drv_map_array(void *virt, uintptr_t *phys,
 			 size_t cnt, uint32_t flags)
 {
-	void *va = (__sparse_force void *)z_soc_cached_ptr(virt);
+	void *va = (__sparse_force void *)sys_cache_cached_ptr_get(virt);
 
 	return sys_mm_drv_simple_map_array(va, phys, cnt, flags);
 }
@@ -166,7 +165,7 @@ int sys_mm_drv_unmap_page(void *virt)
 	int ret = 0;
 
 	/* Use cached virtual address */
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	/* Check bounds of virtual address space */
 	CHECKIF((va < CONFIG_KERNEL_VM_BASE) ||
@@ -202,7 +201,7 @@ int sys_mm_drv_unmap_page(void *virt)
 
 int sys_mm_drv_unmap_region(void *virt, size_t size)
 {
-	void *va = (__sparse_force void *)z_soc_cached_ptr(virt);
+	void *va = (__sparse_force void *)sys_cache_cached_ptr_get(virt);
 
 	return sys_mm_drv_simple_unmap_region(va, size);
 }
@@ -214,7 +213,7 @@ int sys_mm_drv_page_phys_get(void *virt, uintptr_t *phys)
 	int ret = 0;
 
 	/* Use cached address */
-	uintptr_t va = POINTER_TO_UINT(z_soc_cached_ptr(virt));
+	uintptr_t va = POINTER_TO_UINT(sys_cache_cached_ptr_get(virt));
 
 	CHECKIF(!sys_mm_drv_is_addr_aligned(va)) {
 		ret = -EINVAL;
@@ -274,7 +273,7 @@ int sys_mm_drv_update_page_flags(void *virt, uint32_t flags)
 int sys_mm_drv_update_region_flags(void *virt, size_t size,
 				   uint32_t flags)
 {
-	void *va = (__sparse_force void *)z_soc_cached_ptr(virt);
+	void *va = (__sparse_force void *)sys_cache_cached_ptr_get(virt);
 
 	return sys_mm_drv_simple_update_region_flags(va, size, flags);
 }
@@ -283,8 +282,8 @@ int sys_mm_drv_update_region_flags(void *virt, size_t size,
 int sys_mm_drv_remap_region(void *virt_old, size_t size,
 			    void *virt_new)
 {
-	void *va_new = (__sparse_force void *)z_soc_cached_ptr(virt_new);
-	void *va_old = (__sparse_force void *)z_soc_cached_ptr(virt_old);
+	void *va_new = (__sparse_force void *)sys_cache_cached_ptr_get(virt_new);
+	void *va_old = (__sparse_force void *)sys_cache_cached_ptr_get(virt_old);
 
 	return sys_mm_drv_simple_remap_region(va_old, size, va_new);
 }
@@ -294,8 +293,8 @@ int sys_mm_drv_move_region(void *virt_old, size_t size, void *virt_new,
 {
 	int ret;
 
-	void *va_new = (__sparse_force void *)z_soc_cached_ptr(virt_new);
-	void *va_old = (__sparse_force void *)z_soc_cached_ptr(virt_old);
+	void *va_new = (__sparse_force void *)sys_cache_cached_ptr_get(virt_new);
+	void *va_old = (__sparse_force void *)sys_cache_cached_ptr_get(virt_old);
 
 	ret = sys_mm_drv_simple_move_region(va_old, size, va_new, phys_new);
 
@@ -314,8 +313,8 @@ int sys_mm_drv_move_array(void *virt_old, size_t size, void *virt_new,
 {
 	int ret;
 
-	void *va_new = (__sparse_force void *)z_soc_cached_ptr(virt_new);
-	void *va_old = (__sparse_force void *)z_soc_cached_ptr(virt_old);
+	void *va_new = (__sparse_force void *)sys_cache_cached_ptr_get(virt_new);
+	void *va_old = (__sparse_force void *)sys_cache_cached_ptr_get(virt_old);
 
 	ret = sys_mm_drv_simple_move_array(va_old, size, va_new,
 					    phys_new, phys_cnt);