[RPSDK-1389] Enable rpmsg-lite Zephyr for RT700 and RT600

Signed-off-by: Tomas Galbicka <tomas.galbicka@nxp.com>

Author: TomasGalbickaNXP

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added i.MX952 parts support
 - Added mcxl14x parts support
 - Added mcxw70 parts support
+- Zephyr rpmsg-lite samples add support for RT600 and RT700 DSP cores
 
 ### Changed
 

lib/include/rpmsg_compiler.h

@@ -100,6 +100,8 @@
 #define MEM_BARRIER() __asm__ volatile("dsb sy" : : : "memory")
 #elif defined(__riscv)
 #define MEM_BARRIER() mb()
+#elif defined(__XTENSA__)
+#define MEM_BARRIER() __asm__ __volatile__("memw" : : : "memory")
 #else
 #define MEM_BARRIER() __asm__ volatile("dsb" : : : "memory")
 #endif

lib/rpmsg_lite/porting/platform/imxrt600_hifi4/rpmsg_platform_zephyr_ipm.c

@@ -0,0 +1,270 @@
+/*
+ * Copyright 2023-2024 NXP
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include <stdio.h>
+#include <string.h>
+
+#include "rpmsg_platform.h"
+#include "rpmsg_env.h"
+#include <zephyr/drivers/ipm.h>
+
+#if defined(RL_USE_ENVIRONMENT_CONTEXT) && (RL_USE_ENVIRONMENT_CONTEXT == 1)
+#error "This RPMsg-Lite port requires RL_USE_ENVIRONMENT_CONTEXT set to 0"
+#endif
+
+static int32_t isr_counter     = 0;
+static int32_t disable_counter = 0;
+static void *platform_lock;
+#if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
+static LOCK_STATIC_CONTEXT platform_lock_static_ctxt;
+#endif
+static const struct device *const ipm_handle = DEVICE_DT_GET(DT_CHOSEN(zephyr_ipc));
+static unsigned int irq_key;
+
+void platform_ipm_callback(const struct device *dev, void *context, uint32_t id, volatile void *data)
+{
+    if (((*(uint32_t *)data) & 0x01) != 0UL)
+    {
+        env_isr(0);
+    }
+    if (((*(uint32_t *)data) & 0x02) != 0UL)
+    {
+        env_isr(1);
+    }
+}
+
+static void platform_global_isr_disable(void)
+{
+    irq_key = irq_lock();
+}
+
+static void platform_global_isr_enable(void)
+{
+    irq_unlock(irq_key);
+}
+
+int32_t platform_init_interrupt(uint32_t vector_id, void *isr_data)
+{
+    /* Register ISR to environment layer */
+    env_register_isr(vector_id, isr_data);
+
+    env_lock_mutex(platform_lock);
+
+    RL_ASSERT(0 <= isr_counter);
+
+    isr_counter++;
+
+    env_unlock_mutex(platform_lock);
+
+    return 0;
+}
+
+int32_t platform_deinit_interrupt(uint32_t vector_id)
+{
+    /* Prepare the MU Hardware */
+    env_lock_mutex(platform_lock);
+
+    RL_ASSERT(0 < isr_counter);
+    isr_counter--;
+    if ((isr_counter == 0) && (ipm_handle != ((void *)0)))
+    {
+        ipm_set_enabled(ipm_handle, 0);
+    }
+
+    /* Unregister ISR from environment layer */
+    env_unregister_isr(vector_id);
+
+    env_unlock_mutex(platform_lock);
+
+    return 0;
+}
+
+void platform_notify(uint32_t vector_id)
+{
+    env_lock_mutex(platform_lock);
+    uint32_t data = (1 << RL_GET_Q_ID(vector_id));
+    RL_ASSERT(ipm_handle);
+    ipm_send(ipm_handle, 0, 0, &data, sizeof(uint32_t));
+    env_unlock_mutex(platform_lock);
+}
+
+/**
+ * platform_in_isr
+ *
+ * Return whether CPU is processing IRQ
+ *
+ * @return True for IRQ, false otherwise.
+ *
+ */
+int32_t platform_in_isr(void)
+{
+    return (0 != k_is_in_isr());
+}
+
+/**
+ * platform_interrupt_enable
+ *
+ * Enable peripheral-related interrupt
+ *
+ * @param vector_id Virtual vector ID that needs to be converted to IRQ number
+ *
+ * @return vector_id Return value is never checked.
+ *
+ */
+int32_t platform_interrupt_enable(uint32_t vector_id)
+{
+    RL_ASSERT(0 < disable_counter);
+
+    platform_global_isr_disable();
+    disable_counter--;
+
+    if ((disable_counter == 0) && (ipm_handle != ((void *)0)))
+    {
+        ipm_set_enabled(ipm_handle, 1);
+    }
+    platform_global_isr_enable();
+    return 0;
+}
+
+/**
+ * platform_interrupt_disable
+ *
+ * Disable peripheral-related interrupt.
+ *
+ * @param vector_id Virtual vector ID that needs to be converted to IRQ number
+ *
+ * @return vector_id Return value is never checked.
+ *
+ */
+int32_t platform_interrupt_disable(uint32_t vector_id)
+{
+    RL_ASSERT(0 <= disable_counter);
+
+    platform_global_isr_disable();
+    /* virtqueues use the same NVIC vector
+       if counter is set - the interrupts are disabled */
+    if ((disable_counter == 0) && (ipm_handle != ((void *)0)))
+    {
+        ipm_set_enabled(ipm_handle, 0);
+    }
+
+    disable_counter++;
+    platform_global_isr_enable();
+    return 0;
+}
+
+/**
+ * platform_map_mem_region
+ *
+ * Dummy implementation
+ *
+ */
+void platform_map_mem_region(uint32_t vrt_addr, uint32_t phy_addr, uint32_t size, uint32_t flags)
+{
+}
+
+/**
+ * platform_cache_all_flush_invalidate
+ *
+ * Dummy implementation
+ *
+ */
+void platform_cache_all_flush_invalidate(void)
+{
+}
+
+/**
+ * platform_cache_disable
+ *
+ * Dummy implementation
+ *
+ */
+void platform_cache_disable(void)
+{
+}
+
+/**
+ * platform_cache_flush
+ *
+ * Empty implementation
+ *
+ */
+void platform_cache_flush(void *data, uint32_t len)
+{
+}
+
+/**
+ * platform_cache_invalidate
+ *
+ * Empty implementation
+ *
+ */
+void platform_cache_invalidate(void *data, uint32_t len)
+{
+}
+
+/**
+ * platform_vatopa
+ *
+ * Dummy implementation
+ *
+ */
+uintptr_t platform_vatopa(void *addr)
+{
+    return ((uintptr_t)(char *)addr);
+}
+
+/**
+ * platform_patova
+ *
+ * Dummy implementation
+ *
+ */
+void *platform_patova(uintptr_t addr)
+{
+    return ((void *)(char *)addr);
+}
+
+/**
+ * platform_init
+ *
+ * platform/environment init
+ */
+int32_t platform_init(void)
+{
+    /* Get IPM device handle */
+    if (!ipm_handle)
+    {
+        return -1;
+    }
+
+    /* Register application callback with no context */
+    ipm_register_callback(ipm_handle, platform_ipm_callback, ((void *)0));
+
+    /* Create lock used in multi-instanced RPMsg */
+#if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
+    if (0 != env_create_mutex(&platform_lock, 1, &platform_lock_static_ctxt))
+#else
+    if (0 != env_create_mutex(&platform_lock, 1))
+#endif
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * platform_deinit
+ *
+ * platform/environment deinit process
+ */
+int32_t platform_deinit(void)
+{
+    /* Delete lock used in multi-instanced RPMsg */
+    env_delete_mutex(platform_lock);
+    platform_lock = ((void *)0);
+    return 0;
+}