VOID _HeapKernelInit (VOID)
#endif /* LW_CFG_MEMORY_HEAP_... */
{
#if LW_CFG_MEMORY_HEAP_CONFIG_TYPE > 0
_K_pheapKernel = _HeapCreate(pvKernelHeapMem, stKernelHeapSize);
#else
#if LW_CFG_MEMORY_KERNEL_HEAP_ADDRESS == 0
_K_pheapKernel = _HeapCreate((PVOID)_K_stkKernelHeap, LW_CFG_MEMORY_KERNEL_HEAP_SIZE_BYTE);
#else
_K_pheapKernel = _HeapCreate((PVOID)(LW_CFG_MEMORY_KERNEL_HEAP_ADDRESS),
LW_CFG_MEMORY_KERNEL_HEAP_SIZE_BYTE);
#endif
#endif /* LW_CFG_MEMORY_HEAP_... */
#if (LW_CFG_DEVICE_EN > 0) && (LW_CFG_FIO_LIB_EN > 0)
#if LW_CFG_ERRORMESSAGE_EN > 0 || LW_CFG_LOGMESSAGE_EN > 0
#if LW_CFG_MEMORY_HEAP_CONFIG_TYPE > 0
_DebugFormat(__LOGMESSAGE_LEVEL, "kernel heap has been create 0x%lx (%zd Bytes).\r\n",
(addr_t)pvKernelHeapMem, stKernelHeapSize);
#else
_DebugFormat(__LOGMESSAGE_LEVEL, "kernel heap has been create 0x%lx (%zd Bytes).\r\n",
(LW_CFG_MEMORY_KERNEL_HEAP_ADDRESS == 0) ?
(addr_t)_K_stkKernelHeap : (addr_t)LW_CFG_MEMORY_KERNEL_HEAP_ADDRESS,
(size_t)LW_CFG_MEMORY_KERNEL_HEAP_SIZE_BYTE);
#endif /* LW_CFG_MEMORY_HEAP_... */
#endif /* LW_CFG_ERRORMESSAGE_EN... */
#endif /* LW_CFG_DEVICE_EN... */
lib_strcpy(_K_pheapKernel->HEAP_cHeapName, "kernel");
}
/*********************************************************************************************************
** 函数名称: archFpuPrimaryInit
** 功能描述: 主核 Fpu 控制器初始化
** 输 入 : pcMachineName 机器名称
** pcFpuName fpu 名称
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID archFpuPrimaryInit (CPCHAR pcMachineName, CPCHAR pcFpuName)
{
_DebugFormat(__LOGMESSAGE_LEVEL, "%s %s FPU pri-core initialization.\r\n",
pcMachineName, pcFpuName);
if (lib_strcmp(pcFpuName, PPC_FPU_NONE) == 0) { /* 选择 VFP 架构 */
_G_pfpuop = ppcVfpNonePrimaryInit(pcMachineName, pcFpuName);
} else if (lib_strcmp(pcFpuName, PPC_FPU_VFP) == 0) {
_G_pfpuop = ppcVfpPrimaryInit(pcMachineName, pcFpuName);
} else {
_DebugHandle(__ERRORMESSAGE_LEVEL, "unknown fpu name.\r\n");
return;
}
if (_G_pfpuop == LW_NULL) {
return;
}
lib_bzero(&_G_fpuCtxInit, sizeof(LW_FPU_CONTEXT));
PPC_VFP_ENABLE(_G_pfpuop);
PPC_VFP_SAVE(_G_pfpuop, (PVOID)&_G_fpuCtxInit);
_G_fpuCtxInit.FPUCTX_fpuctxContext.FPUCTX_uiFpscr = 0x00000000; /* Do not enable FPU */
PPC_VFP_DISABLE(_G_pfpuop);
}
VOID _HeapSystemInit (VOID)
#endif /* LW_CFG_MEMORY_HEAP_... */
{
#if LW_CFG_MEMORY_HEAP_CONFIG_TYPE > 0
if (pvSystemHeapMem && stSystemHeapSize) {
_K_pheapSystem = _HeapCreate(pvSystemHeapMem, stSystemHeapSize);
} else
#else
#if LW_CFG_MEMORY_SYSTEM_HEAP_ADDRESS == 0
if (LW_CFG_MEMORY_SYSTEM_HEAP_SIZE_BYTE) {
_K_pheapSystem = _HeapCreate((PVOID)_K_stkSystemHeap, LW_CFG_MEMORY_SYSTEM_HEAP_SIZE_BYTE);
} else
#else
if (LW_CFG_MEMORY_SYSTEM_HEAP_SIZE_BYTE) {
_K_pheapSystem = _HeapCreate((PVOID)LW_CFG_MEMORY_SYSTEM_HEAP_ADDRESS,
LW_CFG_MEMORY_SYSTEM_HEAP_SIZE_BYTE);
} else
#endif
#endif /* LW_CFG_MEMORY_HEAP_... */
{
_K_pheapSystem = _K_pheapKernel; /* 只使用 kernel heap */
}
#if (LW_CFG_DEVICE_EN > 0) && (LW_CFG_FIO_LIB_EN > 0)
#if (LW_CFG_ERRORMESSAGE_EN > 0) || (LW_CFG_LOGMESSAGE_EN > 0)
#if LW_CFG_MEMORY_HEAP_CONFIG_TYPE > 0
_DebugFormat(__LOGMESSAGE_LEVEL, "system heap has been create 0x%lx (%zd Bytes).\r\n",
(addr_t)pvSystemHeapMem, stSystemHeapSize);
#else
_DebugFormat(__LOGMESSAGE_LEVEL, "system heap has been create 0x%lx (%zd Bytes).\r\n",
(LW_CFG_MEMORY_SYSTEM_HEAP_ADDRESS == 0) ?
(addr_t)_K_stkSystemHeap : (addr_t)LW_CFG_MEMORY_SYSTEM_HEAP_ADDRESS,
(size_t)LW_CFG_MEMORY_SYSTEM_HEAP_SIZE_BYTE);
#endif /* LW_CFG_MEMORY_HEAP_... */
#endif /* LW_CFG_ERRORMESSAGE_EN... */
#endif /* LW_CFG_DEVICE_EN... */
if (_K_pheapSystem == _K_pheapKernel) {
lib_strcpy(_K_pheapSystem->HEAP_cHeapName, "kersys");
} else {
lib_strcpy(_K_pheapSystem->HEAP_cHeapName, "system");
}
}
/*********************************************************************************************************
** 函数名称: API_CacheDisable
** 功能描述: 禁能指定类型的 CACHE
** 输 入 : cachetype CACHE 类型
** 输 出 : BSP 函数返回值
** 全局变量:
** 调用模块:
** 注 意 : dcache 在关闭前, 驱动程序必须先清空数据.
API 函数
*********************************************************************************************************/
LW_API
INT API_CacheDisable (LW_CACHE_TYPE cachetype)
{
INTREG iregInterLevel;
INT iError;
__CACHE_OP_ENTER(iregInterLevel); /* 开始操作 cache */
iError = ((_G_cacheopLib.CACHEOP_pfuncDisable == LW_NULL) ? PX_ERROR :
(_G_cacheopLib.CACHEOP_pfuncDisable)(cachetype));
__CACHE_OP_EXIT(iregInterLevel); /* 结束操作 cache */
_DebugFormat(__LOGMESSAGE_LEVEL, "%sCACHE disable.\r\n",
(cachetype == INSTRUCTION_CACHE) ? "I-" : "D-");
return (iError);
}
/*********************************************************************************************************
** 函数名称: archCacheInit
** 功能描述: 初始化 CACHE
** 输 入 : uiInstruction 指令 CACHE 参数
** uiData 数据 CACHE 参数
** pcMachineName 机器名称
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID archCacheInit (CACHE_MODE uiInstruction, CACHE_MODE uiData, CPCHAR pcMachineName)
{
LW_CACHE_OP *pcacheop = API_CacheGetLibBlock();
_DebugFormat(__LOGMESSAGE_LEVEL, "%s L1 cache controller initialization.\r\n", pcMachineName);
if (lib_strcmp(pcMachineName, MIPS_MACHINE_LS1X) == 0 ||
lib_strcmp(pcMachineName, MIPS_MACHINE_24KF) == 0 ||
lib_strcmp(pcMachineName, MIPS_MACHINE_LS2X) == 0 ||
lib_strcmp(pcMachineName, MIPS_MACHINE_JZ47XX) == 0) {
mips32CacheInit(pcacheop, uiInstruction, uiData, pcMachineName);
} else {
_DebugHandle(__ERRORMESSAGE_LEVEL, "unknown machine name.\r\n");
}
}
VOID archFpuSecondaryInit (CPCHAR pcMachineName, CPCHAR pcFpuName)
{
_DebugFormat(__LOGMESSAGE_LEVEL, "%s %s FPU sec-core initialization.\r\n",
pcMachineName, pcFpuName);
if (lib_strcmp(pcFpuName, PPC_FPU_NONE) == 0) { /* 选择 VFP 架构 */
ppcVfpNoneSecondaryInit(pcMachineName, pcFpuName);
} else if (lib_strcmp(pcFpuName, PPC_FPU_VFP) == 0) {
ppcVfpSecondaryInit(pcMachineName, pcFpuName);
} else {
_DebugHandle(__ERRORMESSAGE_LEVEL, "unknown fpu name.\r\n");
return;
}
}
/*********************************************************************************************************
** 函数名称: API_RomFsDevCreate
** 功能描述: 创建 romfs 文件系统设备.
** 输 入 : pcName 设备名(设备挂接的节点地址)
** pblkd romfs 物理设备.
** 输 出 : < 0 表示失败
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_RomFsDevCreate (PCHAR pcName, PLW_BLK_DEV pblkd)
{
PROM_VOLUME promfs;
if (_G_iRomfsDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "romfs Driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
if ((pblkd == LW_NULL) || (pblkd->BLKD_pcName == LW_NULL)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "block device invalidate.\r\n");
_ErrorHandle(ERROR_IOS_DEVICE_NOT_FOUND);
return (PX_ERROR);
}
if ((pcName == LW_NULL) || __STR_IS_ROOT(pcName)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "mount name invalidate.\r\n");
_ErrorHandle(EFAULT); /* Bad address */
return (PX_ERROR);
}
promfs = (PROM_VOLUME)__SHEAP_ALLOC(sizeof(ROM_VOLUME));
if (promfs == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
lib_bzero(promfs, sizeof(ROM_VOLUME)); /* 清空卷控制块 */
promfs->ROMFS_bValid = LW_TRUE;
promfs->ROMFS_hVolLock = API_SemaphoreMCreate("romvol_lock", LW_PRIO_DEF_CEILING,
LW_OPTION_WAIT_FIFO | LW_OPTION_DELETE_SAFE |
LW_OPTION_INHERIT_PRIORITY | LW_OPTION_OBJECT_GLOBAL,
LW_NULL);
if (!promfs->ROMFS_hVolLock) { /* 无法创建卷锁 */
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
promfs->ROMFS_pblkd = pblkd; /* 记录物理设备 */
promfs->ROMFS_ulSectorSize = pblkd->BLKD_ulBytesPerSector;
if (promfs->ROMFS_ulSectorSize == 0) {
if (pblkd->BLKD_pfuncBlkIoctl(pblkd,
LW_BLKD_GET_SECSIZE,
&promfs->ROMFS_ulSectorSize) < ERROR_NONE) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
}
promfs->ROMFS_ulSectorNum = pblkd->BLKD_ulNSector;
if (promfs->ROMFS_ulSectorNum == 0) {
if (pblkd->BLKD_pfuncBlkIoctl(pblkd,
LW_BLKD_GET_SECNUM,
&promfs->ROMFS_ulSectorNum) < ERROR_NONE) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
}
promfs->ROMFS_pcSector = (PCHAR)__SHEAP_ALLOC((size_t)promfs->ROMFS_ulSectorSize);
if (promfs->ROMFS_pcSector == LW_NULL) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY);
return (PX_ERROR);
}
promfs->ROMFS_ulCurSector = (ULONG)-1; /* 当前窗口无效 */
if (__rfs_mount(promfs)) {
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
_DebugHandle(__ERRORMESSAGE_LEVEL, "format unknown.\r\n");
_ErrorHandle(ERROR_IO_VOLUME_ERROR);
return (PX_ERROR);
}
promfs->ROMFS_uid = getuid();
promfs->ROMFS_gid = getgid();
lib_time(&promfs->ROMFS_time); /* 获得当前时间 */
if (iosDevAddEx(&promfs->ROMFS_devhdrHdr, pcName, _G_iRomfsDrvNum, DT_DIR)
!= ERROR_NONE) { /* 安装文件系统设备 */
API_SemaphoreMDelete(&promfs->ROMFS_hVolLock);
__SHEAP_FREE(promfs->ROMFS_pcSector);
__SHEAP_FREE(promfs);
return (PX_ERROR);
}
__fsDiskLinkCounterAdd(pblkd); /* 增加块设备链接 */
_DebugFormat(__LOGMESSAGE_LEVEL, "target \"%s\" mount ok.\r\n", pcName);
return (ERROR_NONE);
}
LW_API
ULONG API_SemaphoreBDelete (LW_OBJECT_HANDLE *pulId)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER PLW_LIST_RING *ppringList; /* 等待队列地址 */
REGISTER LW_OBJECT_HANDLE ulId;
ulId = *pulId;
usIndex = _ObjectGetIndex(ulId);
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (ERROR_KERNEL_IN_ISR);
}
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_SEM_B)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pevent = &_K_eventBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_Event_Type_Invalid(usIndex, LW_TYPE_EVENT_SEMB)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_TYPE);
return (ERROR_EVENT_TYPE);
}
_ObjectCloseId(pulId); /* 清除句柄 */
pevent->EVENT_ucType = LW_TYPE_EVENT_UNUSED; /* 事件类型为空 */
while (_EventWaitNum(pevent)) { /* 是否存在正在等待的任务 */
if (pevent->EVENT_ulOption & LW_OPTION_WAIT_PRIORITY) { /* 优先级等待队列 */
_EVENT_DEL_Q_PRIORITY(ppringList); /* 检查需要激活的队列 */
/* 激活优先级等待线程 */
ptcb = _EventReadyPriorityLowLevel(pevent, LW_NULL, ppringList);
} else {
_EVENT_DEL_Q_FIFO(ppringList); /* 查找 FIFO 队列指针地址 */
/* 激活FIFO等待线程 */
ptcb = _EventReadyFifoLowLevel(pevent, LW_NULL, ppringList);
}
KN_INT_ENABLE(iregInterLevel); /* 打开中断 */
ptcb->TCB_ucIsEventDelete = LW_EVENT_DELETE; /* 事件已经被删除 */
_EventReadyHighLevel(ptcb, LW_THREAD_STATUS_SEM); /* 处理 TCB */
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
}
pevent->EVENT_pvTcbOwn = LW_NULL;
_Free_Event_Object(pevent); /* 交还控制块 */
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
__LW_OBJECT_DELETE_HOOK(ulId);
MONITOR_EVT_LONG1(MONITOR_EVENT_ID_SEMB, MONITOR_EVENT_SEM_DELETE, ulId, LW_NULL);
_DebugFormat(__LOGMESSAGE_LEVEL, "semaphore \"%s\" has been delete.\r\n", pevent->EVENT_cEventName);
return (ERROR_NONE);
}
ULONG __threadDelete (PLW_CLASS_TCB ptcbDel, BOOL bIsInSafe,
PVOID pvRetVal, BOOL bIsAlreadyWaitDeath)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_PCB ppcbDel;
REGISTER LW_OBJECT_HANDLE ulId;
REGISTER PVOID pvFreeLowAddr; /* 要释放的内存地址 */
PVOID pvVProc;
#if (LW_CFG_EVENTSET_EN > 0) && (LW_CFG_MAX_EVENTSETS > 0)
REGISTER PLW_EVENTSETNODE pesnPtr;
#endif
ulId = ptcbDel->TCB_ulId;
usIndex = _ObjectGetIndex(ulId);
if (bIsAlreadyWaitDeath == LW_FALSE) {
_ThreadDeleteWaitDeath(ptcbDel); /* 将要删除的线程进入僵死状态 */
}
__KERNEL_ENTER(); /* 进入内核 */
ppcbDel = _GetPcb(ptcbDel);
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
if (ptcbDel->TCB_ptcbDeleteWait) { /* 目标线程正在等待其他任务删除*/
ptcbDel->TCB_ptcbDeleteWait->TCB_ptcbDeleteMe = (PLW_CLASS_TCB)1;
ptcbDel->TCB_ptcbDeleteWait = LW_NULL;
}
#if (LW_CFG_EVENT_EN > 0) && (LW_CFG_MAX_EVENTS > 0)
if (ptcbDel->TCB_peventPtr) { /* 等待事件中 */
_EventUnlink(ptcbDel); /* 解等待连 */
}
#endif
#if (LW_CFG_EVENTSET_EN > 0) && (LW_CFG_MAX_EVENTSETS > 0)
pesnPtr = ptcbDel->TCB_pesnPtr;
if (pesnPtr) {
_EventSetUnlink(pesnPtr); /* 解事件集 */
}
#endif
#if LW_CFG_SMP_EN > 0
if (ptcbDel->TCB_ptcbWaitStatus ||
ptcbDel->TCB_plineStatusReqHeader) { /* 正在请求其他线程改变状态 */
_ThreadUnwaitStatus(ptcbDel);
}
#endif /* LW_CFG_SMP_EN */
if (__LW_THREAD_IS_READY(ptcbDel)) { /* 是否就绪 */
__DEL_FROM_READY_RING(ptcbDel, ppcbDel); /* 从就绪队列中删除 */
} else {
if (ptcbDel->TCB_usStatus & LW_THREAD_STATUS_DELAY) {
__DEL_FROM_WAKEUP_LINE(ptcbDel); /* 从等待链中删除 */
ptcbDel->TCB_ulDelay = 0ul;
}
ptcbDel->TCB_usStatus = LW_THREAD_STATUS_RDY; /* 防止 Tick 中断激活 */
}
#if LW_CFG_SOFTWARE_WATCHDOG_EN > 0
if (ptcbDel->TCB_bWatchDogInQ) {
__DEL_FROM_WATCHDOG_LINE(ptcbDel); /* 从 watch dog 中删除 */
ptcbDel->TCB_ulWatchDog = 0ul;
}
#endif
KN_INT_ENABLE(iregInterLevel);
pvFreeLowAddr = (PVOID)ptcbDel->TCB_pstkStackLowAddr; /* 记录地址 */
#if (LW_CFG_THREAD_PRIVATE_VARS_EN > 0) && (LW_CFG_MAX_THREAD_GLB_VARS > 0)
_ThreadVarDelete(ptcbDel); /* 删除并恢复私有化的全局变量 */
#endif
iregInterLevel = KN_INT_DISABLE(); /* 关闭中断 */
_K_usThreadCounter--;
_K_ptcbTCBIdTable[usIndex] = LW_NULL; /* TCB 表清0 */
_List_Line_Del(&ptcbDel->TCB_lineManage, &_K_plineTCBHeader); /* 从管理练表中删除 */
KN_INT_ENABLE(iregInterLevel); /* 打开中断 */
if (ptcbDel->TCB_ptcbJoin) {
_ThreadDisjoin(ptcbDel->TCB_ptcbJoin, ptcbDel); /* 退出 join 状态, 不操作就绪表*/
}
_ThreadDisjoinWakeupAll(ptcbDel, pvRetVal); /* DETACH */
__KERNEL_EXIT(); /* 退出内核 */
#if LW_CFG_COROUTINE_EN > 0
_CoroutineFreeAll(ptcbDel); /* 删除协程内存空间 */
#endif /* LW_CFG_COROUTINE_EN > 0 */
if (bIsInSafe) {
_DebugFormat(__ERRORMESSAGE_LEVEL,
"thread \"%s\" has been delete in SAFE mode.\r\n",
ptcbDel->TCB_cThreadName);
} else {
_DebugFormat(__LOGMESSAGE_LEVEL,
"thread \"%s\" has been delete.\r\n",
ptcbDel->TCB_cThreadName);
}
pvVProc = ptcbDel->TCB_pvVProcessContext; /* 进程信息 */
if (ptcbDel->TCB_ucStackAutoAllocFlag) { /* 是否是内核堆开辟堆栈 */
#if LW_CFG_MODULELOADER_EN > 0
vprocStackFree(ptcbDel, pvFreeLowAddr, LW_FALSE);
#else
__KHEAP_FREE(pvFreeLowAddr); /* 释放堆栈空间 */
#endif /* LW_CFG_MODULELOADER_EN > 0 */
}
_TCBDestroy(ptcbDel); /* 销毁 TCB */
__KERNEL_MODE_PROC(
_Free_Tcb_Object(ptcbDel); /* 释放 ID */
);
/*********************************************************************************************************
** 函数名称: API_InterVectorConnectEx
** 功能描述: 设置系统指定向量中断服务
** 输 入 : ulVector 中断向量号
** pfuncIsr 服务函数
** pfuncClear 附加中断清除函数(可为 NULL)
** pvArg 服务函数参数
** pcName 中断服务名称
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_InterVectorConnectEx (ULONG ulVector,
PINT_SVR_ROUTINE pfuncIsr,
VOIDFUNCPTR pfuncClear,
PVOID pvArg,
CPCHAR pcName)
{
INTREG iregInterLevel;
BOOL bNeedFree;
PLW_LIST_LINE plineTemp;
PLW_CLASS_INTACT piactionOld;
PLW_CLASS_INTACT piaction;
PLW_CLASS_INTDESC pidesc;
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (ERROR_KERNEL_IN_ISR);
}
INTER_SHOWLOCK_CREATE();
if (_Object_Name_Invalid(pcName)) { /* 检查名字有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "name too long.\r\n");
_ErrorHandle(ERROR_KERNEL_PNAME_TOO_LONG);
return (ERROR_KERNEL_PNAME_TOO_LONG);
}
if (_Inter_Vector_Invalid(ulVector)) {
_ErrorHandle(ERROR_KERNEL_VECTOR_NULL);
return (ERROR_KERNEL_VECTOR_NULL);
}
if (pfuncIsr == LW_NULL) {
_ErrorHandle(ERROR_KERNEL_VECTOR_NULL);
return (ERROR_KERNEL_VECTOR_NULL);
}
piaction = (PLW_CLASS_INTACT)__KHEAP_ALLOC(sizeof(LW_CLASS_INTACT));
if (piaction == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "kernel low memory.\r\n");
_ErrorHandle(ERROR_KERNEL_LOW_MEMORY);
return (ERROR_KERNEL_LOW_MEMORY);
}
lib_bzero(piaction, sizeof(LW_CLASS_INTACT));
piaction->IACT_pfuncIsr = pfuncIsr;
piaction->IACT_pfuncClear = pfuncClear;
piaction->IACT_pvArg = pvArg;
if (pcName) {
lib_strcpy(piaction->IACT_cInterName, pcName);
} else {
piaction->IACT_cInterName[0] = PX_EOS;
}
pidesc = LW_IVEC_GET_IDESC(ulVector);
LW_SPIN_LOCK_QUICK(&pidesc->IDESC_slLock, &iregInterLevel); /* 关闭中断同时锁住 spinlock */
if (LW_IVEC_GET_FLAG(ulVector) & LW_IRQ_FLAG_QUEUE) { /* 队列服务类型向量 */
for (plineTemp = pidesc->IDESC_plineAction;
plineTemp != LW_NULL;
plineTemp = _list_line_get_next(plineTemp)) {
piactionOld = _LIST_ENTRY(plineTemp, LW_CLASS_INTACT, IACT_plineManage);
if ((piactionOld->IACT_pfuncIsr == pfuncIsr) &&
(piactionOld->IACT_pvArg == pvArg)) { /* 中断处理函数是否被重复安装 */
break;
}
}
if (plineTemp) { /* 此中断被重复安装 */
bNeedFree = LW_TRUE;
} else {
_List_Line_Add_Ahead(&piaction->IACT_plineManage,
&pidesc->IDESC_plineAction);
bNeedFree = LW_FALSE;
}
} else { /* 非队列服务式中断向量 */
if (pidesc->IDESC_plineAction) {
piactionOld = _LIST_ENTRY(pidesc->IDESC_plineAction,
LW_CLASS_INTACT,
IACT_plineManage);
piactionOld->IACT_pfuncIsr = piaction->IACT_pfuncIsr;
piactionOld->IACT_pfuncClear = piaction->IACT_pfuncClear;
piactionOld->IACT_pvArg = piaction->IACT_pvArg;
lib_strcpy(piactionOld->IACT_cInterName, piaction->IACT_cInterName);
bNeedFree = LW_TRUE;
} else {
_List_Line_Add_Ahead(&piaction->IACT_plineManage,
&pidesc->IDESC_plineAction);
bNeedFree = LW_FALSE;
}
}
LW_SPIN_UNLOCK_QUICK(&pidesc->IDESC_slLock, iregInterLevel); /* 打开中断, 同时打开 spinlock */
if (bNeedFree) {
__KHEAP_FREE(piaction);
}
_DebugFormat(__LOGMESSAGE_LEVEL, "IRQ %d : %s connect : 0x%p\r\n",
(INT)ulVector, (pcName ? pcName : ""), (PVOID)pfuncIsr);
return (ERROR_NONE);
}
