/*
* txDataQueue.c
*
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name Texas Instruments nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** \file txDataQueue.c
* \brief The Tx Data Queues module.
*
* \see txDataQueue.h
*/
#define __FILE_ID__ FILE_ID_60
#include "paramOut.h"
#include "osApi.h"
#include "report.h"
#include "timer.h"
#include "queue.h"
#include "context.h"
#include "Ethernet.h"
#include "TWDriver.h"
#include "DataCtrl_Api.h"
#include "txDataQueue.h"
#include "txCtrl.h"
#include "DrvMainModules.h"
#include "bmtrace_api.h"
/* Internal Functions prototypes */
static void txDataQ_RunScheduler (TI_HANDLE hTxDataQ);
static void txDataQ_UpdateQueuesBusyState (TTxDataQ *pTxDataQ, TI_UINT32 uTidBitMap);
static void txDataQ_TxSendPaceTimeout (TI_HANDLE hTxDataQ, TI_BOOL bTwdInitOccured);
extern void wlanDrvIf_StopTx (TI_HANDLE hOs);
extern void wlanDrvIf_ResumeTx (TI_HANDLE hOs);
/***************************************************************************
* PUBLIC FUNCTIONS IMPLEMENTATION *
****************************************************************************/
/**
* \fn txDataQ_Create
* \brief Create the module and its queues
*
* Create the Tx Data module and its queues.
*
* \note
* \param hOs - Handle to the Os Abstraction Layer
* \return Handle to the allocated Tx Data Queue module (NULL if failed)
* \sa
*/
TI_HANDLE txDataQ_Create(TI_HANDLE hOs)
{
TTxDataQ *pTxDataQ;
/* allocate TxDataQueue module */
pTxDataQ = os_memoryAlloc (hOs, (sizeof(TTxDataQ)));
if (!pTxDataQ)
{
WLAN_OS_REPORT(("Error allocating the TxDataQueue Module\n"));
return NULL;
}
/* Reset TxDataQueue module */
os_memoryZero (hOs, pTxDataQ, (sizeof(TTxDataQ)));
return (TI_HANDLE)pTxDataQ;
}
/**
* \fn txDataQ_Init
* \brief Save required modules handles
*
* Save other modules handles.
*
* \note
* \param pStadHandles - The driver modules handles
* \return void
* \sa
*/
void txDataQ_Init (TStadHandlesList *pStadHandles)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)(pStadHandles->hTxDataQ);
TI_UINT32 uNodeHeaderOffset = TI_FIELD_OFFSET(TTxnStruct, tTxnQNode);
TI_UINT8 uQueId;
/* save modules handles */
pTxDataQ->hContext = pStadHandles->hContext;
pTxDataQ->hTxCtrl = pStadHandles->hTxCtrl;
pTxDataQ->hOs = pStadHandles->hOs;
pTxDataQ->hReport = pStadHandles->hReport;
pTxDataQ->hTxMgmtQ = pStadHandles->hTxMgmtQ;
pTxDataQ->hTWD = pStadHandles->hTWD;
/* Configures the Port Default status to Close */
pTxDataQ->bDataPortEnable = TI_FALSE;
/* Configures the LastQueId to zero => scheduler will strart from Queue 1*/
pTxDataQ->uLastQueId = 0;
/* init the number of the Data queue to be used */
pTxDataQ->uNumQueues = MAX_NUM_OF_AC;
/* init the max size of the Data queues */
pTxDataQ->aQueueMaxSize[QOS_AC_BE] = DATA_QUEUE_DEPTH_BE;
pTxDataQ->aQueueMaxSize[QOS_AC_BK] = DATA_QUEUE_DEPTH_BK;
pTxDataQ->aQueueMaxSize[QOS_AC_VI] = DATA_QUEUE_DEPTH_VI;
pTxDataQ->aQueueMaxSize[QOS_AC_VO] = DATA_QUEUE_DEPTH_VO;
/* Create the tx data queues */
for (uQueId = 0; uQueId < pTxDataQ->uNumQueues; uQueId++)
{
pTxDataQ->aQueues[uQueId] = que_Create (pTxDataQ->hOs,
pTxDataQ->hReport,
pTxDataQ->aQueueMaxSize[uQueId],
uNodeHeaderOffset);
/* If any Queues' allocation failed, print error, free TxDataQueue module and exit */
if (pTxDataQ->aQueues[uQueId] == NULL)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_CONSOLE , "Failed to create queue\n");
WLAN_OS_REPORT(("Failed to create queue\n"));
os_memoryFree (pTxDataQ->hOs, pTxDataQ, sizeof(TTxDataQ));
return;
}
/* Configure the Queues default values */
pTxDataQ->aQueueBusy[uQueId] = TI_FALSE;
pTxDataQ->aNetStackQueueStopped[uQueId] = TI_FALSE;
pTxDataQ->aTxSendPaceThresh[uQueId] = 1;
}
pTxDataQ->hTxSendPaceTimer = tmr_CreateTimer (pStadHandles->hTimer);
if (pTxDataQ->hTxSendPaceTimer == NULL)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "txDataQ_Init(): Failed to create hTxSendPaceTimer!\n");
return;
}
/* Register to the context engine and get the client ID */
pTxDataQ->uContextId = context_RegisterClient (pTxDataQ->hContext,
txDataQ_RunScheduler,
(TI_HANDLE)pTxDataQ,
TI_TRUE,
"TX_DATA",
sizeof("TX_DATA"));
}
/**
* \fn txDataQ_SetDefaults
* \brief Configure module with default settings
*
* Init the Tx Data queues.
* Register as the context-engine client.
*
* \note
* \param hTxDataQ - The object
* \param Other modules handles
* \return TI_OK on success or TI_NOK on failure
* \sa
*/
TI_STATUS txDataQ_SetDefaults (TI_HANDLE hTxDataQ, txDataInitParams_t *pTxDataInitParams)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TI_STATUS eStatus;
/* configure the classifier sub-module */
eStatus = txDataClsfr_Config (hTxDataQ, &pTxDataInitParams->ClsfrInitParam);
if (eStatus != TI_OK)
{
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_CONSOLE ,"FATAL ERROR: txDataQ_SetDefaults(): txDataClsfr_Config failed - Aborting\n");
WLAN_OS_REPORT(("FATAL ERROR: txDataQ_SetDefaults(): txDataClsfr_Config failed - Aborting\n"));
return eStatus;
}
/* Save the module's parameters settings */
pTxDataQ->bStopNetStackTx = pTxDataInitParams->bStopNetStackTx;
pTxDataQ->aTxSendPaceThresh[QOS_AC_BE] = pTxDataInitParams->uTxSendPaceThresh;
pTxDataQ->aTxSendPaceThresh[QOS_AC_BK] = pTxDataInitParams->uTxSendPaceThresh;
pTxDataQ->aTxSendPaceThresh[QOS_AC_VI] = pTxDataInitParams->uTxSendPaceThresh;
pTxDataQ->aTxSendPaceThresh[QOS_AC_VO] = 1; /* Don't delay voice packts! */
TRACE0(pTxDataQ->hReport, REPORT_SEVERITY_INIT, ".....Tx Data Queue configured successfully\n");
return TI_OK;
}
/**
* \fn txDataQ_Destroy
* \brief Destroy the module and its queues
*
* Clear and destroy the queues and then destroy the module object.
*
* \note
* \param hTxDataQ - The object
* \return TI_OK - Unload succesfull, TI_NOK - Unload unsuccesfull
* \sa
*/
TI_STATUS txDataQ_Destroy (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TI_STATUS status = TI_OK;
TI_UINT32 uQueId;
/* Dequeue and free all queued packets */
txDataQ_ClearQueues (hTxDataQ);
/* Free Data queues */
for (uQueId = 0 ; uQueId < pTxDataQ->uNumQueues ; uQueId++)
{
if (que_Destroy(pTxDataQ->aQueues[uQueId]) != TI_OK)
{
TRACE1(pTxDataQ->hReport, REPORT_SEVERITY_ERROR, "txDataQueue_unLoad: fail to free Data Queue number: %d\n",uQueId);
status = TI_NOK;
}
}
/* free timer */
if (pTxDataQ->hTxSendPaceTimer)
{
tmr_DestroyTimer (pTxDataQ->hTxSendPaceTimer);
}
/* Free Tx Data Queue Module */
os_memoryFree (pTxDataQ->hOs, pTxDataQ, sizeof(TTxDataQ));
return status;
}
/**
* \fn txDataQ_ClearQueues
* \brief Clear all queues
*
* Dequeue and free all queued packets.
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa
*/
void txDataQ_ClearQueues (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TTxCtrlBlk *pPktCtrlBlk;
TI_UINT32 uQueId;
/* Dequeue and free all queued packets */
for (uQueId = 0 ; uQueId < pTxDataQ->uNumQueues ; uQueId++)
{
do {
context_EnterCriticalSection (pTxDataQ->hContext);
pPktCtrlBlk = (TTxCtrlBlk *) que_Dequeue(pTxDataQ->aQueues[uQueId]);
context_LeaveCriticalSection (pTxDataQ->hContext);
if (pPktCtrlBlk != NULL) {
txCtrl_FreePacket (pTxDataQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
}
} while (pPktCtrlBlk != NULL);
}
}
/**
* \fn txDataQ_InsertPacket
* \brief Insert packet in queue and schedule task
*
* This function is called by the hard_start_xmit() callback function.
* If the packet it an EAPOL, forward it to the Mgmt-Queue.
* Otherwise, classify the packet, enqueue it and request
* context switch for handling it in the driver's context.
*
* \note
* \param hTxDataQ - The object
* \param pPktCtrlBlk - Pointer to the packet
* \param uPacketDtag - The packet priority optionaly set by the OAL
* \return TI_OK - if the packet was queued, TI_NOK - if the packet was dropped.
* \sa txDataQ_Run
*/
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 txDataQ_StopQueue
* \brief Set queue's busy indication
*
* This function is called by the txCtrl_xmitData() if the queue's backpressure
* indication is set.
* It sets the internal queue's Busy indication.
*
* \note
* \param hTxDataQ - The object
* \param uTidBitMap - The changed TIDs busy bitmap
* \return void
* \sa txDataQ_UpdateBusyMap
*/
void txDataQ_StopQueue (TI_HANDLE hTxDataQ, TI_UINT32 uTidBitMap)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
/* Set the relevant queue(s) busy flag */
txDataQ_UpdateQueuesBusyState (pTxDataQ, uTidBitMap);
}
/**
* \fn txDataQ_UpdateBusyMap
* \brief Set queue's busy indication
*
* This function is called by the txCtrl if the backpressure map per TID is changed.
* This could be as a result of Tx-Complete, admission change or association.
* The function modifies the internal queue's Busy indication and calls the scheduler.
*
* \note
* \param hTxDataQ - The object
* \param uTidBitMap - The changed TIDs busy bitmap
* \return void
* \sa txDataQ_StopQueue
*/
void txDataQ_UpdateBusyMap (TI_HANDLE hTxDataQ, TI_UINT32 tidBitMap)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
/* Update the Queue(s) mode */
txDataQ_UpdateQueuesBusyState (pTxDataQ, tidBitMap);
/* Run the scheduler */
txDataQ_RunScheduler (hTxDataQ);
}
/**
* \fn txDataQ_StopAll
* \brief Disable Data-Queue module access to Tx path.
*
* Called by the Tx-Port when the data-queue module can't access the Tx path.
* Sets stop-all-queues indication.
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa txDataQ_WakeAll
*/
void txDataQ_StopAll (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
/* Disable the data Tx port */
pTxDataQ->bDataPortEnable = TI_FALSE;
}
/**
* \fn txDataQ_WakeAll
* \brief Enable Data-Queue module access to Tx path.
*
* Called by the Tx-Port when the data-queue module can access the Tx path.
* Clears the stop-all-queues indication and calls the scheduler.
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa txDataQ_StopAll
*/
void txDataQ_WakeAll (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
/* Enable the data Tx port */
pTxDataQ->bDataPortEnable = TI_TRUE;
/* Run the scheduler */
txDataQ_RunScheduler (hTxDataQ);
}
/***************************************************************************
* DEBUG FUNCTIONS IMPLEMENTATION *
****************************************************************************/
#ifdef TI_DBG
/**
* \fn txDataQ_PrintModuleParams
* \brief Print Module Parameters
*
* Print Module Parameters
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa
*/
void txDataQ_PrintModuleParams (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TI_UINT32 qIndex;
WLAN_OS_REPORT(("--------- txDataQueue_printModuleParams ----------\n\n"));
WLAN_OS_REPORT(("bStopNetStackTx = %d\n",pTxDataQ->bStopNetStackTx));
WLAN_OS_REPORT(("bDataPortEnable = %d\n",pTxDataQ->bDataPortEnable));
WLAN_OS_REPORT(("uNumQueues = %d\n",pTxDataQ->uNumQueues));
WLAN_OS_REPORT(("uLastQueId = %d\n",pTxDataQ->uLastQueId));
WLAN_OS_REPORT(("uContextId = %d\n",pTxDataQ->uContextId));
for (qIndex = 0; qIndex < pTxDataQ->uNumQueues; qIndex++)
{
WLAN_OS_REPORT(("aQueueBusy[%d] = %d\n", qIndex, pTxDataQ->aQueueBusy[qIndex]));
}
for (qIndex = 0; qIndex < pTxDataQ->uNumQueues; qIndex++)
{
WLAN_OS_REPORT(("aQueueMaxSize[%d] = %d\n", qIndex, pTxDataQ->aQueueMaxSize[qIndex]));
}
for (qIndex = 0; qIndex < pTxDataQ->uNumQueues; qIndex++)
{
WLAN_OS_REPORT(("aTxSendPaceThresh[%d] = %d\n", qIndex, pTxDataQ->aTxSendPaceThresh[qIndex]));
}
for (qIndex = 0; qIndex < pTxDataQ->uNumQueues; qIndex++)
{
WLAN_OS_REPORT(("aNetStackQueueStopped[%d] = %d\n", qIndex, pTxDataQ->aNetStackQueueStopped[qIndex]));
}
WLAN_OS_REPORT(("-------------- Queues Info -----------------------\n"));
for (qIndex = 0; qIndex < MAX_NUM_OF_AC; qIndex++)
{
WLAN_OS_REPORT(("Que %d:\n", qIndex));
que_Print (pTxDataQ->aQueues[qIndex]);
}
WLAN_OS_REPORT(("--------------------------------------------------\n\n"));
}
/**
* \fn txDataQ_PrintQueueStatistics
* \brief Print queues statistics
*
* Print queues statistics
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa
*/
void txDataQ_PrintQueueStatistics (TI_HANDLE hTxDataQ)
{
#ifdef REPORT_LOG
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TI_UINT32 qIndex;
WLAN_OS_REPORT(("-------------- txDataQueue_printStatistics -------\n\n"));
WLAN_OS_REPORT(("uClsfrMismatchCount = %d\n",pTxDataQ->uClsfrMismatchCount));
WLAN_OS_REPORT(("uTxSendPaceTimeoutsCount = %d\n",pTxDataQ->uTxSendPaceTimeoutsCount));
WLAN_OS_REPORT(("-------------- Enqueue to queues -----------------\n"));
for(qIndex = 0; qIndex < MAX_NUM_OF_AC; qIndex++)
WLAN_OS_REPORT(("Que[%d]: = %d\n",qIndex, pTxDataQ->aQueueCounters[qIndex].uEnqueuePacket));
WLAN_OS_REPORT(("-------------- Dequeue from queues ---------------\n"));
for(qIndex = 0; qIndex < MAX_NUM_OF_AC; qIndex++)
WLAN_OS_REPORT(("Que[%d]: = %d\n",qIndex, pTxDataQ->aQueueCounters[qIndex].uDequeuePacket));
WLAN_OS_REPORT(("-------------- Requeue to queues -----------------\n"));
for(qIndex = 0; qIndex < MAX_NUM_OF_AC; qIndex++)
WLAN_OS_REPORT(("Que[%d]: = %d\n",qIndex, pTxDataQ->aQueueCounters[qIndex].uRequeuePacket));
WLAN_OS_REPORT(("-------------- Sent to TxCtrl --------------------\n"));
for(qIndex = 0; qIndex < MAX_NUM_OF_AC; qIndex++)
WLAN_OS_REPORT(("Que[%d]: = %d\n",qIndex, pTxDataQ->aQueueCounters[qIndex].uXmittedPacket));
WLAN_OS_REPORT(("-------------- Dropped - Queue Full --------------\n"));
for(qIndex = 0; qIndex < MAX_NUM_OF_AC; qIndex++)
WLAN_OS_REPORT(("Que[%d]: = %d\n",qIndex, pTxDataQ->aQueueCounters[qIndex].uDroppedPacket));
WLAN_OS_REPORT(("--------------------------------------------------\n\n"));
#endif
}
/**
* \fn txDataQ_ResetQueueStatistics
* \brief Reset queues statistics
*
* Reset queues statistics
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa
*/
void txDataQ_ResetQueueStatistics (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
os_memoryZero(pTxDataQ->hOs, &pTxDataQ->aQueueCounters, sizeof(pTxDataQ->aQueueCounters));
pTxDataQ->uTxSendPaceTimeoutsCount = 0;
}
#endif /* TI_DBG */
/***************************************************************************
* INTERNAL FUNCTIONS IMPLEMENTATION *
****************************************************************************/
/**
* \fn txDataQ_RunScheduler
* \brief The module's Tx scheduler
*
* This function is the Data-Queue scheduler.
* It selects a packet to transmit from the tx queues and sends it to the TxCtrl.
* The queues are selected in a round-robin order.
* The function is called by one of:
* txDataQ_Run()
* txDataQ_UpdateBusyMap()
* txDataQ_WakeAll()
*
* \note
* \param hTxDataQ - The object
* \return void
* \sa
*/
static void txDataQ_RunScheduler (TI_HANDLE hTxDataQ)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
TI_UINT32 uIdleIterationsCount = 0; /* Count iterations without packet transmission (for exit criteria) */
TI_UINT32 uQueId = pTxDataQ->uLastQueId; /* The last iteration queue */
EStatusXmit eStatus; /* The return status of the txCtrl_xmitData function */
TTxCtrlBlk *pPktCtrlBlk; /* Pointer to the packet to be dequeued and sent */
while(1)
{
/* If the Data port is closed or the scheduler couldn't send packets from
all queues, indicate end of current packets burst and exit */
if ( !pTxDataQ->bDataPortEnable || (uIdleIterationsCount >= pTxDataQ->uNumQueues) )
{
TWD_txXfer_EndOfBurst (pTxDataQ->hTWD);
return;
}
/* Selecting the next queue */
uQueId++;
if (uQueId == pTxDataQ->uNumQueues)
{
uQueId = 0;
}
pTxDataQ->uLastQueId = uQueId;
/* Increment the idle iterations counter */
uIdleIterationsCount++;
/* If the queue is busy (AC is full), continue to next queue. */
if (pTxDataQ->aQueueBusy[uQueId])
{
continue;
}
/* Dequeue a packet in a critical section */
context_EnterCriticalSection (pTxDataQ->hContext);
pPktCtrlBlk = (TTxCtrlBlk *) que_Dequeue (pTxDataQ->aQueues[uQueId]);
context_LeaveCriticalSection (pTxDataQ->hContext);
/* If the queue was empty, continue to the next queue */
if (pPktCtrlBlk == NULL)
{
if ((pTxDataQ->bStopNetStackTx) && pTxDataQ->aNetStackQueueStopped[uQueId])
{
pTxDataQ->aNetStackQueueStopped[uQueId] = TI_FALSE;
/*Resume the TX process as our date queues are empty*/
wlanDrvIf_ResumeTx (pTxDataQ->hOs);
}
continue;
}
#ifdef TI_DBG
pTxDataQ->aQueueCounters[uQueId].uDequeuePacket++;
#endif /* TI_DBG */
/* Send the packet */
eStatus = txCtrl_XmitData (pTxDataQ->hTxCtrl, pPktCtrlBlk);
/*
* If the return status is busy it means that the packet was not sent
* so we need to requeue it for future try.
*/
if(eStatus == STATUS_XMIT_BUSY)
{
TI_STATUS eQueStatus;
/* Requeue the packet in a critical section */
context_EnterCriticalSection (pTxDataQ->hContext);
eQueStatus = que_Requeue (pTxDataQ->aQueues[uQueId], (TI_HANDLE)pPktCtrlBlk);
if (eQueStatus != TI_OK)
{
/* If the packet can't be queued drop it */
/* Note: may happen only if this thread was preempted between the
dequeue and requeue and new packets were inserted into this quque */
txCtrl_FreePacket (pTxDataQ->hTxCtrl, pPktCtrlBlk, TI_NOK);
#ifdef TI_DBG
pTxDataQ->aQueueCounters[uQueId].uDroppedPacket++;
#endif /* TI_DBG */
}
context_LeaveCriticalSection (pTxDataQ->hContext);
#ifdef TI_DBG
pTxDataQ->aQueueCounters[uQueId].uRequeuePacket++;
#endif /* TI_DBG */
continue;
}
/* If we reach this point, a packet was sent successfully so reset the idle iterations counter. */
uIdleIterationsCount = 0;
#ifdef TI_DBG
pTxDataQ->aQueueCounters[uQueId].uXmittedPacket++;
#endif /* TI_DBG */
} /* End of while */
/* Unreachable code */
}
/**
* \fn txDataQ_UpdateQueuesBusyState
* \brief Update queues' busy state
*
* Update the Queues Mode to Busy according to the input TidBitMap.
* Each Tid that is set indicates that the related Queue is Busy.
*
* \note
* \param hTxDataQ - The object
* \param uTidBitMap - The changed TIDs busy bitmap
* \return void
* \sa
*/
static void txDataQ_UpdateQueuesBusyState (TTxDataQ *pTxDataQ, TI_UINT32 uTidBitMap)
{
TI_UINT32 uTidIdx;
/* Go over the TidBitMap and update the related queue busy state */
for (uTidIdx = 0; uTidIdx < MAX_NUM_OF_802_1d_TAGS; uTidIdx++, uTidBitMap >>= 1)
{
if (uTidBitMap & 0x1) /* this Tid is busy */
{
pTxDataQ->aQueueBusy[aTidToQueueTable[uTidIdx]] = TI_TRUE;
}
else
{
pTxDataQ->aQueueBusy[aTidToQueueTable[uTidIdx]] = TI_FALSE;
}
}
}
/*
* \brief Handle Tx-Send-Pacing timeout.
*
* \param hTxDataQ - Module handle
* \param bTwdInitOccured - Indicate if TWD restart (recovery) occured
* \return void
*
* \par Description
* Call the Tx scheduler to handle the queued packets.
*
* \sa
*/
static void txDataQ_TxSendPaceTimeout (TI_HANDLE hTxDataQ, TI_BOOL bTwdInitOccured)
{
TTxDataQ *pTxDataQ = (TTxDataQ *)hTxDataQ;
pTxDataQ->uTxSendPaceTimeoutsCount++;
txDataQ_RunScheduler (hTxDataQ);
}