现在的芯片非常复杂，很多都是包含多个核，特别是片上系统（SoC），一颗芯片上不仅包含了很多个核心，并且很多核心都是异构的。

为了最大限度的发挥他们的性能，协同完成某一任务，不同的核心上面运行的系统可能各不相同，有些核心上面运行的通用系统例如 Linux、Android 等，另外一些核心上可能运行的就是实时操作系统（RTOS）等。这些不同架构的核心以及他们上面所运行的软件组合在一起，就成了异构多处理系统（Asymmetric Multiprocessing System）。

异构多处理系统中往往会形成主-从（Master-Slave）结构。主核上的系统先启动，并负责准备好运行环境，然后根据需要或者一定规则启动从核并对其进行管理。主-从核心上的系统都准备好之后，他们之间就通过 IPC（Inter Processor Communication）方式进行通信，而 RPMsg 就是 IPC 中的一种。

RPMsg，全称 Remote Processor Messaging，它定义了异构多核处理系统（AMP，Asymmetric Multiprocessing）中核与核之间进行通信时所使用的标准二进制接口。

对于非通用的操作系统，它上面很可能是没有搭载传统的 TCP/IP 协议栈的，因此，当主核想要通过 RPC 的方式调用从核上的服务的时候，便不能使用一般的 RPC 框架所采用的网络通信方式。这时候类似于 RPMsg 这种专门用于核间通信的通信协议就派上了用场。

1、rpmsg-lite介绍

RPMsg-Lite 是远程处理器消息传递（RPMsg）协议的轻量级实现。 RPMsg 协议定义了标准化的二进制接口，该接口用于在异构多核系统中的多个核之间进行通信。与开放式非对称多处理（OpenAMP）框架的 RPMsg 实现相比，RPMsg-Lite 减少了代码大小，简化了 API，并提高了模块性。

RPMsg-Lite 是由 NXP Semiconductors 开发并在 BSD 兼容许可下发布的开源组件。

官方仓库为：https://github.com/nxp-mcuxpresso/rpmsg-lite

官方详细使用的指南：https://nxp-mcuxpresso.github.io/rpmsg-lite

下载 rpmsg-lite 源码后，查看源码文件较少

$ tree -L 2
.
├── common
│   └── llist.c
├── include
│   ├── environment
│   ├── llist.h
│   ├── platform
│   ├── rpmsg_compiler.h
│   ├── rpmsg_default_config.h
│   ├── rpmsg_env.h
│   ├── rpmsg_lite.h
│   ├── rpmsg_ns.h
│   ├── rpmsg_queue.h
│   ├── virtio_ring.h
│   └── virtqueue.h
├── rpmsg_lite
│   ├── porting
│   ├── rpmsg_lite.c
│   ├── rpmsg_ns.c
│   └── rpmsg_queue.c
└── virtio
    └── virtqueue.c

RPMsg-Lite 的实现可以分为三个子组件，核心组件位于 rpmsg_lite.c 中，rpmsg_ns.c 和 rpmsg_queue.c 是可选的组件。两个可选组件用于实现阻塞接收 API（在 rpmsg_queue.c 中）和动态“命名”端点创建和删除公告服务（在 rpmsg_ns.c 中）。

媒体访问层 是在 virtqueue.c 中实现的，它是与 OpenAMP 实现共享的少数几个文件之一。该层主要定义了共享内存模型，内部定义了使用的组件，如vring或virtqueue。

2、rpmsg-lite 应用

nxp 有很多 AMP 的芯片（如：frdmk32l3a6、imxrt1160、imxrt1170、lpcxpresso55s69、lpcxpresso54114等），都是基于 rpmsg-lite 的实现的核间通信，可下载对应SDK https://github.com/nxp-mcuxpresso/mcux-sdk-examples 学习。

下面通过 lpcxpresso54114 中的示例展示 rpmsg 中比较典型的 pingpong 应用实现。

lpcxpresso54114 中 master 端是 Cortex-M4 核， remote 端 Cortex-M0 + 核。

• master 端

static void app_nameservice_isr_cb(uint32_t new_ept, const char *new_ept_name, uint32_t flags, void *user_data)
{
    uint32_t *data = (uint32_t *)user_data;

    *data = new_ept;
}

void app_task_master(void *param)
{
    volatile uint32_t remote_addr = 0U;
    struct rpmsg_lite_endpoint *my_ept;
    rpmsg_queue_handle my_queue;
    struct rpmsg_lite_instance *my_rpmsg;
    rpmsg_ns_handle ns_handle;

    my_rpmsg =
        rpmsg_lite_master_init((void *)RPMSG_LITE_SHMEM_BASE, SH_MEM_TOTAL_SIZE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS);

    my_queue  = rpmsg_queue_create(my_rpmsg);
    my_ept    = rpmsg_lite_create_ept(my_rpmsg, LOCAL_EPT_ADDR, rpmsg_queue_rx_cb, my_queue);
    ns_handle = rpmsg_ns_bind(my_rpmsg, app_nameservice_isr_cb, (void *)&remote_addr);

    /* Wait until the secondary core application issues the nameservice isr and the remote endpoint address is known. */
    while (0U == remote_addr)
    {
    };

    /* Send the first message to the remoteproc */
    msg.DATA = 0U;
    (void)rpmsg_lite_send(my_rpmsg, my_ept, remote_addr, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);

    while (msg.DATA <= 100U)
    {
        (void)rpmsg_queue_recv(my_rpmsg, my_queue, (uint32_t *)&remote_addr, (char *)&msg, sizeof(THE_MESSAGE), &len,
                               RL_BLOCK);
        (void)PRINTF("Primary core received a msg\r\n");
        (void)PRINTF("Message: Size=%x, DATA = %i\r\n", len, msg.DATA);
        msg.DATA++;

        (void)rpmsg_lite_send(my_rpmsg, my_ept, remote_addr, (char *)&msg, sizeof(THE_MESSAGE), RL_BLOCK);
    }

    (void)rpmsg_lite_destroy_ept(my_rpmsg, my_ept);
    my_ept = ((void *)0);
    (void)rpmsg_queue_destroy(my_rpmsg, my_queue);
    my_queue = ((void *)0);
    (void)rpmsg_ns_unbind(my_rpmsg, ns_handle);
    (void)rpmsg_lite_deinit(my_rpmsg);

    wile (1)
    {
         vTaskDelay(1000);
    }
}

• remote 端

static void app_nameservice_isr_cb(uint32_t new_ept, const char *new_ept_name, uint32_t flags, void *user_data)
{
}

void app_task_remote(void *param)
{
    volatile uint32_t remote_addr;
    volatile rpmsg_ns_handle ns_handle;
    
    my_rpmsg = rpmsg_lite_remote_init((void *)RPMSG_LITE_SHMEM_BASE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS);

    rpmsg_lite_wait_for_link_up(my_rpmsg);
    (void)PRINTF("Link is up!\r\n");

    my_queue  = rpmsg_queue_create(my_rpmsg);
    my_ept    = rpmsg_lite_create_ept(my_rpmsg, LOCAL_EPT_ADDR, rpmsg_queue_rx_cb, my_queue);
    ns_handle = rpmsg_ns_bind(my_rpmsg, app_nameservice_isr_cb, ((void *)0));
    /* Introduce some delay to avoid NS announce message not being captured by the master side.
       This could happen when the remote side execution is too fast and the NS announce message is triggered
       before the nameservice_isr_cb is registered on the master side. */
    SDK_DelayAtLeastUs(1000000U, SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY);
    (void)rpmsg_ns_announce(my_rpmsg, my_ept, RPMSG_LITE_NS_ANNOUNCE_STRING, (uint32_t)RL_NS_CREATE);
    (void)PRINTF("Nameservice announce sent.\r\n");

    while (msg.DATA <= 100U)
    {
        (void)PRINTF("Waiting for ping...\r\n");
        (void)rpmsg_queue_recv(my_rpmsg, my_queue, (uint32_t *)&remote_addr, (char *)&msg, sizeof(THE_MESSAGE),
                               ((void *)0), RL_BLOCK);
        msg.DATA++;
        (void)PRINTF("Sending pong...\r\n");
        (void)rpmsg_lite_send(my_rpmsg, my_ept, remote_addr, (char *)&msg, sizeof(THE_MESSAGE), RL_BLOCK);
    }

    (void)PRINTF("Ping pong done, deinitializing...\r\n");

    (void)rpmsg_lite_destroy_ept(my_rpmsg, my_ept);
    my_ept = ((void *)0);
    (void)rpmsg_queue_destroy(my_rpmsg, my_queue);
    my_queue = ((void *)0);
    (void)rpmsg_ns_unbind(my_rpmsg, ns_handle);
    (void)rpmsg_lite_deinit(my_rpmsg);
    my_rpmsg = ((void *)0);
    msg.DATA = 0U;

    while (1)
    {
         vTaskDelay(1000);
    }
}