This PR adds support for OpenAMP in MicroPython, with the goal of standardizing asymmetric multi-core support across different hardware running MicroPython. There are 3 major components to OpenAMP, libmetal, remoteproc and RPMsg. libmetal provides abstraction of the low-level underlying hardware, remoteproc is used for processor Life Cycle Management (LCM) (i.e loading firmware, starting, stopping a core etc..), and RPMsg is a bus infrastructure that enables Inter Processor Communications (IPC) between different cores. These components are implemented in this PR as follows:

• OpenAMP's libmetal submodule is added in this PR (see note about this submodule), and a generic MicroPython system port is implemented, one that uses some sane defaults and common mp_hal functions, and also allows for MicroPython's ports to override defaults and config libmetal.

• OpenAMP's remoteproc component is implemented in extmod/modremoteproc.c module which provides an API to load firmware and control remote processors. Port-specific ops must be implemented for this module (similar to mpbthciport.c or mpnetworkport.c). One example is already done in this PR for stm32.

• OpenAMP's RPMsg component and the rest of the logic is implemented in extmod/modopenamp.c. This module provides anendpoint type (a logical connection on top of RPMsg channel) that can be used to communicate with the remote core.

Example: The following script loads a firmware image that implements a virtual uart over RPMsg channel, built for STM32H7's M4 core, starts it, and communicates with the M4 once the core is ready to communicate. The remote core becomes ready to communicate after the master/host core initializes a shared memory area, and it announces its readiness by creating a new RPMsg channel. At this point, the ns_callback is called, and the host processor creates an endpoint to communicate over that RPMsg channel. Note the firmware is parsed and loaded from an elf file stored on the filesystem, I can share the source somewhere later as an example or for testing.

import openamp
import time

ept = None


def ept_recv_callback(src_addr, data):
    print(f'Received message on endpoint "{data}"')


def ns_bind_callback(src_addr, name):
    global ept
    print(f'New service announcement src address: {src_addr} name: "{name}"')
    # Create a new RPMsg endpoint to communicate with the M4.
    ept = openamp.RPMsg(
        name, src_addr=openamp.RPMSG_ADDR_ANY, dst_addr=src_addr, callback=ept_recv_callback
    )


# Initialize OpenAMP. Name service callback is called when the remote
# processor creates an RPMsg channel, and is ready to communicate.
openamp.init(ns_callback=ns_bind_callback)

# Create a remoteproc object, load its firmware and start it.
# Note you can also start from an entry point (ex 0x081E0000)
#rproc = openamp.RProc(0x081E0000)
rproc = openamp.RProc("vuart.elf")
rproc.start()

while True:
    if ept is not None:
        ept.send("Hello World!", timeout=1000)
    time.sleep_ms(1000)

Output:

registered generic bus
remoteproc_load: check remoteproc status
remoteproc_load: open executable image
remoteproc_load: check loader
remoteproc_load: loading headers
Loading ELF headering
Loading ELF program header.
Loading ELF section header.
remoteproc_load, load header 0x0, 0x1000, next 0x18098, 0x258
Loading ELF section header.
Loading ELF section header complete.
Loading ELF shstrtab.
remoteproc_load, load header 0x18098, 0x258, next 0x1800d, 0x8a
Loading ELF shstrtab.
remoteproc_load, load header 0x1800d, 0x8a, next 0x1800d, 0x0
remoteproc_load: load executable data
segment: 1, total segs 1
load data: da 0x38000000, offset 0x10000, len = 0x7f90, memsize = 0xc138, state 0x20801
load data: da 0xffffffff, offset 0x0, len = 0x0, memsize = 0x0, state 0x40801
remoteproc_load: successfully load firmware
New service announcement src address: 1024 name: "m4-vuart-channel"
Received message on endpoint "Hello from M4!"

The firmware running on the M4 can be found here: https://github.com/iabdalkader/openamp_vuart

Todo:

• Handle file system access in a generic way using mp_vfs
• Support endpoint send/send non-blocking and off-channel.
• Add optional trace buffer resource.
• Support loading/starting firmware from Flash address.
• Support loading/starting firmware from SD-RAM on H7.
• Provide an example for the H7 M4 side (optional).

• Note about libmetal it's basically impossible to add its upstream as a submodule, since it only supports cmake, and it hard-codes configure_file variables into headers, and it's basically expected to be built into a static library and installed somewhere. So for now I've used my own fork, with minor changes to make it more "MicroPython-friendly". This library hardly changes, I think it would make sense to maintain our own fork, I can transfer ownership of the libmetal repo to MicroPython later if you want, I have no need to maintain it.