path: root/wl1271/stad/src/Data_link/txDataQueue.c

/*
 * txDataQueue.c
 *
 * Copyright(c) 1998 - 2009 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);
}