/*********************************************************************************************************
** 函数名称: API_KernelReboot
** 功能描述: 内核重新启动函数
** 输 入 : iRebootType 重启类型
LW_REBOOT_FORCE
LW_REBOOT_WARM
LW_REBOOT_COLD
LW_REBOOT_SHUTDOWN
LW_REBOOT_POWEROFF
** ulStartAddress 启动地址
** 输 出 : NONE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
VOID API_KernelRebootEx (INT iRebootType, addr_t ulStartAddress)
{
INTREG iregInterLevel;
ULONG ulI;
if (iRebootType == LW_REBOOT_FORCE) {
archReboot(iRebootType, ulStartAddress); /* 调用体系架构重启操作 */
_BugHandle(LW_TRUE, LW_TRUE, "kernel reboot error!\r\n"); /* 不会运行到这里 */
}
if (LW_CPU_GET_CUR_NESTING() || (API_ThreadIdSelf() != API_KernelGetExc())) {
_excJobAdd(API_KernelRebootEx, (PVOID)iRebootType, (PVOID)ulStartAddress, 0, 0, 0, 0);
return;
}
_DebugHandle(__LOGMESSAGE_LEVEL, "kernel rebooting...\r\n");
_K_ulRebootStartAddress = ulStartAddress; /* 记录局部变量, 防止 XXX */
#if LW_CFG_SMP_EN > 0
if (LW_NCPUS > 1) {
__makeOtherDown(); /* 将其他 CPU 设置为 idle 模式 */
}
#endif /* LW_CFG_SMP_EN */
if (iRebootType != LW_REBOOT_FORCE) {
__LW_KERNEL_REBOOT_HOOK(iRebootType); /* 调用回调函数 */
_cppRtUninit(); /* 卸载 C++ 运行时 */
}
for (ulI = 0; ulI < LW_CFG_MAX_INTER_SRC; ulI++) {
API_InterVectorDisable(ulI); /* 关闭所有中断 */
}
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核同时关闭中断 */
#if LW_CFG_CACHE_EN > 0
API_CacheDisable(DATA_CACHE); /* 禁能 CACHE */
API_CacheDisable(INSTRUCTION_CACHE);
#endif /* LW_CFG_CACHE_EN > 0 */
#if LW_CFG_VMM_EN > 0
API_VmmMmuDisable(); /* 关闭 MMU */
#endif /* LW_CFG_VMM_EN > 0 */
archReboot(iRebootType, _K_ulRebootStartAddress); /* 调用体系架构重启操作 */
_BugHandle(LW_TRUE, LW_TRUE, "kernel reboot error!\r\n"); /* 不会运行到这里 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核同时打开中断 */
}
/*********************************************************************************************************
** 函数名称: _SmpSpinUnlockTask
** 功能描述: 自旋锁原始解锁操作. (不锁定中断, 同时允许加锁后调用可能产生阻塞的操作)
** 输 入 : psl 自旋锁
** 输 出 : 调度器返回值
** 全局变量:
** 调用模块:
*********************************************************************************************************/
INT _SmpSpinUnlockTask (spinlock_t *psl)
{
INTREG iregInterLevel;
PLW_CLASS_CPU pcpuCur;
PLW_CLASS_TCB ptcbCur;
BOOL bTrySched = LW_FALSE;
iregInterLevel = KN_INT_DISABLE();
KN_SMP_MB();
__ARCH_SPIN_UNLOCK_RAW(psl);
pcpuCur = LW_CPU_GET_CUR();
_BugHandle(pcpuCur->CPU_ulInterNesting, LW_TRUE, "called from ISR.\r\n");
ptcbCur = pcpuCur->CPU_ptcbTCBCur;
__THREAD_LOCK_DEC(ptcbCur); /* 解除任务锁定 */
if (__ISNEED_SCHED(pcpuCur, 0)) {
bTrySched = LW_TRUE; /* 需要尝试调度 */
}
KN_INT_ENABLE(iregInterLevel);
if (bTrySched) {
return (_ThreadSched(ptcbCur));
} else {
return (ERROR_NONE);
}
}
LW_API
VOID API_KernelPrimaryStart (PKERNEL_START_ROUTINE pfuncStartHook)
#endif /* LW_CFG_MEMORY_HEAP_... */
{
INT iError;
_BugHandle(LW_SYS_STATUS_IS_RUNNING(), LW_TRUE, "kernel is already start.\r\n");
_BugHandle(LW_NCPUS > LW_CFG_MAX_PROCESSORS, LW_TRUE, "LW_NCPUS > LW_CFG_MAX_PROCESSORS.\r\n");
_DebugHandle(__LOGMESSAGE_LEVEL, "longwing(TM) kernel initialize...\r\n");
#if LW_CFG_MEMORY_HEAP_CONFIG_TYPE > 0
_BugHandle(!pvKernelHeapMem, LW_TRUE, "heap memory invalidate.\r\n");
_BugHandle(!_Addresses_Is_Aligned(pvKernelHeapMem), LW_TRUE, "heap memory is not align.\r\n");
_BugHandle(stKernelHeapSize < LW_CFG_KB_SIZE, LW_TRUE, "heap memory is too little.\r\n");
if (pvSystemHeapMem && stSystemHeapSize) {
_BugHandle(!pvSystemHeapMem, LW_TRUE, "heap memory invalidate.\r\n");
_BugHandle(!_Addresses_Is_Aligned(pvSystemHeapMem), LW_TRUE, "heap memory is not align.\r\n");
_BugHandle(stSystemHeapSize < LW_CFG_KB_SIZE, LW_TRUE, "heap memory is too little.\r\n");
}
_KernelPrimaryLowLevelInit(pvKernelHeapMem, stKernelHeapSize,
pvSystemHeapMem, stSystemHeapSize); /* 内核底层初始化 */
#else
_KernelPrimaryLowLevelInit(); /* 内核底层初始化 */
#endif /* LW_CFG_MEMORY_HEAP_... */
_DebugHandle(__LOGMESSAGE_LEVEL, "kernel interrupt vector initialize...\r\n");
bspIntInit(); /* 初始化中断系统 */
_KernelHighLevelInit(); /* 内核高级初始化 */
iError = _cppRtInit(); /* CPP 运行时库初始化 */
if (iError != ERROR_NONE) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "c++ run time lib initialized error!\r\n");
} else {
_DebugHandle(__LOGMESSAGE_LEVEL, "c++ run time lib initialized.\r\n");
}
_DebugHandle(__LOGMESSAGE_LEVEL, "kernel primary cpu usrStartup...\r\n");
if (pfuncStartHook) { /* 用户是否要求需要初始化 */
pfuncStartHook(); /* 用户系统初始化 */
}
#if LW_CFG_MODULELOADER_EN > 0
_resInit(); /* 从现在开始记录资源情况 */
#endif /* LW_CFG_MODULELOADER_EN > 0 */
#if LW_CFG_SMP_EN > 0
_KernelBootSecondary(); /* 从核可以进行初始化操作 */
#endif /* LW_CFG_SMP_EN */
_KernelPrimaryEntry(LW_CPU_GET_CUR()); /* 启动内核 */
/* 多核将在第一次调度被启用 */
}
/*********************************************************************************************************
** 函数名称: __smpProcCallfunc
** 功能描述: 处理核间中断调用函数
** 输 入 : pcpuCur 当前 CPU
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static VOID __smpProcCallfunc (PLW_CLASS_CPU pcpuCur)
{
#define LW_KERNEL_OWN_CPU() (PLW_CLASS_CPU)(_K_klKernel.KERN_pvCpuOwner)
UINT i, uiCnt;
PLW_IPI_MSG pipim;
PLW_LIST_RING pringTemp;
PLW_LIST_RING pringDelete;
VOIDFUNCPTR pfuncAsync;
PVOID pvAsync;
LW_SPIN_LOCK_IGNIRQ(&pcpuCur->CPU_slIpi); /* 锁定 CPU */
pringTemp = pcpuCur->CPU_pringMsg;
uiCnt = pcpuCur->CPU_uiMsgCnt;
for (i = 0; i < uiCnt; i++) {
_BugHandle((!pcpuCur->CPU_pringMsg), LW_TRUE, "ipi call func error!\r\n");
pipim = _LIST_ENTRY(pringTemp, LW_IPI_MSG, IPIM_ringManage);
if ((LW_KERNEL_OWN_CPU() == pcpuCur) &&
(pipim->IPIM_iOption & IPIM_OPT_NOKERN)) { /* 此函数不能再内核锁定状态执行*/
pringTemp = _list_ring_get_next(pringTemp);
continue;
}
pringDelete = pringTemp;
pringTemp = _list_ring_get_next(pringTemp);
_List_Ring_Del(pringDelete, &pcpuCur->CPU_pringMsg); /* 删除一个节点 */
pcpuCur->CPU_uiMsgCnt--;
if (pipim->IPIM_pfuncCall) {
pipim->IPIM_iRet = pipim->IPIM_pfuncCall(pipim->IPIM_pvArg);/* 执行同步调用 */
}
pfuncAsync = pipim->IPIM_pfuncAsyncCall;
pvAsync = pipim->IPIM_pvAsyncArg;
KN_SMP_MB();
pipim->IPIM_iWait = 0; /* 调用结束 */
KN_SMP_WMB();
LW_SPINLOCK_NOTIFY();
if (pfuncAsync) {
pfuncAsync(pvAsync); /* 执行异步调用 */
}
}
KN_SMP_MB();
if (pcpuCur->CPU_pringMsg == LW_NULL) {
LW_CPU_CLR_IPI_PEND2(pcpuCur, LW_IPI_CALL_MSK); /* 清除 */
}
LW_SPIN_UNLOCK_IGNIRQ(&pcpuCur->CPU_slIpi); /* 解锁 CPU */
LW_SPINLOCK_NOTIFY();
}
/*********************************************************************************************************
** 函数名称: _SmpSpinLockTask
** 功能描述: 自旋锁原始加锁操作. (不锁定中断, 同时允许加锁后调用可能产生阻塞的操作)
** 输 入 : psl 自旋锁
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _SmpSpinLockTask (spinlock_t *psl)
{
INTREG iregInterLevel;
PLW_CLASS_CPU pcpuCur;
iregInterLevel = KN_INT_DISABLE();
pcpuCur = LW_CPU_GET_CUR();
_BugHandle(pcpuCur->CPU_ulInterNesting, LW_TRUE, "called from ISR.\r\n");
__THREAD_LOCK_INC(pcpuCur->CPU_ptcbTCBCur); /* 锁定任务在当前 CPU */
__ARCH_SPIN_LOCK_RAW(psl); /* 驱动保证锁定必须成功 */
KN_SMP_MB();
KN_INT_ENABLE(iregInterLevel);
}
/*********************************************************************************************************
** 函数名称: vprocStackFree
** 功能描述: 释放 stack
** 输 入 : ptcbDel 被删除的任务
** pvStack 线程堆栈
** bImmed 立即回收
** 输 出 : 堆栈
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID vprocStackFree (PLW_CLASS_TCB ptcbDel, PVOID pvStack, BOOL bImmed)
{
#if (LW_CFG_VMM_EN > 0) && !defined(LW_CFG_CPU_ARCH_PPC)
LW_LD_VPROC *pvproc;
BOOL bFree = LW_TRUE;
switch (ptcbDel->TCB_iStkLocation) {
case LW_TCB_STK_VMM:
pvproc = __LW_VP_GET_TCB_PROC(ptcbDel);
if (pvproc && (pvproc->VP_ulMainThread == ptcbDel->TCB_ulId)) { /* 如果是主线程 */
if (bImmed) {
#if LW_CFG_COROUTINE_EN > 0
if (pvproc->VP_pvMainStack == pvStack) {
pvproc->VP_pvMainStack = LW_NULL; /* 主线程堆栈删除 */
}
#else
pvproc->VP_pvMainStack = LW_NULL;
#endif /* LW_CFG_COROUTINE_EN > 0 */
} else {
bFree = LW_FALSE; /* 延迟删除主线程堆栈 */
}
}
if (bFree) {
API_VmmFree(pvStack);
}
break;
case LW_TCB_STK_HEAP:
__KHEAP_FREE(pvStack);
break;
default:
_BugHandle(LW_TRUE, LW_FALSE, "unknown stack property!\r\n");
break;
}
#else
__KHEAP_FREE(pvStack);
#endif /* LW_CFG_VMM_EN > 0 */
}
/*********************************************************************************************************
** 函数名称: _SmpSpinTryLockTask
** 功能描述: 自旋锁尝试原始加锁操作. (不锁定中断, 同时允许加锁后调用可能产生阻塞的操作)
** 输 入 : psl 自旋锁
** 输 出 : LW_TRUE 加锁正常 LW_FALSE 加锁失败
** 全局变量:
** 调用模块:
*********************************************************************************************************/
BOOL _SmpSpinTryLockTask (spinlock_t *psl)
{
INTREG iregInterLevel;
PLW_CLASS_CPU pcpuCur;
INT iRet;
iregInterLevel = KN_INT_DISABLE();
pcpuCur = LW_CPU_GET_CUR();
_BugHandle(pcpuCur->CPU_ulInterNesting, LW_TRUE, "called from ISR.\r\n");
__THREAD_LOCK_INC(pcpuCur->CPU_ptcbTCBCur); /* 锁定任务在当前 CPU */
iRet = __ARCH_SPIN_TRYLOCK_RAW(psl);
KN_SMP_MB();
if (iRet != LW_SPIN_OK) {
__THREAD_LOCK_DEC(pcpuCur->CPU_ptcbTCBCur); /* 解锁失败, 解除任务锁定 */
}
KN_INT_ENABLE(iregInterLevel);
return ((iRet == LW_SPIN_OK) ? (LW_TRUE) : (LW_FALSE));
}
