ports/stm32: Add OpenAMP's remoteproc port.

iabdalkader · iabdalkader · commit bb7f27cb44a9 · 2023-11-22T22:36:28.000+01:00
Signed-off-by: iabdalkader &lt;i.abdalkader@gmail.com&gt;
diff --git a/ports/stm32/Makefile b/ports/stm32/Makefile
@@ -495,6 +495,9 @@ endif # MICROPY_PY_BLUETOOTH
 
 ifeq ($(MICROPY_PY_OPENAMP),1)
 SRC_C += metal/metal_port.c
+ifeq ($(MICROPY_PY_REMOTEPROC),1)
+SRC_C += mprprocport.c
+endif
 endif
 
 # SRC_O should be placed first to work around this LTO bug with binutils <2.35:
diff --git a/ports/stm32/mprprocport.c b/ports/stm32/mprprocport.c
@@ -0,0 +1,246 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2023 Arduino SA
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * modremoteproc stm32 port.
+ */
+#include <stdio.h>
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "py/stream.h"
+#include "extmod/vfs.h"
+
+#include "metal/alloc.h"
+#include "metal/errno.h"
+#include "metal/io.h"
+#include "metal/sys.h"
+#include "metal/device.h"
+#include "metal/utilities.h"
+#include "openamp/remoteproc.h"
+#include "openamp/remoteproc_loader.h"
+
+#define debug_printf(...)   // mp_printf(&mp_plat_print, __VA_ARGS__)
+
+#define FILE_STORE_BUF_SIZE   (1024)
+
+typedef struct filestore {
+    size_t len;
+    uint8_t *buf;
+    mp_obj_t file;
+} filestore_t;
+
+static int store_open(void *store, const char *path, const void **image_data) {
+    debug_printf("store_open(): %s\n", path);
+
+    mp_obj_t args[2] = {
+        mp_obj_new_str(path, strlen(path)),
+        MP_OBJ_NEW_QSTR(MP_QSTR_rb),
+    };
+
+    filestore_t *fstore = store;
+    fstore->file = mp_vfs_open(MP_ARRAY_SIZE(args), args, (mp_map_t *)&mp_const_empty_map);
+
+    int error = 0;
+    mp_uint_t bytes = mp_stream_read_exactly(fstore->file, fstore->buf, FILE_STORE_BUF_SIZE, &error);
+    if (error != 0 || bytes != FILE_STORE_BUF_SIZE) {
+        return -EINVAL;
+    }
+    *image_data = fstore->buf;
+    return bytes;
+}
+
+static void store_close(void *store) {
+    debug_printf("store_close()\n");
+    filestore_t *fstore = store;
+    mp_stream_close(fstore->file);
+    metal_free_memory(fstore->buf);
+    metal_free_memory(fstore);
+}
+
+static int store_load(void *store, size_t offset, size_t size,
+    const void **data, metal_phys_addr_t pa,
+    struct metal_io_region *io,
+    char is_blocking) {
+
+    int error = 0;
+    filestore_t *fstore = store;
+
+    if (mp_stream_seek(fstore->file, offset, MP_SEEK_SET, &error) == -1) {
+        return -EINVAL;
+    }
+
+    if (pa == METAL_BAD_PHYS) {
+        if (size > fstore->len) {
+            // Note tracked allocs don't support realloc.
+            fstore->len = size;
+            fstore->buf = metal_allocate_memory(size);
+            debug_printf("store_load() realloc to %lu\n", fstore->len);
+        }
+        *data = fstore->buf;
+        debug_printf("store_load(): pa 0x%lx offset %u size %u \n", (uint32_t)pa, offset, size);
+    } else {
+        void *va = metal_io_phys_to_virt(io, pa);
+        if (va == NULL) {
+            return -EINVAL;
+        }
+        *data = va;
+        debug_printf("store_load(): pa 0x%lx va 0x%p offset %u size %u \n", (uint32_t)pa, va, offset, size);
+    }
+
+    mp_uint_t bytes = mp_stream_read_exactly(fstore->file, (void *)*data, size, &error);
+    if (bytes != size || error != 0) {
+        return -EINVAL;
+    }
+
+    return bytes;
+}
+
+const struct image_store_ops mp_store_ops = {
+    .open = store_open,
+    .close = store_close,
+    .load = store_load,
+    .features = SUPPORT_SEEK,
+};
+
+static struct remoteproc *rproc_init(struct remoteproc *rproc,
+    const struct remoteproc_ops *ops, void *arg) {
+    debug_printf("rproc_init()\n");
+
+    rproc = rproc;
+    rproc->ops = ops;
+    // Allocate filestore struct.
+    filestore_t *filestore = metal_allocate_memory(sizeof(filestore_t));
+    filestore->len = FILE_STORE_BUF_SIZE;
+    filestore->buf = metal_allocate_memory(FILE_STORE_BUF_SIZE);
+    // Store in rproc's private data.
+    rproc->priv = filestore;
+    metal_list_init(&rproc->mems);
+    // Set RPROC_OFFLINE to make rproc_config get called.
+    rproc->state = RPROC_READY;
+    return rproc;
+}
+
+static void *rproc_mmap(struct remoteproc *rproc, metal_phys_addr_t *pa,
+    metal_phys_addr_t *da, size_t size, unsigned int attribute,
+    struct metal_io_region **io) {
+    debug_printf("rproc_mmap(): pa 0x%p da 0x%p io 0x%p size %u\n", *pa, *da, *io, size);
+
+    struct remoteproc_mem *mem;
+    metal_phys_addr_t lpa = *pa;
+    metal_phys_addr_t lda = *da;
+
+    if (lda == METAL_BAD_PHYS) {
+        return NULL;
+    }
+
+    if (lpa == METAL_BAD_PHYS) {
+        lpa = lda;
+    }
+
+    mem = metal_allocate_memory(sizeof(*mem));
+    if (!mem) {
+        return NULL;
+    }
+
+    *io = metal_allocate_memory(sizeof(struct metal_io_region));
+    if (!*io) {
+        metal_free_memory(mem);
+        return NULL;
+    }
+
+    remoteproc_init_mem(mem, NULL, lpa, lda, size, *io);
+
+    metal_io_init(*io, (void *)mem->da, &mem->pa, size,
+        sizeof(metal_phys_addr_t) << 3, attribute, NULL);
+
+    remoteproc_add_mem(rproc, mem);
+    *pa = lpa;
+    *da = lda;
+    return metal_io_phys_to_virt(*io, mem->pa);
+}
+
+static int rproc_start(struct remoteproc *rproc) {
+    debug_printf("rproc_start()\n");
+    if (RCC->GCR & RCC_GCR_BOOT_C2) {
+        // CM4 core is already booted.
+        debug_printf("rproc_start(): CM4 core is already booted.\n");
+        return -1;
+    }
+
+    // Flush M7 cache.
+    struct metal_list *node;
+    metal_list_for_each(&rproc->mems, node) {
+        struct remoteproc_mem *mem;
+        mem = metal_container_of(node, struct remoteproc_mem, node);
+        SCB_CleanDCache_by_Addr((uint32_t *)mem->pa, mem->size);
+    }
+
+    HAL_SYSCFG_CM4BootAddConfig(SYSCFG_BOOT_ADDR0, (uint32_t)rproc->bootaddr);
+    HAL_RCCEx_EnableBootCore(RCC_BOOT_C2);
+    return 0;
+}
+
+static int rproc_stop(struct remoteproc *rproc) {
+    debug_printf("rproc_stop()\n");
+    if (rproc->state == RPROC_RUNNING) {
+        // There's no straightforward way to reset or shut down
+        // the remote processor, so a full system reset is needed.
+        NVIC_SystemReset();
+    }
+    return 0;
+}
+
+static int rproc_config(struct remoteproc *rproc, void *data) {
+    debug_printf("rproc_config()\n");
+    (void)rproc;
+    return 0;
+}
+
+static void rproc_remove(struct remoteproc *rproc) {
+    debug_printf("rproc_remove()\n");
+    (void)rproc;
+}
+
+static int rproc_shutdown(struct remoteproc *rproc) {
+    debug_printf("rproc_shutdown()\n");
+    if (rproc->state == RPROC_RUNNING) {
+        // There's no straightforward way to reset or shut down
+        // the remote processor, so a full system reset is needed.
+        NVIC_SystemReset();
+    }
+    return 0;
+}
+
+const struct remoteproc_ops mp_rproc_ops = {
+    .init = rproc_init,
+    .mmap = rproc_mmap,
+    .start = rproc_start,
+    .stop = rproc_stop,
+    .config = rproc_config,
+    .remove = rproc_remove,
+    .shutdown = rproc_shutdown,
+};
