int RtmpTimerQThread(IN void *Context)
{
struct rt_rtmp_os_task *pTask;
struct rt_rtmp_adapter *pAd;
pTask = Context;
pAd = pTask->priv;
RtmpOSTaskCustomize(pTask);
RtmpTimerQHandle(pAd);
DBGPRINT(RT_DEBUG_TRACE, ("<---%s\n", __func__));
#ifndef KTHREAD_SUPPORT
pTask->taskPID = THREAD_PID_INIT_VALUE;
#endif
/* notify the exit routine that we're actually exiting now
*
* complete()/wait_for_completion() is similar to up()/down(),
* except that complete() is safe in the case where the structure
* is getting deleted in a parallel mode of execution (i.e. just
* after the down() -- that's necessary for the thread-shutdown
* case.
*
* complete_and_exit() goes even further than this -- it is safe in
* the case that the thread of the caller is going away (not just
* the structure) -- this is necessary for the module-remove case.
* This is important in preemption kernels, which transfer the flow
* of execution immediately upon a complete().
*/
RtmpOSTaskNotifyToExit(pTask);
return 0;
}
INT write_dat_file_thread (
IN ULONG Context)
{
RTMP_OS_TASK *pTask;
RTMP_ADAPTER *pAd;
//int Status = 0;
pTask = (RTMP_OS_TASK *)Context;
if (pTask == NULL)
{
DBGPRINT(RT_DEBUG_TRACE, ("%s: pTask is NULL\n", __FUNCTION__));
return 0;
}
pAd = (PRTMP_ADAPTER)RTMP_OS_TASK_DATA_GET(pTask);
if (pAd == NULL)
{
DBGPRINT(RT_DEBUG_TRACE, ("%s: pAd is NULL\n", __FUNCTION__));
return 0;
}
RtmpOSTaskCustomize(pTask);
/* Update ssid, auth mode and encr type to DAT file */
WriteConfToDatFile(pAd);
RtmpOSTaskNotifyToExit(pTask);
return 0;
}
int RtmpTimerQThread(ULONG Context)
{
RTMP_OS_TASK *pTask;
PRTMP_ADAPTER pAd;
pTask = (RTMP_OS_TASK *)Context;
pAd = (PRTMP_ADAPTER)RTMP_OS_TASK_DATA_GET(pTask);
if (pAd == NULL) {
DBGPRINT(RT_DEBUG_ERROR,( "%s:: pAd is NULL!\n",__FUNCTION__));
return 0;
}
RtmpOSTaskCustomize(pTask);
RtmpTimerQHandle(pAd);
/* notify the exit routine that we're actually exiting now
*
* complete()/wait_for_completion() is similar to up()/down(),
* except that complete() is safe in the case where the structure
* is getting deleted in a parallel mode of execution (i.e. just
* after the down() -- that's necessary for the thread-shutdown
* case.
*
* complete_and_exit() goes even further than this -- it is safe in
* the case that the thread of the caller is going away (not just
* the structure) -- this is necessary for the module-remove case.
* This is important in preemption kernels, which transfer the flow
* of execution immediately upon a complete().
*/
RtmpOSTaskNotifyToExit(pTask);
DBGPRINT(RT_DEBUG_TRACE,( "<---%s\n",__FUNCTION__));
return 0;
}
/*
========================================================================
Routine Description:
MLME kernel thread.
Arguments:
*Context the pAd, driver control block pointer
Return Value:
0 close the thread
Note:
========================================================================
*/
INT MlmeThread(
IN ULONG Context)
{
RTMP_ADAPTER *pAd;
RTMP_OS_TASK *pTask;
int status;
status = 0;
pTask = (RTMP_OS_TASK *)Context;
pAd = (PRTMP_ADAPTER)pTask->priv;
RtmpOSTaskCustomize(pTask);
while(!pTask->task_killed)
{
#ifdef KTHREAD_SUPPORT
RTMP_WAIT_EVENT_INTERRUPTIBLE(pAd, pTask);
#else
RTMP_SEM_EVENT_WAIT(&(pTask->taskSema), status);
/* unlock the device pointers */
if (status != 0)
{
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
break;
}
#endif
/* lock the device pointers , need to check if required*/
//down(&(pAd->usbdev_semaphore));
if (!pAd->PM_FlgSuspend)
MlmeHandler(pAd);
}
/* notify the exit routine that we're actually exiting now
*
* complete()/wait_for_completion() is similar to up()/down(),
* except that complete() is safe in the case where the structure
* is getting deleted in a parallel mode of execution (i.e. just
* after the down() -- that's necessary for the thread-shutdown
* case.
*
* complete_and_exit() goes even further than this -- it is safe in
* the case that the thread of the caller is going away (not just
* the structure) -- this is necessary for the module-remove case.
* This is important in preemption kernels, which transfer the flow
* of execution immediately upon a complete().
*/
DBGPRINT(RT_DEBUG_TRACE,( "<---%s\n",__FUNCTION__));
#ifndef KTHREAD_SUPPORT
pTask->taskPID = THREAD_PID_INIT_VALUE;
complete_and_exit (&pTask->taskComplete, 0);
#endif
return 0;
}
/*
========================================================================
Routine Description:
MLME kernel thread.
Arguments:
*Context the pAd, driver control block pointer
Return Value:
0 close the thread
Note:
========================================================================
*/
INT MlmeThread(
IN ULONG Context)
{
RTMP_ADAPTER *pAd;
RTMP_OS_TASK *pTask;
int status;
status = 0;
pTask = (RTMP_OS_TASK *)Context;
pAd = (PRTMP_ADAPTER)RTMP_OS_TASK_DATA_GET(pTask);
if (pAd == NULL)
goto LabelExit; /* avoid compile warning */
RtmpOSTaskCustomize(pTask);
while(!RTMP_OS_TASK_IS_KILLED(pTask))
{
if (RtmpOSTaskWait(pAd, pTask, &status) == FALSE)
{
DBGPRINT_ERR(("RtmpOSTaskWait returned false in MlmeThread, setting halt in progress flag!\n"));
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
break;
}
/* lock the device pointers , need to check if required*/
/*down(&(pAd->usbdev_semaphore)); */
if (!pAd->PM_FlgSuspend)
MlmeHandler(pAd);
}
/* notify the exit routine that we're actually exiting now
*
* complete()/wait_for_completion() is similar to up()/down(),
* except that complete() is safe in the case where the structure
* is getting deleted in a parallel mode of execution (i.e. just
* after the down() -- that's necessary for the thread-shutdown
* case.
*
* complete_and_exit() goes even further than this -- it is safe in
* the case that the thread of the caller is going away (not just
* the structure) -- this is necessary for the module-remove case.
* This is important in preemption kernels, which transfer the flow
* of execution immediately upon a complete().
*/
LabelExit:
DBGPRINT(RT_DEBUG_TRACE,( "<---%s\n",__FUNCTION__));
RtmpOSTaskNotifyToExit(pTask);
return 0;
}
/*
========================================================================
Routine Description:
USB command kernel thread.
Arguments:
*Context the pAd, driver control block pointer
Return Value:
0 close the thread
Note:
========================================================================
*/
INT RTUSBCmdThread(
IN ULONG Context)
{
RTMP_ADAPTER *pAd;
RTMP_OS_TASK *pTask;
int status;
status = 0;
pTask = (RTMP_OS_TASK *)Context;
pAd = (PRTMP_ADAPTER)pTask->priv;
RtmpOSTaskCustomize(pTask);
NdisAcquireSpinLock(&pAd->CmdQLock);
pAd->CmdQ.CmdQState = RTMP_TASK_STAT_RUNNING;
NdisReleaseSpinLock(&pAd->CmdQLock);
while (pAd && pAd->CmdQ.CmdQState == RTMP_TASK_STAT_RUNNING)
{
#ifdef KTHREAD_SUPPORT
RTMP_WAIT_EVENT_INTERRUPTIBLE(pAd, pTask);
#else
/* lock the device pointers */
RTMP_SEM_EVENT_WAIT(&(pTask->taskSema), status);
if (status != 0)
{
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
break;
}
#endif
if (pAd->CmdQ.CmdQState == RTMP_TASK_STAT_STOPED)
break;
if (!pAd->PM_FlgSuspend)
CMDHandler(pAd);
}
if (pAd && !pAd->PM_FlgSuspend)
{ // Clear the CmdQElements.
CmdQElmt *pCmdQElmt = NULL;
NdisAcquireSpinLock(&pAd->CmdQLock);
pAd->CmdQ.CmdQState = RTMP_TASK_STAT_STOPED;
while(pAd->CmdQ.size)
{
RTThreadDequeueCmd(&pAd->CmdQ, &pCmdQElmt);
if (pCmdQElmt)
{
if (pCmdQElmt->CmdFromNdis == TRUE)
{
if (pCmdQElmt->buffer != NULL)
os_free_mem(pAd, pCmdQElmt->buffer);
os_free_mem(pAd, (PUCHAR)pCmdQElmt);
}
else
{
if ((pCmdQElmt->buffer != NULL) && (pCmdQElmt->bufferlength != 0))
os_free_mem(pAd, pCmdQElmt->buffer);
os_free_mem(pAd, (PUCHAR)pCmdQElmt);
}
}
}
NdisReleaseSpinLock(&pAd->CmdQLock);
}
/* notify the exit routine that we're actually exiting now
*
* complete()/wait_for_completion() is similar to up()/down(),
* except that complete() is safe in the case where the structure
* is getting deleted in a parallel mode of execution (i.e. just
* after the down() -- that's necessary for the thread-shutdown
* case.
*
* complete_and_exit() goes even further than this -- it is safe in
* the case that the thread of the caller is going away (not just
* the structure) -- this is necessary for the module-remove case.
* This is important in preemption kernels, which transfer the flow
* of execution immediately upon a complete().
*/
DBGPRINT(RT_DEBUG_TRACE,( "<---RTUSBCmdThread\n"));
#ifndef KTHREAD_SUPPORT
pTask->taskPID = THREAD_PID_INIT_VALUE;
complete_and_exit (&pTask->taskComplete, 0);
#endif
return 0;
}
/*
========================================================================
Routine Description:
USB command kernel thread.
Arguments:
*Context the pAd, driver control block pointer
Return Value:
0 close the thread
Note:
========================================================================
*/
INT RTUSBCmdThread(
IN ULONG Context)
{
RTMP_ADAPTER *pAd;
RTMP_OS_TASK *pTask;
int status;
status = 0;
pTask = (RTMP_OS_TASK *)Context;
pAd = (PRTMP_ADAPTER)RTMP_OS_TASK_DATA_GET(pTask);
if (pAd == NULL)
return 0;
RtmpOSTaskCustomize(pTask);
NdisAcquireSpinLock(&pAd->CmdQLock);
pAd->CmdQ.CmdQState = RTMP_TASK_STAT_RUNNING;
NdisReleaseSpinLock(&pAd->CmdQLock);
while (pAd->CmdQ.CmdQState == RTMP_TASK_STAT_RUNNING)
{
if (RtmpOSTaskWait(pAd, pTask, &status) == FALSE)
{
DBGPRINT_ERR(("RtmpOSTaskWait returned false in RTUSBCmdThread, setting halt in progress flag!\n"));
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
break;
}
if (pAd->CmdQ.CmdQState == RTMP_TASK_STAT_STOPED)
break;
if (!pAd->PM_FlgSuspend)
CMDHandler(pAd);
}
if (!pAd->PM_FlgSuspend)
{ /* Clear the CmdQElements. */
CmdQElmt *pCmdQElmt = NULL;
NdisAcquireSpinLock(&pAd->CmdQLock);
pAd->CmdQ.CmdQState = RTMP_TASK_STAT_STOPED;
while(pAd->CmdQ.size)
{
RTThreadDequeueCmd(&pAd->CmdQ, &pCmdQElmt);
if (pCmdQElmt)
{
if (pCmdQElmt->CmdFromNdis == TRUE)
{
if (pCmdQElmt->buffer != NULL)
os_free_mem(pAd, pCmdQElmt->buffer);
os_free_mem(pAd, (PUCHAR)pCmdQElmt);
}
else
{
if ((pCmdQElmt->buffer != NULL) && (pCmdQElmt->bufferlength != 0))
os_free_mem(pAd, pCmdQElmt->buffer);
os_free_mem(pAd, (PUCHAR)pCmdQElmt);
}
}
}
NdisReleaseSpinLock(&pAd->CmdQLock);
}
/* notify the exit routine that we're actually exiting now
*
* complete()/wait_for_completion() is similar to up()/down(),
* except that complete() is safe in the case where the structure
* is getting deleted in a parallel mode of execution (i.e. just
* after the down() -- that's necessary for the thread-shutdown
* case.
*
* complete_and_exit() goes even further than this -- it is safe in
* the case that the thread of the caller is going away (not just
* the structure) -- this is necessary for the module-remove case.
* This is important in preemption kernels, which transfer the flow
* of execution immediately upon a complete().
*/
DBGPRINT(RT_DEBUG_TRACE,( "<---RTUSBCmdThread\n"));
RtmpOSTaskNotifyToExit(pTask);
return 0;
}