/*********************************************************************************************************
** 函数名称: API_TShellSetOption
** 功能描述: 设置新的 shell 选项.
** 输 入 : hTShellHandle shell 线程
** ulNewOpt 新的 shell 选项
** 输 出 : 错误代码.
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_TShellSetOption (LW_OBJECT_HANDLE hTShellHandle, ULONG ulNewOpt)
{
PLW_CLASS_TCB ptcbShell;
UINT16 usIndex;
usIndex = _ObjectGetIndex(hTShellHandle);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(hTShellHandle, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (PX_ERROR);
}
#endif
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (PX_ERROR);
}
ptcbShell = __GET_TCB_FROM_INDEX(usIndex);
__TTINY_SHELL_SET_OPT(ptcbShell, ulNewOpt);
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_InterVectorDisconnect
** 功能描述: 解除系统指定向量中断服务
** 输 入 : ulVector 中断向量号
** pfuncIsr 服务函数
** pvArg 服务函数参数
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_InterVectorDisconnect (ULONG ulVector,
PINT_SVR_ROUTINE pfuncIsr,
PVOID pvArg)
{
INTREG iregInterLevel;
BOOL bNeedFree = LW_FALSE;
PLW_LIST_LINE plineTemp;
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 (_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);
}
INTER_SHOWLOCK_LOCK();
pidesc = LW_IVEC_GET_IDESC(ulVector);
LW_SPIN_LOCK_QUICK(&pidesc->IDESC_slLock, &iregInterLevel); /* 关闭中断同时锁住 spinlock */
for (plineTemp = pidesc->IDESC_plineAction;
plineTemp != LW_NULL;
plineTemp = _list_line_get_next(plineTemp)) {
piaction = _LIST_ENTRY(plineTemp, LW_CLASS_INTACT, IACT_plineManage);
if ((piaction->IACT_pfuncIsr == pfuncIsr) &&
(piaction->IACT_pvArg == pvArg)) {
_List_Line_Del(&piaction->IACT_plineManage,
&pidesc->IDESC_plineAction);
bNeedFree = LW_TRUE;
break;
}
}
LW_SPIN_UNLOCK_QUICK(&pidesc->IDESC_slLock, iregInterLevel); /* 打开中断, 同时打开 spinlock */
INTER_SHOWLOCK_UNLOCK();
if (bNeedFree) {
__KHEAP_FREE(piaction);
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __inetPingSend
** 功能描述: 发送 ping 包
** 输 入 : iSock 套接字
** inaddr 目标 ip 地址.
** iDataSize 数据大小
** pusSeqRecv 需要判断的 seq
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __inetPingSend (INT iSock, struct in_addr inaddr, INT iDataSize, UINT16 *pusSeqRecv)
{
REGISTER size_t stPingSize = sizeof(struct icmp_echo_hdr) + iDataSize;
struct icmp_echo_hdr *icmphdrEcho;
ssize_t sstError;
struct sockaddr_in sockaddrin;
icmphdrEcho = (struct icmp_echo_hdr *)__SHEAP_ALLOC(stPingSize);
if (icmphdrEcho == LW_NULL) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory\r\n");
return (PX_ERROR);
}
__inetPingPrepare(icmphdrEcho, iDataSize, pusSeqRecv);
sockaddrin.sin_len = sizeof(struct sockaddr_in);
sockaddrin.sin_family = AF_INET;
sockaddrin.sin_port = 0;
sockaddrin.sin_addr = inaddr;
sstError = sendto(iSock, icmphdrEcho, stPingSize, 0,
(const struct sockaddr *)&sockaddrin,
sizeof(struct sockaddr_in));
__SHEAP_FREE(icmphdrEcho);
return ((sstError > 0) ? ERR_OK : ERR_VAL);
}
/*********************************************************************************************************
** 函数名称: API_HotplugPollAdd
** 功能描述: 在 hotplug 事件处理上下文中, 加入一个循环检测函数.
** 输 入 : pfunc 函数指针
** pvArg 函数参数
** 输 出 : 操作是否成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_HotplugPollAdd (VOIDFUNCPTR pfunc, PVOID pvArg)
{
PLW_HOTPLUG_POLLNODE phppn;
phppn = (PLW_HOTPLUG_POLLNODE)__SHEAP_ALLOC(sizeof(LW_HOTPLUG_POLLNODE));
/* 申请控制块内存 */
if (!phppn) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "system low memory.\r\n");
_ErrorHandle(ERROR_SYSTEM_LOW_MEMORY); /* 缺少内存 */
return (PX_ERROR);
}
phppn->HPPN_pfunc = pfunc;
phppn->HPPN_pvArg = pvArg;
__HOTPLUG_LOCK(); /* lock hotplug poll list */
_List_Line_Add_Ahead(&phppn->HPPN_lineManage, &_G_plineHotplugPoll);
__HOTPLUG_UNLOCK(); /* unlock hotplug poll list */
#if LW_CFG_MODULELOADER_EN > 0
if (__PROC_GET_PID_CUR() && vprocFindProc((PVOID)pfunc)) {
__resAddRawHook(&phppn->HPPN_resraw, (VOIDFUNCPTR)API_HotplugPollDelete,
(PVOID)pfunc, pvArg, 0, 0, 0, 0);
} else {
phppn->HPPN_resraw.RESRAW_bIsInstall = LW_FALSE; /* 不需要回收操作 */
}
#else
__resAddRawHook(&phppn->HPPN_resraw, (VOIDFUNCPTR)API_HotplugPollDelete,
(PVOID)pfunc, pvArg, 0, 0, 0, 0);
#endif
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: mips32CacheProbe
** 功能描述: CACHE 探测
** 输 入 : NONE
** 输 出 : ERROR or OK
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT mips32CacheProbe (VOID)
{
UINT32 uiTemp;
UINT32 uiConfig = mipsCp0ConfigRead(); /* 读 Config0 */
if (!(uiConfig & (M_ConfigMore))) { /* 没有 Config1, 退出 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "No CP0 Config1 Register!\r\n");
return (PX_ERROR);
}
uiConfig = mipsCp0Config1Read(); /* 读 Config1 */
uiTemp = (uiConfig & M_Config1IL) >> S_Config1IL;
if (uiTemp) {
_G_ICache.CACHE_bPresent = LW_TRUE;
_G_ICache.CACHE_uiLineSize = 2 << uiTemp;
uiTemp = (uiConfig & M_Config1IS) >> S_Config1IS;
_G_ICache.CACHE_uiSetNr = 64 << uiTemp;
uiTemp = (uiConfig & M_Config1IA) >> S_Config1IA;
_G_ICache.CACHE_uiWayNr = 1 + uiTemp;
_G_ICache.CACHE_uiSize = _G_ICache.CACHE_uiSetNr * _G_ICache.CACHE_uiWayNr *
_G_ICache.CACHE_uiLineSize;
_G_ICache.CACHE_uiWayStep = _G_ICache.CACHE_uiSetNr * _G_ICache.CACHE_uiLineSize;
} else { /* 没有 I-Cache */
LW_API
ULONG API_SemaphoreCStatus (LW_OBJECT_HANDLE ulId,
ULONG *pulCounter,
ULONG *pulOption,
ULONG *pulThreadBlockNum)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_SEM_C)) { /* 类型是否正确 */
_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_SEMC)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "semaphore handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_TYPE);
return (ERROR_EVENT_TYPE);
}
if (pulCounter) {
*pulCounter = pevent->EVENT_ulCounter;
}
if (pulOption) {
*pulOption = pevent->EVENT_ulOption;
}
if (pulThreadBlockNum) {
*pulThreadBlockNum = _EventWaitNum(pevent);
}
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __ataPread
** 功能描述: 读取设备的参数
** 输 入 : patactrler ATA控制器结构指针
** iDrive 驱动号
** pvBuffer 缓冲
** 输 出 : ERROR
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT __ataPread (__PATA_CTRL patactrler,
INT iDrive,
PVOID pvBuffer)
{
__PATA_CTRL patactrl = LW_NULL;
INT iRetry = 1;
INT iRetryCount = 0;
ULONG ulSemStatus = 0;
INT16 *psBuf = LW_NULL;
if ((!patactrler) || (!pvBuffer)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "parameter error.\r\n");
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
patactrl = patactrler;
while (iRetry) {
if (__ataWait(patactrl, __ATA_STAT_READY) != ERROR_NONE) {
return (PX_ERROR);
}
__ATA_CTRL_OUTBYTE(patactrl, __ATA_SDH(patactrl), \
(UINT8)(__ATA_SDH_LBA | (iDrive << __ATA_DRIVE_BIT)));
__ATA_CTRL_OUTBYTE(patactrl, __ATA_COMMAND(patactrl), __ATA_CMD_READP);
/* 写入确认命令 */
if (patactrl->ATACTRL_bIntDisable == LW_FALSE) {
ulSemStatus = API_SemaphoreBPend(patactrl->ATACTRL_ulSyncSem, \
patactrl->ATACTRL_ulSyncSemTimeout); /* 等待同步信号 */
}
if ((patactrl->ATACTRL_iIntStatus & __ATA_STAT_ERR) || (ulSemStatus != ERROR_NONE)) {
ATA_DEBUG_MSG(("__ataPread() error : status=0x%x intStatus=0x%x " \
"error=0x%x ulSemStatus=%d\n", \
__ATA_CTRL_INBYTE(patactrl, __ATA_ASTATUS(patactrl)), \
patactrl->ATACTRL_iIntStatus, \
__ATA_CTRL_INBYTE(patactrl, __ATA_ERROR(patactrl)), ulSemStatus));
if (++iRetryCount > _G_iAtaRetry) {
return (PX_ERROR);
}
} else {
iRetry = 0;
}
}
if (__ataWait(patactrl, __ATA_STAT_DRQ) != ERROR_NONE) { /* 等待设备准备好传输数据 */
return (PX_ERROR);
}
psBuf = (INT16 *)pvBuffer;
__ATA_CTRL_INSTRING(patactrl, __ATA_DATA(patactrl), psBuf, 256);
ATA_DEBUG_MSG(("__ataPread() end :\n"));
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: sigprocmask
** 功能描述: 测试或改变当前线程的信号掩码
** 输 入 : iCmd 命令
** psigset 新信号集
** psigsetOld 先早信号集
** 输 出 : ERROR or OK
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT sigprocmask (INT iCmd,
const sigset_t *psigset,
sigset_t *psigsetOld)
{
PLW_CLASS_TCB ptcbCur;
PLW_CLASS_SIGCONTEXT psigctx;
sigset_t sigsetBlock;
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
return (PX_ERROR);
}
LW_TCB_GET_CUR_SAFE(ptcbCur);
psigctx = _signalGetCtx(ptcbCur);
if (psigsetOld) { /* 保存古老的 */
*psigsetOld = psigctx->SIGCTX_sigsetSigBlockMask;
}
if (!psigset) { /* 新的是否有效 */
return (ERROR_NONE);
}
__KERNEL_ENTER(); /* 进入内核 */
switch (iCmd) {
case SIG_BLOCK: /* 添加阻塞 */
sigsetBlock = *psigset;
sigsetBlock &= ~__SIGNO_UNMASK; /* 有些信号是不可屏蔽的 */
psigctx->SIGCTX_sigsetSigBlockMask |= sigsetBlock;
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
case SIG_UNBLOCK: /* 删除阻塞 */
psigctx->SIGCTX_sigsetSigBlockMask &= ~(*psigset);
break;
case SIG_SETMASK: /* 设置阻塞 */
psigctx->SIGCTX_sigsetSigBlockMask = *psigset;
break;
default: /* 错误 */
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "command invalidate.\r\n");
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
_sigPendRun(ptcbCur); /* 可能有先前被阻塞信号需要运行*/
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_ThreadIsSafe
** 功能描述: 检测目标线程是否处于安全模式.
** 输 入 :
** ulId 线程句柄
** 输 出 :
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
BOOL API_ThreadIsSafe (LW_OBJECT_HANDLE ulId)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcb;
REGISTER BOOL bIsInSafeMode;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (LW_FALSE);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (LW_FALSE);
}
#endif
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (LW_FALSE);
}
ptcb = _K_ptcbTCBIdTable[usIndex]; /* 获得 TCB 指针 */
if (ptcb->TCB_ulThreadSafeCounter) {
bIsInSafeMode = LW_TRUE;
} else {
bIsInSafeMode = LW_FALSE;
}
__KERNEL_EXIT(); /* 退出内核 */
return (bIsInSafeMode);
}
LW_API
ULONG API_EventSetStatus (LW_OBJECT_HANDLE ulId,
ULONG *pulEvent,
ULONG *pulOption)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENTSET pes;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_EVENT_SET)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "eventset handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_EventSet_Index_Invalid(usIndex)) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "eventset handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
#endif
pes = &_K_esBuffer[usIndex];
iregInterLevel = __KERNEL_ENTER_IRQ(); /* 进入内核 */
if (_EventSet_Type_Invalid(usIndex, LW_TYPE_EVENT_EVENTSET)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "eventset handle invalidate.\r\n");
_ErrorHandle(ERROR_EVENTSET_TYPE);
return (ERROR_EVENTSET_TYPE);
}
if (pulEvent) {
*pulEvent = pes->EVENTSET_ulEventSets;
}
if (pulOption) {
*pulOption = 0ul;
}
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
return (ERROR_NONE);
}
LW_API
ULONG API_MsgQueueClear (LW_OBJECT_HANDLE ulId)
{
INTREG iregInterLevel;
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_EVENT pevent;
REGISTER PLW_CLASS_MSGQUEUE pmsgqueue;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_MSGQUEUE)) { /* 类型是否正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Event_Index_Invalid(usIndex)) { /* 下标是否正正确 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue 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_MSGQUEUE)) {
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "msgqueue handle invalidate.\r\n");
_ErrorHandle(ERROR_MSGQUEUE_TYPE);
return (ERROR_MSGQUEUE_TYPE);
}
pmsgqueue = (PLW_CLASS_MSGQUEUE)pevent->EVENT_pvPtr;
pevent->EVENT_ulCounter = 0ul;
pmsgqueue->MSGQUEUE_pucInputPtr = pmsgqueue->MSGQUEUE_pucBufferLowAddr;
pmsgqueue->MSGQUEUE_pucOutputPtr = pmsgqueue->MSGQUEUE_pucBufferLowAddr;
__KERNEL_EXIT_IRQ(iregInterLevel); /* 退出内核 */
MONITOR_EVT_LONG1(MONITOR_EVENT_ID_MSGQ, MONITOR_EVENT_MSGQ_CLEAR, ulId, LW_NULL);
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_ThreadGetSliceEx
** 功能描述: 获得指定线程时间片(扩展接口)
** 输 入 :
** ulId 线程ID
** pusSliceTemp 时间片
** pusCounter 剩余时间片
** 输 出 :
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_ThreadGetSliceEx (LW_OBJECT_HANDLE ulId, UINT16 *pusSliceTemp, UINT16 *pusCounter)
{
REGISTER UINT16 usIndex;
REGISTER PLW_CLASS_TCB ptcb;
usIndex = _ObjectGetIndex(ulId);
#if LW_CFG_ARG_CHK_EN > 0
if (!_ObjectClassOK(ulId, _OBJECT_THREAD)) { /* 检查 ID 类型有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_KERNEL_HANDLE_NULL);
return (ERROR_KERNEL_HANDLE_NULL);
}
if (_Thread_Index_Invalid(usIndex)) { /* 检查线程有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
#endif
__KERNEL_ENTER(); /* 进入内核 */
if (_Thread_Invalid(usIndex)) {
__KERNEL_EXIT(); /* 退出内核 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "thread handle invalidate.\r\n");
_ErrorHandle(ERROR_THREAD_NULL);
return (ERROR_THREAD_NULL);
}
ptcb = _K_ptcbTCBIdTable[usIndex];
if (pusSliceTemp) {
*pusSliceTemp = ptcb->TCB_usSchedSlice;
}
if (pusCounter) {
*pusCounter = ptcb->TCB_usSchedCounter;
}
__KERNEL_EXIT(); /* 退出内核 */
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: API_DiskRiad0Delete
** 功能描述: 删除一个 RAID-0 类型磁盘阵列块设备
** 输 入 : pblkDiskRaid 之前创建的 RAID-0 虚拟磁盘
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_DiskRiad0Delete (PLW_BLK_DEV pblkDiskRaid)
{
if (pblkDiskRaid == LW_NULL) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
_DebugHandle(__LOGMESSAGE_LEVEL, "RAID-0 system has been delete.\r\n");
return (ERROR_NONE);
}
LW_API
ULONG API_VmmLibSecondaryInit (CPCHAR pcMachineName)
{
ULONG ulError;
ulError = __vmmLibSecondaryInit(pcMachineName);
_DebugHandle(__LOGMESSAGE_LEVEL, "secondary MMU initilaized.\r\n");
return (ulError);
}
LW_API
LW_OBJECT_HANDLE API_SemaphoreCCreate (CPCHAR pcName,
ULONG ulInitCounter,
ULONG ulMaxCounter,
ULONG ulOption,
LW_OBJECT_ID *pulId)
{
REGISTER PLW_CLASS_EVENT pevent;
REGISTER ULONG ulI;
REGISTER PLW_CLASS_WAITQUEUE pwqTemp;
REGISTER ULONG ulIdTemp;
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (LW_OBJECT_HANDLE_INVALID);
}
#if LW_CFG_ARG_CHK_EN > 0
if (!ulMaxCounter) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "max counter invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_MAX_COUNTER_NULL);
return (LW_OBJECT_HANDLE_INVALID);
}
if (ulInitCounter > ulMaxCounter) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "initialize counter invalidate.\r\n");
_ErrorHandle(ERROR_EVENT_INIT_COUNTER);
return (LW_OBJECT_HANDLE_INVALID);
}
#endif
if (_Object_Name_Invalid(pcName)) { /* 检查名字有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "name too long.\r\n");
_ErrorHandle(ERROR_KERNEL_PNAME_TOO_LONG);
return (LW_OBJECT_HANDLE_INVALID);
}
__KERNEL_MODE_PROC(
pevent = _Allocate_Event_Object(); /* 获得一个事件控制块 */
);
/*********************************************************************************************************
** 函数名称: _posixAioInit
** 功能描述: 初始化 AIO 函数库
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _posixAioInit (VOID)
{
_G_aioqueue.aioq_mutex = API_SemaphoreMCreate("aio_mutex", LW_PRIO_DEF_CEILING,
LW_OPTION_DELETE_SAFE | LW_OPTION_INHERIT_PRIORITY, LW_NULL);
if (_G_aioqueue.aioq_mutex == 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "can not initialize mutex.\r\n");
return;
}
if (API_ThreadCondInit(&_G_aioqueue.aioq_newreq, LW_THREAD_PROCESS_SHARED) != ERROR_NONE) {
API_SemaphoreMDelete(&_G_aioqueue.aioq_mutex);
_DebugHandle(__ERRORMESSAGE_LEVEL, "can not initialize thread cond.\r\n");
return;
}
_G_aioqueue.aioq_plinework = LW_NULL;
_G_aioqueue.aioq_plineidle = LW_NULL;
_G_aioqueue.aioq_idlethread = 0;
_G_aioqueue.aioq_actthread = 0;
}
/*********************************************************************************************************
** 函数名称: archCacheReset
** 功能描述: 复位 CACHE, MMU 初始化时需要调用此函数
** 输 入 : pcMachineName 机器名称
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID archCacheReset (CPCHAR 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) {
mips32CacheReset(pcMachineName);
} else {
_DebugHandle(__ERRORMESSAGE_LEVEL, "unknown machine name.\r\n");
}
}
/*********************************************************************************************************
** 函数名称: _KernelHighLevelInit
** 功能描述: 内核高层初始化
** 输 入 : NONE
** 输 出 : NONE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
VOID _KernelHighLevelInit (VOID)
{
VOID _HookListInit(VOID);
#if LW_CFG_SIGNAL_EN > 0
VOID _signalInit(VOID);
#endif /* LW_CFG_SIGNAL_EN */
REGISTER INT iErr;
_DebugHandle(__LOGMESSAGE_LEVEL, "kernel high level initialize...\r\n");
_HookListInit(); /* 系统动态 HOOK 初始化 */
#if LW_CFG_SIGNAL_EN > 0
_signalInit(); /* 信号初始化 */
#endif /* LW_CFG_SIGNAL_EN */
_CreateIdleThread(); /* 建立空闲任务 */
_CreateITimerThread(); /* ITIMER 任务建立 */
#if LW_CFG_ISR_DEFER_EN > 0
_interDeferInit();
#endif /* LW_CFG_ISR_DEFER_EN > 0 */
iErr = _SysInit();
if (iErr != ERROR_NONE) {
_DebugHandle(__LOGMESSAGE_LEVEL, "system initialized error!\r\n");
} else {
_DebugHandle(__LOGMESSAGE_LEVEL, "system initialized.\r\n");
}
#if LW_CFG_MPI_EN > 0
_mpiInit();
#endif /* LW_CFG_MPI_EN */
bspKernelInitHook();
__LW_KERNEL_INIT_END_HOOK(iErr); /* 入口参数为系统初始化结果 */
}
/*********************************************************************************************************
** 函数名称: API_ThreadPoolCreate
** 功能描述: 建立一个 ThreadPool
** 输 入 : pcName 线程池名字
** pfuncThread 代码入口
** pthreadattr 线程属性控制块
** usMaxThreadCounter 最大线程数量
** pulId Id指针
** 输 出 : 新建立的线程池句柄
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
LW_OBJECT_HANDLE API_ThreadPoolCreate (PCHAR pcName,
PTHREAD_START_ROUTINE pfuncThread,
PLW_CLASS_THREADATTR pthreadattr,
UINT16 usMaxThreadCounter,
LW_OBJECT_ID *pulId)
{
REGISTER PLW_CLASS_THREADPOOL pthreadpool;
REGISTER ULONG ulIdTemp;
REGISTER ULONG ulOption;
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (LW_OBJECT_HANDLE_INVALID);
}
#if LW_CFG_ARG_CHK_EN > 0
if (!pfuncThread) { /* 没有线程执行函数 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "pfuncThread invalidate.\r\n");
_ErrorHandle(EINVAL);
return (LW_OBJECT_HANDLE_INVALID);
}
if (usMaxThreadCounter >= LW_CFG_MAX_THREADS ||
usMaxThreadCounter == 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "usMaxThreadCounter invalidate.\r\n");
_ErrorHandle(ERROR_THREADPOOL_MAX_COUNTER);
return (LW_OBJECT_HANDLE_INVALID);
}
#endif
if (_Object_Name_Invalid(pcName)) { /* 检查名字有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "name too long.\r\n");
_ErrorHandle(ERROR_KERNEL_PNAME_TOO_LONG);
return (LW_OBJECT_HANDLE_INVALID);
}
__KERNEL_MODE_PROC(
pthreadpool = _Allocate_ThreadPool_Object(); /* 获得一个分区控制块 */
);
/*********************************************************************************************************
** 函数名称: 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); /* 退出内核同时打开中断 */
}
/*********************************************************************************************************
** 函数名称: API_IoGetDrvLicense
** 功能描述: 获得指定驱动程序的许可证信息
** 输 入 :
** iDrvNum 驱动程式号 (主设备号)
** 输 出 : 许可证字符串
** 全局变量:
** 调用模块:
API 函数
********************************************************************************************************/
LW_API
PCHAR API_IoGetDrvLicense (INT iDrvNum)
{
REGISTER LW_DRV_LICENSE *pdrvlic;
if (iDrvNum >= LW_CFG_MAX_DRIVERS ||
iDrvNum < 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (LW_NULL);
}
if (_S_deventryTbl[iDrvNum].DEVENTRY_bInUse == LW_FALSE) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (LW_NULL);
}
pdrvlic = &_S_deventryTbl[iDrvNum].DEVENTRY_drvlicLicense;
return (pdrvlic->DRVLIC_pcLicense);
}
/*********************************************************************************************************
** 函数名称: spiBusDrv
** 功能描述: 初始化 spi 总线并获取驱动程序
** 输 入 : uiChannel 通道号
** 输 出 : spi 总线驱动程序
** 全局变量:
** 调用模块:
*********************************************************************************************************/
PLW_SPI_FUNCS spiBusDrv (UINT uiChannel)
{
if (uiChannel >= LS1X_SPI_CHANNEL_NR) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "spiBusDrv(): spi channel invalid!\r\n");
return (LW_NULL);
}
if (ls1xSpiInit(&_G_ls1xSpiChannels[uiChannel]) != ERROR_NONE) {
return (LW_NULL);
}
return (&_G_ls1xSpiFuncs[uiChannel]);
}
LW_API
LW_OBJECT_HANDLE API_TimerCreate (CPCHAR pcName,
ULONG ulOption,
LW_OBJECT_ID *pulId)
{
REGISTER PLW_CLASS_TIMER ptmr;
REGISTER ULONG ulIdTemp;
if (LW_CPU_GET_CUR_NESTING()) { /* 不能在中断中调用 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "called from ISR.\r\n");
_ErrorHandle(ERROR_KERNEL_IN_ISR);
return (LW_OBJECT_HANDLE_INVALID);
}
if (_Object_Name_Invalid(pcName)) { /* 检查名字有效性 */
_DebugHandle(__ERRORMESSAGE_LEVEL, "name too long.\r\n");
_ErrorHandle(ERROR_KERNEL_PNAME_TOO_LONG);
return (LW_OBJECT_HANDLE_INVALID);
}
__KERNEL_MODE_PROC(
ptmr = _Allocate_Timer_Object(); /* 获得一个定时器控制块 */
);
/*********************************************************************************************************
** 函数名称: API_IoSetDrvDescroption
** 功能描述: 设置指定驱动程序的描述信息
** 输 入 :
** iDrvNum 驱动程式号 (主设备号)
** pcDescription 描述信息
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
********************************************************************************************************/
LW_API
INT API_IoSetDrvDescription (INT iDrvNum, PCHAR pcDescription)
{
REGISTER LW_DRV_LICENSE *pdrvlic;
if (iDrvNum >= LW_CFG_MAX_DRIVERS ||
iDrvNum < 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
if (_S_deventryTbl[iDrvNum].DEVENTRY_bInUse == LW_FALSE) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "driver invalidate.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
pdrvlic = &_S_deventryTbl[iDrvNum].DEVENTRY_drvlicLicense;
pdrvlic->DRVLIC_pcDescription = pcDescription;
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: __vmmVirtualCreate
** 功能描述: 创建虚拟空间区域.
** 输 入 : ulAddr 起始地址
** stSize 虚拟空间大小
** 输 出 : ERROR CODE
** 全局变量:
** 调用模块:
*********************************************************************************************************/
ULONG __vmmVirtualCreate (addr_t ulAddr, size_t stSize)
{
REGISTER PLW_MMU_CONTEXT pmmuctx = __vmmGetCurCtx();
REGISTER ULONG ulError;
ulError = __pageZoneCreate(&pmmuctx->MMUCTX_vmzoneVirtual, ulAddr, stSize, LW_ZONE_ATTR_NONE,
__VMM_PAGE_TYPE_VIRTUAL);
if (ulError) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "kernel low memory.\r\n");
return (ulError);
} else {
return (ERROR_NONE);
}
}
/*********************************************************************************************************
** 函数名称: API_CoroutineStackCheck
** 功能描述: 检测一个协程的堆栈使用量!!, 该协程的父系线程建立时必须使用 STK_CHK 选项.
** 输 入 : pvCrcb 协程句柄
** pstFreeByteSize 空闲堆栈大小 (可为 LW_NULL)
** pstUsedByteSize 使用堆栈大小 (可为 LW_NULL)
** pstCrcbByteSize 协程控制块大小 (可为 LW_NULL)
** 输 出 : ERROR
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
ULONG API_CoroutineStackCheck (PVOID pvCrcb,
size_t *pstFreeByteSize,
size_t *pstUsedByteSize,
size_t *pstCrcbByteSize)
{
REGISTER PLW_CLASS_COROUTINE pcrcb = (PLW_CLASS_COROUTINE)pvCrcb;
REGISTER size_t stTotal;
REGISTER size_t stFree = 0;
REGISTER PLW_STACK pstkButtom;
if (!pcrcb) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "coroutine handle invalidate.\r\n");
_ErrorHandle(EINVAL);
return (EINVAL);
}
__KERNEL_ENTER(); /* 进入内核 */
stTotal = pcrcb->COROUTINE_stStackSize; /* 总大小 */
#if CPU_STK_GROWTH == 0 /* 寻找堆栈头尾 */
for (pstkButtom = pcrcb->COROUTINE_pstkStackBottom;
*pstkButtom == _K_stkFreeFlag;
pstkButtom--,
stFree++);
#else
for (pstkButtom = pcrcb->COROUTINE_pstkStackBottom;
*pstkButtom == _K_stkFreeFlag;
pstkButtom++,
stFree++);
#endif
__KERNEL_EXIT(); /* 退出内核 */
if (pstFreeByteSize) {
*pstFreeByteSize = stFree * sizeof(LW_STACK);
}
if (pstUsedByteSize) {
*pstUsedByteSize = (stTotal - stFree) * sizeof(LW_STACK);
}
if (pstCrcbByteSize) {
*pstCrcbByteSize = sizeof(LW_CLASS_COROUTINE);
}
return (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: 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 API_KernelSecondaryStart (PKERNEL_START_ROUTINE pfuncStartHook)
{
KN_SMP_MB();
while (KN_SECONDARY_WAIT()) {
LW_SPINLOCK_DELAY(); /* 短延迟并释放总线 */
}
_KernelSecondaryLowLevelInit(); /* 从核底层初始化 */
_DebugHandle(__LOGMESSAGE_LEVEL, "kernel secondary cpu usrStartup...\r\n");
if (pfuncStartHook) { /* 用户是否要求需要初始化 */
pfuncStartHook(); /* 用户系统初始化 */
}
_KernelSecondaryCoreStartup(LW_CPU_GET_CUR()); /* 主核初始化完毕直接启动多任务*/
}
/*********************************************************************************************************
** 函数名称: API_EventfdDevCreate
** 功能描述: 安装 eventfd 设备
** 输 入 : NONE
** 输 出 : 设备是否创建成功
** 全局变量:
** 调用模块:
API 函数
*********************************************************************************************************/
LW_API
INT API_EventfdDevCreate (VOID)
{
if (_G_iEvtfdDrvNum <= 0) {
_DebugHandle(__ERRORMESSAGE_LEVEL, "no driver.\r\n");
_ErrorHandle(ERROR_IO_NO_DRIVER);
return (PX_ERROR);
}
if (iosDevAddEx(&_G_evtfddev.ED_devhdrHdr, LW_EVTFD_DEV_PATH,
_G_iEvtfdDrvNum, DT_CHR) != ERROR_NONE) {
return (PX_ERROR);
}
return (ERROR_NONE);
}
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;
}
}
