/*
 * txCtrl.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.
 */

/*******************************************************************************/
/*                                                                             */
/*      MODULE: txCtrl.c                                                       */
/*    PURPOSE:  The central Tx path module.                                    */
/*              Prepares Tx packets sent from the data-queue and mgmt-queue    */
/*                for copy to the FW, including building the header and the    */
/*                Tx-descriptor.                                               */
/*                                                                             */
/*******************************************************************************/
#define __FILE_ID__  FILE_ID_56
#include "tidef.h"
#include "paramOut.h"
#include "osApi.h"
#include "TWDriver.h"
#include "DataCtrl_Api.h"
#include "802_11Defs.h"
#include "Ethernet.h"
#include "report.h"
#include "timer.h"
#include "TI_IPC_Api.h"
#include "EvHandler.h"
#include "qosMngr_API.h"
#include "healthMonitor.h"
#include "txCtrl.h"
#include "txCtrl_Api.h"
#include "DrvMainModules.h"
#ifdef XCC_MODULE_INCLUDED
#include "XCCMngr.h"
#endif
#include "bmtrace_api.h"


/* 
 * Module internal functions prototypes:
 */

/* Note: put here and not in txCtrl.h to avoid warning in the txCtrl submodules that include txCtrl.h */ 
 
static void   txCtrl_TxCompleteCb (TI_HANDLE hTxCtrl, TxResultDescriptor_t *pTxResultInfo);
static void   txCtrl_BuildDataPkt (txCtrl_t *pTxCtrl, TTxCtrlBlk *pPktCtrlBlk,
                                   TI_UINT32 uAc, TI_UINT32 uBackpressure);
static void	  txCtrl_BuildMgmtPkt (txCtrl_t *pTxCtrl, TTxCtrlBlk *pPktCtrlBlk, TI_UINT32 uAc);
static void   txCtrl_UpdateHighestAdmittedAcTable (txCtrl_t *pTxCtrl);
static void   txCtrl_UpdateAcToTidMapping (txCtrl_t *pTxCtrl);
static void   txCtrl_UpdateBackpressure (txCtrl_t *pTxCtrl, TI_UINT32 freedAcBitmap);
static void   txCtrl_UpdateTxCounters (txCtrl_t *pTxCtrl, 
                                       TxResultDescriptor_t *pTxResultInfo,
                                       TTxCtrlBlk *pPktCtrlBlk, 
                                       TI_UINT32 ac, 
                                       TI_BOOL bIsDataPkt);
#ifdef XCC_MODULE_INCLUDED  /* Needed only for XCC-V4 */
static void   txCtrl_SetTxDelayCounters (txCtrl_t *pTxCtrl, 
                                         TI_UINT32 ac, 
                                         TI_UINT32 fwDelay, 
                                         TI_UINT32 driverDelay, 
                                         TI_UINT32 mediumDelay);
#endif /* XCC_MODULE_INCLUDED */


/********************************************************************************
*																				*
*                       MACROS and INLINE FUNCTIONS           					*
*																				*
*********************************************************************************/
/* Get the highest admitted AC equal or below the requested one. */
/* AC to TID translation is bivalent so update TID only if the AC was changed. */
#define SELECT_AC_FOR_TID(ptc,tid,ac)                      \
	ac = ptc->highestAdmittedAc[WMEQosTagToACTable[tid]];  \
    if (ac != WMEQosTagToACTable[tid])                     \
		tid = WMEQosAcToTid[ac]

/* Update packet length in the descriptor according to HW interface requirements */
static inline TI_UINT16 txCtrl_TranslateLengthToFw (TTxCtrlBlk *pPktCtrlBlk)
{
    TI_UINT16 uPktLen = pPktCtrlBlk->tTxDescriptor.length;
    TI_UINT16 uLastWordPad;
    TI_UINT32 uBufNum;

    uPktLen = (uPktLen + 3) & 0xFFFC;                               /* Add alignment bytes if needed */
    uLastWordPad = uPktLen - pPktCtrlBlk->tTxDescriptor.length;     /* Find number of alignment bytes added */
    uPktLen = uPktLen >> 2;                                         /* Convert length to words */
	pPktCtrlBlk->tTxDescriptor.length = ENDIAN_HANDLE_WORD(uPktLen);/* Save FW format length in descriptor */

    /* Find last buffer (last buffer in use is pointed by uBufNum-1) */
    for (uBufNum = 1; uBufNum < MAX_XFER_BUFS; uBufNum++) 
    {
        if (pPktCtrlBlk->tTxnStruct.aLen[uBufNum] == 0)
        {
            break;
        }
    }
    /* Add last word alignment pad also to the last buffer length */
    pPktCtrlBlk->tTxnStruct.aLen[uBufNum - 1] += uLastWordPad;
    
    return uLastWordPad;
}

/* Translate packet timestamp to FW time, and update also lifeTime and uDriverDelay */
static inline void txCtrl_TranslateTimeToFw (txCtrl_t *pTxCtrl, TTxCtrlBlk *pPktCtrlBlk, TI_UINT16 uLifeTime)
{
    TI_UINT32 uPktStartTime = pPktCtrlBlk->tTxDescriptor.startTime;  /* Contains host start time */

    /* Save host packet handling time until this point (for statistics) */
    pPktCtrlBlk->tTxPktParams.uDriverDelay = os_timeStampMs (pTxCtrl->hOs) - uPktStartTime;

    /* Translate packet timestamp to FW time and undate descriptor */
    uPktStartTime = TWD_TranslateToFwTime (pTxCtrl->hTWD, uPktStartTime); 
	pPktCtrlBlk->tTxDescriptor.startTime = ENDIAN_HANDLE_LONG (uPktStartTime);
	pPktCtrlBlk->tTxDescriptor.lifeTime  = ENDIAN_HANDLE_WORD (uLifeTime);
}


/********************************************************************************
*																				*
*                       PUBLIC  FUNCTIONS  IMPLEMENTATION						*
*																				*
*********************************************************************************/

/*************************************************************************
*                        txCtrl_Create                                   *
**************************************************************************
* DESCRIPTION:  This function initializes the Tx module.
*
* INPUT:        hOs - handle to Os Abstraction Layer
*
* OUTPUT:
*
* RETURN:       Handle to the allocated Tx data control block
*************************************************************************/
TI_HANDLE txCtrl_Create (TI_HANDLE hOs)
{
	txCtrl_t *pTxCtrl;

	/* allocate Tx module control block */
	pTxCtrl = os_memoryAlloc(hOs, (sizeof(txCtrl_t)));

	if (!pTxCtrl)
		return NULL;

	/* reset tx control object */
	os_memoryZero(hOs, pTxCtrl, (sizeof(txCtrl_t)));

	pTxCtrl->TxEventDistributor = DistributorMgr_Create(hOs, MAX_TX_NOTIF_REQ_ELMENTS);

	pTxCtrl->hOs = hOs;

	return pTxCtrl;
}


/***************************************************************************
*                           txCtrl_Init                                  *
****************************************************************************
* DESCRIPTION:  This function configures the TxCtrl module.
***************************************************************************/
void txCtrl_Init (TStadHandlesList *pStadHandles)
{
	txCtrl_t *pTxCtrl = (txCtrl_t *)(pStadHandles->hTxCtrl);
	TI_UINT32 ac;

	/* Save other modules handles */
	pTxCtrl->hOs			= pStadHandles->hOs;
	pTxCtrl->hReport		= pStadHandles->hReport;
	pTxCtrl->hCtrlData		= pStadHandles->hCtrlData;
	pTxCtrl->hTWD		    = pStadHandles->hTWD;
	pTxCtrl->hTxDataQ	    = pStadHandles->hTxDataQ;
	pTxCtrl->hTxMgmtQ	    = pStadHandles->hTxMgmtQ;
	pTxCtrl->hEvHandler		= pStadHandles->hEvHandler;
	pTxCtrl->hHealthMonitor = pStadHandles->hHealthMonitor;
	pTxCtrl->hTimer         = pStadHandles->hTimer;
	pTxCtrl->hStaCap        = pStadHandles->hStaCap;
	pTxCtrl->hXCCMngr       = pStadHandles->hXCCMngr;
	pTxCtrl->hQosMngr       = pStadHandles->hQosMngr;
	pTxCtrl->hRxData        = pStadHandles->hRxData;

	/* Set Tx parameters to defaults */
	pTxCtrl->headerConverMode = HDR_CONVERT_NONE;
	pTxCtrl->currentPrivacyInvokedMode = DEF_CURRENT_PRIVACY_MODE;
	pTxCtrl->eapolEncryptionStatus = DEF_EAPOL_ENCRYPTION_STATUS;
	pTxCtrl->encryptionFieldSize = 0;
	pTxCtrl->currBssType = BSS_INFRASTRUCTURE;
	pTxCtrl->busyAcBitmap = 0;
	pTxCtrl->dbgPktSeqNum = 0;		
	pTxCtrl->bCreditCalcTimerRunning = TI_FALSE;
	pTxCtrl->genericEthertype = ETHERTYPE_EAPOL;

	for (ac = 0; ac < MAX_NUM_OF_AC; ac++)
	{
		pTxCtrl->aMsduLifeTimeTu[ac] = MGMT_PKT_LIFETIME_TU;
		pTxCtrl->ackPolicy[ac] = ACK_POLICY_LEGACY;
		pTxCtrl->admissionState[ac] = AC_ADMITTED;
		pTxCtrl->admissionRequired[ac] = ADMISSION_NOT_REQUIRED;
		pTxCtrl->useAdmissionAlgo[ac] = TI_FALSE;
		pTxCtrl->mediumTime[ac] = 0;
		pTxCtrl->lastCreditCalcTimeStamp[ac] = 0;
		pTxCtrl->credit[ac] = 0;
	}

	/* Reset counters */
	txCtrlParams_resetCounters (pStadHandles->hTxCtrl);

#ifdef TI_DBG
	txCtrlParams_resetDbgCounters (pStadHandles->hTxCtrl);
#endif

	/* Register the Tx-Complete callback function. */
	TWD_RegisterCb (pTxCtrl->hTWD, 
			TWD_EVENT_TX_RESULT_SEND_PKT_COMPLETE, 
			(void*)txCtrl_TxCompleteCb, 
			pStadHandles->hTxCtrl);

	/* Register the Update-Busy-Map callback function. */
	TWD_RegisterCb (pTxCtrl->hTWD, 
			TWD_EVENT_TX_HW_QUEUE_UPDATE_BUSY_MAP, 
			(void *)txCtrl_UpdateBackpressure, 
			pStadHandles->hTxCtrl);

	TRACE0(pTxCtrl->hReport, REPORT_SEVERITY_INIT, ".....Tx Data configured successfully\n");
}


/*************************************************************************
*                        txCtrl_SetDefaults                                   *
**************************************************************************
* DESCRIPTION:  
*
* INPUT:        
*               txDataInitParams - Tx Data creation parameters
*               
* OUTPUT:
*
* RETURN:       
*************************************************************************/
TI_STATUS txCtrl_SetDefaults (TI_HANDLE hTxCtrl, txDataInitParams_t *txDataInitParams)
{
	txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;

	pTxCtrl->creditCalculationTimeout = txDataInitParams->creditCalculationTimeout;
	pTxCtrl->bCreditCalcTimerEnabled  = txDataInitParams->bCreditCalcTimerEnabled;

	/* Update queues mapping (AC/TID/Backpressure) after module init. */
	txCtrl_UpdateQueuesMapping (hTxCtrl); 

	/* allocate timer for credit calculation */
	pTxCtrl->hCreditTimer = tmr_CreateTimer (pTxCtrl->hTimer);
	if (pTxCtrl->hCreditTimer == NULL)
	{
		TRACE0(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, "txCtrl_SetDefaults(): Failed to create hCreditTimer!\n");
		return TI_NOK;
	}

	return TI_OK;
}


/***************************************************************************
*                           txCtrl_Unload                                  *
****************************************************************************
* DESCRIPTION:  This function unload the tx ctrl module. 
*
***************************************************************************/
TI_STATUS txCtrl_Unload (TI_HANDLE hTxCtrl)
{
    txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;

    if (pTxCtrl == NULL)
    {
        return TI_NOK;
    }

    DistributorMgr_Destroy (pTxCtrl->TxEventDistributor);

	if (pTxCtrl->hCreditTimer)
	{
		tmr_DestroyTimer (pTxCtrl->hCreditTimer);
	}

    /* free Tx Data control block */
    os_memoryFree (pTxCtrl->hOs, pTxCtrl, sizeof(txCtrl_t));

    return TI_OK;
}


/*******************************************************************************
*                          txCtrl_XmitData		                               *
********************************************************************************
* DESCRIPTION:  Get a packet from the data-queue, allocate HW resources and CtrlBlk,
*				  build header and descriptor, and send it to HW by TxXfer.
*
* RETURNS:      STATUS_XMIT_SUCCESS - Packet sent succesfully
*				STATUS_XMIT_BUSY    - Packet dropped due to lack of HW resources, retransmit later.
*				STATUS_XMIT_ERROR   - Packet dropped due to an unexpected problem (bug).
********************************************************************************/
TI_STATUS txCtrl_XmitData (TI_HANDLE hTxCtrl, TTxCtrlBlk *pPktCtrlBlk)
{
    txCtrl_t   *pTxCtrl = (txCtrl_t *)hTxCtrl;
	ETxnStatus eStatus;       /* The Xfer return value (different than this function's return values). */
	TI_UINT32  uAc;
	TI_UINT32  uBackpressure = 0; /* HwQueue's indication when the current queue becomes busy. */
    ETxHwQueStatus eHwQueStatus;
	CL_TRACE_START_L3();
    
	/* Get an admitted AC corresponding to the packet TID. 
	 * If downgraded due to admission limitation, the TID is downgraded as well. 
	 */
	SELECT_AC_FOR_TID (pTxCtrl, pPktCtrlBlk->tTxDescriptor.tid, uAc);

#ifdef TI_DBG
TRACE3(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_XmitData(): Pkt Tx, DescID=%d, AC=%d, Len=%d\n", pPktCtrlBlk->tTxDescriptor.descID, uAc, pPktCtrlBlk->tTxDescriptor.length );

	pTxCtrl->dbgCounters.dbgNumPktsSent[uAc]++;
#endif

	/* Call TxHwQueue for Hw resources allocation. */
	{
		CL_TRACE_START_L4();
		eHwQueStatus = TWD_txHwQueue_AllocResources (pTxCtrl->hTWD, pPktCtrlBlk);
		CL_TRACE_END_L4("tiwlan_drv.ko", "INHERIT", "TX", ".allocResources");
	}

	/* If the current AC can't get more packets, stop it in data-queue module. */
	if (eHwQueStatus == TX_HW_QUE_STATUS_STOP_NEXT)
	{
#ifdef TI_DBG
		pTxCtrl->dbgCounters.dbgNumPktsBackpressure[uAc]++;
        TRACE2(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_XmitData(): Backpressure = 0x%x, queue = %d\n", uBackpressure, uAc);
#endif
        uBackpressure = 1 << uAc;
		pTxCtrl->busyAcBitmap |= uBackpressure; /* Set the busy bit of the current AC. */
		txDataQ_StopQueue (pTxCtrl->hTxDataQ, pTxCtrl->admittedAcToTidMap[uAc]);
	}

	/* If current packet can't be transmitted due to lack of resources, return with BUSY value. */
	else if (eHwQueStatus == TX_HW_QUE_STATUS_STOP_CURRENT)
	{
#ifdef TI_DBG
		pTxCtrl->dbgCounters.dbgNumPktsBusy[uAc]++;
        TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_XmitData(): Queue busy - Packet dropped, queue = %d\n", uAc);
#endif
		txDataQ_StopQueue (pTxCtrl->hTxDataQ, pTxCtrl->admittedAcToTidMap[uAc]);
		CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "TX", "");
		return STATUS_XMIT_BUSY;
	}
	
	/* Prepare the packet control-block including the Tx-descriptor. */
	{
		CL_TRACE_START_L4();
		txCtrl_BuildDataPkt(pTxCtrl, pPktCtrlBlk, uAc, uBackpressure);
		CL_TRACE_END_L4("tiwlan_drv.ko", "INHERIT", "TX", ".FillCtrlBlk");
	}

	/* Call the Tx-Xfer to start packet transfer to the FW and return its result. */
	{
		CL_TRACE_START_L4();
		eStatus = TWD_txXfer_SendPacket (pTxCtrl->hTWD, pPktCtrlBlk);
		CL_TRACE_END_L4("tiwlan_drv.ko", "INHERIT", "TX", ".XferSendPacket");
	}

	if (eStatus == TXN_STATUS_ERROR)
	{
#ifdef TI_DBG  
TRACE2(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, "txCtrl_XmitData(): Xfer Error, queue = %d, Status = %d\n", uAc, eStatus);
		pTxCtrl->dbgCounters.dbgNumPktsError[uAc]++;	
#endif

		/* Free the packet resources (packet and CtrlBlk)  */
        txCtrl_FreePacket (pTxCtrl, pPktCtrlBlk, TI_NOK);

		CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "TX", "");
		return STATUS_XMIT_ERROR;
	}

#ifdef TI_DBG  
    pTxCtrl->dbgCounters.dbgNumPktsSuccess[uAc]++;	
#endif
    CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "TX", "");
    return STATUS_XMIT_SUCCESS;
}


/*******************************************************************************
*                          txCtrl_XmitMgmt		                               *
********************************************************************************
* DESCRIPTION:  Get a packet from the Mgmt-Queue (management, EAPOL or IAPP), 
*				  allocate HW resources and CtrlBlk, build header if Ethernet (EAPOL),
*				  build descriptor, and send packet to HW by TxXfer.
*
* RETURNS:      STATUS_XMIT_SUCCESS - Packet sent succesfully.
*				STATUS_XMIT_BUSY - Packet dropped due to lack of HW resources, retransmit later.
*				STATUS_XMIT_ERROR - Packet dropped due to an unexpected problem (bug).
********************************************************************************/
TI_STATUS txCtrl_XmitMgmt (TI_HANDLE hTxCtrl, TTxCtrlBlk *pPktCtrlBlk)
{
    txCtrl_t   *pTxCtrl = (txCtrl_t *)hTxCtrl;
	ETxnStatus eStatus;      /* The Xfer return value (different than this function's return values). */
	TI_UINT32  uAc;  /* The AC selected for the packet transmission. */
	TI_UINT32  uBackpressure = 0;/* HwQueue's indication when the current queue becomes busy. */
    ETxHwQueStatus eHwQueStatus;

	/* Get an admitted AC corresponding to the packet TID. 
	 * If downgraded due to admission limitation, the TID is downgraded as well. 
	 */
	SELECT_AC_FOR_TID (pTxCtrl, pPktCtrlBlk->tTxDescriptor.tid, uAc);

#ifdef TI_DBG
	pTxCtrl->dbgCounters.dbgNumPktsSent[uAc]++;
#endif

	/* Call TxHwQueue for Hw resources allocation. */
   	eHwQueStatus = TWD_txHwQueue_AllocResources (pTxCtrl->hTWD, pPktCtrlBlk);

	/* If the used AC can't get more packets, stop it in mgmt-queue module. */
	if (eHwQueStatus == TX_HW_QUE_STATUS_STOP_NEXT)
	{
#ifdef TI_DBG
		pTxCtrl->dbgCounters.dbgNumPktsBackpressure[uAc]++;
        TRACE2(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_XmitMgmt(): Backpressure = 0x%x, queue = %d\n", uBackpressure, uAc);
#endif
        uBackpressure = 1 << uAc;
		pTxCtrl->busyAcBitmap |= uBackpressure; /* Set the busy bit of the current AC. */
		txMgmtQ_StopQueue (pTxCtrl->hTxMgmtQ, pTxCtrl->admittedAcToTidMap[uAc]);
	}

	/* If current packet can't be transmitted due to lack of resources, return with BUSY value. */
	else if (eHwQueStatus == TX_HW_QUE_STATUS_STOP_CURRENT)
	{
#ifdef TI_DBG
		pTxCtrl->dbgCounters.dbgNumPktsBusy[uAc]++;
        TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_XmitMgmt(): Queue busy - Packet dropped, queue = %d\n", uAc);
#endif
		txMgmtQ_StopQueue (pTxCtrl->hTxMgmtQ, pTxCtrl->admittedAcToTidMap[uAc]);
		return STATUS_XMIT_BUSY;
	}
	
	/* Prepare the packet control-block including the Tx-descriptor. */
	txCtrl_BuildMgmtPkt (pTxCtrl, pPktCtrlBlk, uAc);
    
	/* Call the Tx-Xfer to start packet transfer to the FW and return the result. */
	eStatus = TWD_txXfer_SendPacket (pTxCtrl->hTWD, pPktCtrlBlk);

	if (eStatus == TXN_STATUS_ERROR)
	{
#ifdef TI_DBG  
TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, "txCtrl_XmitMgmt(): Xfer Error, Status = %d\n", eStatus);
		pTxCtrl->dbgCounters.dbgNumPktsError[uAc]++;	
#endif
		/* Free the packet resources (packet and CtrlBlk)  */
        txCtrl_FreePacket (pTxCtrl, pPktCtrlBlk, TI_NOK);
		return STATUS_XMIT_ERROR;
	}

#ifdef TI_DBG  
    pTxCtrl->dbgCounters.dbgNumPktsSuccess[uAc]++;	
#endif
    return STATUS_XMIT_SUCCESS;
}


/***************************************************************************
*                           txCtrl_UpdateQueuesMapping 
****************************************************************************
* DESCRIPTION:  This function should be called upon the following events:
*					1) Init
*					2) ACs admission required change (upon association)
*					3) ACs admission state change (upon association and add/delete Tspec).
*				It updates the following mappings (by this oredr!):
*					1) Update mapping from requested-AC to highest-admitted-AC.
*					2) Update mapping from actual-AC to requested-TID (for backpressure mapping).
*					3) Update TID-backpressure bitmap, and if changed update data-queue and mgmt-queue.
*
***************************************************************************/
void txCtrl_UpdateQueuesMapping (TI_HANDLE hTxCtrl)
{
	txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
	
	/* Update mapping from requested-AC to highest-admitted-AC. */
	txCtrl_UpdateHighestAdmittedAcTable (pTxCtrl);

	/* Update mapping from actual-AC to requested-TID (for backpressure mapping). */
	txCtrl_UpdateAcToTidMapping (pTxCtrl);

	/* Update TID-backpressure bitmap, and if changed update data-queue and mgmt-queue. */
	txCtrl_UpdateBackpressure (pTxCtrl, 0);
}


/***************************************************************************
*                           txCtrl_AllocPacketBuffer
****************************************************************************
* DESCRIPTION:  Allocate a raw buffer for the whole Tx packet.
                Used for driver generated packets and when the OAL needs to 
                    copy the packet to a new buffer (e.g. to gather multiple buffers). 
***************************************************************************/
void *txCtrl_AllocPacketBuffer (TI_HANDLE hTxCtrl, TTxCtrlBlk *pPktCtrlBlk, TI_UINT32 uPacketLen)
{
    txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
    void     *pRawBuf = os_memoryAlloc (pTxCtrl->hOs, uPacketLen);

    if (pRawBuf) 
    {
        /* Indicate that the packet is in a raw buffer (i.e. not OS packet) and save its address and length */
        pPktCtrlBlk->tTxPktParams.uFlags |= TX_CTRL_FLAG_PKT_IN_RAW_BUF;
        
        /* Save buffer address and length for the free operation */
        pPktCtrlBlk->tTxPktParams.pInputPkt    = pRawBuf;
        pPktCtrlBlk->tTxPktParams.uInputPktLen = uPacketLen;
        
        TRACE2(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_AllocPacketBuffer(): pRawBuf = 0x%x, uPacketLen = %d\n", pRawBuf, uPacketLen);
    } 
    else 
    {
        TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, "txCtrl_AllocPacketBuffer(): uPacketLen = %d, returning NULL\n", uPacketLen);
    }

    return pRawBuf;
}


/***************************************************************************
*                           txCtrl_FreePacket 
****************************************************************************
* DESCRIPTION:  Free the packet resources, including the packet and the CtrlBlk 
***************************************************************************/
void txCtrl_FreePacket (TI_HANDLE hTxCtrl, TTxCtrlBlk *pPktCtrlBlk, TI_STATUS eStatus)
{
    txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;

    TRACE3(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_FreePacket(): RawBufFlag = 0x%x, pBuf = 0x%x, Len = %d\n", (pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_PKT_IN_RAW_BUF), pPktCtrlBlk->tTxPktParams.pInputPkt, pPktCtrlBlk->tTxPktParams.uInputPktLen);

    /* If the packet is in a raw buffer, free its memory */
    if (pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_PKT_IN_RAW_BUF)
    {
        os_memoryFree (pTxCtrl->hOs, 
                       pPktCtrlBlk->tTxPktParams.pInputPkt, 
                       pPktCtrlBlk->tTxPktParams.uInputPktLen);
    }
    /* If the original packet is in OS format, call the OAL to free it */
    else 
    {
        wlanDrvIf_FreeTxPacket (pTxCtrl->hOs, pPktCtrlBlk, eStatus);
    }

    /* Free the CtrlBlk */
    TWD_txCtrlBlk_Free (pTxCtrl->hTWD, pPktCtrlBlk);
}


/********************************************************************************
*																				*
*                       LOCAL  FUNCTIONS  IMPLEMENTATION						*
*																				*
*********************************************************************************/


/*************************************************************************
*                        txCtrl_TxCompleteCb		                             *
**************************************************************************
* DESCRIPTION:  Called by the TWD upon Tx-complete of one packet.
*				Handle packet result:
*				- Update counters (statistics and medium-usage)
*				- Free the packet resources (Wbuf and CtrlBlk)
*
* INPUT:    hTWD -  The Tnetw-Driver handle.
*		    pTxResultInfo - The packet's Tx result information.   
*              
*************************************************************************/
static void txCtrl_TxCompleteCb (TI_HANDLE hTxCtrl, TxResultDescriptor_t *pTxResultInfo)
{
    txCtrl_t    *pTxCtrl = (txCtrl_t *)hTxCtrl;
	TTxCtrlBlk  *pPktCtrlBlk;
	TI_UINT32	ac;
	TI_BOOL	    bIsDataPkt;
	CL_TRACE_START_L3();

	/* Get packet ctrl-block by desc-ID. */
	pPktCtrlBlk = TWD_txCtrlBlk_GetPointer (pTxCtrl->hTWD, pTxResultInfo->descID);
	ac = WMEQosTagToACTable[pPktCtrlBlk->tTxDescriptor.tid];

#ifdef TI_DBG
	/* If the pointed entry is already free, print error and exit (not expected to happen). */
	if (pPktCtrlBlk->pNextFreeEntry != NULL)
	{
TRACE2(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, "txCtrl_TxCompleteCb(): Pkt already free!!, DescID=%d, AC=%d\n", pTxResultInfo->descID, ac);
		CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "TX_Cmplt", "");
		return;
	}
TRACE3(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_TxCompleteCb(): Pkt Tx Complete, DescID=%d, AC=%d, Status=%d\n", pTxResultInfo->descID, ac, pTxResultInfo->status);
#endif
	/* Update the TKIP/AES sequence-number according to the Tx data packet security-seq-num. */
	/* Note: The FW always provides the last used seq-num so no need to check if the current 
			 packet is data and WEP is on. */
	TWD_SetSecuritySeqNum (pTxCtrl->hTWD, pTxResultInfo->lsbSecuritySequenceNumber);

	bIsDataPkt = ( (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_ETHER) || 
		           (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_WLAN_DATA) );

#ifdef XCC_MODULE_INCLUDED    
	/* If it's a XCC link-test packet, call its handler. */
	if (pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_LINK_TEST)
    {
        CL_TRACE_START_L4();
        XCCMngr_LinkTestRetriesUpdate (pTxCtrl->hXCCMngr, pTxResultInfo->ackFailures);
        CL_TRACE_END_L4("tiwlan_drv.ko", "INHERIT", "TX_Cmplt", ".XCCLinkTest");
    }
#endif

	/* Add the medium usage time for the specific queue. */
	pTxCtrl->totalUsedTime[ac] += (TI_UINT32)ENDIAN_HANDLE_WORD(pTxResultInfo->mediumUsage);

	/* update TX counters for txDistributer */
    {
        CL_TRACE_START_L4();
        txCtrl_UpdateTxCounters (pTxCtrl, pTxResultInfo, pPktCtrlBlk, ac, bIsDataPkt);
        CL_TRACE_END_L4("tiwlan_drv.ko", "INHERIT", "TX_Cmplt", ".Cntrs");
    }

	/* Free the packet resources (packet and CtrlBlk)  */
    txCtrl_FreePacket (pTxCtrl, pPktCtrlBlk, TI_OK);

	CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "TX_Cmplt", "");
}


/***************************************************************************
*                   txCtrl_BuildDataPktHdr                                 *
****************************************************************************
* DESCRIPTION:  this function builds the WLAN header from ethernet format, 
*               including 802.11-MAC, LLC/SNAP, security padding, alignment padding.
*
* INPUTS:       hTxCtrl - the object
*               pPktCtrlBlk - data packet control block (Ethernet header)
*
* RETURNS:      uHdrAlignPad - Num of bytes (0 or 2) added at the header's beginning for 4-bytes alignment.
***************************************************************************/

TI_UINT32 txCtrl_BuildDataPktHdr (TI_HANDLE hTxCtrl, TTxCtrlBlk *pPktCtrlBlk, AckPolicy_e eAckPolicy)
{
    txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;    
    TEthernetHeader     *pEthHeader;
    dot11_header_t      *pDot11Header;
    Wlan_LlcHeader_T    *pWlanSnapHeader;
	EHeaderConvertMode	eQosMode = pTxCtrl->headerConverMode;
	TI_UINT32			uHdrLen = 0;
	TI_UINT32			uHdrAlignPad = 0;
	TI_UINT16			uQosControl;
	TI_UINT16			fc = 0;
 	TI_UINT16           typeLength;


	/* 
	 * Handle encryption if needed, for data or EAPOL (decision was done at RSN):
	 *   - Set WEP bit in header.
	 *   - Add padding for FW security overhead: 4 bytes for TKIP, 8 for AES.
	 */

       	if (( (pPktCtrlBlk->tTxPktParams.uPktType == TX_PKT_TYPE_EAPOL)
			  &&
			  pTxCtrl->eapolEncryptionStatus) 
		 ||
			((pPktCtrlBlk->tTxPktParams.uPktType != TX_PKT_TYPE_EAPOL)
			  &&
			  pTxCtrl->currentPrivacyInvokedMode ))
        {
			fc |= DOT11_FC_WEP;
			uHdrLen += pTxCtrl->encryptionFieldSize;
			uHdrAlignPad = pTxCtrl->encryptionFieldSize % 4;
	}

	/*
	 * Handle QoS if needed:
	 */
    if (eQosMode == HDR_CONVERT_QOS)
	{
		uHdrAlignPad = (uHdrAlignPad + HEADER_PAD_SIZE) % 4; /* Add 2 bytes pad at the header beginning for 4 bytes alignment. */
		pDot11Header = (dot11_header_t *)&(pPktCtrlBlk->aPktHdr[uHdrAlignPad]);
		uHdrLen += WLAN_QOS_HDR_LEN;

        /* add empty 4Byte for HT control field set via the FW */
        if (pTxCtrl->tTxCtrlHtControl.bHtEnable == TI_TRUE)
        {
            uHdrLen += WLAN_QOS_HT_CONTROL_FIELD_LEN;
            fc |= DOT11_FC_ORDER;
        }

		/* Set Qos control fields. */
		uQosControl = (TI_UINT16)(pPktCtrlBlk->tTxDescriptor.tid); 
		if ( TI_UNLIKELY(eAckPolicy == ACK_POLICY_NO_ACK) )
			uQosControl |= DOT11_QOS_CONTROL_DONT_ACK;
		COPY_WLAN_WORD(&pDot11Header->qosControl, &uQosControl); /* copy with endianess handling. */
	}
	else  /* No QoS (legacy header, padding is not needed). */
	{
		pDot11Header = (dot11_header_t *)&(pPktCtrlBlk->aPktHdr[uHdrAlignPad]);
		uHdrLen += WLAN_HDR_LEN;
	}
	uHdrLen += uHdrAlignPad;

    /* Before the header translation the first buf-pointer points to the Ethernet header. */	
	pEthHeader = (TEthernetHeader *)(pPktCtrlBlk->tTxnStruct.aBuf[0]);

    if (TI_UNLIKELY(MAC_MULTICAST(pEthHeader->dst)))
    {
        pPktCtrlBlk->tTxPktParams.uFlags |= TX_CTRL_FLAG_MULTICAST;
        if (MAC_BROADCAST(pEthHeader->dst))
        {
            pPktCtrlBlk->tTxPktParams.uFlags |= TX_CTRL_FLAG_BROADCAST;
        }
    }

	/* Set MAC header fields for Independent-BSS case. */
    if ( TI_UNLIKELY(pTxCtrl->currBssType == BSS_INDEPENDENT) )
    {
        MAC_COPY (pDot11Header->address1, pEthHeader->dst);
        MAC_COPY (pDot11Header->address2, pEthHeader->src);
        MAC_COPY (pDot11Header->address3, pTxCtrl->currBssId);

        if (eQosMode == HDR_CONVERT_QOS)
            fc |= DOT11_FC_DATA_QOS;
        else
            fc |= DOT11_FC_DATA;
    }

	/* Set MAC header fields for Infrastructure-BSS case. */
    else
    {
        MAC_COPY (pDot11Header->address1, pTxCtrl->currBssId);
        MAC_COPY (pDot11Header->address2, pEthHeader->src);
        MAC_COPY (pDot11Header->address3, pEthHeader->dst);

        if (eQosMode == HDR_CONVERT_QOS)
            fc |= DOT11_FC_DATA_QOS | DOT11_FC_TO_DS;
        else
            fc |= DOT11_FC_DATA | DOT11_FC_TO_DS;
    }

	COPY_WLAN_WORD(&pDot11Header->fc, &fc); /* copy with endianess handling. */
	
    /* Set the SNAP header pointer right after the other header parts handled above. */
    pWlanSnapHeader = (Wlan_LlcHeader_T *)&(pPktCtrlBlk->aPktHdr[uHdrLen]);
    
	typeLength = HTOWLANS(pEthHeader->type);

    /* Detect the packet type and decide if to create a     */
    /*          new SNAP or leave the original LLC.         */
    /*------------------------------------------------------*/
   	if( typeLength > ETHERNET_MAX_PAYLOAD_SIZE )
    {
        /* Create the SNAP Header:     */
        /*-----------------------------*/
        /*
         * Make a working copy of the SNAP header
         * initialised to zero
         */
		
        pWlanSnapHeader->DSAP = SNAP_CHANNEL_ID;
        pWlanSnapHeader->SSAP = SNAP_CHANNEL_ID;
        pWlanSnapHeader->Control = LLC_CONTROL_UNNUMBERED_INFORMATION;

        /* Check to see if the Ethertype matches anything in the translation     */
        /* table (Appletalk AARP or DixII/IPX).  If so, add the 802.1h           */
        /* SNAP.                                                                 */

        if(( ETHERTYPE_APPLE_AARP == typeLength ) ||
           ( ETHERTYPE_DIX_II_IPX == typeLength ))
        {
            /* Fill out the SNAP Header with 802.1H extention   */
            pWlanSnapHeader->OUI[0] = SNAP_OUI_802_1H_BYTE0;
			pWlanSnapHeader->OUI[1] = SNAP_OUI_802_1H_BYTE1;
			pWlanSnapHeader->OUI[2] = SNAP_OUI_802_1H_BYTE2;

        }
        else
        {
            /* otherwise, add the RFC1042 SNAP   */
    		pWlanSnapHeader->OUI[0] = SNAP_OUI_RFC1042_BYTE0;
			pWlanSnapHeader->OUI[1] = SNAP_OUI_RFC1042_BYTE0;
			pWlanSnapHeader->OUI[2] = SNAP_OUI_RFC1042_BYTE0;
        }

        /* set type length */
        pWlanSnapHeader->Type = pEthHeader->type;
    
        /* Add the SNAP length to the total header length. */
        uHdrLen += sizeof(Wlan_LlcHeader_T);
    }

    /* Replace first buffer pointer and length to the descriptor and WLAN-header (instead of Ether header) */
    pPktCtrlBlk->tTxnStruct.aBuf[0] = (TI_UINT8 *)&(pPktCtrlBlk->tTxDescriptor);
    pPktCtrlBlk->tTxnStruct.aLen[0] = sizeof(TxIfDescriptor_t) + uHdrLen;
    pPktCtrlBlk->tTxDescriptor.length += pPktCtrlBlk->tTxnStruct.aLen[0] - ETHERNET_HDR_LEN;

	/* Return the number of bytes (0 or 2) added at the header's beginning for 4-bytes alignment. */
    return uHdrAlignPad;
}


/***************************************************************************
*                       txCtrl_BuildDataPkt                            
****************************************************************************
* DESCRIPTION:  Prepare the Data packet control-block including the Tx-descriptor.
***************************************************************************/
static void txCtrl_BuildDataPkt (txCtrl_t *pTxCtrl, TTxCtrlBlk *pPktCtrlBlk, 
                                 TI_UINT32 uAc, TI_UINT32 uBackpressure)
{
	TI_UINT32 uHdrAlignPad; /* Num of bytes added between Tx-descriptor and header for 4 bytes alignment (0 or 2). */
    TI_UINT16 uLastWordPad; /* Num of bytes added at the end of the packet for 4 bytes alignment */
	TI_UINT16 uTxDescAttr;
	AckPolicy_e eAckPolicy = pTxCtrl->ackPolicy[uAc];

	/* Build packet header (including MAC, LLC/SNAP, security padding, header alignment padding). */
    uHdrAlignPad = txCtrl_BuildDataPktHdr ((TI_HANDLE)pTxCtrl, pPktCtrlBlk, eAckPolicy);

	/* Update packet length in the descriptor according to HW interface requirements */
    uLastWordPad = txCtrl_TranslateLengthToFw (pPktCtrlBlk);

    /* Set the descriptor attributes */
	uTxDescAttr  = pTxCtrl->dataPktDescAttrib;
    uTxDescAttr |= uLastWordPad << TX_ATTR_OFST_LAST_WORD_PAD;
	uTxDescAttr |= pTxCtrl->dataRatePolicy[uAc] << TX_ATTR_OFST_RATE_POLICY;
	if (uHdrAlignPad)
	{
		uTxDescAttr |= TX_ATTR_HEADER_PAD;
	}
	if (uBackpressure)
    {
		uTxDescAttr |= TX_ATTR_TX_CMPLT_REQ;  /* Request immediate Tx-Complete from FW if the AC is busy */
    }
    if (TI_UNLIKELY(pTxCtrl->currBssType == BSS_INDEPENDENT) &&
        (pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_MULTICAST))
	{
        /* If packet is Broadcast in IBSS, overwrite rate policy with mgmt value. */
		uTxDescAttr &= ~TX_ATTR_RATE_POLICY;
		uTxDescAttr |= pTxCtrl->mgmtRatePolicy[uAc] << TX_ATTR_OFST_RATE_POLICY;
	}
	pPktCtrlBlk->tTxDescriptor.txAttr = ENDIAN_HANDLE_WORD(uTxDescAttr); 

    /* Translate packet timestamp to FW time (also updates lifeTime and driverHandlingTime) */
    txCtrl_TranslateTimeToFw (pTxCtrl, pPktCtrlBlk, pTxCtrl->aMsduLifeTimeTu[uAc]);

    /* Indicate that the packet is transfered to the FW, and the descriptor fields are in FW format! */
    pPktCtrlBlk->tTxPktParams.uFlags |= TX_CTRL_FLAG_SENT_TO_FW;

#ifdef TI_DBG  
	pTxCtrl->dbgPktSeqNum++;
	pTxCtrl->dbgCounters.dbgNumPktsXfered[uAc]++;	/* Count packets sent to Xfer. */
#endif
}


/***************************************************************************
*                       txCtrl_BuildMgmtPkt                            
****************************************************************************
* DESCRIPTION:  Prepare the Mgmt-Queue packet control-block including the Tx-descriptor.
***************************************************************************/
static void txCtrl_BuildMgmtPkt (txCtrl_t *pTxCtrl, TTxCtrlBlk *pPktCtrlBlk, TI_UINT32 uAc)
{
	TI_UINT32 uHdrAlignPad; /* Num of bytes added between Tx-descriptor and header for alignment (0 or 2). */
    TI_UINT16 uLastWordPad; /* Num of bytes added at the end of the packet for 4 bytes alignment */
	TI_UINT16 uTxDescAttr;
	TI_UINT16 uRatePolicy;
	TI_UINT8  uPktType = pPktCtrlBlk->tTxPktParams.uPktType;
	dot11_header_t *pDot11Header;
	
	/* If EAPOL packet (Ethernet), build header (including MAC,SNAP,security pad & alignment pad). */
	if (uPktType == TX_PKT_TYPE_EAPOL)
	{
        uHdrAlignPad = txCtrl_BuildDataPktHdr ((TI_HANDLE)pTxCtrl, pPktCtrlBlk, ACK_POLICY_LEGACY);

		uRatePolicy = pTxCtrl->dataRatePolicy[uAc];
	}

	/*  Other types are already in WLAN format so copy header from Wbuf to Ctrl-Blk. */
	else         
	{
		TI_UINT32 uHdrLen = pPktCtrlBlk->tTxnStruct.aLen[0];
		TI_UINT32 uHdrLenDelta; /* Add the header pad (2 bytes) and Tx-Descriptor length */

		/*  
         * Update the length fields to include the header pad and the Tx-Descriptor.
         * Note: The mgmt-queue provides the header length without the alignment pad, so if 
		 *       it's not 4-byte aligned, a 2-bytes pad was added at the header beginning. 
		 */
		uHdrAlignPad = (uHdrLen & ALIGN_4BYTE_MASK) ? HEADER_PAD_SIZE : 0;  
        uHdrLenDelta = uHdrAlignPad + sizeof(TxIfDescriptor_t);
        pPktCtrlBlk->tTxnStruct.aBuf[0]   -= uHdrLenDelta;
        pPktCtrlBlk->tTxnStruct.aLen[0]   += uHdrLenDelta;
        pPktCtrlBlk->tTxDescriptor.length += uHdrLenDelta;
		
		uRatePolicy = pTxCtrl->mgmtRatePolicy[uAc];

        if (uPktType == TX_PKT_TYPE_WLAN_DATA)  
		{
			/* If QoS mode, update TID in QoS header in case it was downgraded. */
			/* Note: Qos-hdr update for EAPOL is done in txCtrl_BuildDataPktHeader() and doesn't exist in mgmt. */
			if (pTxCtrl->headerConverMode == HDR_CONVERT_QOS)
			{
				TI_UINT16 tidWord = (TI_UINT16)pPktCtrlBlk->tTxDescriptor.tid;
				pDot11Header = (dot11_header_t *)&(pPktCtrlBlk->aPktHdr[uHdrAlignPad]);
				COPY_WLAN_WORD(&pDot11Header->qosControl, &tidWord); /* copy with endianess handling. */
			}
		}
	}

	/* Update packet length in the descriptor according to HW interface requirements */
    uLastWordPad = txCtrl_TranslateLengthToFw (pPktCtrlBlk);

	/* Set fields in the descriptor attributes bitmap. */
	uTxDescAttr  = uRatePolicy << TX_ATTR_OFST_RATE_POLICY;
	uTxDescAttr |= pTxCtrl->txSessionCount << TX_ATTR_OFST_SESSION_COUNTER;
    uTxDescAttr |= uLastWordPad << TX_ATTR_OFST_LAST_WORD_PAD;
	uTxDescAttr |= TX_ATTR_TX_CMPLT_REQ;
	if (uHdrAlignPad)
    {
		uTxDescAttr |= TX_ATTR_HEADER_PAD;
    }
	pPktCtrlBlk->tTxDescriptor.txAttr = ENDIAN_HANDLE_WORD(uTxDescAttr); 

    /* Translate packet timestamp to FW time (also updates lifeTime and driverHandlingTime) */
    txCtrl_TranslateTimeToFw (pTxCtrl, pPktCtrlBlk, MGMT_PKT_LIFETIME_TU);

    /* Indicate that the packet is transfered to the FW, and the descriptor fields are in FW format! */
    pPktCtrlBlk->tTxPktParams.uFlags |= TX_CTRL_FLAG_SENT_TO_FW;

#ifdef TI_DBG  
	pTxCtrl->dbgPktSeqNum++;
	pTxCtrl->dbgCounters.dbgNumPktsXfered[uAc]++;	/* Count packets sent to Xfer. */
#endif
}


/***************************************************************************
*                           txCtrl_UpdateHighestAdmittedAcTable 
****************************************************************************
* DESCRIPTION:  This function updates the table that provides for each requested AC  
*				  the highest AC that can be currently used, as follows:
*					If requested AC is admitted use it.
*					If not, find highest AC below it that doesn't require admission.
*				This function should be called opon the following events:
*					1) Init
*					2) ACs admission required change (upon association)
*					3) ACs admission state change (upon association and add/delete Tspec).
*
***************************************************************************/
static void txCtrl_UpdateHighestAdmittedAcTable (txCtrl_t *pTxCtrl)
{
	int			 inputIdx;
	int			 outputIdx;
	EAcTrfcType inputAc;
	EAcTrfcType outputAc; 
        
	/* Loop over all ACs in priority order (BE is higher priority than BK). */
	for (inputIdx = 0; inputIdx < MAX_NUM_OF_AC; inputIdx++)
	{
		inputAc = priorityOrderedAc[inputIdx];

		/* If input AC is admitted, use it. */
		if(pTxCtrl->admissionState[inputAc] == AC_ADMITTED)
			pTxCtrl->highestAdmittedAc[inputAc] = inputAc;

		/* If input AC is not admitted, find next highest priority AC that doesn't require admission. */
		else	
		{
			/* Loop from input AC downward by priority order. */
			for (outputIdx = inputIdx; outputIdx >= 0; outputIdx--)
			{
				outputAc = priorityOrderedAc[outputIdx]; /* Get priority ordered AC. */

				/* Break with first (highest) AC that doesn't require admission (we don't want to 
				 *   redirect traffic to an AC that requires admission even if admitted for other traffic).
				 */
				if(pTxCtrl->admissionRequired[outputAc] == ADMISSION_NOT_REQUIRED)
					break;
			}

			/* If we've found a valid AC insert it, else use BE as default. */
			if (outputIdx >= 0)
				pTxCtrl->highestAdmittedAc[inputAc] = outputAc;
			else
				pTxCtrl->highestAdmittedAc[inputAc] = QOS_AC_BE; 
		}
	}
}


/***************************************************************************
*                           txCtrl_UpdateAcToTidMapping 
****************************************************************************
* DESCRIPTION:  This function updates the table that provides per each AC  
*				  a bitmap of the TIDs that are mapped to it when transitting packets.
*				Note that this mapping considers the ACs admission states.
*				It is used for mapping ACs backpressure to TIDs (for updating the data/mgmt queues)
*
*				This table is updated after txCtrl_UpdateHighestAdmittedAcTable() is called!
*				It may also effect the backpressure picture seen by the Data-Queue and
*				  Mgmt-Queue, so they should be updated subsequently.
*
***************************************************************************/
static void txCtrl_UpdateAcToTidMapping (txCtrl_t *pTxCtrl)
{
	TI_UINT32	tid;
	EAcTrfcType inputAc;
	EAcTrfcType admittedAc; 
        
    os_memoryZero(pTxCtrl->hOs, (void *)&(pTxCtrl->admittedAcToTidMap[0]), sizeof(pTxCtrl->admittedAcToTidMap));

	/* Loop over all TIDs. */
	for (tid = 0; tid < MAX_NUM_OF_802_1d_TAGS; tid++)
	{
		/* Find the AC that is used for transmitting this TID. */
		inputAc = (EAcTrfcType)WMEQosTagToACTable[tid];					/* Standard translation from TID to AC. */
		admittedAc = pTxCtrl->highestAdmittedAc[inputAc];	/* The actual AC that is used for Tx. */

		/* Set the bit related to the TID in the correlated AC. */
		pTxCtrl->admittedAcToTidMap[admittedAc] |= 1 << tid;		
	}
}


/***************************************************************************
*                           txCtrl_UpdateBackpressure 
****************************************************************************
* DESCRIPTION:  This function is called whenever the busy-TIDs bitmap may change, 
*				  (except on packet-xmit - handled separately for performance). 
*				This includes:
*					1) Init
*					2) ACs admission required change (upon association)
*					3) ACs admission state change (upon association and add/delete Tspec).
*					4) Tx-Complete - provides also freed ACs.
*
*				It updates the local bitmap, and the data-queue and mgmt-queue.
*
***************************************************************************/
static void txCtrl_UpdateBackpressure (txCtrl_t *pTxCtrl, TI_UINT32 freedAcBitmap)
{
	TI_UINT32 busyAcBitmap = pTxCtrl->busyAcBitmap;
	TI_UINT32 busyTidBitmap = 0;
	TI_UINT32 ac = 0;

	
	busyAcBitmap &= ~freedAcBitmap;			/* Clear backpressure bits of freed ACs. */
	pTxCtrl->busyAcBitmap = busyAcBitmap;	/* Save new bitmap before manipulating it. */

	/* Loop while there are busy ACs. */
	while (busyAcBitmap)
	{
		/* If the AC is busy, add its related TIDs to the total busy TIDs bitmap. */
		if (busyAcBitmap & 1)
			busyTidBitmap |= pTxCtrl->admittedAcToTidMap[ac];

		/* Move to next AC. */
		busyAcBitmap = busyAcBitmap >> 1;
		ac++;
	}

    TRACE6(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "txCtrl_UpdateBackpressure(): busyTidBitmap = 0x%x, busyAcBitmap = 0x%x, HighestAdmittedAc[3,2,1,0] = %d, %d, %d, %d\n", busyTidBitmap, pTxCtrl->busyAcBitmap, pTxCtrl->highestAdmittedAc[3], 		pTxCtrl->highestAdmittedAc[2], pTxCtrl->highestAdmittedAc[1], pTxCtrl->highestAdmittedAc[0]);

	/* Save new bitmap and update the data-queue and mgmt-queue. */
	pTxCtrl->busyTidBitmap = busyTidBitmap;
	txDataQ_UpdateBusyMap (pTxCtrl->hTxDataQ, busyTidBitmap);
	txMgmtQ_UpdateBusyMap (pTxCtrl->hTxMgmtQ, busyTidBitmap);
}


/****************************************************************************
 *                      txCtrl_SetTxDelayCounters()
 ****************************************************************************
 * DESCRIPTION:          Update transmission path delay counters.
*
* INPUTS:       hTxCtrl - the object
*               ac - the AC to count delay for
*				fwDelay - the time consumed in FW for packet transmission
*				driverDelay - the time consumed in driver for packet transmission
*
* OUTPUT:
*
* RETURNS:
 ****************************************************************************/

#ifdef XCC_MODULE_INCLUDED  /* Needed only for XCC-V4 */

static void txCtrl_SetTxDelayCounters (txCtrl_t *pTxCtrl, 
                                       TI_UINT32 ac, 
                                       TI_UINT32 fwDelay, 
                                       TI_UINT32 driverDelay, 
                                       TI_UINT32 mediumDelay)
{
	int     rangeIndex;
	TI_UINT32  totalTxDelayUsec = fwDelay + driverDelay;

	/* Increment the delay range counter that the current packet Tx delay falls in. */
	for (rangeIndex = TX_DELAY_RANGE_MIN; rangeIndex <= TX_DELAY_RANGE_MAX; rangeIndex++)
	{
		if ( (totalTxDelayUsec >= txDelayRangeStart[rangeIndex]) &&
			 (totalTxDelayUsec <= txDelayRangeEnd  [rangeIndex]) )
		{
			pTxCtrl->txDataCounters[ac].txDelayHistogram[rangeIndex]++;
			break;
		}
	}
	
	/* Update total delay and FW delay sums and packets number for average delay calculation. */
	/* Note: Accumulate Total-Delay in usec to avoid division per packet (convert to msec 
	         only when results are requested by user). */
	if (pTxCtrl->SumTotalDelayUs[ac] < 0x7FFFFFFF) /* verify we are not close to the edge. */
	{
		pTxCtrl->txDataCounters[ac].NumPackets++; 
		pTxCtrl->SumTotalDelayUs[ac] += totalTxDelayUsec;   
        pTxCtrl->txDataCounters[ac].SumFWDelayUs += fwDelay;
        pTxCtrl->txDataCounters[ac].SumMacDelayUs += mediumDelay;
	}
	else  /* If we get close to overflow, restart average accumulation. */
	{
		pTxCtrl->txDataCounters[ac].NumPackets = 1; 
		pTxCtrl->SumTotalDelayUs[ac] = totalTxDelayUsec;   
        pTxCtrl->txDataCounters[ac].SumFWDelayUs = fwDelay;
        pTxCtrl->txDataCounters[ac].SumMacDelayUs = mediumDelay;
	}
}

#endif /* XCC_MODULE_INCLUDED */


/***************************************************************************
*                       txCtrl_UpdateTxCounters                            
****************************************************************************
* DESCRIPTION:  Update Tx statistics counters according to the transmitted packet.
***************************************************************************/
static void txCtrl_UpdateTxCounters (txCtrl_t *pTxCtrl, 
                                     TxResultDescriptor_t *pTxResultInfo,
                                     TTxCtrlBlk *pPktCtrlBlk, 
                                     TI_UINT32 ac, 
                                     TI_BOOL bIsDataPkt)
{
	TI_UINT32 pktLen;
    TI_UINT32 dataLen;
	TI_UINT32 retryHistogramIndex;
    TI_UINT16 EventMask = 0;

    pktLen = (TI_UINT32)ENDIAN_HANDLE_WORD(pPktCtrlBlk->tTxDescriptor.length);
    pktLen = pktLen << 2;

#ifdef TI_DBG

	/* update debug counters. */
	pTxCtrl->dbgCounters.dbgNumTxCmplt[ac]++;
	if (pTxResultInfo->status == TX_SUCCESS) 
	{
		pTxCtrl->dbgCounters.dbgNumTxCmpltOk[ac]++;
		pTxCtrl->dbgCounters.dbgNumTxCmpltOkBytes[ac] += pktLen;
	}
	else
	{
		pTxCtrl->dbgCounters.dbgNumTxCmpltError[ac]++;

		if (pTxResultInfo->status == TX_HW_ERROR        ||
			pTxResultInfo->status == TX_KEY_NOT_FOUND   ||
			pTxResultInfo->status == TX_PEER_NOT_FOUND)
		{
TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, "txCtrl_UpdateTxCounters(): TxResult = %d !!!\n", pTxResultInfo->status);
		}
        else 
        {
TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_WARNING, "txCtrl_UpdateTxCounters(): TxResult = %d !!!\n", pTxResultInfo->status);
        }
	}

#endif /* TI_DBG */

	/* If it's not a data packet, exit (the formal statistics are only on network stack traffic). */
	if ( !bIsDataPkt )
		return;

	if (pTxResultInfo->status == TX_SUCCESS) 
	{
		/* update the retry histogram */
		retryHistogramIndex = (pTxResultInfo->ackFailures >= TX_RETRY_HISTOGRAM_SIZE) ? 
							   (TX_RETRY_HISTOGRAM_SIZE - 1) : pTxResultInfo->ackFailures;
		pTxCtrl->txDataCounters[ac].RetryHistogram[retryHistogramIndex]++;

#ifdef XCC_MODULE_INCLUDED
		/* update delay histogram */
		txCtrl_SetTxDelayCounters (pTxCtrl, 
        						   ac, 
        						   ENDIAN_HANDLE_LONG(pTxResultInfo->fwHandlingTime), 
        						   pPktCtrlBlk->tTxPktParams.uDriverDelay, 
        						   ENDIAN_HANDLE_LONG(pTxResultInfo->mediumDelay));  
#endif

		if (pTxCtrl->headerConverMode == HDR_CONVERT_QOS)
        {
			dataLen = pktLen - (WLAN_WITH_SNAP_QOS_HEADER_MAX_SIZE - ETHERNET_HDR_LEN);
        }
        else
        {
			dataLen = pktLen - (WLAN_WITH_SNAP_HEADER_MAX_SIZE - ETHERNET_HDR_LEN);
        }

        if (pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_MULTICAST)
        {
            if (pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_BROADCAST)
            {
                /* Broadcast frame */
                pTxCtrl->txDataCounters[ac].BroadcastFramesXmit++;
                pTxCtrl->txDataCounters[ac].BroadcastBytesXmit += dataLen;
                EventMask |= BROADCAST_BYTES_XFER;
                EventMask |= BROADCAST_FRAMES_XFER;
            }
            else 
            {
                /* Multicast Address */
                pTxCtrl->txDataCounters[ac].MulticastFramesXmit++;
                pTxCtrl->txDataCounters[ac].MulticastBytesXmit += dataLen;
                EventMask |= MULTICAST_BYTES_XFER;
                EventMask |= MULTICAST_FRAMES_XFER;
            }
        }
        else 
        {
            /* Save last data Tx rate for applications' query */
            EHwBitRate eHwTxRate = ENDIAN_HANDLE_LONG((EHwBitRate)(pTxResultInfo->rate)); 
            rate_PolicyToDrv (eHwTxRate, &pTxCtrl->eCurrentTxRate);

            /* Directed frame statistics */
            pTxCtrl->txDataCounters[ac].DirectedFramesXmit++;
            pTxCtrl->txDataCounters[ac].DirectedBytesXmit += dataLen;
            EventMask |= DIRECTED_BYTES_XFER;
            EventMask |= DIRECTED_FRAMES_XFER;
        }

        pTxCtrl->txDataCounters[ac].XmitOk++;
        EventMask |= XFER_OK;

		/* update the max consecutive retry failures (if needed) */
		if (pTxCtrl->currentConsecutiveRetryFail > pTxCtrl->txDataCounters[ac].MaxConsecutiveRetryFail)
        {
			pTxCtrl->txDataCounters[ac].MaxConsecutiveRetryFail = pTxCtrl->currentConsecutiveRetryFail;
        }
		pTxCtrl->currentConsecutiveRetryFail = 0;

		if(pTxCtrl->TxEventDistributor)
        {
			DistributorMgr_EventCall(pTxCtrl->TxEventDistributor, EventMask, dataLen);
        }
	}
	else	/* Handle Errors */
	{
		/* 
			NOTE: if the FW sets more then 1 error bit  at a time change the error handling
			code below 
		*/
		if (pTxResultInfo->status == TX_RETRY_EXCEEDED) 
		{
			pTxCtrl->txDataCounters[ac].RetryFailCounter++;
			pTxCtrl->currentConsecutiveRetryFail++;
		}
		else if (pTxResultInfo->status == TX_TIMEOUT) 
		{
			pTxCtrl->txDataCounters[ac].TxTimeoutCounter++;
		}
		else
		{
			pTxCtrl->txDataCounters[ac].OtherFailCounter++;
		}
	}
}


/***************************************************************************
*                           txCtrl_notifyFwReset                           *
****************************************************************************
* DESCRIPTION:  Go over all CtrlBlk entries and free the active ones including the packet.
***************************************************************************/
TI_STATUS txCtrl_NotifyFwReset (TI_HANDLE hTxCtrl)
{
	txCtrl_t   *pTxCtrl = (txCtrl_t *)hTxCtrl;
	TI_UINT32  entry;
	TTxCtrlBlk *pPktCtrlBlk;

	pTxCtrl->busyAcBitmap = 0; /* clean busy bitmap */
	txCtrl_UpdateBackpressure(pTxCtrl, 0);

	for (entry = 0; entry < CTRL_BLK_ENTRIES_NUM-1; entry++)
	{
		/* Get packet ctrl-block by desc-ID. */
		pPktCtrlBlk = TWD_txCtrlBlk_GetPointer(pTxCtrl->hTWD, entry);
		if (pPktCtrlBlk->pNextFreeEntry == 0)
		{
		    /* Don't free if the packet still in tx input queues */
		    if ((pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_SENT_TO_FW))
		    {
		        /* Free the packet resources (packet and CtrlBlk)  */
		        txCtrl_FreePacket (pTxCtrl, pPktCtrlBlk, TI_NOK);
		    }
		}
	}

	return TI_OK;
} /* txCtrl_notifyFwReset */


/***************************************************************************
*                           txCtrl_CheckForTxStuck                         *
****************************************************************************
* DESCRIPTION:  Check if there are stale packets in the TxCtrlTable. 
* The criterion for staleness is function of life time (2 times the longest life time)
* Note that only packets that were not sent to the FW are checked for simplicity!
***************************************************************************/
TI_STATUS txCtrl_CheckForTxStuck (TI_HANDLE hTxCtrl)
{
	txCtrl_t   *pTxCtrl = (txCtrl_t *)hTxCtrl;
	TI_UINT32  entry;
	TTxCtrlBlk *pPktCtrlBlk;
	TI_UINT32  uPktAge;		/* Time in uSec since packet start time. */

	for (entry = 0; entry < CTRL_BLK_ENTRIES_NUM-1; entry++)
	{
		/* Get packet ctrl-block by desc-ID. */
		pPktCtrlBlk = TWD_txCtrlBlk_GetPointer(pTxCtrl->hTWD, entry);

        /* If entry is in use */
		if (pPktCtrlBlk->pNextFreeEntry == 0)
		{
            /* If the packet wasn't sent to the FW yet (time is in host format) */
            if ((pPktCtrlBlk->tTxPktParams.uFlags & TX_CTRL_FLAG_SENT_TO_FW) == 0)
            {
                /* If packet age is more than twice the maximum lifetime, return NOK */
                uPktAge = os_timeStampMs (pTxCtrl->hOs) - pPktCtrlBlk->tTxDescriptor.startTime;
                if (uPktAge > ((MGMT_PKT_LIFETIME_TU << SHIFT_BETWEEN_TU_AND_USEC) * 2))
                {
                    return TI_NOK; /* call for recovery */
                }
            }
		}
	}

	return TI_OK;
} /* txCtrl_FailureTest */