/**
* \fn twIf_TxnDoneCb
* \brief Transaction completion CB
*
* This callback is called by the TxnQ upon transaction completion, unless is was completed in
* the original context where it was issued.
* It may be called from bus driver external context (TxnDone ISR) or from WLAN driver context.
*
* \note
* \param hTwIf - The module's object
* \param pTxn - The completed transaction object
* \return void
* \sa twIf_HandleTxnDone
*/
static void twIf_TxnDoneCb(TI_HANDLE hTwIf, TTxnStruct * pTxn)
{
TTwIfObj *pTwIf = (TTwIfObj *) hTwIf;
#ifdef TI_DBG
pTwIf->uDbgCountTxnDoneCb++;
TRACE6(pTwIf->hReport, REPORT_SEVERITY_INFORMATION,
"twIf_TxnDoneCb: Params=0x%x, HwAddr=0x%x, Len0=%d, Len1=%d, Len2=%d, Len3=%d\n",
pTxn->uTxnParams, pTxn->uHwAddr, pTxn->aLen[0], pTxn->aLen[1],
pTxn->aLen[2], pTxn->aLen[3]);
#endif
/* In case of recovery flag, Call directly restart callback */
if (TXN_PARAM_GET_STATUS(pTxn) == TXN_PARAM_STATUS_RECOVERY) {
if (pTwIf->fRecoveryCb) {
TRACE0(pTwIf->hReport, REPORT_SEVERITY_INFORMATION,
"twIf_TxnDoneCb: During Recovery\n");
pTwIf->bTxnDoneInRecovery = TI_TRUE;
/* Request schedule to continue handling in driver context (will call twIf_HandleTxnDone()) */
context_RequestSchedule(pTwIf->hContext,
pTwIf->uContextId);
return;
}
}
/* If the completed Txn is ELP, nothing to do (not counted) so exit */
if (TXN_PARAM_GET_SINGLE_STEP(pTxn)) {
return;
}
if (pTxn->fTxnDoneCb) {
TI_STATUS eStatus;
/* In critical section, enqueue the completed transaction in the TxnDoneQ. */
context_EnterCriticalSection(pTwIf->hContext);
eStatus = que_Enqueue(pTwIf->hTxnDoneQueue, (TI_HANDLE) pTxn);
if (eStatus != TI_OK) {
TRACE3(pTwIf->hReport, REPORT_SEVERITY_ERROR,
"twIf_TxnDoneCb(): Enqueue failed, pTxn=0x%x, HwAddr=0x%x, Len0=%d\n",
pTxn, pTxn->uHwAddr, pTxn->aLen[0]);
}
context_LeaveCriticalSection(pTwIf->hContext);
} else {
context_EnterCriticalSection(pTwIf->hContext);
/* Decrement pending Txn counter, It's value will be checked in twIf_HandleTxnDone() */
if (pTwIf->uPendingTxnCount > 0) { /* in case of callback on recovery after restart */
pTwIf->uPendingTxnCount--;
}
context_LeaveCriticalSection(pTwIf->hContext);
}
/* Request schedule to continue handling in driver context (will call twIf_HandleTxnDone()) */
context_RequestSchedule(pTwIf->hContext, pTwIf->uContextId);
}
/**
* \fn twIf_TxnDoneCb
* \brief Transaction completion CB
*
* This callback is called by the TxnQ upon transaction completion, unless is was completed in
* the original context where it was issued.
* It may be called from bus driver external context (TxnDone ISR) or from WLAN driver context.
*
* \note
* \param hTwIf - The module's object
* \param pTxn - The completed transaction object
* \return void
* \sa twIf_HandleTxnDone
*/
static void twIf_TxnDoneCb (TI_HANDLE hTwIf, TTxnStruct *pTxn)
{
TTwIfObj *pTwIf = (TTwIfObj*)hTwIf;
#ifdef TI_DBG
pTwIf->uDbgCountTxnDoneCb++;
#endif
/* In case of recovery flag, Call directly restart callback */
if (TXN_PARAM_GET_STATUS(pTxn) == TXN_PARAM_STATUS_RECOVERY)
{
if (pTwIf->fRecoveryCb)
{
pTwIf->bTxnDoneInRecovery = TI_TRUE;
/* Request schedule to continue handling in driver context (will call twIf_HandleTxnDone()) */
context_RequestSchedule (pTwIf->hContext, pTwIf->uContextId);
return;
}
}
/* If the completed Txn is ELP, nothing to do (not counted) so exit */
if (TXN_PARAM_GET_SINGLE_STEP(pTxn))
{
return;
}
if (pTxn->fTxnDoneCb)
{
TI_STATUS eStatus;
/* In critical section, enqueue the completed transaction in the TxnDoneQ. */
context_EnterCriticalSection (pTwIf->hContext);
eStatus = que_Enqueue (pTwIf->hTxnDoneQueue, (TI_HANDLE)pTxn);
context_LeaveCriticalSection (pTwIf->hContext);
}
else
{
context_EnterCriticalSection (pTwIf->hContext);
/* Decrement pending Txn counter, It's value will be checked in twIf_HandleTxnDone() */
if (pTwIf->uPendingTxnCount > 0) /* in case of callback on recovery after restart */
{
pTwIf->uPendingTxnCount--;
}
context_LeaveCriticalSection (pTwIf->hContext);
}
/* Request schedule to continue handling in driver context (will call twIf_HandleTxnDone()) */
context_RequestSchedule (pTwIf->hContext, pTwIf->uContextId);
}
/**
* \fn tmr_GetExpiry
* \brief Called by OS-API upon any timer expiry
*
* This is the common callback function called upon expiartion of any timer.
* It is called by the OS-API in timer expiry context and handles the transition
* to the driver's context for handling the expiry event.
*
* \note
* \param hTimerInfo - The specific timer handle
* \return void
* \sa tmr_HandleExpiry
*/
void tmr_GetExpiry (TI_HANDLE hTimerInfo)
{
TTimerInfo *pTimerInfo = (TTimerInfo *)hTimerInfo; /* The timer handle */
TTimerModule *pTimerModule = (TTimerModule *)pTimerInfo->hTimerModule; /* The timer module handle */
if (!pTimerModule) {
WLAN_OS_REPORT (("tmr_GetExpiry(): ERROR - NULL timer!\n"));
return;
}
/* Enter critical section */
context_EnterCriticalSection (pTimerModule->hContext);
/*
* If the expired timer was started when the driver's state was Operational,
* insert it to the Operational-queue
*/
if (pTimerInfo->bOperStateWhenStarted) {
que_Enqueue (pTimerModule->hOperQueue, hTimerInfo);
}
/*
* Else (started when driver's state was NOT-Operational), if now the state is still
* NOT Operational insert it to the Init-queue.
* (If state changed from non-operational to operational the event is ignored)
*/
else if (!pTimerModule->bOperState) {
que_Enqueue (pTimerModule->hInitQueue, hTimerInfo);
}
/* Leave critical section */
context_LeaveCriticalSection (pTimerModule->hContext);
/* Request switch to driver context for handling timer events */
context_RequestSchedule (pTimerModule->hContext, pTimerModule->uContextId);
}
/**
* \fn tmr_UpdateDriverState
* \brief Update driver state
*
* Under critical section, update driver state (operational or not),
* and if opertional, clear init queue.
* Leave critical section and if operational state, request schedule for handling
* timer events in driver context (if any).
*
* \note
* \param hTimerModule - The timer module object
* \param bOperState - TRUE if driver state is now operational, FALSE if not.
* \return void
* \sa
*/
void tmr_UpdateDriverState (TI_HANDLE hTimerModule, TI_BOOL bOperState)
{
TTimerModule *pTimerModule = (TTimerModule *)hTimerModule;
if (bOperState == pTimerModule->bOperState)
{
return;
}
/* Enter critical section */
context_EnterCriticalSection (pTimerModule->hContext);
/* Save new state (TRUE means operational). */
pTimerModule->bOperState = bOperState;
/* If new state is operational */
if (bOperState)
{
/* Increment the TWD initializations counter (for detecting recovery events). */
pTimerModule->uTwdInitCount++;
/* Empty the init queue (obsolete). */
while (que_Dequeue (pTimerModule->hInitQueue) != NULL) {}
}
/* Leave critical section */
context_LeaveCriticalSection (pTimerModule->hContext);
/* If new state is operational, request switch to driver context for handling timer events */
if (bOperState)
{
context_RequestSchedule (pTimerModule->hContext, pTimerModule->uContextId);
}
}
/*
* \brief FW interrupt handler, just switch to WLAN context for handling
*
* \param hFwEvent - FwEvent Driver handle
* \return void
*
* \par Description
* Called by the FW-Interrupt ISR (external context!).
* Requests the context engine to schedule the driver task for handling the FW-Events.
*
* \sa
*/
void fwEvent_InterruptRequest (TI_HANDLE hFwEvent)
{
TfwEvent *pFwEvent = (TfwEvent *)hFwEvent;
/* Request switch to driver context for handling the FW-Interrupt event */
context_RequestSchedule (pFwEvent->hContext, pFwEvent->uContextId);
}
/**
* \fn txMgmtQ_Xmit
* \brief Insert non-data packet for transmission
*
* This function is used by the driver applications to send Tx packets other than the
* regular data traffic, including the following packet types:
* - Management
* - EAPOL
* - NULL
* - IAPP
* The managment packets are enqueued to the Mgmt-queue and the others to the Eapol-queue.
* EAPOL packets may be inserted from the network stack context, so it requires switching
* to the driver's context (after the packet is enqueued).
* If the selected queue was empty before the packet insertion, the SM is called
* with QUEUES_NOT_EMPTY event (in case of external context, only after the context switch).
*
* \note
* \param hTxMgmtQ - The module's object
* \param pPktCtrlBlk - Pointer to the packet CtrlBlk
* \param bExternalContext - Indicates if called from non-driver context
* \return TI_OK - if the packet was queued, TI_NOK - if the packet was dropped.
* \sa txMgmtQ_QueuesNotEmpty
*/
TI_STATUS txMgmtQ_Xmit (TI_HANDLE hTxMgmtQ, TTxCtrlBlk *pPktCtrlBlk, TI_BOOL bExternalContext)
{
TTxMgmtQ *pTxMgmtQ = (TTxMgmtQ *)hTxMgmtQ;
TI_STATUS eStatus;
TI_UINT32 uQueId;
TI_UINT32 uQueSize;
/* Always set highest TID for mgmt-queues packets. */
pPktCtrlBlk->tTxDescriptor.tid = MGMT_QUEUES_TID;
/* Select queue asccording to the packet type */
uQueId = (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_MGMT) ? QUEUE_TYPE_MGMT : QUEUE_TYPE_EAPOL ;
/* Enter critical section to protect queue access */
context_EnterCriticalSection (pTxMgmtQ->hContext);
/* Enqueue the packet in the appropriate Queue */
eStatus = que_Enqueue (pTxMgmtQ->aQueues[uQueId], (TI_HANDLE)pPktCtrlBlk);
/* Get number of packets in current queue */
uQueSize = que_Size (pTxMgmtQ->aQueues[uQueId]);
/* Leave critical section */
context_LeaveCriticalSection (pTxMgmtQ->hContext);
/* If packet enqueued successfully */
if (eStatus == TI_OK)
{
pTxMgmtQ->tDbgCounters.aEnqueuePackets[uQueId]++;
/* If selected queue was empty before packet insertion */
if (uQueSize == 1)
{
/* If called from external context (EAPOL from network), request switch to the driver's context. */
if (bExternalContext)
{
context_RequestSchedule (pTxMgmtQ->hContext, pTxMgmtQ->uContextId);
}
/* If already in the driver's context, call the SM with QUEUES_NOT_EMPTY event. */
else
{
mgmtQueuesSM(pTxMgmtQ, SM_EVENT_QUEUES_NOT_EMPTY);
}
}
}
else
{
/* If the packet can't be queued so drop it */
txCtrl_FreePacket (pTxMgmtQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
pTxMgmtQ->tDbgCounters.aDroppedPackets[uQueId]++;
}
return eStatus;
}
/*
* \brief FW interrupt handler, just switch to WLAN context for handling
*
* \param hFwEvent - FwEvent Driver handle
* \return void
*
* \par Description
* Called by the FW-Interrupt ISR (external context!).
* Requests the context engine to schedule the driver task for handling the FW-Events.
*
* \sa
*/
void fwEvent_InterruptRequest (TI_HANDLE hFwEvent)
{
TfwEvent *pFwEvent = (TfwEvent *)hFwEvent;
CL_TRACE_START_L1();
TRACE0(pFwEvent->hReport, REPORT_SEVERITY_INFORMATION, "fwEvent_InterruptRequest()\n");
/* Request switch to driver context for handling the FW-Interrupt event */
context_RequestSchedule (pFwEvent->hContext, pFwEvent->uContextId);
CL_TRACE_END_L1("tiwlan_drv.ko", "IRQ", "FwEvent", "");
}
/**
* \fn tmr_UpdateDriverState
* \brief Update driver state
*
* Under critical section, update driver state (operational or not),
* and if opertional, clear init queue.
* Leave critical section and if operational state, request schedule for handling
* timer events in driver context (if any).
*
* \note
* \param hTimerModule - The timer module object
* \param bOperState - TRUE if driver state is now operational, FALSE if not.
* \return void
* \sa
*/
void tmr_UpdateDriverState (TI_HANDLE hTimerModule, TI_BOOL bOperState)
{
TTimerModule *pTimerModule = (TTimerModule *)hTimerModule;
if (!pTimerModule)
{
WLAN_OS_REPORT (("tmr_UpdateDriverState(): ERROR - NULL timer!\n"));
return;
}
/* Enter critical section */
context_EnterCriticalSection (pTimerModule->hContext);
if (bOperState == pTimerModule->bOperState)
{
context_LeaveCriticalSection (pTimerModule->hContext);
TRACE1(pTimerModule->hReport, REPORT_SEVERITY_ERROR, "tmr_UpdateDriverState(): New bOperState (%d) is as current!\n", bOperState);
return;
}
/* Save new state (TRUE means operational). */
pTimerModule->bOperState = bOperState;
/* If new state is operational */
if (bOperState)
{
/* Increment the TWD initializations counter (for detecting recovery events). */
pTimerModule->uTwdInitCount++;
/* Empty the init queue (obsolete). */
while (que_Dequeue (pTimerModule->hInitQueue) != NULL) {}
}
/* Leave critical section */
context_LeaveCriticalSection (pTimerModule->hContext);
/* If new state is operational, request switch to driver context for handling timer events */
if (bOperState)
{
context_RequestSchedule (pTimerModule->hContext, pTimerModule->uContextId);
}
}
TI_STATUS txDataQ_InsertPacket (TI_HANDLE hTxDataQ, TTxCtrlBlk *pPktCtrlBlk, TI_UINT8 uPacketDtag)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TEthernetHeader *pEthHead = (TEthernetHeader *)(pPktCtrlBlk->tTxnStruct.aBuf[0]);
TI_STATUS eStatus;
TI_UINT32 uQueId;
TI_UINT32 uQueSize;
txCtrl_t *pTxCtrl = (txCtrl_t *)(pTxDataQ->hTxCtrl);
TI_BOOL bRequestSchedule = TI_FALSE;
TI_BOOL bStopNetStack = TI_FALSE;
CL_TRACE_START_L3();
/* If packet is EAPOL or from the generic Ethertype, forward it to the Mgmt-Queue and exit */
if ((HTOWLANS(pEthHead->type) == ETHERTYPE_EAPOL) ||
(HTOWLANS(pEthHead->type) == pTxCtrl->genericEthertype)) {
pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_EAPOL;
return txMgmtQ_Xmit (pTxDataQ->hTxMgmtQ, pPktCtrlBlk, TI_TRUE);
/* Note: The last parameter indicates that we are running in external context */
}
pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_ETHER;
/* Enter critical section to protect classifier data and queue access */
context_EnterCriticalSection (pTxDataQ->hContext);
/* Call the Classify function to set the TID field */
if (txDataClsfr_ClassifyTxPacket (hTxDataQ, pPktCtrlBlk, uPacketDtag) != TI_OK) {
#ifdef TI_DBG
pTxDataQ->uClsfrMismatchCount++;
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_WARNING, "txDataQueue_xmit: No matching classifier found \n");
#endif /* TI_DBG */
}
/* Enqueue the packet in the appropriate Queue */
uQueId = aTidToQueueTable[pPktCtrlBlk->tTxDescriptor.tid];
eStatus = que_Enqueue (pTxDataQ->aQueues[uQueId], (TI_HANDLE)pPktCtrlBlk);
/* Get number of packets in current queue */
uQueSize = que_Size (pTxDataQ->aQueues[uQueId]);
/* If the current queue is not stopped */
if (pTxDataQ->aQueueBusy[uQueId] == TI_FALSE) {
/* If the queue has the desired number of packets, request switch to driver context for handling them */
if (uQueSize == pTxDataQ->aTxSendPaceThresh[uQueId]) {
tmr_StopTimer (pTxDataQ->hTxSendPaceTimer);
bRequestSchedule = TI_TRUE;
}
/* If below Tx-Send pacing threshold, start timer to trigger packets handling if expired */
else if (uQueSize < pTxDataQ->aTxSendPaceThresh[uQueId]) {
tmr_StartTimer (pTxDataQ->hTxSendPaceTimer,
txDataQ_TxSendPaceTimeout,
hTxDataQ,
TX_SEND_PACE_TIMEOUT_MSEC,
TI_FALSE);
}
}
/* If allowed to stop network stack and the queue is full, indicate to stop network and
to schedule Tx handling (both are executed below, outside the critical section!) */
if ((pTxDataQ->bStopNetStackTx) && (uQueSize == pTxDataQ->aQueueMaxSize[uQueId])) {
pTxDataQ->aNetStackQueueStopped[uQueId] = TI_TRUE;
bRequestSchedule = TI_TRUE;
bStopNetStack = TI_TRUE;
}
/* Leave critical section */
context_LeaveCriticalSection (pTxDataQ->hContext);
/* If needed, schedule Tx handling */
if (bRequestSchedule) {
context_RequestSchedule (pTxDataQ->hContext, pTxDataQ->uContextId);
}
/* If needed, stop the network stack Tx */
if (bStopNetStack) {
/* Stop the network stack from sending Tx packets as we have at least one date queue full.
Note that in some of the OS's (e.g Win Mobile) it is implemented by blocking the thread*/
wlanDrvIf_StopTx (pTxDataQ->hOs);
}
if (eStatus != TI_OK) {
/* If the packet can't be queued drop it */
txCtrl_FreePacket (pTxDataQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
#ifdef TI_DBG
pTxDataQ->aQueueCounters[uQueId].uDroppedPacket++;
#endif /* TI_DBG */
} else {
#ifdef TI_DBG
pTxDataQ->aQueueCounters[uQueId].uEnqueuePacket++;
#endif /* TI_DBG */
}
CL_TRACE_END_L3 ("tiwlan_drv.ko", "INHERIT", "TX", "");
return eStatus;
}
/**
* \fn cmdHndlr_InsertCommand
* \brief Insert a new command to the driver
*
* Insert a new command to the commands queue from user context.
* If commands are not beeing processed set a request to start processing in the driver context.
* Wait on the current command's signal until its processing is completed.
* Note that this prevents the user application from sending further commands before completion.
*
* \note
* \param hCmdHndlr - The module object
* \param cmd - User request
* \param others - The command flags, data and params
* \return TI_OK if command processed successfully, TI_NOK if failed in processing or memory allocation.
* \sa cmdHndlr_HandleCommands, cmdHndlr_Complete
*/
TI_STATUS cmdHndlr_InsertCommand (TI_HANDLE hCmdHndlr,
TI_UINT32 cmd,
TI_UINT32 flags,
void *buffer1,
TI_UINT32 buffer1_len,
void *buffer2,
TI_UINT32 buffer2_len,
TI_UINT32 *param3,
TI_UINT32 *param4)
{
TCmdHndlrObj *pCmdHndlr = (TCmdHndlrObj *)hCmdHndlr;
TConfigCommand *pNewCmd;
TI_STATUS eStatus;
/* Allocated command structure */
pNewCmd = os_memoryAlloc (pCmdHndlr->hOs, sizeof (TConfigCommand));
if (pNewCmd == NULL)
{
return TI_NOK;
}
os_memoryZero (pCmdHndlr->hOs, (void *)pNewCmd, sizeof(TConfigCommand));
/* Copy user request into local structure */
pNewCmd->cmd = cmd;
pNewCmd->flags = flags;
pNewCmd->buffer1 = buffer1;
pNewCmd->buffer1_len = buffer1_len;
pNewCmd->buffer2 = buffer2;
pNewCmd->buffer2_len = buffer2_len;
pNewCmd->param3 = param3;
pNewCmd->param4 = param4;
pNewCmd->pSignalObject = os_SignalObjectCreate (pCmdHndlr->hOs); /* initialize "complete-flag" */
/* If creating the signal object failed */
if (pNewCmd->pSignalObject == NULL)
{
os_printf("cmdPerform: Failed to create signalling object\n");
/* free allocated memory and return error */
os_memoryFree (pCmdHndlr->hOs, pNewCmd, sizeof (TConfigCommand));
return TI_NOK;
}
/* Indicate the start of command process, from adding it to the queue until get return status form it */
pNewCmd->bWaitFlag = TI_TRUE;
/* Enter critical section to protect queue access */
context_EnterCriticalSection (pCmdHndlr->hContext);
/* Enqueue the command (if failed, release memory and return NOK) */
eStatus = que_Enqueue (pCmdHndlr->hCmdQueue, (TI_HANDLE)pNewCmd);
if (eStatus != TI_OK)
{
os_printf("cmdPerform: Failed to enqueue new command\n");
os_SignalObjectFree (pCmdHndlr->hOs, pNewCmd->pSignalObject);
pNewCmd->pSignalObject = NULL;
os_memoryFree (pCmdHndlr->hOs, pNewCmd, sizeof (TConfigCommand));
context_LeaveCriticalSection (pCmdHndlr->hContext); /* Leave critical section */
return TI_NOK;
}
/*
* Note: The bProcessingCmds flag is used for indicating if we are already processing
* the queued commands, so the context-engine shouldn't invoke cmdHndlr_HandleCommands.
* This is important because if we make this decision according to the queue being empty,
* there may be a command under processing (already dequeued) while the queue is empty.
* Note that although we are blocking the current command's originator, there may be another
* application that will issue a command.
*/
if (pCmdHndlr->bProcessingCmds)
{
/* No need to schedule the driver (already handling commands) so just leave critical section */
context_LeaveCriticalSection (pCmdHndlr->hContext);
}
else
{
/* Indicate that we are handling queued commands (before leaving critical section!) */
pCmdHndlr->bProcessingCmds = TI_TRUE;
/* Leave critical section */
context_LeaveCriticalSection (pCmdHndlr->hContext);
/* Request driver task schedule for command handling (after we left critical section!) */
context_RequestSchedule (pCmdHndlr->hContext, pCmdHndlr->uContextId);
}
/* Wait until the command is executed */
os_SignalObjectWait (pCmdHndlr->hOs, pNewCmd->pSignalObject);
/* After "wait" - the command has already been processed by the drivers' context */
/* Indicate the end of command process, from adding it to the queue until get return status form it */
pNewCmd->bWaitFlag = TI_FALSE;
/* Copy the return code */
eStatus = pNewCmd->return_code;
/* Free signalling object and command structure */
os_SignalObjectFree (pCmdHndlr->hOs, pNewCmd->pSignalObject);
pNewCmd->pSignalObject = NULL;
/* If command not completed in this context (Async) don't free the command memory */
if(COMMAND_PENDING != pNewCmd->eCmdStatus)
{
os_memoryFree (pCmdHndlr->hOs, pNewCmd, sizeof (TConfigCommand));
}
/* Return to calling process with command return code */
return eStatus;
}
/**
* \fn txMgmtQ_Xmit
* \brief Insert non-data packet for transmission
*
* This function is used by the driver applications to send Tx packets other than the
* regular data traffic, including the following packet types:
* - Management
* - EAPOL
* - NULL
* - IAPP
* The managment packets are enqueued to the Mgmt-queue and the others to the Eapol-queue.
* EAPOL packets may be inserted from the network stack context, so it requires switching
* to the driver's context (after the packet is enqueued).
* If the selected queue was empty before the packet insertion, the SM is called
* with QUEUES_NOT_EMPTY event (in case of external context, only after the context switch).
*
* \note
* \param hTxMgmtQ - The module's object
* \param pPktCtrlBlk - Pointer to the packet CtrlBlk
* \param bExternalContext - Indicates if called from non-driver context
* \return TI_OK - if the packet was queued, TI_NOK - if the packet was dropped.
* \sa txMgmtQ_QueuesNotEmpty
*/
TI_STATUS txMgmtQ_Xmit (TI_HANDLE hTxMgmtQ, TTxCtrlBlk *pPktCtrlBlk, TI_BOOL bExternalContext)
{
TTxMgmtQ *pTxMgmtQ = (TTxMgmtQ *)hTxMgmtQ;
TI_STATUS eStatus;
TI_UINT32 uQueId;
TI_UINT32 uQueSize;
TI_UINT32 uHlid;
TMgmtLinkQ *pLinkQ;
/* Find link id by destination MAC address, if not found use global link id */
if (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_MGMT)
{
/* MGMT packet, use destination MAC address from WLAN header, aBuf[0] is the WLAN header */
if ((txDataQ_LinkMacFind( pTxMgmtQ->hTxDataQ, &uHlid ,((dot11_header_t *)(pPktCtrlBlk->tTxnStruct.aBuf[0]))->address1 )) != TI_OK)
{
uHlid = pTxMgmtQ->uGlobalHlid;
}
}
else
{
/* EAPOL packet, use destination MAC address from ETHERNET header, aBuf[0] is the ETHERNET header */
if ((txDataQ_LinkMacFind( pTxMgmtQ->hTxDataQ, &uHlid, ((TEthernetHeader *)(pPktCtrlBlk->tTxnStruct.aBuf[0]))->dst)) != TI_OK)
{
uHlid = pTxMgmtQ->uGlobalHlid;
}
}
pPktCtrlBlk->tTxDescriptor.hlid = uHlid;
pLinkQ = &pTxMgmtQ->aMgmtLinkQ[uHlid]; /* Link queues */
/* Always set highest TID for mgmt-queues packets. */
pPktCtrlBlk->tTxDescriptor.tid = MGMT_QUEUES_TID;
if ((pLinkQ->bEncrypt)&& (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_EAPOL))
{
SET_PKT_TYPE_ENCRYPT(pPktCtrlBlk);
}
/* Select queue asccording to the packet type */
uQueId = (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_MGMT) ? QUEUE_TYPE_MGMT : QUEUE_TYPE_EAPOL ;
/* Enter critical section to protect queue access */
context_EnterCriticalSection (pTxMgmtQ->hContext);
/* Check resources per LINK and per MGMT AC (VOICE)*/
if (txDataQ_AllocCheckResources( pTxMgmtQ->hTxDataQ, pPktCtrlBlk) != TI_OK)
{
pLinkQ->tDbgCounters.aDroppedPackets[uQueId]++;
pLinkQ->tDbgCounters.uNoResourcesCount++;
/* Leave critical section */
context_LeaveCriticalSection (pTxMgmtQ->hContext);
/* If the packet can't be queued drop it */
/* !!! This call should be out of the critical section */
txCtrl_FreePacket (pTxMgmtQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
return TI_NOK;
}
/* Enqueue the packet in the appropriate Queue */
eStatus = que_Enqueue (pLinkQ->aQueues[uQueId], (TI_HANDLE)pPktCtrlBlk);
/* Get number of packets in current queue */
uQueSize = que_Size (pLinkQ->aQueues[uQueId]);
/* Leave critical section */
context_LeaveCriticalSection (pTxMgmtQ->hContext);
/* If packet enqueued successfully */
if (eStatus == TI_OK)
{
pLinkQ->tDbgCounters.aEnqueuePackets[uQueId]++;
/* If selected queue was empty before packet insertion */
if (uQueSize == 1 )
if (uQueSize )
{
/* If called from external context (EAPOL from network), request switch to the driver's context. */
if (bExternalContext)
{
/* Set bSendEvent_NotEmpty flag to use in driver context */
pLinkQ->bSendEvent_NotEmpty = TI_TRUE;
context_RequestSchedule (pTxMgmtQ->hContext, pTxMgmtQ->uContextId);
}
/* If already in the driver's context, call the SM with QUEUES_NOT_EMPTY event. */
else
{
mgmtQueuesSM(pTxMgmtQ, uHlid, SM_EVENT_QUEUES_NOT_EMPTY);
}
}
}
else
{
/* If the packet can't be queued so drop it */
txCtrl_FreePacket (pTxMgmtQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
pLinkQ->tDbgCounters.aDroppedPackets[uQueId]++;
}
return eStatus;
}
TI_STATUS txDataQ_InsertPacket (TI_HANDLE hTxDataQ, TTxCtrlBlk *pPktCtrlBlk, TI_UINT8 uPacketDtag, TIntraBssBridge *pIntraBssBridgeParam)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TEthernetHeader *pEthHead = (TEthernetHeader *)(pPktCtrlBlk->tTxnStruct.aBuf[0]);
TI_STATUS eStatus;
TI_UINT32 uQueId;
TI_UINT32 uQueSize;
txCtrl_t *pTxCtrl = (txCtrl_t *)(pTxDataQ->hTxCtrl);
TI_BOOL bRequestSchedule = TI_FALSE;
TI_BOOL bStopNetStack = TI_FALSE;
TDataLinkQ *pLinkQ;
TI_UINT32 uHlid;
/* If packet is EAPOL or from the generic Ethertype, forward it to the Mgmt-Queue and exit */
if ((HTOWLANS(pEthHead->type) == ETHERTYPE_EAPOL) ||
(HTOWLANS(pEthHead->type) == pTxCtrl->genericEthertype)) {
pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_EAPOL;
return txMgmtQ_Xmit (pTxDataQ->hTxMgmtQ, pPktCtrlBlk, TI_TRUE);
/* Note: The last parameter indicates that we are running in external context */
}
/* Find link id by destination MAC address, if not found drop the packet */
/* use Intra Bss bridge params*/
if(!pIntraBssBridgeParam) {
if (TI_UNLIKELY(MAC_MULTICAST(pEthHead->dst))) {
uHlid = pTxDataQ->uBcastHlid;
} else {
if (txDataQ_LinkMacFind( hTxDataQ, &uHlid, pEthHead->dst) != TI_OK) {
/* If the packet can't be queued drop it */
txCtrl_FreePacket (pTxDataQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
pTxDataQ->uLinkNotFoundCount++;
return TI_NOK;
}
}
} else {
uHlid = pIntraBssBridgeParam->uParam;
}
pPktCtrlBlk->tTxDescriptor.hlid = uHlid;
pLinkQ = &pTxDataQ->aDataLinkQ[uHlid]; /* Link queues */
pPktCtrlBlk->tTxPktParams.uPktType = TX_PKT_TYPE_ETHER;
/* set encryption bit */
if (pLinkQ->bEncrypt) {
SET_PKT_TYPE_ENCRYPT(pPktCtrlBlk);
}
/* Enter critical section to protect classifier data and queue access */
context_EnterCriticalSection (pTxDataQ->hContext);
/* Call the Classify function to set the TID field */
if (txDataClsfr_ClassifyTxPacket (hTxDataQ, pPktCtrlBlk, uPacketDtag) != TI_OK) {
#ifdef TI_DBG
pTxDataQ->uClsfrMismatchCount++;
#endif /* TI_DBG */
}
uQueId = aTidToQueueTable[pPktCtrlBlk->tTxDescriptor.tid];
/* Check resources per LINK and per AC */
if (txDataQ_AllocCheckResources( hTxDataQ, pPktCtrlBlk) != TI_OK) {
#ifdef TI_DBG
pLinkQ->aQueueCounters[uQueId].uDroppedPacket++;
pTxDataQ->uNoResourcesCount++;
#endif /* TI_DBG */
/* Leave critical section */
context_LeaveCriticalSection (pTxDataQ->hContext);
/* If the packet can't be queued drop it - Should be out of the critical section */
/* !!! This call should be out of the critical section */
txCtrl_FreePacket (pTxDataQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
return TI_NOK;
}
/* Enqueue the packet in the appropriate Queue */
eStatus = que_Enqueue (pLinkQ->aQueues[uQueId], (TI_HANDLE)pPktCtrlBlk);
/* Get number of packets in current queue */
uQueSize = que_Size (pLinkQ->aQueues[uQueId]);
/* If the current queue is not stopped */
if (pTxDataQ->aQueueBusy[uQueId] == TI_FALSE) {
/* If the queue has the desired number of packets, request switch to driver context for handling them */
if (uQueSize == pTxDataQ->aTxSendPaceThresh[uQueId]) {
tmr_StopTimer (pTxDataQ->hTxSendPaceTimer);
bRequestSchedule = TI_TRUE;
}
/* If below Tx-Send pacing threshold, start timer to trigger packets handling if expired */
else if (uQueSize < pTxDataQ->aTxSendPaceThresh[uQueId]) {
tmr_StartTimer (pTxDataQ->hTxSendPaceTimer,
txDataQ_TxSendPaceTimeout,
hTxDataQ,
TX_SEND_PACE_TIMEOUT_MSEC,
TI_FALSE);
}
}
/* If allowed to stop network stack and the queue is full, indicate to stop network and
to schedule Tx handling (both are executed below, outside the critical section!) */
if ((pTxDataQ->bStopNetStackTx) && (uQueSize == pTxDataQ->aQueueMaxSize[uQueId])) {
pLinkQ->aNetStackQueueStopped[uQueId] = TI_TRUE;
bRequestSchedule = TI_TRUE;
bStopNetStack = TI_TRUE;
}
/* Leave critical section */
context_LeaveCriticalSection (pTxDataQ->hContext);
/* If needed, schedule Tx handling */
if (bRequestSchedule) {
context_RequestSchedule (pTxDataQ->hContext, pTxDataQ->uContextId);
}
/* If needed, stop the network stack Tx */
if (bStopNetStack) {
/* Stop the network stack from sending Tx packets as we have at least one date queue full.
Note that in some of the OS's (e.g Win Mobile) it is implemented by blocking the thread! */
wlanDrvIf_StopTx (pTxDataQ->hOs);
}
if (eStatus != TI_OK) {
/* If the packet can't be queued drop it */
txCtrl_FreePacket (pTxDataQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
#ifdef TI_DBG
pLinkQ->aQueueCounters[uQueId].uDroppedPacket++;
#endif /* TI_DBG */
} else {
#ifdef TI_DBG
pLinkQ->aQueueCounters[uQueId].uEnqueuePacket++;
#endif /* TI_DBG */
}
return eStatus;
}
