本文通过SDK中最简单的hello_world例程来说明一下双核程序如何运行。在CM7和CM4的工程中都有一个MCMGR(Multicore Manager)文件夹，它是用来管理多核之间的操作的，当然也包括我们前面提到的那些寄存器的设置。
文章目录
我们现在就以CM7核激活CM4核为例，先分析一下CM7核的代码。实际上在CM7的例程中就调用了
MCMGR_EarlyInit、
MCMGR_Init和
MCMGR_StartCore三个函数就能启动M4核了。下面就来分析一下这三个函数：
1 MCMGR_EarlyInit
无论是CM7还是CM4，都需要调用这个函数，它是用来初始化底层的多核管理库(MCMGR)的，这个函数应该尽可能在reset_handler附近调用，表示某个核已经启动并准备好执行任务。在这里，这个函数在ResetISR->SystemInit中就调用了。这个函数最终调用的是mcmgr_early_init_internal：
mcmgr_status_t mcmgr_early_init_internal(mcmgr_core_t coreNum)
{
MU_Init(MUA); //实际上就是使能MU的时钟(M7核初始化MUA,M4核这里的参数为MUB)
return MCMGR_TriggerEvent(kMCMGR_RemoteCoreUpEvent, 0);
}
1.1 MCMGR_TriggerEvent
MCMGR_TriggerEvent函数实际上调用的是MCMGR_TriggerEventCommon：
mcmgr_status_t MCMGR_TriggerEvent(mcmgr_event_type_t type, uint16_t eventData)
{
return MCMGR_TriggerEventCommon(type, eventData, false);
}
所以来看一下MCMGR_TriggerEventCommon函数：
/*! @brief Type definition of event types. */
typedef enum _mcmgr_event_type_t
{
kMCMGR_RemoteCoreUpEvent = 1,
kMCMGR_RemoteCoreDownEvent,
kMCMGR_RemoteExceptionEvent,
kMCMGR_StartupDataEvent,
kMCMGR_FeedStartupDataEvent,
kMCMGR_RemoteRPMsgEvent,
kMCMGR_RemoteApplicationEvent,
kMCMGR_FreeRtosMessageBuffersEvent,
kMCMGR_EventTableLength
} mcmgr_event_type_t;
static mcmgr_status_t MCMGR_TriggerEventCommon(mcmgr_event_type_t type, uint16_t eventData, bool forcedWrite)
{
uint32_t remoteData;
remoteData = (((uint32_t)type) << 16) | eventData;
return mcmgr_trigger_event_internal(remoteData, forcedWrite);
}
接着看一下mcmgr_trigger_event_internal函数：
/* MCMGR MU channel index - used for passing startupData */
#define MCMGR_MU_CHANNEL 3
mcmgr_status_t mcmgr_trigger_event_internal(uint32_t remoteData, bool forcedWrite)
{
/* When forcedWrite is false, execute the blocking call, i.e. wait until previously
sent data is processed. Otherwise, run the non-blocking version of the MU send function. */
if (false == forcedWrite)
{
MU_SendMsg(MUA, MCMGR_MU_CHANNEL, remoteData);// M7执行这条,M4的第一个参数MUA换为MUB
}
else
{
MU_SendMsgNonBlocking(MUA, MCMGR_MU_CHANNEL, remoteData);// M7执行这条,M4的第一个参数MUA换为MUB
}
return kStatus_MCMGR_Success;
}
这里的forcedWrite参数为false的时候，执行阻塞写函数，等待上一次发送的数据处理完了才发送；forcedWrite参数为true时，直接往寄存器中写数据，这个函数最好搭配中断使用。
从上面我们知道，mcmgr_early_init_internal实际上就是通过自己核对应的MU的通道3发送一个组合的32位数(高16位为type，低16位为eventData，这里type为kMCMGR_RemoteCoreUpEvent，eventData为0)给对方核对应的MU的通道3。
- 如果不知道
MU的，建议看一下我之前介绍MU的文章：双核通信之MU消息单元详解
2 MCMGR_Init函数
接着就是调用MCMGR_Init函数：
mcmgr_status_t MCMGR_Init(void)
{
// 通过OCOTP熔丝相应位可以判断当前是CM4(返回0)还是CM7核(返回1)
mcmgr_core_t coreNum = MCMGR_GetCurrentCore();
// 两个回调函数
MCMGR_RegisterEvent(kMCMGR_StartupDataEvent, MCMGR_StartupDataEventHandler, (void *)&s_mcmgrCoresContext[coreNum]);
MCMGR_RegisterEvent(kMCMGR_FeedStartupDataEvent, MCMGR_FeedStartupDataEventHandler, (void *)&s_mcmgrCoresContext[(coreNum == 0) ? 1 : 0]);
return mcmgr_late_init_internal(coreNum);
}
MCMGR_RegisterEvent用来注册某个事件(参数一)的回调函数(参数二)，其中参数三s_mcmgrCoresContext会传给回调函数作为其参数供其使用，它的定义如下：
typedef struct _mcmgr_core_context
{
/*! @brief Current state of the core. */
mcmgr_core_state_t state;
/*! @brief Startup data, if state >= kMCMGR_RunningCoreState */
uint32_t startupData;
} mcmgr_core_context_t;
/*! @brief Type definition of possible core states. */
typedef enum _mcmgr_core_state
{
kMCMGR_ResetCoreState = 0,
kMCMGR_StartupGettingLowCoreState,
kMCMGR_StartupGettingHighCoreState,
kMCMGR_RunningCoreState,
} mcmgr_core_state_t;
volatile mcmgr_core_context_t s_mcmgrCoresContext[2] = {
{.state = kMCMGR_ResetCoreState, .startupData = 0}, {.state = kMCMGR_ResetCoreState, .startupData = 0}};
看样子似乎是一个状态机，其中：
-
s_mcmgrCoresContext[0]用于kMCMGR_StartupDataEvent事件的MCMGR_StartupDataEventHandler回调 -
s_mcmgrCoresContext[1]用于kMCMGR_FeedStartupDataEvent事件的MCMGR_FeedStartupDataEventHandler回调
具体完成了什么我们后面用到了再分析。
2.1 MCMGR_RegisterEvent函数
顾名思义就是用来注册回调函数的，实现也非常简单，就是定义了一个结构体数组，然后填充即可：
/*! @brief Type definition of structure with event handler and data. */
typedef struct _mcmgr_event
{
/*! @brief Pointer to callback function. */
mcmgr_event_callback_t callback;
/*! @brief Context data for callback. */
void *callbackData;
} mcmgr_event_t;
mcmgr_event_t MCMGR_eventTable[kMCMGR_EventTableLength] = {0};
mcmgr_status_t MCMGR_RegisterEvent(mcmgr_event_type_t type, mcmgr_event_callback_t callback, void *callbackData)
{
if (type >= kMCMGR_EventTableLength)
{
return kStatus_MCMGR_Error;
}
MCMGR_eventTable[type].callback = ((void *)0);
MCMGR_eventTable[type].callbackData = callbackData;
MCMGR_eventTable[type].callback = callback;
return kStatus_MCMGR_Success;
}
在mcmgr_event_type_t有8种事件，每个事件占据MCMGR_eventTable数组的一个索引。
接下来看一下两个回调函数完成了什么：
2.2 事件回调函数
下面来看一下MCMGR_StartupDataEventHandler和MCMGR_FeedStartupDataEventHandler：
static void MCMGR_StartupDataEventHandler(uint16_t startupDataChunk, void *context)
{
mcmgr_core_context_t *coreContext = (mcmgr_core_context_t *)context;
switch (coreContext->state)
{
case kMCMGR_StartupGettingLowCoreState:
coreContext->startupData = startupDataChunk; /* Receive the low part */
coreContext->state = kMCMGR_StartupGettingHighCoreState;
(void)MCMGR_TriggerEvent(kMCMGR_FeedStartupDataEvent, (uint16_t)kMCMGR_StartupGettingHighCoreState);
break;
case kMCMGR_StartupGettingHighCoreState:
coreContext->startupData |= ((uint32_t)startupDataChunk) << 16;
coreContext->state = kMCMGR_RunningCoreState;
(void)MCMGR_TriggerEvent(kMCMGR_FeedStartupDataEvent, (uint16_t)kMCMGR_RunningCoreState);
break;
default:
break;
}
}
static void MCMGR_FeedStartupDataEventHandler(uint16_t startupDataChunk, void *context)
{
mcmgr_core_context_t *coreContext = (mcmgr_core_context_t *)context;
switch ((mcmgr_core_state_t)startupDataChunk)
{
case kMCMGR_StartupGettingLowCoreState:
(void)MCMGR_TriggerEvent(kMCMGR_StartupDataEvent, (uint16_t)(coreContext->startupData & 0xFFFFU));
coreContext->state = (mcmgr_core_state_t)startupDataChunk;
break;
case kMCMGR_StartupGettingHighCoreState:
(void)MCMGR_TriggerEvent(kMCMGR_StartupDataEvent, (uint16_t)((coreContext->startupData) >> 16));
coreContext->state = (mcmgr_core_state_t)startupDataChunk;
break;
case kMCMGR_RunningCoreState:
coreContext->state = (mcmgr_core_state_t)startupDataChunk;
break;
default:
break;
}
}
这里的context就是前面注册回调函数时的第三个参数s_mcmgrCoresContext[0/1]，前面我们看到默认的state为kMCMGR_ResetCoreState，所以不会进入任何分支中，具体初始状态在何时改变的，我们后续分析。
我们看到这里两个Handler最后都是调用MCMGR_TriggerEvent函数，即通过MU发送一个32位数给对方核。
2.3 mcmgr_late_init_internal
MCMGR_Init最后调用mcmgr_late_init_internal打开MU的通道3的接收中断：
(下面代码为CM7核的，CM4核打开的是MUB)
mcmgr_status_t mcmgr_late_init_internal(mcmgr_core_t coreNum)
{
MU_EnableInterrupts(MUA, (uint32_t)kMU_Rx3FullInterruptEnable);
NVIC_SetPriority(MUA_IRQn, 2);
NVIC_EnableIRQ(MUA_IRQn);
return kStatus_MCMGR_Success;
}
在前面的MCMGR_TriggerEvent中，最后也是使用通道3发送的消息，所以在SDK中使用MU的通道3来完成双核执行的同步。
3 MCMGR_StartCore函数
对于CM7来说，注册完回调函数之后，还需要调用MCMGR_StartCore来启动CM4核。
MCMGR_StartCore(kMCMGR_Core1, (void *)(char *)CORE1_BOOT_ADDRESS, 2, kMCMGR_Start_Synchronous);
具体实现如下：
#define CORE1_BOOT_ADDRESS (void *)0x20200000
MCMGR_StartCore(kMCMGR_Core1, (void *)(char *)CORE1_BOOT_ADDRESS, 2, kMCMGR_Start_Synchronous); //kMCMGR_Core1=1
mcmgr_status_t MCMGR_StartCore(mcmgr_core_t coreNum, void *bootAddress, uint32_t startupData, mcmgr_start_mode_t mode)
{
mcmgr_status_t ret;
/* 填充startupData */
s_mcmgrCoresContext[coreNum].startupData = startupData;
/* 设置相关寄存器 */
ret = mcmgr_start_core_internal(coreNum, bootAddress);
if (mode == kMCMGR_Start_Synchronous)
{
/* 等待M4核读取和确认我们刚刚填充的startupData */
while (s_mcmgrCoresContext[coreNum].state != kMCMGR_RunningCoreState){}
}
return kStatus_MCMGR_Success;
}
这里假设我们将CM4的程序通过CM7的映射地址0x20200000拷贝到CM4的TCM中了，如果CM4的程序在NOR Flash中，填写对应的地址即可。
mcmgr_start_core_internal就是我们上一篇文章双核相互激活和启动流程提到的CM7激活CM4相关寄存器的修改：
mcmgr_status_t mcmgr_start_core_internal(mcmgr_core_t coreNum, void *bootAddress)
{
IOMUXC_LPSR_GPR->GPR0 = IOMUXC_LPSR_GPR_GPR0_CM4_INIT_VTOR_LOW(((uint32_t)(char *)bootAddress) >> 3u);
IOMUXC_LPSR_GPR->GPR1 = IOMUXC_LPSR_GPR_GPR1_CM4_INIT_VTOR_HIGH(((uint32_t)(char *)bootAddress) >> 16u);
SRC->CTRL_M4CORE = SRC_CTRL_M4CORE_SW_RESET_MASK;
SRC->SCR |= SRC_SCR_BT_RELEASE_M4_MASK;
return kStatus_MCMGR_Success;
}
4 MCMGR_GetStartupData函数
在CM4核启动后会调用MCMGR_GetStartupData函数，直到这个函数返回kStatus_MCMGR_Success：
do
{
status = MCMGR_GetStartupData(&startupData);
} while (status != kStatus_MCMGR_Success);
现在来看一下这个函数：
mcmgr_status_t MCMGR_GetStartupData(uint32_t *startupData)
{
if (s_mcmgrCoresContext[1].state == kMCMGR_ResetCoreState)
{
s_mcmgrCoresContext[1].state = kMCMGR_StartupGettingLowCoreState;
if (kStatus_MCMGR_Success !=
MCMGR_TriggerEvent(kMCMGR_FeedStartupDataEvent, (uint16_t)kMCMGR_StartupGettingLowCoreState))
{
return kStatus_MCMGR_Error;
}
}
return mcmgr_get_startup_data_internal(1, startupData);
}
mcmgr_status_t mcmgr_get_startup_data_internal(mcmgr_core_t coreNum, uint32_t *startupData)
{
if (s_mcmgrCoresContext[1].state >= kMCMGR_RunningCoreState)
{
*startupData = s_mcmgrCoresContext[1].startupData;
return kStatus_MCMGR_Success;
}
return kStatus_MCMGR_NotReady;
}
实际上也是和刚刚的状态机相关。
5 MU中断接收函数
现在我们对CM7和CM4的交互过程还是一头雾水，前面注册的回调函数什么时刻被调用，CM7启动CM4后等待s_mcmgrCoresContext[coreNum].state变为kMCMGR_RunningCoreState，还有CM4启动后，CM4也要等待状态变化再往下执行程序，那么这些状态是在哪里被修改的呢？下面就来分析一下这个过程。
前面我们打开了中断，所以我们首先看一下中断处理回调函数，在通道三收到数据后将调用此回调函数：(下面为CM7核MUA的回调，MUB的类似)
void MU_Rx3FullFlagISR(void)
{
uint32_t data;
uint16_t eventType;
uint16_t eventData;
#if defined(FSL_FEATURE_MU_SIDE_A)
data = MU_ReceiveMsgNonBlocking(MUA, 3);
#elif defined(FSL_FEATURE_MU_SIDE_B)
data = MU_ReceiveMsgNonBlocking(MUB, 3);
#endif
/* To be MISRA compliant, return value needs to be checked even it could not never be 0 */
if (0U != data)
{
eventType = (uint16_t)(data >> 16u);
eventData = (uint16_t)(data & 0x0000FFFFu);
if (((mcmgr_event_type_t)eventType >= kMCMGR_RemoteCoreUpEvent) &&
((mcmgr_event_type_t)eventType < kMCMGR_EventTableLength))
{
if (MCMGR_eventTable[(mcmgr_event_type_t)eventType].callback != ((void *)0))
{
MCMGR_eventTable[(mcmgr_event_type_t)eventType].callback(
eventData, MCMGR_eventTable[(mcmgr_event_type_t)eventType].callbackData);
}
}
}
}
- 在理论上我们的程序中没有发送数据内容为0的代码，但是为了符合
MISRA规范，这里还是检查了0U != data。
前面在MCMGR_TriggerEvent中，我们将type和event组合成一个32位的数发送给对方，这里同样的，我们收到数据后取出高16位的type和低16位的event。然后调用我们使用MCMGR_RegisterEvent注册的回调函数，第一个参数为eventData，第二个参数为我们注册的时候提供的callbackData(这里为s_mcmgrCoresContext)。
6 双核状态机交互过程详解
看完了中断函数后，感觉两个核有一些联系了，我们先来看一下两个核的执行流程：
这些函数前面都分析过了，但是里面状态机的状态改变似乎有些复杂，而状态的改变是通过双核之间的通道3进行交互的，这里我们就来捋清里面的流程：
- 这里通道间发送数据为32位，高16位为
type，低16位为eventData，下面都表示为(type, eventData)
1、MCMGR_EarlyInit
发送32位数据，(kMCMGR_RemoteCoreUpEvent,0)。由于后面我们在MCMGR_Init函数中并没有注册kMCMGR_RemoteCoreUpEvent的回调函数，实际上这个消息会被忽略。
2、MCMGR_Init
这里没有发送任何数据，但是注册了两个回调函数，在回调函数中会发送数据：
3、启动CM4：MCMGR_StartCore
s_mcmgrCoresContext[1].startupData = 2;
while (s_mcmgrCoresContext[1].state != kMCMGR_RunningCoreState);
这里CM7将s_mcmgrCoresContext[1]的startupData设置为了2，然后等待s_mcmgrCoresContext[1]的state变为kMCMGR_RunningCoreState。
4、CM4和CM7消息同步
(1)CM4在MCMGR_GetStartupData中将s_mcmgrCoresContext[1]的state设置为了kMCMGR_StartupGettingLowCoreState，然后向CM7发送(kMCMGR_FeedStartupDataEvent, kMCMGR_StartupGettingLowCoreState)。
(2)在CM7接收到这个32位消息后，将进入MCMGR_FeedStartupDataEventHandler中，向CM4发送(kMCMGR_StartupDataEvent, 2)，然后将state设置为kMCMGR_StartupGettingLowCoreState。
case kMCMGR_StartupGettingLowCoreState:
(void)MCMGR_TriggerEvent(kMCMGR_StartupDataEvent, (uint16_t)(coreContext->startupData & 0xFFFFU));
coreContext->state = (mcmgr_core_state_t)startupDataChunk;
break;
此时双核的状态如下：
(3)CM4收到(kMCMGR_StartupDataEvent, 0)，进入MCMGR_StartupDataEventHandler的下面分支：
case kMCMGR_StartupGettingLowCoreState:
coreContext->startupData = startupDataChunk; /* Receive the low part */
coreContext->state = kMCMGR_StartupGettingHighCoreState;
(void)MCMGR_TriggerEvent(kMCMGR_FeedStartupDataEvent, (uint16_t)kMCMGR_StartupGettingHighCoreState);
break;
将startupData设置为2，state设置为kMCMGR_StartupGettingHighCoreState，然后发送(kMCMGR_FeedStartupDataEvent, kMCMGR_StartupGettingHighCoreState)给CM7。
(4)CM7收到(kMCMGR_FeedStartupDataEvent, kMCMGR_StartupGettingHighCoreState)，进入MCMGR_FeedStartupDataEventHandler的下面分支：
case kMCMGR_StartupGettingHighCoreState:
(void)MCMGR_TriggerEvent(kMCMGR_StartupDataEvent, (uint16_t)((coreContext->startupData) >> 16));
coreContext->state = (mcmgr_core_state_t)startupDataChunk;
break;
这里发送(kMCMGR_StartupDataEvent, (uint16_t)(2>> 16))给CM4，然后设置自身的state为kMCMGR_StartupGettingHighCoreState。
此时双核的状态如下：
(5)CM4收到(kMCMGR_StartupDataEvent, 0)后，进入MCMGR_StartupDataEventHandler的下面分支：
case kMCMGR_StartupGettingHighCoreState:
coreContext->startupData |= ((uint32_t)startupDataChunk) << 16;
coreContext->state = kMCMGR_RunningCoreState;
(void)MCMGR_TriggerEvent(kMCMGR_FeedStartupDataEvent, (uint16_t)kMCMGR_RunningCoreState);
break;
将startupData与之前收到的低16位进行组合，然后赋到startupData中，即CM7在MCMGR_StartCore函数中的第三个参数传给了CM4。然后将state设置为kMCMGR_RunningCoreState，并向CM7发送(kMCMGR_FeedStartupDataEvent, kMCMGR_RunningCoreState)。
(6)CM7收到(kMCMGR_FeedStartupDataEvent, kMCMGR_RunningCoreState)后进入MCMGR_FeedStartupDataEventHandler中的kMCMGR_RunningCoreState分支：
case kMCMGR_RunningCoreState:
coreContext->state = (mcmgr_core_state_t)startupDataChunk;
break;
最终就将state设置为了kMCMGR_RunningCoreState。此时在MCMGR_StartCore中等待s_mcmgrCoresContext[1]的state变为kMCMGR_RunningCoreState则成立，此时CM7知道CM4已经成功启动。
最终的状态如下：
7 总结
从上面状态机分析可知，CM7仅用了kMCMGR_FeedStartupDataEvent，而CM4仅用了kMCMGR_StartupDataEvent。在CM4启动后，先发送一个消息给CM7，然后CM7开始传startupData给CM4，最终CM7的状态都变为kMCMGR_RunningCoreState，表示CM7知道CM4已经启动了，就可以执行其它操作了。
1210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
