Updating message handler firmware
The 'message handler' firmware was based on a custom interface between
Linux and the firmware. Because the kernel driver has been converted
into a rpmsg driver, the 'message handler' application has been updated
into an OpenAMP based firmware.
Change-Id: I1339180c4f53cbad42501a2827863b7b49561ff4
diff --git a/applications/message_handler_openamp/CMakeLists.txt b/applications/message_handler_openamp/CMakeLists.txt
new file mode 100644
index 0000000..f2624c3
--- /dev/null
+++ b/applications/message_handler_openamp/CMakeLists.txt
@@ -0,0 +1,76 @@
+#
+# SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the License); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an AS IS BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+if(NOT TARGET freertos_kernel)
+ message("Skipping message handler openamp")
+ return()
+endif()
+
+#############################################################################
+# Configuration
+#############################################################################
+
+set(MESSAGE_HANDLER_MODEL_0 "" CACHE STRING "Path to built in model 0")
+set(MESSAGE_HANDLER_MODEL_1 "" CACHE STRING "Path to built in model 1")
+set(MESSAGE_HANDLER_MODEL_2 "" CACHE STRING "Path to built in model 2")
+set(MESSAGE_HANDLER_MODEL_3 "" CACHE STRING "Path to built in model 3")
+
+set(MESSAGE_HANDLER_ARENA_SIZE 2000000 CACHE STRING "Total size of all message handler tensor arenas")
+
+#############################################################################
+# TFLM arena
+#############################################################################
+
+# Split total tensor arena equally for each NPU
+if(TARGET ethosu_core_driver AND ETHOSU_TARGET_NPU_COUNT GREATER 0)
+ set(NUM_ARENAS ${ETHOSU_TARGET_NPU_COUNT})
+else()
+ set(NUM_ARENAS 1)
+endif()
+
+math(EXPR TENSOR_ARENA_SIZE "${MESSAGE_HANDLER_ARENA_SIZE} / ${NUM_ARENAS}")
+
+#############################################################################
+# Message handler application
+#############################################################################
+
+ethosu_add_executable(message_handler_openamp
+ SOURCES
+ main.cpp
+ core_driver_mutex.cpp
+ freertos_allocator.cpp
+ inference_runner.cpp
+ message_handler.cpp
+ remoteproc.cpp
+ LIBRARIES
+ $<$<TARGET_EXISTS:ethosu_core_driver>:ethosu_core_driver>
+ ethosu_log
+ ethosu_mailbox
+ freertos_kernel
+ inference_process
+ openamp-freertos)
+
+target_include_directories(message_handler_openamp PRIVATE
+ ${LINUX_DRIVER_STACK_PATH}/kernel)
+
+target_compile_definitions(message_handler_openamp PRIVATE
+ TENSOR_ARENA_SIZE=${TENSOR_ARENA_SIZE}
+ $<$<BOOL:${MESSAGE_HANDLER_MODEL_0}>:MODEL_0=${MESSAGE_HANDLER_MODEL_0}>
+ $<$<BOOL:${MESSAGE_HANDLER_MODEL_1}>:MODEL_1=${MESSAGE_HANDLER_MODEL_1}>
+ $<$<BOOL:${MESSAGE_HANDLER_MODEL_2}>:MODEL_2=${MESSAGE_HANDLER_MODEL_2}>
+ $<$<BOOL:${MESSAGE_HANDLER_MODEL_3}>:MODEL_3=${MESSAGE_HANDLER_MODEL_3}>)
diff --git a/applications/message_handler_openamp/core_driver_mutex.cpp b/applications/message_handler_openamp/core_driver_mutex.cpp
new file mode 100644
index 0000000..d023ad2
--- /dev/null
+++ b/applications/message_handler_openamp/core_driver_mutex.cpp
@@ -0,0 +1,81 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined(ETHOSU)
+
+#include "FreeRTOS.h"
+#include "semphr.h"
+
+#include <ethosu_driver.h>
+#include <stdio.h>
+
+extern "C" {
+
+void *ethosu_mutex_create(void) {
+ return xSemaphoreCreateMutex();
+}
+
+int ethosu_mutex_lock(void *mutex) {
+ SemaphoreHandle_t handle = reinterpret_cast<SemaphoreHandle_t>(mutex);
+ if (xSemaphoreTake(handle, portMAX_DELAY) != pdTRUE) {
+ printf("Error: Failed to lock mutex.\n");
+ return -1;
+ }
+ return 0;
+}
+
+int ethosu_mutex_unlock(void *mutex) {
+ SemaphoreHandle_t handle = reinterpret_cast<SemaphoreHandle_t>(mutex);
+ if (xSemaphoreGive(handle) != pdTRUE) {
+ printf("Error: Failed to unlock mutex.\n");
+ return -1;
+ }
+ return 0;
+}
+
+void *ethosu_semaphore_create(void) {
+ return xSemaphoreCreateCounting(255, 0);
+}
+
+int ethosu_semaphore_take(void *sem) {
+ SemaphoreHandle_t handle = reinterpret_cast<SemaphoreHandle_t>(sem);
+ if (xSemaphoreTake(handle, portMAX_DELAY) != pdTRUE) {
+ printf("Error: Failed to take semaphore.\n");
+ return -1;
+ }
+ return 0;
+}
+
+int ethosu_semaphore_give(void *sem) {
+ SemaphoreHandle_t handle = reinterpret_cast<SemaphoreHandle_t>(sem);
+ if (xPortIsInsideInterrupt()) {
+ if (xSemaphoreGiveFromISR(handle, NULL) != pdTRUE) {
+ printf("Error: Failed to give semaphore from ISR.\n");
+ return -1;
+ }
+ } else {
+ if (xSemaphoreGive(handle) != pdTRUE) {
+ printf("Error: Failed to give semaphore.\n");
+ return -1;
+ }
+ }
+ return 0;
+}
+}
+
+#endif
diff --git a/applications/message_handler_openamp/freertos_allocator.cpp b/applications/message_handler_openamp/freertos_allocator.cpp
new file mode 100644
index 0000000..9850928
--- /dev/null
+++ b/applications/message_handler_openamp/freertos_allocator.cpp
@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FreeRTOS.h"
+#include <cstddef>
+#include <new>
+
+void *operator new(size_t size) {
+ return pvPortMalloc(size);
+}
+
+void *operator new[](size_t size) {
+ return pvPortMalloc(size);
+}
+
+void operator delete(void *ptr) noexcept {
+ vPortFree(ptr);
+}
+
+void operator delete(void *ptr, std::size_t) noexcept {
+ vPortFree(ptr);
+}
+
+void operator delete[](void *ptr) noexcept {
+ vPortFree(ptr);
+}
+
+void operator delete[](void *ptr, std::size_t) noexcept {
+ vPortFree(ptr);
+}
diff --git a/applications/message_handler_openamp/inference_runner.cpp b/applications/message_handler_openamp/inference_runner.cpp
new file mode 100644
index 0000000..2f9d8ec
--- /dev/null
+++ b/applications/message_handler_openamp/inference_runner.cpp
@@ -0,0 +1,194 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include "inference_runner.hpp"
+
+#include <cstdlib>
+
+#include <ethosu_log.h>
+
+#if defined(ETHOSU)
+#include <ethosu_driver.h>
+#include <pmu_ethosu.h>
+#endif
+
+/*****************************************************************************
+ * InferenceRunner
+ *****************************************************************************/
+
+InferenceRunner::InferenceRunner(uint8_t *tensorArena,
+ size_t arenaSize,
+ MessageHandler::InferenceQueue &_inferenceQueue,
+ MessageHandler::ResponseQueue &_responseQueue) :
+ inferenceQueue(_inferenceQueue),
+ responseQueue(_responseQueue), inference(tensorArena, arenaSize) {
+ BaseType_t ret = xTaskCreate(inferenceTask, "inferenceTask", 8 * 1024, this, 4, &taskHandle);
+ if (ret != pdPASS) {
+ LOG_ERR("Failed to create inference task");
+ abort();
+ }
+}
+
+InferenceRunner::~InferenceRunner() {
+ vTaskDelete(taskHandle);
+}
+
+void InferenceRunner::inferenceTask(void *param) {
+ auto _this = static_cast<InferenceRunner *>(param);
+
+ LOG_DEBUG("Starting inference task");
+
+ while (true) {
+ Message *message;
+ auto ret = _this->inferenceQueue.receive(message);
+ if (ret) {
+ abort();
+ }
+
+ auto &rpmsg = message->rpmsg;
+
+ switch (rpmsg.header.type) {
+ case EthosU::ETHOSU_CORE_MSG_INFERENCE_REQ: {
+ _this->handleInferenceRequest(message->src, rpmsg.header.msg_id, rpmsg.inf_req);
+ break;
+ }
+ default: {
+ LOG_WARN("Unsupported message for inference runner. type=%lu", rpmsg.header.type);
+ }
+ }
+
+ delete message;
+ }
+}
+
+void InferenceRunner::handleInferenceRequest(const uint32_t src,
+ const uint64_t msgId,
+ const EthosU::ethosu_core_msg_inference_req &request) {
+ auto message =
+ new Message(src, EthosU::ETHOSU_CORE_MSG_INFERENCE_RSP, msgId, sizeof(EthosU::ethosu_core_msg_inference_rsp));
+ auto &response = message->rpmsg.inf_rsp;
+
+ // Setup PMU configuration
+ response.pmu_cycle_counter_enable = request.pmu_cycle_counter_enable;
+
+ for (int i = 0; i < ETHOSU_CORE_PMU_MAX; i++) {
+ response.pmu_event_config[i] = request.pmu_event_config[i];
+ }
+
+ // Run inference
+ auto job = makeInferenceJob(request, response);
+ auto failed = inference.runJob(job);
+
+ // Send response rpmsg
+ response.ofm_count = job.output.size();
+ response.status = failed ? EthosU::ETHOSU_CORE_STATUS_ERROR : EthosU::ETHOSU_CORE_STATUS_OK;
+
+ for (size_t i = 0; i < job.output.size(); ++i) {
+ response.ofm_size[i] = job.output[i].size;
+ }
+
+ responseQueue.send(message);
+}
+
+InferenceProcess::InferenceJob InferenceRunner::makeInferenceJob(const EthosU::ethosu_core_msg_inference_req &request,
+ EthosU::ethosu_core_msg_inference_rsp &response) {
+ InferenceProcess::InferenceJob job;
+
+ job.networkModel =
+ InferenceProcess::DataPtr(reinterpret_cast<void *>(request.network.buffer.ptr), request.network.buffer.size);
+
+ for (uint32_t i = 0; i < request.ifm_count; ++i) {
+ job.input.push_back(
+ InferenceProcess::DataPtr(reinterpret_cast<void *>(request.ifm[i].ptr), request.ifm[i].size));
+ }
+
+ for (uint32_t i = 0; i < request.ofm_count; ++i) {
+ job.output.push_back(
+ InferenceProcess::DataPtr(reinterpret_cast<void *>(request.ofm[i].ptr), request.ofm[i].size));
+ }
+
+ job.externalContext = &response;
+
+ return job;
+}
+
+#if defined(ETHOSU)
+extern "C" {
+
+void ethosu_inference_begin(ethosu_driver *drv, void *userArg) {
+ LOG_DEBUG("");
+
+ auto response = static_cast<EthosU::ethosu_core_msg_inference_rsp *>(userArg);
+
+ // Calculate maximum number of events
+ const int numEvents = std::min(static_cast<int>(ETHOSU_PMU_Get_NumEventCounters()), ETHOSU_CORE_PMU_MAX);
+
+ // Enable PMU
+ ETHOSU_PMU_Enable(drv);
+
+ // Configure and enable events
+ for (int i = 0; i < numEvents; i++) {
+ ETHOSU_PMU_Set_EVTYPER(drv, i, static_cast<ethosu_pmu_event_type>(response->pmu_event_config[i]));
+ ETHOSU_PMU_CNTR_Enable(drv, 1 << i);
+ }
+
+ // Enable cycle counter
+ if (response->pmu_cycle_counter_enable) {
+ ETHOSU_PMU_PMCCNTR_CFG_Set_Stop_Event(drv, ETHOSU_PMU_NPU_IDLE);
+ ETHOSU_PMU_PMCCNTR_CFG_Set_Start_Event(drv, ETHOSU_PMU_NPU_ACTIVE);
+
+ ETHOSU_PMU_CNTR_Enable(drv, ETHOSU_PMU_CCNT_Msk);
+ ETHOSU_PMU_CYCCNT_Reset(drv);
+ }
+
+ // Reset all counters
+ ETHOSU_PMU_EVCNTR_ALL_Reset(drv);
+}
+
+void ethosu_inference_end(ethosu_driver *drv, void *userArg) {
+ auto response = static_cast<EthosU::ethosu_core_msg_inference_rsp *>(userArg);
+
+ // Get cycle counter
+ if (response->pmu_cycle_counter_enable) {
+ response->pmu_cycle_counter_count = ETHOSU_PMU_Get_CCNTR(drv);
+ }
+
+ // Calculate maximum number of events
+ const int numEvents = std::min(static_cast<int>(ETHOSU_PMU_Get_NumEventCounters()), ETHOSU_CORE_PMU_MAX);
+
+ // Get event counters
+ int i;
+ for (i = 0; i < numEvents; i++) {
+ response->pmu_event_count[i] = ETHOSU_PMU_Get_EVCNTR(drv, i);
+ }
+
+ for (; i < ETHOSU_CORE_PMU_MAX; i++) {
+ response->pmu_event_config[i] = 0;
+ response->pmu_event_count[i] = 0;
+ }
+
+ // Disable PMU
+ ETHOSU_PMU_Disable(drv);
+}
+}
+
+#endif
diff --git a/applications/message_handler_openamp/inference_runner.hpp b/applications/message_handler_openamp/inference_runner.hpp
new file mode 100644
index 0000000..c9461a0
--- /dev/null
+++ b/applications/message_handler_openamp/inference_runner.hpp
@@ -0,0 +1,56 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include "message_handler.hpp"
+
+#include <inference_process.hpp>
+
+/*****************************************************************************
+ * InferenceRunner
+ *****************************************************************************/
+
+class InferenceRunner {
+public:
+ InferenceRunner(uint8_t *tensorArena,
+ size_t arenaSize,
+ MessageHandler::InferenceQueue &inferenceQueue,
+ MessageHandler::ResponseQueue &responseQueue);
+ ~InferenceRunner();
+
+private:
+ static void inferenceTask(void *param);
+
+ void handleInferenceRequest(const uint32_t src,
+ const uint64_t msgId,
+ const EthosU::ethosu_core_msg_inference_req &request);
+ InferenceProcess::InferenceJob makeInferenceJob(const EthosU::ethosu_core_msg_inference_req &request,
+ EthosU::ethosu_core_msg_inference_rsp &response);
+
+ MessageHandler::InferenceQueue &inferenceQueue;
+ MessageHandler::ResponseQueue &responseQueue;
+ InferenceProcess::InferenceProcess inference;
+
+ // FreeRTOS
+ TaskHandle_t taskHandle;
+};
diff --git a/applications/message_handler_openamp/main.cpp b/applications/message_handler_openamp/main.cpp
new file mode 100644
index 0000000..2aad224
--- /dev/null
+++ b/applications/message_handler_openamp/main.cpp
@@ -0,0 +1,122 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include <memory>
+#include <stdio.h>
+
+#include <ethosu_log.h>
+#include <mailbox.hpp>
+
+#if defined(MHU_V2)
+#include <mhu_v2.hpp>
+#elif defined(MHU_JUNO)
+#include <mhu_juno.hpp>
+#else
+#include <mhu_dummy.hpp>
+#endif
+
+#include "inference_runner.hpp"
+#include "message_handler.hpp"
+#include "remoteproc.hpp"
+
+/*****************************************************************************
+ * TFLM arena
+ *****************************************************************************/
+
+// Number of parallell inference tasks. Typically one per NPU.
+#if defined(ETHOSU) && defined(ETHOSU_NPU_COUNT) && ETHOSU_NPU_COUNT > 0
+constexpr size_t NUM_PARALLEL_TASKS = ETHOSU_NPU_COUNT;
+#else
+constexpr size_t NUM_PARALLEL_TASKS = 1;
+#endif
+
+#ifndef TENSOR_ARENA_SIZE
+#define TENSOR_ARENA_SIZE 2000000
+#endif
+
+// TensorArena static initialisation
+constexpr size_t arenaSize = TENSOR_ARENA_SIZE;
+
+/*****************************************************************************
+ * Resource table
+ *****************************************************************************/
+
+extern "C" {
+__attribute__((section(".resource_table"))) ResourceTable resourceTable(8, sizeof(arenaSize *NUM_PARALLEL_TASKS));
+}
+
+/*****************************************************************************
+ * Mailbox
+ *****************************************************************************/
+
+namespace {
+
+#ifdef MHU_V2
+Mailbox::MHUv2 mailbox(MHU_TX_BASE_ADDRESS, MHU_RX_BASE_ADDRESS); // txBase, rxBase
+#elif defined(MHU_JUNO)
+Mailbox::MHUJuno mailbox(MHU_BASE_ADDRESS);
+#else
+Mailbox::MHUDummy mailbox;
+#endif
+
+#ifdef MHU_IRQ
+void mailboxIrqHandler() {
+ LOG_DEBUG("");
+ mailbox.handleMessage();
+}
+#endif
+
+} // namespace
+
+/*****************************************************************************
+ * main
+ *****************************************************************************/
+
+int main() {
+ printf("Ethos-U Message Handler OpenAMP\n");
+
+ auto mem = std::make_shared<MetalIO>();
+ auto rproc = std::make_shared<RProc>(mailbox, resourceTable.table, sizeof(resourceTable), *mem);
+ auto messageHandler = std::make_shared<MessageHandler>(*rproc, "ethos-u-0.0");
+
+ std::array<std::shared_ptr<InferenceRunner>, NUM_PARALLEL_TASKS> inferenceRunner;
+
+ for (size_t i = 0; i < NUM_PARALLEL_TASKS; i++) {
+ auto tensorArena = static_cast<uint8_t *>(messageHandler->physicalToVirtual(resourceTable.carveout.pa));
+
+ inferenceRunner[i] = std::make_shared<InferenceRunner>(&tensorArena[arenaSize * i],
+ arenaSize,
+ messageHandler->getInferenceQueue(),
+ messageHandler->getResponseQueue());
+ }
+
+#ifdef MHU_IRQ
+ // Register mailbox interrupt handler
+ NVIC_SetVector((IRQn_Type)MHU_IRQ, (uint32_t)&mailboxIrqHandler);
+ NVIC_EnableIRQ((IRQn_Type)MHU_IRQ);
+#endif
+
+ // Start Scheduler
+ vTaskStartScheduler();
+
+ return 0;
+}
diff --git a/applications/message_handler_openamp/message_handler.cpp b/applications/message_handler_openamp/message_handler.cpp
new file mode 100644
index 0000000..4bd611d
--- /dev/null
+++ b/applications/message_handler_openamp/message_handler.cpp
@@ -0,0 +1,437 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include "message_handler.hpp"
+
+#include <cinttypes>
+#include <cstdlib>
+
+#include <ethosu_log.h>
+#include <inference_parser.hpp>
+
+#ifdef ETHOSU
+#include <ethosu_driver.h>
+#endif
+
+/*****************************************************************************
+ * Networks
+ *****************************************************************************/
+
+namespace {
+#if defined(__has_include)
+
+#if defined(MODEL_0)
+namespace Model0 {
+#include STRINGIFY(MODEL_0)
+}
+#endif
+
+#if defined(MODEL_1)
+namespace Model1 {
+#include STRINGIFY(MODEL_1)
+}
+#endif
+
+#if defined(MODEL_2)
+namespace Model2 {
+#include STRINGIFY(MODEL_2)
+}
+#endif
+
+#if defined(MODEL_3)
+namespace Model3 {
+#include STRINGIFY(MODEL_3)
+}
+#endif
+
+#endif
+
+bool getIndexedNetwork(const uint32_t index, void *&data, size_t &size) {
+ switch (index) {
+#if defined(MODEL_0)
+ case 0:
+ data = reinterpret_cast<void *>(Model0::networkModelData);
+ size = sizeof(Model0::networkModelData);
+ break;
+#endif
+
+#if defined(MODEL_1)
+ case 1:
+ data = reinterpret_cast<void *>(Model1::networkModelData);
+ size = sizeof(Model1::networkModelData);
+ break;
+#endif
+
+#if defined(MODEL_2)
+ case 2:
+ data = reinterpret_cast<void *>(Model2::networkModelData);
+ size = sizeof(Model2::networkModelData);
+ break;
+#endif
+
+#if defined(MODEL_3)
+ case 3:
+ data = reinterpret_cast<void *>(Model3::networkModelData);
+ size = sizeof(Model3::networkModelData);
+ break;
+#endif
+
+ default:
+ LOG_WARN("Network model index out of range. index=%" PRIu32, index);
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace
+
+/*****************************************************************************
+ * MessageHandler
+ *****************************************************************************/
+
+MessageHandler::MessageHandler(RProc &_rproc, const char *const _name) :
+ Rpmsg(_rproc, _name), capabilities(getCapabilities()) {
+ BaseType_t ret = xTaskCreate(responseTask, "responseTask", 1024, this, 3, &taskHandle);
+ if (ret != pdPASS) {
+ LOG_ERR("Failed to create response task");
+ abort();
+ }
+}
+
+MessageHandler::~MessageHandler() {
+ vTaskDelete(taskHandle);
+}
+
+int MessageHandler::handleMessage(void *data, size_t len, uint32_t src) {
+ auto rpmsg = static_cast<EthosU::ethosu_core_rpmsg *>(data);
+
+ LOG_DEBUG("Msg: src=%" PRIX32 ", len=%zu, magic=%" PRIX32 ", type=%" PRIu32,
+ src,
+ len,
+ rpmsg->header.magic,
+ rpmsg->header.type);
+
+ if (rpmsg->header.magic != ETHOSU_CORE_MSG_MAGIC) {
+ LOG_WARN("Msg: Invalid Magic");
+ sendError(src, EthosU::ETHOSU_CORE_MSG_ERR_INVALID_MAGIC, "Invalid magic");
+ return 0;
+ }
+
+ switch (rpmsg->header.type) {
+ case EthosU::ETHOSU_CORE_MSG_PING: {
+ LOG_INFO("Msg: Ping");
+ sendPong(src, rpmsg->header.msg_id);
+ break;
+ }
+ case EthosU::ETHOSU_CORE_MSG_VERSION_REQ: {
+ LOG_INFO("Msg: Version request");
+ sendVersionRsp(src, rpmsg->header.msg_id);
+ break;
+ }
+ case EthosU::ETHOSU_CORE_MSG_CAPABILITIES_REQ: {
+ if (len != sizeof(rpmsg->header)) {
+ sendError(
+ src, EthosU::ETHOSU_CORE_MSG_ERR_INVALID_PAYLOAD, "Incorrect capabilities request payload length.");
+ break;
+ }
+
+ LOG_INFO("Msg: Capabilities request");
+
+ sendCapabilitiesRsp(src, rpmsg->header.msg_id);
+ break;
+ }
+ case EthosU::ETHOSU_CORE_MSG_INFERENCE_REQ: {
+ if (len != sizeof(rpmsg->header) + sizeof(rpmsg->inf_req)) {
+ sendError(src, EthosU::ETHOSU_CORE_MSG_ERR_INVALID_PAYLOAD, "Incorrect inference request payload length.");
+ break;
+ }
+
+ forwardInferenceReq(src, rpmsg->header.msg_id, rpmsg->inf_req);
+ break;
+ }
+ case EthosU::ETHOSU_CORE_MSG_CANCEL_INFERENCE_REQ: {
+ if (len != sizeof(rpmsg->header) + sizeof(rpmsg->cancel_req)) {
+ sendError(
+ src, EthosU::ETHOSU_CORE_MSG_ERR_INVALID_PAYLOAD, "Incorrect cancel inference request payload length.");
+ break;
+ }
+
+ auto &request = rpmsg->cancel_req;
+ bool found = false;
+ inferenceQueue.erase([request, &found](auto &message) {
+ if (message->rpmsg.header.msg_id == request.inference_handle) {
+ found = true;
+ delete message;
+ return true;
+ }
+
+ return false;
+ });
+
+ if (found) {
+ sendInferenceRsp(src, request.inference_handle, EthosU::ETHOSU_CORE_STATUS_ABORTED);
+ }
+
+ sendCancelInferenceRsp(
+ src, rpmsg->header.msg_id, found ? EthosU::ETHOSU_CORE_STATUS_OK : EthosU::ETHOSU_CORE_STATUS_ERROR);
+ break;
+ }
+ case EthosU::ETHOSU_CORE_MSG_NETWORK_INFO_REQ: {
+ if (len != sizeof(rpmsg->header) + sizeof(rpmsg->net_info_req)) {
+ sendError(
+ src, EthosU::ETHOSU_CORE_MSG_ERR_INVALID_PAYLOAD, "Incorrect network info request payload length.");
+ break;
+ }
+
+ LOG_INFO("Msg: NetworkInfoReq. network={ type=%" PRIu32 ", index=%" PRIu32 ", buffer={ ptr=0x%" PRIX32
+ ", size=%" PRIu32 " } }",
+ rpmsg->net_info_req.network.type,
+ rpmsg->net_info_req.network.index,
+ rpmsg->net_info_req.network.buffer.ptr,
+ rpmsg->net_info_req.network.buffer.size);
+
+ sendNetworkInfoRsp(src, rpmsg->header.msg_id, rpmsg->net_info_req.network);
+ break;
+ }
+ default: {
+ LOG_WARN("Msg: Unsupported message. type=%" PRIu32, rpmsg->header.type);
+
+ char errMsg[128];
+ snprintf(
+ &errMsg[0], sizeof(errMsg), "Msg: Unknown message. type=%" PRIu32 ", length=%zu", rpmsg->header.type, len);
+
+ sendError(src, EthosU::ETHOSU_CORE_MSG_ERR_UNSUPPORTED_TYPE, errMsg);
+ }
+ }
+
+ return 0;
+}
+
+void MessageHandler::sendError(const uint32_t src, const EthosU::ethosu_core_err_type type, const char *msg) {
+ auto message = new Message(src, EthosU::ETHOSU_CORE_MSG_ERR, 0, sizeof(EthosU::ethosu_core_msg_err));
+
+ message->rpmsg.error.type = type;
+
+ for (size_t i = 0; i < sizeof(message->rpmsg.error.msg) && msg[i]; i++) {
+ message->rpmsg.error.msg[i] = msg[i];
+ }
+
+ responseQueue.send(message);
+}
+
+void MessageHandler::sendPong(const uint32_t src, const uint64_t msgId) {
+ auto message = new Message(src, EthosU::ETHOSU_CORE_MSG_PONG, msgId);
+
+ responseQueue.send(message);
+}
+
+void MessageHandler::sendVersionRsp(const uint32_t src, const uint64_t msgId) {
+ auto message =
+ new Message(src, EthosU::ETHOSU_CORE_MSG_VERSION_RSP, msgId, sizeof(EthosU::ethosu_core_msg_version_rsp));
+
+ message->rpmsg.version_rsp = {
+ ETHOSU_CORE_MSG_VERSION_MAJOR,
+ ETHOSU_CORE_MSG_VERSION_MINOR,
+ ETHOSU_CORE_MSG_VERSION_PATCH,
+ 0,
+ };
+
+ responseQueue.send(message);
+}
+
+void MessageHandler::sendCapabilitiesRsp(const uint32_t src, const uint64_t msgId) {
+ auto message = new Message(
+ src, EthosU::ETHOSU_CORE_MSG_CAPABILITIES_RSP, msgId, sizeof(EthosU::ethosu_core_msg_capabilities_rsp));
+
+ message->rpmsg.cap_rsp = capabilities;
+
+ responseQueue.send(message);
+}
+
+EthosU::ethosu_core_msg_capabilities_rsp MessageHandler::getCapabilities() const {
+ EthosU::ethosu_core_msg_capabilities_rsp cap = {};
+
+#ifdef ETHOSU
+ ethosu_driver_version version;
+ ethosu_get_driver_version(&version);
+
+ ethosu_hw_info info;
+ ethosu_driver *drv = ethosu_reserve_driver();
+ ethosu_get_hw_info(drv, &info);
+ ethosu_release_driver(drv);
+
+ cap.version_status = info.version.version_status;
+ cap.version_minor = info.version.version_minor;
+ cap.version_major = info.version.version_major;
+ cap.product_major = info.version.product_major;
+ cap.arch_patch_rev = info.version.arch_patch_rev;
+ cap.arch_minor_rev = info.version.arch_minor_rev;
+ cap.arch_major_rev = info.version.arch_major_rev;
+ cap.driver_patch_rev = version.patch;
+ cap.driver_minor_rev = version.minor;
+ cap.driver_major_rev = version.major;
+ cap.macs_per_cc = info.cfg.macs_per_cc;
+ cap.cmd_stream_version = info.cfg.cmd_stream_version;
+ cap.custom_dma = info.cfg.custom_dma;
+#endif
+
+ return cap;
+}
+
+void MessageHandler::sendNetworkInfoRsp(const uint32_t src,
+ const uint64_t msgId,
+ EthosU::ethosu_core_network_buffer &network) {
+ auto message = new Message(
+ src, EthosU::ETHOSU_CORE_MSG_NETWORK_INFO_RSP, msgId, sizeof(EthosU::ethosu_core_msg_network_info_rsp));
+ auto &rsp = message->rpmsg.net_info_rsp;
+
+ rsp.ifm_count = 0;
+ rsp.ofm_count = 0;
+
+ bool failed = networkToVirtual(network);
+
+ if (!failed) {
+ InferenceProcess::InferenceParser parser;
+
+ failed = parser.parseModel(reinterpret_cast<void *>(network.buffer.ptr),
+ network.buffer.size,
+ rsp.desc,
+ InferenceProcess::makeArray(rsp.ifm_size, rsp.ifm_count, ETHOSU_CORE_BUFFER_MAX),
+ InferenceProcess::makeArray(rsp.ofm_size, rsp.ofm_count, ETHOSU_CORE_BUFFER_MAX));
+ }
+
+ rsp.status = failed ? EthosU::ETHOSU_CORE_STATUS_ERROR : EthosU::ETHOSU_CORE_STATUS_OK;
+
+ responseQueue.send(message);
+}
+
+void MessageHandler::forwardInferenceReq(const uint32_t src,
+ const uint64_t msgId,
+ const EthosU::ethosu_core_msg_inference_req &inference) {
+ auto message = new Message(src, EthosU::ETHOSU_CORE_MSG_INFERENCE_REQ, msgId);
+ auto &req = message->rpmsg.inf_req;
+
+ req = inference;
+
+ for (uint32_t i = 0; i < req.ifm_count; i++) {
+ bufferToVirtual(req.ifm[i]);
+ }
+
+ for (uint32_t i = 0; i < req.ofm_count; i++) {
+ bufferToVirtual(req.ofm[i]);
+ }
+
+ networkToVirtual(req.network);
+
+ inferenceQueue.send(message);
+}
+
+void MessageHandler::sendInferenceRsp(const uint32_t src,
+ const uint64_t msgId,
+ const EthosU::ethosu_core_status status) {
+ auto message =
+ new Message(src, EthosU::ETHOSU_CORE_MSG_INFERENCE_RSP, msgId, sizeof(EthosU::ethosu_core_msg_inference_rsp));
+
+ message->rpmsg.inf_rsp.status = status;
+
+ responseQueue.send(message);
+}
+
+void MessageHandler::sendCancelInferenceRsp(const uint32_t src,
+ const uint64_t msgId,
+ const EthosU::ethosu_core_status status) {
+ auto message = new Message(
+ src, EthosU::ETHOSU_CORE_MSG_CANCEL_INFERENCE_RSP, msgId, sizeof(EthosU::ethosu_core_msg_cancel_inference_rsp));
+
+ message->rpmsg.cancel_rsp.status = status;
+
+ responseQueue.send(message);
+}
+
+bool MessageHandler::getNetwork(const EthosU::ethosu_core_network_buffer &buffer, void *&data, size_t &size) {
+ switch (buffer.type) {
+ case EthosU::ETHOSU_CORE_NETWORK_BUFFER:
+ data = physicalToVirtual(buffer.buffer.ptr);
+ size = buffer.buffer.size;
+ return false;
+ case EthosU::ETHOSU_CORE_NETWORK_INDEX:
+ return getIndexedNetwork(buffer.index, data, size);
+ default:
+ LOG_WARN("Unsupported network model type. type=%" PRIu32, buffer.type);
+ return true;
+ }
+}
+
+bool MessageHandler::bufferToVirtual(EthosU::ethosu_core_buffer &buffer) {
+ void *ptr = physicalToVirtual(buffer.ptr);
+ if (ptr == nullptr) {
+ return true;
+ }
+
+ buffer.ptr = reinterpret_cast<uint32_t>(ptr);
+
+ return false;
+}
+
+bool MessageHandler::networkToVirtual(EthosU::ethosu_core_network_buffer &buffer) {
+ switch (buffer.type) {
+ case EthosU::ETHOSU_CORE_NETWORK_BUFFER:
+ return bufferToVirtual(buffer.buffer);
+ case EthosU::ETHOSU_CORE_NETWORK_INDEX: {
+ void *ptr;
+ size_t size;
+ if (getIndexedNetwork(buffer.index, ptr, size)) {
+ return true;
+ }
+
+ buffer.type = EthosU::ETHOSU_CORE_NETWORK_BUFFER;
+ buffer.buffer.ptr = reinterpret_cast<uint32_t>(ptr);
+ buffer.buffer.size = size;
+
+ return false;
+ }
+ default:
+ LOG_WARN("Unsupported network model type. type=%" PRIu32, buffer.type);
+ return true;
+ }
+}
+
+void MessageHandler::responseTask(void *param) {
+ auto _this = static_cast<MessageHandler *>(param);
+
+ LOG_DEBUG("Starting message response task");
+
+ while (true) {
+ Message *message;
+ auto ret = _this->responseQueue.receive(message);
+ if (ret) {
+ abort();
+ }
+
+ LOG_DEBUG("Sending message. type=%" PRIu32, message->rpmsg.header.type);
+
+ _this->send(&message->rpmsg, sizeof(message->rpmsg.header) + message->length, message->src);
+
+ delete message;
+ }
+}
diff --git a/applications/message_handler_openamp/message_handler.hpp b/applications/message_handler_openamp/message_handler.hpp
new file mode 100644
index 0000000..779b05f
--- /dev/null
+++ b/applications/message_handler_openamp/message_handler.hpp
@@ -0,0 +1,106 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include <ethosu_core_rpmsg.h>
+#include <mailbox.hpp>
+
+#include "queue.hpp"
+#include "remoteproc.hpp"
+
+/*****************************************************************************
+ * Messages
+ *****************************************************************************/
+
+struct Message {
+ Message() {}
+
+ Message(const uint32_t _src,
+ const EthosU::ethosu_core_msg_type _type = EthosU::ETHOSU_CORE_MSG_MAX,
+ const uint64_t msgId = 0,
+ const uint32_t _length = 0) :
+ src(_src),
+ length(_length) {
+ rpmsg.header.magic = ETHOSU_CORE_MSG_MAGIC;
+ rpmsg.header.type = _type;
+ rpmsg.header.msg_id = msgId;
+ }
+
+ uint32_t src = 0;
+ uint32_t length = 0;
+ EthosU::ethosu_core_rpmsg rpmsg;
+};
+
+/*****************************************************************************
+ * MessageHandler
+ *****************************************************************************/
+
+class MessageHandler : public Rpmsg {
+public:
+ using InferenceQueue = Queue<Message *>;
+ using ResponseQueue = Queue<Message *>;
+
+ MessageHandler(RProc &rproc, const char *const name);
+ virtual ~MessageHandler();
+
+ InferenceQueue &getInferenceQueue() {
+ return inferenceQueue;
+ }
+
+ InferenceQueue &getResponseQueue() {
+ return responseQueue;
+ }
+
+protected:
+ // Handle incoming rpmsg
+ int handleMessage(void *data, size_t len, uint32_t src) override;
+
+ // Outgoing messages
+ void sendError(const uint32_t src, const EthosU::ethosu_core_err_type type, const char *message);
+ void sendPong(const uint32_t src, const uint64_t msgId);
+ void sendVersionRsp(const uint32_t src, const uint64_t msgId);
+ void sendCapabilitiesRsp(const uint32_t src, const uint64_t msgId);
+ void sendNetworkInfoRsp(const uint32_t src, const uint64_t msgId, EthosU::ethosu_core_network_buffer &network);
+ void forwardInferenceReq(const uint32_t src,
+ const uint64_t msgId,
+ const EthosU::ethosu_core_msg_inference_req &inference);
+ void sendInferenceRsp(const uint32_t src, const uint64_t msgId, const EthosU::ethosu_core_status status);
+ void sendCancelInferenceRsp(const uint32_t src, const uint64_t msgId, const EthosU::ethosu_core_status status);
+
+ EthosU::ethosu_core_msg_capabilities_rsp getCapabilities() const;
+ bool getNetwork(const EthosU::ethosu_core_network_buffer &buffer, void *&data, size_t &size);
+
+ // Tasks returning response messages
+ static void responseTask(void *param);
+
+private:
+ bool bufferToVirtual(EthosU::ethosu_core_buffer &buffer);
+ bool networkToVirtual(EthosU::ethosu_core_network_buffer &buffer);
+
+ InferenceQueue inferenceQueue;
+ ResponseQueue responseQueue;
+ EthosU::ethosu_core_msg_capabilities_rsp capabilities;
+
+ // FreeRTOS
+ TaskHandle_t taskHandle;
+};
diff --git a/applications/message_handler_openamp/queue.hpp b/applications/message_handler_openamp/queue.hpp
new file mode 100644
index 0000000..dcf676b
--- /dev/null
+++ b/applications/message_handler_openamp/queue.hpp
@@ -0,0 +1,87 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include <FreeRTOS.h>
+#include <queue.h>
+
+#include <cstdlib>
+#include <functional>
+
+#include <ethosu_log.h>
+
+/*****************************************************************************
+ * Queue
+ *****************************************************************************/
+
+template <typename T>
+class Queue {
+public:
+ using Predicate = std::function<bool(const T &data)>;
+
+ Queue(const size_t size = 10) : queue(xQueueCreate(size, sizeof(T))) {}
+
+ ~Queue() {
+ vQueueDelete(queue);
+ }
+
+ int send(const T &msg, TickType_t delay = portMAX_DELAY) {
+ if (pdPASS != xQueueSend(queue, &msg, delay)) {
+ LOG_ERR("Failed to send message");
+ return -1;
+ }
+
+ return 0;
+ }
+
+ int receive(T &msg, TickType_t delay = portMAX_DELAY) {
+ if (pdTRUE != xQueueReceive(queue, &msg, delay)) {
+ LOG_ERR("Failed to receive message");
+ return -1;
+ }
+
+ return 0;
+ }
+
+ void erase(Predicate pred) {
+ const size_t count = uxQueueMessagesWaiting(queue);
+ for (size_t i = 0; i < count; i++) {
+ T data;
+
+ if (pdPASS != xQueueReceive(queue, &data, 0)) {
+ LOG_ERR("Failed to dequeue message");
+ abort();
+ }
+
+ if (!pred(data)) {
+ if (pdPASS != xQueueSend(queue, &data, 0)) {
+ LOG_ERR("Failed to requeue message");
+ abort();
+ }
+ }
+ }
+ }
+
+private:
+ QueueHandle_t queue;
+};
diff --git a/applications/message_handler_openamp/remoteproc.cpp b/applications/message_handler_openamp/remoteproc.cpp
new file mode 100644
index 0000000..f355634
--- /dev/null
+++ b/applications/message_handler_openamp/remoteproc.cpp
@@ -0,0 +1,243 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include "remoteproc.hpp"
+
+#include <cinttypes>
+
+#include <ethosu_log.h>
+
+/*****************************************************************************
+ * MetalIO
+ *****************************************************************************/
+
+extern "C" {
+
+__attribute__((weak)) void *ethosu_phys_to_virt(const uint64_t pa) {
+ return reinterpret_cast<void *>(pa);
+}
+}
+
+MetalIO::MetalIO() :
+ ops{.read = nullptr,
+ .write = nullptr,
+ .block_read = nullptr,
+ .block_write = nullptr,
+ .block_set = nullptr,
+ .close = nullptr,
+ .offset_to_phys = nullptr,
+ .phys_to_offset = physToOffset} {
+ remoteproc_init_mem(&mem, "shm", 0, 0, 0xffffffff, ®ion);
+
+ metal_io_init(®ion,
+ reinterpret_cast<void *>(0), /* virt */
+ &mem.pa, /* physmap */
+ 0xffffffff, /* size */
+ -1L, /* pagemask */
+ 0, /* attributes */
+ &ops); /* ops */
+}
+
+remoteproc_mem *MetalIO::operator&() {
+ return &mem;
+}
+
+unsigned long MetalIO::physToOffset(metal_io_region *io, metal_phys_addr_t pa) {
+ auto offset = reinterpret_cast<unsigned long>(ethosu_phys_to_virt(pa));
+ LOG_DEBUG("Translate PA to offset. pa=%lx, offset=%lx", pa, offset);
+ return offset;
+}
+
+/*****************************************************************************
+ * RProc
+ *****************************************************************************/
+
+RProc::RProc(Mailbox::Mailbox &_mailbox, resource_table &table, size_t tableSize, MetalIO &_mem) :
+ mailbox(_mailbox), mem(_mem),
+ ops{
+ .init = init, // initialize the remoteproc instance
+ .remove = remove, // remove the remoteproc instance
+ .mmap = nullptr, // memory mapped the memory with physical address as input
+ .handle_rsc = nullptr, // handle the vendor specific resource
+ .config = nullptr, // configure the remoteproc to make it ready to load and run executable
+ .start = nullptr, // kick the remoteproc to run application
+ .stop = nullptr, // stop the remoteproc from running application, the resource such as memory may not be off.
+ .shutdown = nullptr, // shutdown the remoteproc and release its resources.
+ .notify = notify, // notify the remote
+ .get_mem = nullptr, // get remoteproc memory I/O region.
+ },
+ vdev(nullptr), notifySemaphore(xSemaphoreCreateBinary()) {
+ mailbox.registerCallback(mailboxCallback, static_cast<void *>(this));
+
+ if (!remoteproc_init(&rproc, &ops, this)) {
+ LOG_ERR("Failed to intialize remoteproc");
+ abort();
+ }
+
+ int ret = remoteproc_set_rsc_table(&rproc, &table, tableSize);
+ if (ret) {
+ LOG_ERR("Failed to set resource table. ret=%d", ret);
+ abort();
+ }
+
+ vdev = remoteproc_create_virtio(&rproc, 0, VIRTIO_DEV_DEVICE, nullptr);
+ if (!vdev) {
+ LOG_ERR("Failed to create vdev");
+ abort();
+ }
+
+ BaseType_t taskret = xTaskCreate(notifyTask, "notifyTask", 1024, this, 2, ¬ifyHandle);
+ if (taskret != pdPASS) {
+ LOG_ERR("Failed to create remoteproc notify task");
+ abort();
+ }
+}
+
+RProc::~RProc() {
+ mailbox.deregisterCallback(mailboxCallback, static_cast<void *>(this));
+ vTaskDelete(notifyHandle);
+}
+
+remoteproc *RProc::getRProc() {
+ return &rproc;
+}
+
+virtio_device *RProc::getVDev() {
+ return vdev;
+}
+
+void RProc::mailboxCallback(void *userArg) {
+ auto _this = static_cast<RProc *>(userArg);
+
+ xSemaphoreGiveFromISR(_this->notifySemaphore, nullptr);
+}
+
+void RProc::notifyTask(void *param) {
+ LOG_DEBUG("Starting message notify task");
+
+ auto _this = static_cast<RProc *>(param);
+
+ while (true) {
+ // Wait for event
+ xSemaphoreTake(_this->notifySemaphore, portMAX_DELAY);
+
+ // Read virtio queue and notify all rpmsg clients
+ rproc_virtio_notified(_this->vdev, RSC_NOTIFY_ID_ANY);
+ }
+}
+
+struct remoteproc *RProc::init(remoteproc *rproc, const remoteproc_ops *ops, void *arg) {
+ LOG_DEBUG("");
+
+ auto _this = static_cast<RProc *>(arg);
+
+ rproc->ops = ops;
+ rproc->priv = arg;
+ remoteproc_add_mem(rproc, &_this->mem);
+
+ return rproc;
+}
+
+void RProc::remove(remoteproc *rproc) {
+ LOG_DEBUG("");
+}
+
+int RProc::notify(remoteproc *rproc, uint32_t id) {
+ LOG_DEBUG("");
+
+ auto *_this = static_cast<RProc *>(rproc->priv);
+ _this->mailbox.sendMessage();
+ return 0;
+}
+
+/*****************************************************************************
+ * Rpmsg
+ *****************************************************************************/
+
+Rpmsg::Rpmsg(RProc &rproc, const char *const name) {
+
+ metal_io_region *region = remoteproc_get_io_with_name(rproc.getRProc(), "shm");
+ if (!region) {
+ LOG_ERR("Failed to get shared mem region");
+ abort();
+ }
+
+ if (rpmsg_init_vdev(&rvdev, rproc.getVDev(), nullptr, region, nullptr)) {
+ LOG_ERR("Failed to initialize rpmsg vdev");
+ abort();
+ }
+
+ rdev = rpmsg_virtio_get_rpmsg_device(&rvdev);
+ if (!rdev) {
+ LOG_ERR("Failed to get rpmsg dev");
+ abort();
+ }
+
+ int ret =
+ rpmsg_create_ept(&endpoint, rdev, name, RPMSG_ADDR_ANY, RPMSG_ADDR_ANY, endpointCallback, nsUnbindCallback);
+ if (ret != RPMSG_SUCCESS) {
+ LOG_ERR("Failed to create rpmsg endpoint. ret=%d", ret);
+ abort();
+ }
+
+ endpoint.priv = static_cast<void *>(this);
+}
+
+int Rpmsg::send(void *data, size_t len, uint32_t dst) {
+ LOG_DEBUG("Sending rpmsg. dst=%" PRIu32 ", len=%zu", dst, len);
+
+ int ret = rpmsg_sendto(&endpoint, data, len, dst);
+ return ret;
+}
+
+void *Rpmsg::physicalToVirtual(metal_phys_addr_t pa) {
+ return metal_io_phys_to_virt(rvdev.shbuf_io, pa);
+}
+
+void Rpmsg::rpmsgNsBind(rpmsg_device *rdev, const char *name, uint32_t dest) {
+ LOG_DEBUG("");
+}
+
+void Rpmsg::nsUnbindCallback(rpmsg_endpoint *ept) {
+ LOG_DEBUG("");
+}
+
+int Rpmsg::endpointCallback(rpmsg_endpoint *ept, void *data, size_t len, uint32_t src, void *priv) {
+ LOG_DEBUG("src=%" PRIX32 ", len=%zu", src, len);
+
+ auto _this = static_cast<Rpmsg *>(priv);
+ _this->handleMessage(data, len, src);
+
+ return 0;
+}
+
+int Rpmsg::handleMessage(void *data, size_t len, uint32_t src) {
+ LOG_DEBUG("Receiving rpmsg. src=%" PRIu32 ", len=%zu", src, len);
+
+ auto c = static_cast<char *>(data);
+ for (size_t i = 0; i < len; i++) {
+ printf("%c", c[i]);
+ }
+ printf("\n");
+
+ return 0;
+}
diff --git a/applications/message_handler_openamp/remoteproc.hpp b/applications/message_handler_openamp/remoteproc.hpp
new file mode 100644
index 0000000..2f16e24
--- /dev/null
+++ b/applications/message_handler_openamp/remoteproc.hpp
@@ -0,0 +1,200 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use _this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/*****************************************************************************
+ * Includes
+ *****************************************************************************/
+
+#include <FreeRTOS.h>
+#include <queue.h>
+#include <semphr.h>
+
+#include <metal/alloc.h>
+#include <openamp/open_amp.h>
+#include <openamp/remoteproc.h>
+
+#include <mailbox.hpp>
+
+/*****************************************************************************
+ * Resource table
+ *****************************************************************************/
+
+struct ResourceTable {
+ static constexpr uint32_t VERSION = 1;
+ static constexpr uint32_t NUM_RESOURCES = 2;
+ static constexpr uint32_t NUM_VRINGS = 2;
+ static constexpr uint32_t VRING_ALIGN = 0x100;
+ // static constexpr uint32_t VRING_SIZE = 0x10;
+ static constexpr uint32_t RESERVED = 0;
+
+ resource_table table;
+ uint32_t offset[NUM_RESOURCES];
+ fw_rsc_vdev vdev;
+ fw_rsc_vdev_vring vring[NUM_VRINGS];
+ fw_rsc_carveout carveout;
+
+ // clang-format off
+ constexpr ResourceTable(const uint32_t vringSize = 0x100, const uint32_t carveoutSize = 0) :
+ table {
+ VERSION,
+ NUM_RESOURCES,
+ { RESERVED, RESERVED },
+ {}
+ },
+ offset {
+ offsetof(ResourceTable, vdev),
+ offsetof(ResourceTable, carveout),
+ },
+ vdev {
+ RSC_VDEV,
+ VIRTIO_ID_RPMSG,
+ 2, // Notify ID
+ 1 << VIRTIO_RPMSG_F_NS,
+ 0,
+ 0,
+ 0,
+ NUM_VRINGS,
+ { 0, RESERVED },
+ {}
+ },
+ vring {
+ {
+ FW_RSC_U32_ADDR_ANY,
+ VRING_ALIGN,
+ vringSize,
+ 1,
+ RESERVED
+ },
+ {
+ FW_RSC_U32_ADDR_ANY,
+ VRING_ALIGN,
+ vringSize,
+ 2,
+ RESERVED
+ }
+ },
+ carveout {
+ RSC_CARVEOUT,
+ FW_RSC_U32_ADDR_ANY,
+ FW_RSC_U32_ADDR_ANY,
+ carveoutSize,
+ 0,
+ RESERVED,
+ "TFLM arena"
+ }
+ {}
+ // clang-format off
+} __attribute__((packed));
+
+/*****************************************************************************
+ * MetalIO
+ *****************************************************************************/
+
+class MetalIO {
+public:
+ MetalIO();
+
+ remoteproc_mem *operator&();
+
+private:
+ static metal_phys_addr_t offsetToPhys(metal_io_region *io, unsigned long offset);
+ static unsigned long physToOffset(metal_io_region *io, metal_phys_addr_t phys);
+
+ metal_io_ops ops;
+ metal_io_region region;
+ remoteproc_mem mem;
+};
+
+/*****************************************************************************
+ * RProc
+ *****************************************************************************/
+
+class RProc {
+public:
+ RProc(Mailbox::Mailbox &_mailbox, resource_table &table, size_t tableSize, MetalIO &_mem);
+ ~RProc();
+
+ remoteproc *getRProc();
+ virtio_device *getVDev();
+
+private:
+ // IRQ notification callback
+ static void mailboxCallback(void *userArg);
+
+ // Notification task handling virtio messages
+ static void notifyTask(void *param);
+
+ // Remote proc ops
+ static struct remoteproc *init(remoteproc *rproc, const remoteproc_ops *ops, void *arg);
+ static void remove(remoteproc *rproc);
+ static void *mmap(remoteproc *rproc,
+ metal_phys_addr_t *pa,
+ metal_phys_addr_t *da,
+ size_t size,
+ unsigned int attribute,
+ metal_io_region **io);
+ static int notify(remoteproc *rproc, uint32_t id);
+ static struct remoteproc_mem *getMem(remoteproc *rproc,
+ const char *name,
+ metal_phys_addr_t pa,
+ metal_phys_addr_t da,
+ void *va,
+ size_t size,
+ remoteproc_mem *buf);
+
+ // IRQ notification
+ Mailbox::Mailbox &mailbox;
+
+ // Remoteproc
+ MetalIO &mem;
+ remoteproc rproc;
+ remoteproc_ops ops;
+ virtio_device *vdev;
+
+ // FreeRTOS
+ SemaphoreHandle_t notifySemaphore;
+ TaskHandle_t notifyHandle;
+};
+
+/*****************************************************************************
+ * Rpmsg
+ *****************************************************************************/
+
+class Rpmsg {
+public:
+ Rpmsg(RProc &rproc, const char *const name);
+
+ int send(void *data, size_t len, uint32_t dst = 0);
+ void *physicalToVirtual(metal_phys_addr_t pa);
+
+protected:
+ virtual int handleMessage(void *data, size_t len, uint32_t src);
+
+private:
+ // RPMsg ops
+ static void rpmsgNsBind(rpmsg_device *rdev, const char *name, uint32_t dest);
+ static void nsUnbindCallback(rpmsg_endpoint *ept);
+ static int endpointCallback(rpmsg_endpoint *ept, void *data, size_t len, uint32_t src, void *priv);
+
+ // RPMsg
+ rpmsg_virtio_device rvdev;
+ rpmsg_device *rdev;
+ rpmsg_endpoint endpoint;
+};