diff --git a/ns_interface/multi_core/tfm_ns_mailbox_rtos_api.c b/ns_interface/multi_core/tfm_ns_mailbox_rtos_api.c
new file mode 100644
index 0000000..629e108
--- /dev/null
+++ b/ns_interface/multi_core/tfm_ns_mailbox_rtos_api.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2020-2021, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+/*
+ * This file is a reference implementation of Non-secure mailbox RTOS API.
+ * This reference implementation is based on TF-M ROTS wrapper API.
+ * It can be replaced by RTOS specific implementation.
+ */
+
+#ifdef TFM_MULTI_CORE_NS_OS_MAILBOX_THREAD
+#include "os_wrapper/msg_queue.h"
+#else
+#include "os_wrapper/semaphore.h"
+#endif
+#include "os_wrapper/thread.h"
+
+#include "tfm_ns_mailbox.h"
+
+/*
+ * Thread flag to manage wait/wake mechanism in mailbox.、
+ * Thread flag can be RTOS specific.
+ * The following example definition also covers the rule of CMSIS-RTOS2, which
+ * requires the MSB of thread flags must be 0b0.
+ */
+#define MAILBOX_THREAD_FLAG            0x5FCA0000
+
+#ifndef TFM_MULTI_CORE_NS_OS_MAILBOX_THREAD
+#define MAX_SEMAPHORE_COUNT            NUM_MAILBOX_QUEUE_SLOT
+
+static void *ns_lock_handle = NULL;
+#endif
+
+const void *tfm_ns_mailbox_os_get_task_handle(void)
+{
+    return os_wrapper_thread_get_handle();
+}
+
+void tfm_ns_mailbox_os_wait_reply(void)
+{
+    os_wrapper_thread_wait_flag(MAILBOX_THREAD_FLAG, OS_WRAPPER_WAIT_FOREVER);
+}
+
+void tfm_ns_mailbox_os_wake_task_isr(const void *task_handle)
+{
+    os_wrapper_thread_set_flag_isr((void *)task_handle, MAILBOX_THREAD_FLAG);
+}
+
+#ifdef TFM_MULTI_CORE_NS_OS_MAILBOX_THREAD
+void *tfm_ns_mailbox_os_mq_create(size_t msg_size, uint8_t msg_count)
+{
+    return os_wrapper_msg_queue_create(msg_size, msg_count);
+}
+
+int32_t tfm_ns_mailbox_os_mq_send(void *mq_handle, const void *msg_ptr)
+{
+    int32_t ret;
+
+    if (!mq_handle || !msg_ptr) {
+        return MAILBOX_INVAL_PARAMS;
+    }
+
+    while (1) {
+        ret = os_wrapper_msg_queue_send(mq_handle, msg_ptr);
+        if (ret == OS_WRAPPER_SUCCESS) {
+            return MAILBOX_SUCCESS;
+        }
+    }
+
+    return MAILBOX_GENERIC_ERROR;
+}
+
+int32_t tfm_ns_mailbox_os_mq_receive(void *mq_handle, void *msg_ptr)
+{
+    int32_t ret;
+
+    if (!mq_handle || !msg_ptr) {
+        return MAILBOX_INVAL_PARAMS;
+    }
+
+    while (1) {
+        ret = os_wrapper_msg_queue_receive(mq_handle, msg_ptr);
+        if (ret == OS_WRAPPER_SUCCESS) {
+            return MAILBOX_SUCCESS;
+        }
+    }
+
+    return MAILBOX_GENERIC_ERROR;
+}
+#else /* TFM_MULTI_CORE_NS_OS_MAILBOX_THREAD */
+int32_t tfm_ns_mailbox_os_lock_init(void)
+{
+    ns_lock_handle = os_wrapper_semaphore_create(MAX_SEMAPHORE_COUNT,
+                                                 MAX_SEMAPHORE_COUNT,
+                                                 NULL);
+    if (!ns_lock_handle) {
+        return MAILBOX_GENERIC_ERROR;
+    }
+
+    return MAILBOX_SUCCESS;
+}
+
+int32_t tfm_ns_mailbox_os_lock_acquire(void)
+{
+    return os_wrapper_semaphore_acquire(ns_lock_handle,
+                                        OS_WRAPPER_WAIT_FOREVER);
+}
+
+int32_t tfm_ns_mailbox_os_lock_release(void)
+{
+    return os_wrapper_semaphore_release(ns_lock_handle);
+}
+#endif /* TFM_MULTI_CORE_NS_OS_MAILBOX_THREAD */
diff --git a/ns_interface/os_wrapper/common.h b/ns_interface/os_wrapper/common.h
new file mode 100644
index 0000000..6494723
--- /dev/null
+++ b/ns_interface/os_wrapper/common.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2017-2019, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+#ifndef __OS_WRAPPER_COMMON_H__
+#define __OS_WRAPPER_COMMON_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define OS_WRAPPER_SUCCESS            (0x0)
+#define OS_WRAPPER_ERROR              (0xFFFFFFFFU)
+#define OS_WRAPPER_WAIT_FOREVER       (0xFFFFFFFFU)
+#define OS_WRAPPER_DEFAULT_STACK_SIZE (-1)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OS_WRAPPER_COMMON_H__ */
diff --git a/ns_interface/os_wrapper/msg_queue.h b/ns_interface/os_wrapper/msg_queue.h
new file mode 100644
index 0000000..ac69773
--- /dev/null
+++ b/ns_interface/os_wrapper/msg_queue.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2020-2021, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+#ifndef __OS_WRAPPER_MSG_QUEUE_H__
+#define __OS_WRAPPER_MSG_QUEUE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+#include "common.h"
+
+/**
+ * \brief Create and initialize a message queue
+ *
+ * \param[in] msg_size        The maximum message size in bytes
+ * \param[in] msg_count       The maximum number of messages in queue
+ *
+ * \return Returns handle of the message queue created, or NULL in case of error
+ */
+void *os_wrapper_msg_queue_create(size_t msg_size, uint8_t msg_count);
+
+/**
+ * \brief Send a message via message queue
+ *
+ * \param[in] mq_handle       The handle of message queue
+ * \param[in] msg_ptr         The pointer to the message to be sent
+ *
+ * \return \ref OS_WRAPPER_SUCCESS if the message is successfully sent, or
+ *         \ref OS_WRAPPER_ERROR in case of error
+ *
+ * \note The message size must be the same as the value set in
+ *       \ref os_wrapper_msg_queue_create.
+ *
+ * \note Time out value is not specified here. Whether the function is blocked
+ *       or returns instantly depends on the actual implementation and usage
+ *       scenario.
+ */
+int32_t os_wrapper_msg_queue_send(void *mq_handle,
+                                  const void *msg_ptr);
+
+/**
+ * \brief Receive a message from message queue
+ *
+ * \param[in] mq_handle       The handle of message queue
+ * \param[in] msg_ptr         The pointer to buffer for message to be received
+ *
+ * \return \ref OS_WRAPPER_SUCCESS if the message is successfully received, or
+ *         \ref OS_WRAPPER_ERROR in case of error
+ *
+ * \note The message size is the same as the value set in
+ *       \ref os_wrapper_msg_queue_create.
+ *
+ * \note The function should be blocked until a message is received from message
+ *       queue, unless an error occurs.
+ */
+int32_t os_wrapper_msg_queue_receive(void *mq_handle,
+                                     void *msg_ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OS_WRAPPER_MSG_QUEUE_H__ */
diff --git a/ns_interface/os_wrapper/mutex.h b/ns_interface/os_wrapper/mutex.h
new file mode 100644
index 0000000..e55ef70
--- /dev/null
+++ b/ns_interface/os_wrapper/mutex.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2017-2019, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+#ifndef __OS_WRAPPER_MUTEX_H__
+#define __OS_WRAPPER_MUTEX_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "common.h"
+
+/**
+ * \brief Creates a mutex for mutual exclusion of resources
+ *
+ * \return The handle of the created mutex on success or NULL on error
+ */
+void *os_wrapper_mutex_create(void);
+
+/**
+ * \brief Acquires a mutex that is created by \ref os_wrapper_mutex_create()
+ *
+ * \param[in] handle   The handle of the mutex to acquire. Should be one of the
+ *                     handles returned by \ref os_wrapper_mutex_create()
+ * \param[in] timeout  The maximum amount of time(in tick periods) for the
+ *                     thread to wait for the mutex to be available.
+ *                     If timeout is zero, the function will return immediately.
+ *                     Setting timeout to \ref OS_WRAPPER_WAIT_FOREVER will
+ *                     cause the thread to wait indefinitely
+ *
+ * \return \ref OS_WRAPPER_SUCCESS on success or \ref OS_WRAPPER_ERROR on error
+ */
+uint32_t os_wrapper_mutex_acquire(void *handle, uint32_t timeout);
+
+/**
+ * \brief Releases the mutex acquired previously
+ *
+
+ * \param[in] handle The handle of the mutex that has been acquired
+ *
+ * \return \ref OS_WRAPPER_SUCCESS on success or \ref OS_WRAPPER_ERROR on error
+ */
+uint32_t os_wrapper_mutex_release(void *handle);
+
+/**
+ * \brief Deletes a mutex that is created by \ref os_wrapper_mutex_create()
+ *
+ * \param[in] handle The handle of the mutex to be deleted
+ *
+ * \return \ref OS_WRAPPER_SUCCESS on success or \ref OS_WRAPPER_ERROR on error
+ */
+uint32_t os_wrapper_mutex_delete(void *handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OS_WRAPPER_MUTEX_H__ */
diff --git a/ns_interface/os_wrapper/semaphore.h b/ns_interface/os_wrapper/semaphore.h
new file mode 100644
index 0000000..83d88ca
--- /dev/null
+++ b/ns_interface/os_wrapper/semaphore.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2017-2020, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+#ifndef __OS_WRAPPER_SEMAPHORE_H__
+#define __OS_WRAPPER_SEMAPHORE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "common.h"
+
+/**
+ * \brief Creates a new semaphore
+ *
+ * \param[in] max_count       Highest count of the semaphore
+ * \param[in] initial_count   Starting count of the available semaphore
+ * \param[in] name            Name of the semaphore
+ *
+ * \return Returns handle of the semaphore created, or NULL in case of error
+ */
+void *os_wrapper_semaphore_create(uint32_t max_count, uint32_t initial_count,
+                                  const char *name);
+
+/**
+ * \brief Acquires the semaphore
+ *
+ * \param[in] hanlde  Semaphore handle
+ * \param[in] timeout Timeout value
+ *
+ * \return \ref OS_WRAPPER_SUCCESS in case of successful acquision, or
+ *         \ref OS_WRAPPER_ERROR in case of error
+ */
+uint32_t os_wrapper_semaphore_acquire(void *handle, uint32_t timeout);
+
+/**
+ * \brief Releases the semaphore
+ *
+ * \param[in] hanlde Semaphore handle
+ *
+ * \return \ref OS_WRAPPER_SUCCESS in case of successful release, or
+ *         \ref OS_WRAPPER_ERROR in case of error
+ */
+uint32_t os_wrapper_semaphore_release(void *handle);
+
+/**
+ * \brief Deletes the semaphore
+ *
+ * \param[in] handle Semaphore handle
+ *
+ * \return \ref OS_WRAPPER_SUCCESS in case of successful release, or
+ *         \ref OS_WRAPPER_ERROR in case of error
+ */
+uint32_t os_wrapper_semaphore_delete(void *handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OS_WRAPPER_SEMAPHORE_H__ */
diff --git a/ns_interface/os_wrapper/thread.h b/ns_interface/os_wrapper/thread.h
new file mode 100644
index 0000000..a493593
--- /dev/null
+++ b/ns_interface/os_wrapper/thread.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2017-2020, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+#ifndef __OS_WRAPPER_THREAD_H__
+#define __OS_WRAPPER_THREAD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "common.h"
+
+/* prototype for the thread entry function */
+typedef void (*os_wrapper_thread_func) (void *argument);
+
+/**
+ * \brief Creates a new thread
+ *
+ * \param[in] name        Name of the thread
+ * \param[in] stack_size  Size of stack to be allocated for this thread. It can
+ *                        be \ref OS_WRAPPER_DEFAULT_STACK_SIZE to use the
+ *                        default value provided by the underlying RTOS
+ * \param[in] func        Pointer to the function invoked by thread
+ * \param[in] arg         Argument to pass to the function invoked by thread
+ * \param[in] priority    Initial thread priority
+ *
+ * \return Returns the thread handle created, or NULL in case of error
+ */
+void *os_wrapper_thread_new(const char *name, int32_t stack_size,
+                            os_wrapper_thread_func func, void *arg,
+                            uint32_t priority);
+/**
+ * \brief Gets current thread handle
+ *
+ * \return Returns the thread handle, or NULL in case of error
+ */
+void *os_wrapper_thread_get_handle(void);
+
+/**
+ * \brief Gets thread priority
+ *
+ * \param[in]  handle   Thread handle
+ * \param[out] priority The priority of the thread
+ *
+ * \return Returns \ref OS_WRAPPER_SUCCESS on success, or \ref OS_WRAPPER_ERROR
+ *                 in case of error
+ */
+uint32_t os_wrapper_thread_get_priority(void *handle, uint32_t *priority);
+
+/**
+ * \brief Exits the calling thread
+ */
+void os_wrapper_thread_exit(void);
+
+/**
+ * \brief Set the event flags for synchronizing a thread specified by handle.
+ *
+ * \note This function may not be allowed to be called from Interrupt Service
+ *       Routines.
+ *
+ * \param[in] handle    Thread handle to be notified
+ * \param[in] flags     Event flags value
+ *
+ * \return Returns \ref OS_WRAPPER_SUCCESS on success, or \ref OS_WRAPPER_ERROR
+ *         in case of error
+ */
+uint32_t os_wrapper_thread_set_flag(void *handle, uint32_t flags);
+
+/**
+ * \brief Set the event flags in an interrupt handler for synchronizing a thread
+ *        specified by handle.
+ *
+ * \param[in] handle    Thread handle to be notified
+ * \param[in] flags     Event flags value
+ *
+ * \return Returns \ref OS_WRAPPER_SUCCESS on success, or \ref OS_WRAPPER_ERROR
+ *         in case of error
+ */
+uint32_t os_wrapper_thread_set_flag_isr(void *handle, uint32_t flags);
+
+/**
+ * \brief Wait for the event flags for synchronizing threads.
+ *
+ * \note This function may not be allowed to be called from Interrupt Service
+ *       Routines.
+ *
+ * \param[in] flags     Specify the flags to wait for
+ * \param[in] timeout   Timeout value
+ *
+ * \return Returns \ref OS_WRAPPER_SUCCESS on success, or \ref OS_WRAPPER_ERROR
+ *         in case of error
+ */
+uint32_t os_wrapper_thread_wait_flag(uint32_t flags, uint32_t timeout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OS_WRAPPER_THREAD_H__ */
diff --git a/ns_interface/os_wrapper/tick.h b/ns_interface/os_wrapper/tick.h
new file mode 100644
index 0000000..b377b0e
--- /dev/null
+++ b/ns_interface/os_wrapper/tick.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ */
+
+#ifndef __OS_WRAPPER_TICK_H__
+#define __OS_WRAPPER_TICK_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "common.h"
+
+/**
+ * \brief Return RTOS current tick count
+ *
+ * \return The current tick count
+ */
+uint32_t os_wrapper_get_tick(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __OS_WRAPPER_TICK_H__ */