/drivers/net/wireless/tiwlan1251/common/src/Management/QOS/qosMngr.c

/****************************************************************************
**+-----------------------------------------------------------------------+**
**|                                                                       |**
**| Copyright(c) 1998 - 2008 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 qosMngr.c
 *  \brief QOS module interface
 *
 *  \see qosMngr.h
 */

/****************************************************************************************************/
/*																									*/
/*		MODULE:		qosMGr.c																	    */
/*		PURPOSE:	QOS module interface.												            */
/*                  This module handles the QOS manager configuration.	 							*/
/*																						 			*/
/****************************************************************************************************/
#include "report.h"
#include "osApi.h"
#include "paramOut.h"
#include "paramIn.h"
#include "utils.h"
#include "siteMgrApi.h"
#include "public_infoele.h"
#include "whalCtrl_api.h"
#include "qosMngr.h"
#include "qosMngr_API.h"
#include "qosMngr_QueueMapping.h"
#include "smeSmApi.h"
#include "EvHandler.h"
#ifdef EXC_MODULE_INCLUDED
#include "excMngr.h"
#include "excTSMngr.h"
#endif

static int NonQosTagToACTable[MAX_NUM_OF_802_1d_TAGS] = { NonQosTag0ToAC, NonQosTag1ToAC, NonQosTag2ToAC, NonQosTag3ToAC, NonQosTag4ToAC, NonQosTag5ToAC, NonQosTag6ToAC, NonQosTag7ToAC };

/* This structure is now shared between the qosMngr and TxData to allow PS_POLL voice delivery mode for NON_QOS AP */
int WMEQosTagToACTable[MAX_NUM_OF_802_1d_TAGS] = { WMEQosTag0ToAC, WMEQosTag1ToAC, WMEQosTag2ToAC, WMEQosTag3ToAC, WMEQosTag4ToAC, WMEQosTag5ToAC, WMEQosTag6ToAC, WMEQosTag7ToAC };

/* This array is now shared between qosMngr and TxData */
UINT8 wmeAcToUpIndex[MAX_NUM_OF_AC] = {0,1,4,6};

/* Used to indicate no user priority is assigned for AC */
#define INACTIVE_USER_PRIORITY 0xFF

/********************************************************************************/
/*						Internal functions prototypes.							*/
/********************************************************************************/
static void release_module(qosMngr_t *pQosMngr, UINT32 initVec);
static TI_STATUS verifyAndConfigTrafficParams(qosMngr_t *pQosMngr, queueTrafficParams_t *pQtrafficParams);
static TI_STATUS verifyAndConfigQosParams(qosMngr_t *pQosMngr,acQosParams_t *pAcQosParams);
static TI_STATUS getWMEInfoElement(qosMngr_t *pQosMngr,UINT8 *pWMEie,UINT8 *pLen);
static TI_STATUS verifyWmeIeParams(qosMngr_t *pQosMngr,UINT8 *pQosIeParams);
static TI_STATUS updateACParams(qosMngr_t *pQosMngr,ACParameters_t *pAcParams);
static void      updateTagToAcTable(qosMngr_t *pQosMngr,acTrfcType_e *pProtocolTagToACTable);
static TI_STATUS setWmeSiteParams(qosMngr_t *pQosMngr, UINT8 *pQosIeParams);
void qosMngr_resetAdmCtrlParameters(TI_HANDLE hQosMngr);
static TI_STATUS qosMngr_getCurrAcStatus(TI_HANDLE hQosMngr, OS_802_11_AC_UPSD_STATUS_PARAMS *pAcStatusParams);
static void deleteTspecConfiguration(qosMngr_t *pQosMngr, UINT8 acID);
static void setNonQosAdmissionState(qosMngr_t *pQosMngr, UINT8 acID);
static void qosMngr_storeTspecCandidateParams (tspecInfo_t *pCandidateParams, OS_802_11_QOS_TSPEC_PARAMS *pTSPECParams, UINT8 ac);

/********************************************************************************
 *							qosMngr_create										*
 ********************************************************************************
DESCRIPTION: QOS module creation function, called by the config mgr in creation phase. 
				performs the following:
				- Allocate the QOS MNGR handle.				                                                                                                   
INPUT:      hOs -			Handle to OS		


OUTPUT:		

RETURN:     Handle to the QOS MNGR module on success, NULL otherwise

************************************************************************/
TI_HANDLE qosMngr_create(TI_HANDLE hOs)
{
	qosMngr_t		*pQosMngr = NULL;
	UINT32			initVec = 0;

	if(!hOs)
		return NULL;
	
	/* allocating the WME object */
	pQosMngr = os_memoryAlloc(hOs,sizeof(qosMngr_t));

	if (pQosMngr == NULL)
		return NULL;

	initVec |= (1 << QOS_MNGR_INIT_BIT_LOCAL_VECTOR);
    
	/* create admission control object */
	pQosMngr->pTrafficAdmCtrl = trafficAdmCtrl_create(hOs);

	if (pQosMngr->pTrafficAdmCtrl == NULL)
	{
		qosMngr_destroy(pQosMngr);
		return NULL;
	}

	initVec |= (1 << QOS_MNGR_INIT_BIT_ADM_CTRL);

	return(pQosMngr);
}

/************************************************************************
 *                        qosMngr_destroy							    *
 ************************************************************************
DESCRIPTION: QOS MNGR module destroy function, called by the config mgr in
				 the destroy phase 
				 performs the following:
				-	Free all memory alocated by the module
				
INPUT:      hQosMngr	-	QOS Manager handle.		

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/
TI_STATUS qosMngr_destroy(TI_HANDLE hQosMngr)
{
	UINT32				   initVec;
	qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

	if (pQosMngr == NULL)
		return OK;

	initVec = 0xFFFF; 
    release_module(pQosMngr, initVec);

	return OK;
}

/***********************************************************************
 *                        release_module									
 ***********************************************************************
DESCRIPTION:	Called by the destroy function or by the create function (on failure)
				Go over the vector, for each bit that is set, release the corresponding module.
                                                                                                   
INPUT:      pQosMngr  -  QOS Mngr pointer.
			initVec	  -	 Vector that contains a bit set for each module thah had been initiualized

OUTPUT:		

RETURN:     OK on success, NOK otherwise
************************************************************************/
static void release_module(qosMngr_t *pQosMngr, UINT32 initVec)
{
	
	if (initVec & (1 << QOS_MNGR_INIT_BIT_ADM_CTRL))
		trafficAdmCtrl_unload(pQosMngr->pTrafficAdmCtrl);

	if (initVec & (1 << QOS_MNGR_INIT_BIT_LOCAL_VECTOR))
		utils_nullMemoryFree(pQosMngr->hOs, pQosMngr, sizeof(qosMngr_t));
		
	initVec = 0;
}

/************************************************************************
 *                        qosMngr_config								*
 ************************************************************************
DESCRIPTION: QOS Manager module configuration function, called by the config 
				mgr in configuration phase
				performs the following:
				-	Reset & initiailzes local variables
				-	Init the handles to be used by the module
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.
		    List of handles to be used by the module
			pQosMngrInitParams	-	Init table of the module.		


OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/
TI_STATUS   qosMngr_config(TI_HANDLE     	        hQosMngr,
						   TI_HANDLE		        hHalCtrl,
						   TI_HANDLE		        hSiteMgr,
						   TI_HANDLE		        hReport,
						   TI_HANDLE		        hOs,
                           TI_HANDLE                hTxData,
                           TI_HANDLE                hMeasurementMngr,
                           TI_HANDLE                hSmeSm,
						   TI_HANDLE				hMemMgr,
						   TI_HANDLE				hCtrlData,
						   TI_HANDLE				hEvHandler,
						   TI_HANDLE				hExcMgr,
						   QosMngrInitParams_t		*pQosMngrInitParams)
{

    qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;
	paramInfo_t			  param;
  	UINT8                 acID;
	TI_STATUS             status;

    /* init handles */
    pQosMngr->hOs       = hOs;
    pQosMngr->hReport   = hReport;
    pQosMngr->hSiteMgr  = hSiteMgr;
    pQosMngr->hHalCtrl  = hHalCtrl;
    pQosMngr->hTxData   = hTxData;
    pQosMngr->hMeasurementMngr = hMeasurementMngr;
    pQosMngr->hSmeSm = hSmeSm;
    pQosMngr->hMemMgr   = hMemMgr;
    pQosMngr->hCtrlData = hCtrlData;
	pQosMngr->hEvHandler = hEvHandler;
	pQosMngr->hExcMgr = hExcMgr;

    pQosMngr->isConnected = FALSE;

    /* init params */
    pQosMngr->WMEEnable = pQosMngrInitParams->wmeEnable;
    pQosMngr->trafficAdmCtrlEnable = pQosMngrInitParams->trafficAdmCtrlEnable;
    pQosMngr->tagZeroConverHeader = pQosMngrInitParams->qosTagZeroConverHeader;
	pQosMngr->qosPacketBurstEnable = pQosMngrInitParams->PacketBurstEnable;
	pQosMngr->qosPacketBurstTxOpLimit = pQosMngrInitParams->PacketBurstTxOpLimit;
	pQosMngr->desiredPsMode = pQosMngrInitParams->desiredPsMode;

    pQosMngr->activeProtocol    = NONE_QOS;
    pQosMngr->WMESiteSupport    = FALSE;

	pQosMngr->desiredMaxSpLen	= pQosMngrInitParams->desiredMaxSpLen;
	pQosMngr->desiredVoiceDeliveryProtocol = PS_SCHEME_LEGACY_PSPOLL;

    pQosMngr->voiceTspecConfigured = FALSE;
	pQosMngr->videoTspecConfigured = FALSE;
    pQosMngr->performTSPECRenegotiation = FALSE;
	pQosMngr->TSPECNegotiationResultCallb = NULL;
	pQosMngr->TSPECNegotiationResultModule = NULL;

    /* No template has been set for UPSD */
    pQosMngr->QosNullDataTemplateUserPriority = 0xFF;

	/* configure admission control parameters */
	qosMngr_resetAdmCtrlParameters(pQosMngr);

	status = trafficAdmCtrl_config(pQosMngr->pTrafficAdmCtrl,
								pQosMngr->hTxData,
								pQosMngr->hReport,
								pQosMngr->hOs,
								pQosMngr,
								pQosMngr->hCtrlData,
								pQosMngr->hMemMgr,
								pQosMngr->hExcMgr,
								&pQosMngrInitParams->trafficAdmCtrlInitParams);
	if(status != OK)
		return NOK;

	/* 
	 * configure per AC traffic parameters
	 */
    for(acID = FIRST_AC_INDEX;acID < MAX_NUM_OF_AC; acID++)
	{
		/*
		 * setting ac traffic params for TrafficCategoryCfg (TNET configuration 
		 * The parameters can be changed in run-time, so they are saved in "init params"
		 * for 'disconnecting' .
		 * the parameters being set in setSite; "select" phase.
         */
		pQosMngr->acParams[acID].QtrafficParams.queueID       = acID;
		pQosMngr->acParams[acID].QtrafficParams.channelType   = CHANNEL_TYPE_EDCF;
		pQosMngr->acParams[acID].QtrafficParams.tsid          = acID;
		pQosMngr->acParams[acID].QtrafficParams.dot11EDCATableMSDULifeTime = 0;
		pQosMngr->acParams[acID].QtrafficParams.psScheme      = PS_SCHEME_LEGACY;
		pQosMngr->acParams[acID].QtrafficParams.ackPolicy     = pQosMngrInitParams->acAckPolicy[acID];
		pQosMngr->acParams[acID].QtrafficParams.APSDConf[0]   = 0;
		pQosMngr->acParams[acID].QtrafficParams.APSDConf[1]   = 0;


		/* 
		 * Update the qTrafficInitParams as well 
		 */
		os_memoryCopy(hOs,&(pQosMngr->acParams[acID].QTrafficInitParams),&(pQosMngr->acParams[acID].QtrafficParams),sizeof(queueTrafficParams_t));

		/* will be config only after select */
		verifyAndConfigTrafficParams(pQosMngr,&(pQosMngr->acParams[acID].QtrafficParams));
		
		/*
		 * setting ac QoS params for acQosParams (TNET configuration) 
		 * The parameters can be changed in run-time, so they are saved in "init params"
		 * for 'disconnecting'.
		 * the parameters being set in setSite; "select" phase.
         */
		pQosMngr->acParams[acID].acQosParams.ac        = acID;
		pQosMngr->acParams[acID].acQosParams.aifsn     = AIFS_DEF;
		pQosMngr->acParams[acID].acQosParams.cwMax     = CW_MAX_DEF;
		pQosMngr->acParams[acID].acQosParams.cwMin     = CW_MIN_MAX;
		pQosMngr->acParams[acID].acQosParams.txopLimit = QOS_TX_OP_LIMIT_DEF;
		pQosMngr->acParams[acID].msduLifeTimeParam     = pQosMngrInitParams->MsduLifeTime[acID];

		/* The protocol is NONE_QOS. If Packet Burst is Enable,            */
		/* then, the BE queue is configured to the TxOP Limit of Packet burst */
		/* (that is, 3 ms) and the txopContinuation is set to  qosPacketBurstEnable  */
		/* The protocol is NONE_QOS. If Packet Burst is Enable,            */
		/* then, the BE queue is configured to the TxOP Limit of Packet burst */
		/* (that is, 3 ms) and the txopContinuation is set to  qosPacketBurstEnable  */

		if (acID == QOS_AC_BE)	
		{
			if (pQosMngr->qosPacketBurstEnable==TRUE)
			{
				pQosMngr->acParams[QOS_AC_BE].acQosParams.txopLimit = pQosMngr->qosPacketBurstTxOpLimit;
			}
			else 
			{
				pQosMngr->acParams[QOS_AC_BE].acQosParams.txopLimit = QOS_TX_OP_LIMIT_DEF;
			}
		}

		/* 
		 * Update the acQosInitParams as well 
		 */
		os_memoryCopy(hOs,&(pQosMngr->acParams[acID].acQosInitParams),&(pQosMngr->acParams[acID].acQosParams),sizeof(acQosParams_t));

		/* will be config only after select */
		verifyAndConfigQosParams(hQosMngr,&(pQosMngr->acParams[acID].acQosParams));
		
		


		/*
		 * setting ps mode per ac for protocol specific configuration.
		 */

        /* validity check - allow to set the desired Ps mode per-AC to UPSD ONLY IF the station supports UPSD */
        if ((pQosMngrInitParams->desiredPsMode == PS_SCHEME_UPSD_TRIGGER) && (pQosMngrInitParams->desiredWmeAcPsMode[acID] == PS_SCHEME_UPSD_TRIGGER))
        {
		        pQosMngr->acParams[acID].desiredWmeAcPsMode = PS_SCHEME_UPSD_TRIGGER;
        }
        else
        {
               pQosMngr->acParams[acID].desiredWmeAcPsMode = PS_SCHEME_LEGACY_PSPOLL;
        }

		pQosMngr->acParams[acID].currentWmeAcPsMode  = PS_SCHEME_LEGACY_PSPOLL; /* default configuration is legacy PS  for all queues */

		/*
		 * configure TxData per AC params
		 */
		param.content.txDataQosParams.acID                      = acID;
		param.content.txDataQosParams.acTrfcCtrl.PsMode         = PS_SCHEME_LEGACY;
		param.content.txDataQosParams.acTrfcCtrl.QueueIndex     = acID; 
        param.content.txDataQosParams.acTrfcCtrl.TxQueueSize    = pQosMngrInitParams->TxQueueSize[acID];
		param.content.txDataQosParams.acTrfcCtrl.QueueOvFlowPolicy = pQosMngrInitParams->QueueOvFlowPolicy[acID];			              
		param.content.txDataQosParams.acTrfcCtrl.MsduLifeTime 	= pQosMngrInitParams->MsduLifeTime[acID];
		param.content.txDataQosParams.acTrfcCtrl.ackPolicy    	= ACK_POLICY_LEGACY; /* working with Non - Qos method */

		param.paramType = TX_DATA_PS_MODE_PARAM;
		txData_setParam(pQosMngr->hTxData,&param);

		param.paramType = TX_DATA_CONFIG_TX_QUEUE_SIZE;
		txData_setParam(pQosMngr->hTxData,&param);

		param.paramType = TX_DATA_CONFIG_TX_QUEUE_OVFLOW_POLICY;
		txData_setParam(pQosMngr->hTxData,&param);

		param.paramType = TX_DATA_CONFIG_AC_MSDU_LIFE_TIME;
		txData_setParam(pQosMngr->hTxData,&param);

		param.paramType = TX_DATA_CONFIG_AC_ACK_POLICY;
		txData_setParam(pQosMngr->hTxData,&param);


		/* setting wme Ack Policy */
		pQosMngr->acParams[acID].wmeAcAckPolicy = pQosMngrInitParams->acAckPolicy[acID];

		/* Set admission state per AC for non-QoS and update the Tx module. */
		setNonQosAdmissionState(pQosMngr, acID);
	}

	pQosMngr->headerConvetMode = LEGACY_CONVERT;
	param.content.txDataQosParams.qosParams.headerConverMode          = LEGACY_CONVERT;

	/* Update the Tx tag to AC tables for legacy mode. */
	updateTagToAcTable(pQosMngr, (acTrfcType_e *)NonQosTagToACTable);

	
	param.paramType = TX_DATA_CONVERT_HEADER_MODE;
	txData_setParam(pQosMngr->hTxData,&param);

	param.paramType = TX_DATA_CONVERT_TAG_ZERO_HEADER_MODE;
    param.content.txDataQosParams.qosParams.convertTagZeroFrames = pQosMngrInitParams->qosTagZeroConverHeader;
	txData_setParam(pQosMngr->hTxData,&param);

	WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
		  ("qosMngr_config : QoS configuration complete!")); 
	

    return OK;
}

/************************************************************************
 *                    qosMngr_resetAdmCtrlParameters	                *
 ************************************************************************
DESCRIPTION: reset the admCtrl parameters
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.

OUTPUT:		

RETURN:     

************************************************************************/

void qosMngr_resetAdmCtrlParameters(TI_HANDLE hQosMngr)
{
	UINT8 acID;
    qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

	/* reset admission control parameters */
	for(acID = FIRST_AC_INDEX ; acID < MAX_NUM_OF_AC ; acID++)
	{
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].AC = (acTrfcType_e)acID;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].userPriority = INACTIVE_USER_PRIORITY; /* Setting invalid user Priority to prevent GET_TSPEC or DELETE */
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].nominalMsduSize = 0;
        pQosMngr->resourceMgmtTable.currentTspecInfo[acID].minimumPHYRate = 0;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].meanDataRate = 0;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].surplausBwAllowance = 0;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].mediumTime = 0;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].UPSDFlag = 0;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].streamDirection = BI_DIRECTIONAL;
		pQosMngr->resourceMgmtTable.currentTspecInfo[acID].trafficAdmState = AC_NOT_ADMITTED;

		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].AC = (acTrfcType_e)acID;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].userPriority = INACTIVE_USER_PRIORITY; /* Setting invalid user Priority to prevent GET_TSPEC or DELETE */
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].nominalMsduSize = 0;
        pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].minimumPHYRate = 0;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].meanDataRate = 0;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].surplausBwAllowance = 0;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].mediumTime = 0;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].UPSDFlag = 0;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].streamDirection = BI_DIRECTIONAL;
		pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].trafficAdmState = AC_NOT_ADMITTED;

		pQosMngr->resourceMgmtTable.totalAllocatedMediumTime = 0;
	}
}


/************************************************************************
 *                        qosMngr_disconnect   			                *
 ************************************************************************
DESCRIPTION: the function is called upon driver disconnecting to reset all
             QOS parameters to init values.
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

TI_STATUS qosMngr_disconnect(TI_HANDLE hQosMngr)
{
    qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;
	paramInfo_t			  param;
	UINT8                 acID;
	TI_STATUS             status;

	if(hQosMngr == NULL)
		return OK;

	pQosMngr->activeProtocol    = NONE_QOS;
    pQosMngr->WMESiteSupport    = FALSE;

	/* clear admission control params */
	qosMngr_resetAdmCtrlParameters(pQosMngr);
	
	trafficAdmCtrl_stop(pQosMngr->pTrafficAdmCtrl);

	for(acID = FIRST_AC_INDEX;acID < MAX_NUM_OF_AC; acID++)
	{

		/* disable event in rate adaptation */
		ctrlData_setTspecsRateEvent(pQosMngr->hCtrlData, acID, FALSE);

        /* Disable medium time events in TX */
		txData_setAdmisionCtrlParams(pQosMngr->hTxData, acID, 0 , 0, FALSE);

		/* The protocol after disconnect is NONE_QOS. If Packet Burst is Enabled, the BE queue InitParams 
		    is configured to the TxOP Limit of Packet burst  (that is, 3 ms) and the 
		    txopContinuation is set to qosPacketBurstEnable. */
		
		if (acID == QOS_AC_BE)
		{
			if (pQosMngr->qosPacketBurstEnable==TRUE)
			{
				pQosMngr->acParams[QOS_AC_BE].acQosInitParams.txopLimit = pQosMngr->qosPacketBurstTxOpLimit;
			}
			else 
			{
				pQosMngr->acParams[QOS_AC_BE].acQosInitParams.txopLimit = QOS_TX_OP_LIMIT_DEF;
			}
		}
		
		/* Copy init traffic params (non-QoS defaults) to current traffic params, and config to HAL and TNET. */
       os_memoryCopy(pQosMngr->hOs,&(pQosMngr->acParams[acID].acQosParams),&(pQosMngr->acParams[acID].acQosInitParams),sizeof(acQosParams_t));		

		/* 
		 * Update the qTrafficInitParams as well 
		 */
	   os_memoryCopy(pQosMngr->hOs,&(pQosMngr->acParams[acID].QtrafficParams),&(pQosMngr->acParams[acID].QTrafficInitParams),sizeof(queueTrafficParams_t));



	   pQosMngr->acParams[acID].currentWmeAcPsMode  = PS_SCHEME_LEGACY_PSPOLL; /* default configuration is legacy PS  for all queues */

	    /*
	    * setting TxData params, only PS , Txoplimit and Admission State and AC status
	    * can be changed and reset to defaults.
	    */
	   param.content.txDataQosParams.acID                      = acID;
	   param.content.txDataQosParams.acTrfcCtrl.PsMode         = PS_SCHEME_LEGACY;
	   param.content.txDataQosParams.acTrfcCtrl.ackPolicy      = ACK_POLICY_LEGACY; /* working with Non - Qos method */
	   param.content.txDataQosParams.acTrfcCtrl.MsduLifeTime   = pQosMngr->acParams[acID].msduLifeTimeParam;

	   param.paramType = TX_DATA_CONFIG_AC_MSDU_LIFE_TIME;
	   txData_setParam(pQosMngr->hTxData, &param);

	   param.paramType = TX_DATA_PS_MODE_PARAM;
	   txData_setParam(pQosMngr->hTxData,&param);

	   param.paramType = TX_DATA_CONFIG_AC_ACK_POLICY;
	   txData_setParam(pQosMngr->hTxData,&param);

	   /* Set admission state per AC for non-QoS and update the Tx module. */
	   setNonQosAdmissionState(pQosMngr, acID);
	}

	/* 
	 * configure only BE AC 
	 * NOTE : this is done after "disconnect" or Init phase so those are defaults BE params 
	 */

	/*
	 * configureQueue
	 */
	status = verifyAndConfigTrafficParams(hQosMngr,&(pQosMngr->acParams[QOS_AC_BE].QtrafficParams));
	if (status != OK)
	{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
							("qosMngr_setSite:failed to init NON_QOS Queue Traffic parameters!!!\n\n")); 
			return status;
	}

	/*
	 * configureAC
	 */

	status = verifyAndConfigQosParams(hQosMngr,&(pQosMngr->acParams[QOS_AC_BE].acQosParams));
	if (status != OK)
	{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
							("qosMngr_setSite:failed to init NON_QOS AC QoS parameters!!!\n\n")); 
			return status;
	}


	/*
	 * reset TxData globals parameters:  header converting to legacy and Tag to Ac table without
	 * QOS 
	 */
	pQosMngr->headerConvetMode = LEGACY_CONVERT;
	param.content.txDataQosParams.qosParams.headerConverMode          = LEGACY_CONVERT;



	/* Update the Tx and HAL tag to AC tables for legacy mode. */
	updateTagToAcTable(pQosMngr, (acTrfcType_e *)NonQosTagToACTable);


	param.paramType = TX_DATA_CONVERT_HEADER_MODE;
	txData_setParam(pQosMngr->hTxData,&param);


    /* Update our internal state */
    pQosMngr->isConnected = FALSE;

    /* Mark that no Qos Null template is currently set into firmware */
    pQosMngr->QosNullDataTemplateUserPriority = 0xFF;

    pQosMngr->voiceTspecConfigured = FALSE;

	pQosMngr->videoTspecConfigured = FALSE;

    /* Mark that no Qos Null template is currently set into firmware */
    pQosMngr->QosNullDataTemplateUserPriority = 0xFF;

	WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
		  ("qosMngr_disconnect : QoS disconnect complete!")); 

#ifdef EXC_MODULE_INCLUDED
	measurementMgr_stopTsMetrics(pQosMngr->hMeasurementMngr);
#endif

	return OK;
}


/************************************************************************
 *                        qosMngr_connect   			                *
 ************************************************************************
DESCRIPTION: the function is called upon driver connection to inform all 
             the other modules about the voice mode
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

TI_STATUS qosMngr_connect(TI_HANDLE hQosMngr)
{
    qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;
    psPollTemplate_t        psPollTemplate;
    whalCtrl_setTemplate_t  templateStruct;
    QosNullDataTemplate_t  QosNullDataTemplate;
    UINT8   acID,UPSDCnt=0;

   if (pQosMngr->isConnected == TRUE)
   {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_connect : Already connected !!!\n")); 
     return OK;
   }

    /* Send PsPoll template to HAL */
    
    templateStruct.pTemplate = (UINT8 *)&psPollTemplate;
    templateStruct.templateType = PS_POLL_TEMPLATE;
    buildPsPollTemplate(pQosMngr->hSiteMgr, &templateStruct);
    whalCtrl_SetTemplate(pQosMngr->hHalCtrl, &templateStruct);
    	
    /* Update our internal state */
    pQosMngr->isConnected = TRUE;

    /* Set Qos-Null Data template into firmware */
	for(acID = FIRST_AC_INDEX;acID < MAX_NUM_OF_AC; acID++)
	{
        /* Set QOS Null data template into the firmware (only if at least one AC is configured as UPSD )*/
        if (pQosMngr->acParams[acID].currentWmeAcPsMode == PS_SCHEME_UPSD_TRIGGER)
        {
           UPSDCnt++;
           if ( pQosMngr->acParams[acID].apInitAdmissionState != ADMISSION_REQUIRED )
           {
            pQosMngr->QosNullDataTemplateUserPriority = wmeAcToUpIndex[acID];

            templateStruct.pTemplate = (UINT8 *)&QosNullDataTemplate;
            templateStruct.templateType = QOS_NULL_DATA_TEMPLATE;
            buildQosNullDataTemplate(pQosMngr->hSiteMgr, &templateStruct,pQosMngr->QosNullDataTemplateUserPriority);
            whalCtrl_SetTemplate(pQosMngr->hHalCtrl, &templateStruct);

            WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
               ("setWmeSiteParams: Setting QOS Null data for UserPriority %d (belongs to AC %d)\n",wmeAcToUpIndex[acID],acID));

            break; /* Only need to set ONE template, so after setting it, we can exit the loop */
           }
        }

    }

    /* If MAX_NUM_OF_AC (4) ACs were found as UPSD, but we still haven't configured any UP in the Qos Null data template, it must mean all ACs require admission - not valid*/
    if ((pQosMngr->QosNullDataTemplateUserPriority == 0xFF) && (UPSDCnt == MAX_NUM_OF_AC))
    {
      WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_connect : QOS Null Data template not set since all ACs require admission !!!\n")); 
	}

	return OK;
}

/************************************************************************
 *                        qosMngr_evalSite					            *
 ************************************************************************
DESCRIPTION: Evaluate the site for the selction algorithm
			 In case the station is configure to work in UPSD mode
			 prefer a site that support UPSD and return 1.
			 All other case return 0.
                                                                                                   
INPUT:      siteAPSDSupport - the UPSD capabilit of the site

OUTPUT:		 

RETURN:     1 - evaluation is good...
			0 - evaluation can be better....

************************************************************************/
UINT8 qosMngr_evalSite(TI_HANDLE hQosMngr, BOOL siteAPSDSupport)
{
   qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

   if (pQosMngr->desiredPsMode == PS_SCHEME_UPSD_TRIGGER && siteAPSDSupport)
   {
		return 1;
   }

   return 0;
}

/************************************************************************
 *                        qosMngr_getParamsPatial         			    *
 ************************************************************************
DESCRIPTION: The function is an API for external modules to qet qos parameters
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.
            pParamInfo           -  qos parameters information.


OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

TI_STATUS qosMngr_getParamsPatial(TI_HANDLE  hQosMngr,paramInfoPartial_t *pParamInfo)
{
	qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

	if(pQosMngr == NULL)
		return NOK;

	WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_getParams: %x\n", pParamInfo->paramType)); 

	switch(pParamInfo->paramType)
	{

	case QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC:
	/* Check if voice call present. If so, store current TSPEC configuration */
		pParamInfo->content.TspecConfigure.voiceTspecConfigure = (UINT8)pQosMngr->voiceTspecConfigured;
		pParamInfo->content.TspecConfigure.videoTspecConfigure = (UINT8)pQosMngr->videoTspecConfigured;

		WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_getParams: QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC=%d\n", pQosMngr->voiceTspecConfigured)); 

		if (pQosMngr->voiceTspecConfigured == TRUE) 
		{
			OS_802_11_QOS_TSPEC_PARAMS *pTspecParams;
			tspecInfo_t *pConfiguredParams;

			/* Store voice TSPEC params - must be configured */
			pTspecParams = &pQosMngr->tspecRenegotiationParams[USER_PRIORITY_6];
			pConfiguredParams = &pQosMngr->resourceMgmtTable.candidateTspecInfo[USER_PRIORITY_6];

			pTspecParams->uUserPriority = pConfiguredParams->userPriority;
			pTspecParams->uNominalMSDUsize = pConfiguredParams->nominalMsduSize;
			pTspecParams->uMeanDataRate = pConfiguredParams->meanDataRate;
			pTspecParams->uMinimumPHYRate = pConfiguredParams->minimumPHYRate;
			pTspecParams->uSurplusBandwidthAllowance = pConfiguredParams->surplausBwAllowance;
			pTspecParams->uAPSDFlag = pConfiguredParams->UPSDFlag;
			pTspecParams->uMediumTime = pConfiguredParams->mediumTime;
		}
		else
		{
			pQosMngr->tspecRenegotiationParams[USER_PRIORITY_6].uUserPriority = MAX_USER_PRIORITY;
		}

		if (pQosMngr->videoTspecConfigured == TRUE) 
		{
			OS_802_11_QOS_TSPEC_PARAMS *pTspecParams;
			tspecInfo_t *pConfiguredParams;

			/* Store signalling TSPEC params if configured in user priority 4 */
			pTspecParams = &pQosMngr->tspecRenegotiationParams[USER_PRIORITY_4];
			pConfiguredParams = &pQosMngr->resourceMgmtTable.candidateTspecInfo[USER_PRIORITY_4];

			pTspecParams->uUserPriority = pConfiguredParams->userPriority;
			pTspecParams->uNominalMSDUsize = pConfiguredParams->nominalMsduSize;
			pTspecParams->uMeanDataRate = pConfiguredParams->meanDataRate;
			pTspecParams->uMinimumPHYRate = pConfiguredParams->minimumPHYRate;
			pTspecParams->uSurplusBandwidthAllowance = pConfiguredParams->surplausBwAllowance;
			pTspecParams->uAPSDFlag = pConfiguredParams->UPSDFlag;
			pTspecParams->uMediumTime = pConfiguredParams->mediumTime;
		}
		else
		{
			pQosMngr->tspecRenegotiationParams[USER_PRIORITY_4].uUserPriority = MAX_USER_PRIORITY;
		}
		break;

	default:
           WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_getParamsExtend Error: unknown paramType 0x%x!\n",pParamInfo->paramType)); 
			return (PARAM_NOT_SUPPORTED);

	}
	return OK;
}

/************************************************************************
 *                        qosMngr_getACparams           			    *
 ************************************************************************
DESCRIPTION: The function is an API for external modules to qet qos parameters
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.
            pParamInfo           -  qos parameters information.


OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

TI_STATUS qosMngr_getParams(TI_HANDLE  hQosMngr,paramInfo_t *pParamInfo)
{
	acTrfcType_e           acID;
	qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

	if(pQosMngr == NULL)
		return NOK;

	WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_getParams: %x\n", pParamInfo->paramType)); 

	switch(pParamInfo->paramType)
	{
	case QOS_PACKET_BURST_ENABLE:
		pParamInfo->content.qosPacketBurstEnb = pQosMngr->qosPacketBurstEnable;
		break;
	case QOS_MNGR_CURRENT_PS_MODE:
		pParamInfo->content.currentPsMode = pQosMngr->currentPsMode;
		break;

    case QOS_MNGR_ACTIVE_PROTOCOL:
       pParamInfo->content.qosSiteProtocol = pQosMngr->activeProtocol;
       break;

    case QOS_MNGR_GET_DESIRED_PS_MODE:
        pParamInfo->content.qosDesiredPsMode.uDesiredPsMode = pQosMngr->desiredPsMode;
		for(acID = FIRST_AC_INDEX; acID < MAX_NUM_OF_AC ; acID++ )
			pParamInfo->content.qosDesiredPsMode.uDesiredWmeAcPsMode[acID] = pQosMngr->acParams[acID].desiredWmeAcPsMode;
        break;
	   
	case QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC:
	/* Check if voice call present. If so, store current TSPEC configuration */
		pParamInfo->content.TspecConfigure.voiceTspecConfigure = (UINT8)pQosMngr->voiceTspecConfigured;
		pParamInfo->content.TspecConfigure.videoTspecConfigure = (UINT8)pQosMngr->videoTspecConfigured;

		WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_getParams: QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC=%d\n", pQosMngr->voiceTspecConfigured)); 

		if (pQosMngr->voiceTspecConfigured == TRUE) 
		{
			OS_802_11_QOS_TSPEC_PARAMS *pTspecParams;
			tspecInfo_t *pConfiguredParams;

			/* Store voice TSPEC params - must be configured */
			pTspecParams = &pQosMngr->tspecRenegotiationParams[USER_PRIORITY_6];
			pConfiguredParams = &pQosMngr->resourceMgmtTable.candidateTspecInfo[USER_PRIORITY_6];

			pTspecParams->uUserPriority = pConfiguredParams->userPriority;
			pTspecParams->uNominalMSDUsize = pConfiguredParams->nominalMsduSize;
			pTspecParams->uMeanDataRate = pConfiguredParams->meanDataRate;
			pTspecParams->uMinimumPHYRate = pConfiguredParams->minimumPHYRate;
			pTspecParams->uSurplusBandwidthAllowance = pConfiguredParams->surplausBwAllowance;
			pTspecParams->uAPSDFlag = pConfiguredParams->UPSDFlag;
			pTspecParams->uMediumTime = pConfiguredParams->mediumTime;
		}
		else
		{
			pQosMngr->tspecRenegotiationParams[USER_PRIORITY_6].uUserPriority = MAX_USER_PRIORITY;
		}

		if (pQosMngr->videoTspecConfigured == TRUE) 
		{
			OS_802_11_QOS_TSPEC_PARAMS *pTspecParams;
			tspecInfo_t *pConfiguredParams;

			/* Store signalling TSPEC params if configured in user priority 4 */
			pTspecParams = &pQosMngr->tspecRenegotiationParams[USER_PRIORITY_4];
			pConfiguredParams = &pQosMngr->resourceMgmtTable.candidateTspecInfo[USER_PRIORITY_4];

			pTspecParams->uUserPriority = pConfiguredParams->userPriority;
   			pTspecParams->uNominalMSDUsize = pConfiguredParams->nominalMsduSize;
   			pTspecParams->uMeanDataRate = pConfiguredParams->meanDataRate;
   			pTspecParams->uMinimumPHYRate = pConfiguredParams->minimumPHYRate;
   			pTspecParams->uSurplusBandwidthAllowance = pConfiguredParams->surplausBwAllowance;
   			pTspecParams->uAPSDFlag = pConfiguredParams->UPSDFlag;
   			pTspecParams->uMediumTime = pConfiguredParams->mediumTime;
   		}
		else
		{
			pQosMngr->tspecRenegotiationParams[USER_PRIORITY_4].uUserPriority = MAX_USER_PRIORITY;
		}
		break;

	default:
           WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_getParams Error: unknown paramType 0x%x!\n",pParamInfo->paramType)); 
			return (PARAM_NOT_SUPPORTED);
/*		break; - unreachable */

	}
	return OK;
}

/************************************************************************
 *                        qosMngr_setParams              			    *
 ************************************************************************
DESCRIPTION: The function is an API for external modules to set qos parameters
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.
            pParamInfo           -  qos parameters information.


OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

TI_STATUS qosMngr_setParams(TI_HANDLE  hQosMngr,paramInfo_t *pParamInfo)
{
    qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;
	paramInfo_t			   param;
	whalParamInfo_t		   whalParam;		
	acTrfcType_e           acID;
	TI_STATUS              status;

	if(pQosMngr == NULL)
		return NOK;

	if(pParamInfo == NULL)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
			("qosMngr_setParams :Error trying to set NULL params!\n")); 
		return NOK;
	}

	WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_setParams: %x\n", pParamInfo->paramType)); 

	switch(pParamInfo->paramType)
	{

		case QOS_PACKET_BURST_ENABLE:

			if (pParamInfo->content.qosPacketBurstEnb > QOS_PACKET_BURST_ENABLE_MAX)
				return (PARAM_VALUE_NOT_VALID);
			
			/* No change */
			if (pParamInfo->content.qosPacketBurstEnb == pQosMngr->qosPacketBurstEnable)
				return OK;

			/* Update the qosPacketBurstEnable parameter */
			pQosMngr->qosPacketBurstEnable = pParamInfo->content.qosPacketBurstEnb;

			/* Packet burst enable changed from F to T */ 
			if (pParamInfo->content.qosPacketBurstEnb == TRUE)
			{
				/* Update the acTrafficInitParams of BE to the packet burst def*/
				pQosMngr->acParams[QOS_AC_BE].acQosInitParams.txopLimit = pQosMngr->qosPacketBurstTxOpLimit;
			
				/* Update the acTrafficParams of BE and the hal to the packet burst def*/
				if (pQosMngr->activeProtocol == NONE_QOS)
				{
					pQosMngr->acParams[QOS_AC_BE].acQosParams.txopLimit = pQosMngr->qosPacketBurstTxOpLimit;
					/* verify the parameters and update the hal */
					status = verifyAndConfigQosParams(hQosMngr,&(pQosMngr->acParams[QOS_AC_BE].acQosParams));
					if(status != OK)
						return status;
				}
			}
				
			/* Packet burst enable changed from T to F*/ 
			else 
			{
				/* Update the acTrafficInitParams of BE to the AC def*/
				pQosMngr->acParams[QOS_AC_BE].acQosInitParams.txopLimit = QOS_TX_OP_LIMIT_DEF;
			
				/* Update the acTrafficParams of BE  and the hal to the AC def*/
				if (pQosMngr->activeProtocol == NONE_QOS)
				{
					pQosMngr->acParams[QOS_AC_BE].acQosParams.txopLimit = QOS_TX_OP_LIMIT_DEF;
					/* verify the parameters and update the hal */
					status = verifyAndConfigQosParams(hQosMngr,&(pQosMngr->acParams[QOS_AC_BE].acQosParams));
					if(status != OK)
						return status;
				}
			}
			break;

		case QOS_MNGR_SET_SITE_PROTOCOL:
			if(pParamInfo->content.qosSiteProtocol == WME)
				pQosMngr->WMESiteSupport = TRUE;
			else
				pQosMngr->WMESiteSupport = FALSE;
		break;

	case QOS_MNGR_SET_OS_PARAMS:
		if((acTrfcType_e)pParamInfo->content.qosOsParams.acID > QOS_HIGHEST_AC_INDEX)
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
					  ("qosMngr_setParams :Error  trying to set invalid acId: %d param",pParamInfo->content.qosOsParams.acID)); 

			return (PARAM_VALUE_NOT_VALID);
		}

		if((pParamInfo->content.qosOsParams.VoiceDeliveryProtocol != TRUE) && (pParamInfo->content.qosOsParams.VoiceDeliveryProtocol != FALSE))
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_setParams :Error  trying to set invalid VoiceDeliveryProtocol: %d param",pParamInfo->content.qosOsParams.VoiceDeliveryProtocol)); 
			
			return (PARAM_VALUE_NOT_VALID);
		}
		
		if((pParamInfo->content.qosOsParams.VoiceDeliveryProtocol == TRUE) && ((PSScheme_e)pParamInfo->content.qosOsParams.PSDeliveryProtocol == PS_SCHEME_UPSD_TRIGGER))
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_setParams Error: trying to set invalid VoiceDeliveryProtocol == PS_POLL and PSDeliveryProtocol = UPSD\n")); 
			
			return (PARAM_VALUE_NOT_VALID);
		}

		if((pParamInfo->content.qosOsParams.VoiceDeliveryProtocol == TRUE) && ((acTrfcType_e)pParamInfo->content.qosOsParams.acID !=  QOS_AC_VO))
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_setParams Error: trying to set invalid VoiceDeliveryProtocol == PS_POLL and AC != VOICE \n")); 
			
			return (PARAM_VALUE_NOT_VALID);
		}

		if(((PSScheme_e)pParamInfo->content.qosOsParams.PSDeliveryProtocol != PS_SCHEME_LEGACY_PSPOLL) && ((PSScheme_e)pParamInfo->content.qosOsParams.PSDeliveryProtocol != PS_SCHEME_UPSD_TRIGGER))
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_setParams :Error trying to set invalid PSDeliveryProtocol: %d param\n",pParamInfo->content.qosOsParams.PSDeliveryProtocol)); 

			return (PARAM_VALUE_NOT_VALID);
		}

		/* config tidConf */
		acID = (acTrfcType_e)pParamInfo->content.qosOsParams.acID;

        /* Convert TRUE/FALSE setting (from Utility Adapter) to PS_POLL or PS_NONE settings */
        if (pParamInfo->content.qosOsParams.VoiceDeliveryProtocol == FALSE)
        {
           pParamInfo->content.qosOsParams.VoiceDeliveryProtocol = PS_SCHEME_LEGACY;
        }
        if (pParamInfo->content.qosOsParams.VoiceDeliveryProtocol == TRUE)
        {
           pParamInfo->content.qosOsParams.VoiceDeliveryProtocol = PS_SCHEME_LEGACY_PSPOLL;
        }
           

		if( (pParamInfo->content.qosOsParams.PSDeliveryProtocol != pQosMngr->acParams[acID].desiredWmeAcPsMode) && 
			(pQosMngr->isConnected == TRUE) )
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_setParams :Error  trying to set new PS protocol while connected")); 
			
			return (PARAM_VALUE_NOT_VALID);
		}


		/* UPSD_FW open in upsd integration */
		/* set the current PS mode. In not connected state it is always Legacy since the currentPsMode only 
		 update after connection */
		pQosMngr->acParams[acID].QtrafficParams.psScheme = pQosMngr->acParams[acID].currentWmeAcPsMode;
		pQosMngr->acParams[acID].msduLifeTimeParam = pParamInfo->content.qosOsParams.MaxLifeTime;

		status = verifyAndConfigTrafficParams(pQosMngr,&(pQosMngr->acParams[acID].QtrafficParams));
		if(status != OK)
			return status;
		
		/* set txData Voice Delivery Protocol mode */
		if(acID == QOS_AC_VO)
			pQosMngr->desiredVoiceDeliveryProtocol = pParamInfo->content.qosOsParams.VoiceDeliveryProtocol;

		param.content.txDataQosParams.acID = acID;
		param.content.txDataQosParams.acTrfcCtrl.PsMode = pParamInfo->content.qosOsParams.VoiceDeliveryProtocol;
		param.paramType = TX_DATA_PS_MODE_PARAM;
		txData_setParam(pQosMngr->hTxData,&param);

		param.content.txDataQosParams.acTrfcCtrl.MsduLifeTime = pParamInfo->content.qosOsParams.MaxLifeTime;
		param.paramType = TX_DATA_CONFIG_AC_MSDU_LIFE_TIME;
		txData_setParam(pQosMngr->hTxData,&param);

		/* synch psPoll mode with qosMngr */
		/* Update the PsMode parameter */
		pQosMngr->acParams[acID].desiredWmeAcPsMode = pParamInfo->content.qosOsParams.PSDeliveryProtocol;
		break;

	case QOS_MNGR_CURRENT_PS_MODE:
		if( (pQosMngr->activeProtocol == WME) && (pQosMngr->desiredPsMode == PS_SCHEME_UPSD_TRIGGER) && (pParamInfo->content.currentPsMode == PS_SCHEME_UPSD_TRIGGER) )
			pQosMngr->currentPsMode = PS_SCHEME_UPSD_TRIGGER;
		else
			pQosMngr->currentPsMode = PS_SCHEME_LEGACY_PSPOLL;
		break;
		
    case QOS_MNGR_ADD_TSPEC_REQUEST:
		pQosMngr->TSPECNegotiationResultCallb = NULL;
		pQosMngr->TSPECNegotiationResultModule = NULL;
		return (qosMngr_requestAdmission(hQosMngr,  &pParamInfo->content.qosAddTspecRequest));
/*		break; - unreachable */
		
	case QOS_MNGR_RESEND_TSPEC_REQUEST:
		WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
								("qosMngr_setParams: QOS_MNGR_RESEND_TSPEC_REQUEST\n")); 
		pQosMngr->TSPECNegotiationResultCallb = (qosMngrCallb_t)pParamInfo->content.qosRenegotiateTspecRequest.callback;
		pQosMngr->TSPECNegotiationResultModule = pParamInfo->content.qosRenegotiateTspecRequest.handler; 
		status = qosMngr_requestAdmission(hQosMngr,  &pQosMngr->tspecRenegotiationParams[USER_PRIORITY_6]);

		if ((status == OK) && (pQosMngr->tspecRenegotiationParams[USER_PRIORITY_4].uUserPriority != MAX_USER_PRIORITY))
		{
			status = qosMngr_requestAdmission(hQosMngr,  &pQosMngr->tspecRenegotiationParams[USER_PRIORITY_4]);
		}
		return (status);
/*		break;  - unreachable */
		
    case QOS_MNGR_DEL_TSPEC_REQUEST:
		return (qosMngr_deleteAdmission(hQosMngr, &pParamInfo->content.qosDelTspecRequest));
/*		break; - unreachable */
		
    case QOS_MNGR_AC_STATUS:
		return (qosMngr_getCurrAcStatus (hQosMngr,&pParamInfo->content.qosCurrentAcStatus));
/*		break; - unreachable */

    case QOS_MNGR_AP_QOS_PARAMETERS:  /* API GetAPQosParameters */
		acID = (acTrfcType_e) pParamInfo->content.qosApQosParams.uAC;

		if(acID > QOS_HIGHEST_AC_INDEX)
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
					  ("qosMngr_setParams :Error  trying to set invalid acId: %d param\n",pParamInfo->content.qosApQosParams.uAC)); 

			return (PARAM_VALUE_NOT_VALID);
		}
		if(pQosMngr->isConnected == FALSE)
		{
			return NOT_CONNECTED;
		}
		if(pQosMngr->activeProtocol == NONE_QOS)
		{
			return NO_QOS_AP;
		}
		
		pParamInfo->content.qosApQosParams.uAssocAdmissionCtrlFlag = pQosMngr->acParams[acID].apInitAdmissionState; /* admission flag */
		pParamInfo->content.qosApQosParams.uAIFS = pQosMngr->acParams[acID].acQosParams.aifsn;
		pParamInfo->content.qosApQosParams.uCwMin = (1 << pQosMngr->acParams[acID].acQosParams.cwMin)-1;
		pParamInfo->content.qosApQosParams.uCwMax = (1 << pQosMngr->acParams[acID].acQosParams.cwMax)-1;
		pParamInfo->content.qosApQosParams.uTXOPLimit = pQosMngr->acParams[acID].acQosParams.txopLimit << 5;

		break;

	case QOS_MNGR_OS_TSPEC_PARAMS: 

		if( pParamInfo->content.qosTspecParameters.uUserPriority > MAX_USER_PRIORITY )
		{	
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
               ("qosMngr_getTspecParams: userPriority > 7 -> Ignore !!!\n"));
			return NOK;
		}

		if(pQosMngr->isConnected == FALSE)
		{	
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
               ("qosMngr_getTspecParams: Not connected - Ignoring request !!!\n"));
			return NOT_CONNECTED;
		}

		if(pQosMngr->activeProtocol == NONE_QOS)
		{	
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
               ("qosMngr_getTspecParams: Not connected to QOS AP - Ignoring reqeust !!!\n"));
			return NO_QOS_AP;
		}
		
		acID = (acTrfcType_e)WMEQosTagToACTable[pParamInfo->content.qosTspecParameters.uUserPriority];

		/* check if signaling is already in process*/
		if(pQosMngr->resourceMgmtTable.candidateTspecInfo[acID].trafficAdmState == AC_WAIT_ADMISSION)
		{
			WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG,("qosMngr_requestAdmission: AC = %d , TSPEC Signaling is in progress -> Ignoring request !!!\n",acID));
			return TRAFIC_ADM_PENDING;
		}

	   /* check if UP is admitted or not */
	   if(pQosMngr->resourceMgmtTable.currentTspecInfo[acID].userPriority != pParamInfo->content.qosTspecParameters.uUserPriority)
       {	
		 WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
            ("qosMngr_getTspecParams: user priority is not admitted. -> Ignore !!!\n"));
		 return USER_PRIORITY_NOT_ADMITTED;
		}

		pParamInfo->content.qosTspecParameters.uMeanDataRate = pQosMngr->resourceMgmtTable.currentTspecInfo[acID].meanDataRate;
		pParamInfo->content.qosTspecParameters.uNominalMSDUsize = pQosMngr->resourceMgmtTable.currentTspecInfo[acID].nominalMsduSize;
		pParamInfo->content.qosTspecParameters.uAPSDFlag  = pQosMngr->resourceMgmtTable.currentTspecInfo[acID].UPSDFlag;
		pParamInfo->content.qosTspecParameters.uMinimumPHYRate  = pQosMngr->resourceMgmtTable.currentTspecInfo[acID].minimumPHYRate;
		pParamInfo->content.qosTspecParameters.uSurplusBandwidthAllowance  = pQosMngr->resourceMgmtTable.currentTspecInfo[acID].surplausBwAllowance;
		pParamInfo->content.qosTspecParameters.uMediumTime = pQosMngr->resourceMgmtTable.currentTspecInfo[acID].mediumTime;
		break;

	case QOS_SET_RATE_THRESHOLD: 

		ctrlData_setTspecsRateThresholds(pQosMngr->hCtrlData,
											(UINT8)pParamInfo->content.QOSRateThreshold.uAC,
											(UINT8)pParamInfo->content.QOSRateThreshold.uHighThreshold,
											(UINT8)pParamInfo->content.QOSRateThreshold.uLowThreshold);

		
		/* If currently connected to a QOS AP , need to enable the TSPEc event upon the setting of the thresholds */
		if(pQosMngr->activeProtocol == WME)
		{
			ctrlData_setTspecsRateEvent(pQosMngr->hCtrlData, (UINT8)pParamInfo->content.QOSRateThreshold.uAC, TRUE);
		}

		break;

	case QOS_GET_RATE_THRESHOLD:

		/* SET operation is performed, but actually this is only for AC parameter transfer from Utility Adapter to driver, since copy
	      of user supplied block of data (and vice versa) is only performed in SetParam calls, the driver can also modify the supplied
		  structure and thus return it to user mode */
		ctrlData_getTspecsRateThresholds(pQosMngr->hCtrlData,
									(UINT8)pParamInfo->content.QOSRateThreshold.uAC,
									(UINT32*)&pParamInfo->content.QOSRateThreshold.uHighThreshold,
									(UINT32*)&pParamInfo->content.QOSRateThreshold.uLowThreshold);

		break;

	case QOS_SET_RX_TIME_OUT:
		if (pParamInfo->content.rxTimeOut.UPSD == 0)
		{
				WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
								  ("%s :Error trying to set invalid zero timeout for UPSD \n",__FUNCTION__)); 
				return PARAM_VALUE_NOT_VALID;
				
		}
		pQosMngr->rxTimeOut.psPoll = (UINT16)pParamInfo->content.rxTimeOut.psPoll;
		pQosMngr->rxTimeOut.UPSD = (UINT16)pParamInfo->content.rxTimeOut.UPSD;


		/* set RxTimeOut to FW */
		whalParam.paramType	= HAL_CTRL_RX_TIME_OUT_PARAM;
		whalParam.content.halCtrlRxTimeOut = pQosMngr->rxTimeOut;
		whalCtrl_SetParam(pQosMngr->hHalCtrl,&whalParam); 
		break;


	case QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC:
		if( pParamInfo->content.TspecConfigure.voiceTspecConfigure || pParamInfo->content.TspecConfigure.videoTspecConfigure)
            pQosMngr->performTSPECRenegotiation = TRUE;
		else
			pQosMngr->performTSPECRenegotiation = FALSE;

	   WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
							   ("qosMngr_setParams: QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC=%d\n", pQosMngr->performTSPECRenegotiation)); 
	   break;

	default:
         WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_getParams Error: unknown paramType 0x%x!\n",pParamInfo->paramType)); 
			return (PARAM_NOT_SUPPORTED);
/*		break; - unreachable */
	}

	return OK;


}

TI_STATUS qosMngr_setParamsPartial(TI_HANDLE  hQosMngr,paramInfoPartial_t *pParamInfo)
{
    qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;
    
	if(pQosMngr == NULL)
		return NOK;

	if(pParamInfo == NULL)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
			("qosMngr_setParams :Error trying to set NULL params!\n")); 
		return NOK;
	}

	WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, ("qosMngr_setParams: %x\n", pParamInfo->paramType)); 

	switch(pParamInfo->paramType)
	{
	case QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC:
		if( pParamInfo->content.TspecConfigure.voiceTspecConfigure || pParamInfo->content.TspecConfigure.videoTspecConfigure)
            pQosMngr->performTSPECRenegotiation = TRUE;
		else
			pQosMngr->performTSPECRenegotiation = FALSE;

	   WLAN_REPORT_INFORMATION(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
							   ("qosMngr_setParams: QOS_MNGR_VOICE_RE_NEGOTIATE_TSPEC=%d\n", pQosMngr->performTSPECRenegotiation)); 
	   break;

	default:
         WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
				("qosMngr_getParams Error: unknown paramType 0x%x!\n",pParamInfo->paramType)); 
			return (PARAM_NOT_SUPPORTED);
	}

	return OK;
}

/************************************************************************
 *                        verifyAndConfigTrafficParams  			    *
 ************************************************************************
DESCRIPTION: The function verifies the parameters set by qosMngr to 
             the queue traffic params in whalCtrl to be configured to TNET. 
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.
            pAcTrafficParams     -  pointer to ac parameters.

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

static TI_STATUS verifyAndConfigTrafficParams(qosMngr_t *pQosMngr, queueTrafficParams_t *pQtrafficParams)
{
    whalParamInfo_t		   whalParam;    
    queueTrafficParams_t   queueTrafficParams;

	if(pQtrafficParams->queueID >  MAX_NUM_OF_TX_QUEUES - 1)
    {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigTrafficParams :Error  trying to set invalid queueID: %d param",pQtrafficParams->queueID)); 

		return (PARAM_VALUE_NOT_VALID);
	}


	if(pQtrafficParams->channelType > MAX_CHANNEL_TYPE)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigTrafficParams :Error  trying to set invalid channelType: %d param",pQtrafficParams->channelType)); 

		return (PARAM_VALUE_NOT_VALID);

	}

    /* TBD */
	if(pQtrafficParams->tsid > AC_PARAMS_MAX_TSID)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigTrafficParams :Error  trying to set invalid tsid: %d param",pQtrafficParams->tsid)); 

		return (PARAM_VALUE_NOT_VALID);

	}


	if(pQtrafficParams->psScheme > MAX_PS_SCHEME)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigTrafficParams :Error  trying to set invalid psScheme: %d param",pQtrafficParams->psScheme)); 

		return (PARAM_VALUE_NOT_VALID);
	}

    /* TBD */
#if 0
	if(pQtrafficParams->APSDConf > MAX_APSD_CONF)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigTrafficParams :Error  trying to set invalid APSDConf: %d param",pQtrafficParams->APSDConf)); 

		return (PARAM_VALUE_NOT_VALID);
	}
#endif

	if(pQtrafficParams->ackPolicy > MAX_ACK_POLICY)
	{
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigTrafficParams :Error  trying to set invalid ackPolicy: %d param",pQtrafficParams->ackPolicy)); 

		return (PARAM_VALUE_NOT_VALID);
	}

    /*
     * Convert the QOS PS-scheme enum into the WHAL enum.
     * NOTE: need to copy for not to change the QoS configuration
     */
    queueTrafficParams = *pQtrafficParams;

    switch (queueTrafficParams.psScheme)
    {
    case PS_SCHEME_LEGACY:
        queueTrafficParams.psScheme = PS_SCHEME_LEGACY;
        break;
    case PS_SCHEME_UPSD_TRIGGER:
        queueTrafficParams.psScheme = PS_SCHEME_UPSD_TRIGGER;
        break;
    case PS_SCHEME_LEGACY_PSPOLL:
        queueTrafficParams.psScheme = PS_SCHEME_LEGACY;
        break;
    case PS_SCHEME_SAPSD:
        queueTrafficParams.psScheme = PS_SCHEME_SAPSD;
        break;
    }

	whalParam.paramType = HAL_CTRL_QUEUES_PARAMS;
	/* set parameters */
	whalParam.content.pQueueTrafficParams = &queueTrafficParams;

	return(whalCtrl_SetParam(pQosMngr->hHalCtrl, &whalParam));
}

/************************************************************************
 *                        verifyAndConfigQosParams          		    *
 ************************************************************************
DESCRIPTION: The function verifies the parameters set by qosMngr to 
             the AC Qos params in whalCtrl to be configured to TNET. 
                                                                                                   
INPUT:      hQosMngr	         -	Qos Manager handle.
            pAcTrafficParams     -  pointer to ac parameters.

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/

static TI_STATUS  verifyAndConfigQosParams(qosMngr_t *pQosMngr,acQosParams_t *pAcQosParams)
{
    whalParamInfo_t		   whalParam;
	acQosParams_t          acQosParams;

	if(pAcQosParams->ac >  MAX_NUM_OF_AC - 1 )
    {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigQosParams :Error  trying to set invalid ac : %d param",pAcQosParams->ac)); 

		return (PARAM_VALUE_NOT_VALID);
	}
 /*  verification is unnecessary due to limited range of pAcQosParams->aifsn data type (UINT8)
	if(pAcQosParams->aifsn >  QOS_AIFS_MAX )
    {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigQosParams :Error  trying to set invalid aifsn : %d param",pAcQosParams->aifsn)); 

		return (PARAM_VALUE_NOT_VALID);
	}
 */
	if(pAcQosParams->cwMax >  QOS_CWMAX_MAX )
    {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigQosParams :Error  trying to set invalid cwMax : %d param",pAcQosParams->cwMax)); 

		return (PARAM_VALUE_NOT_VALID);
	}

	if(pAcQosParams->cwMin >  QOS_CWMIN_MAX )
    {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigQosParams :Error  trying to set invalid cwMax : %d param",pAcQosParams->cwMax)); 

		return (PARAM_VALUE_NOT_VALID);
	}

	if(pAcQosParams->txopLimit >  QOS_TX_OP_LIMIT_MAX )
    {
		WLAN_REPORT_ERROR(pQosMngr->hReport, QOS_MANAGER_MODULE_LOG, 
						  ("verifyAndConfigQosParams :Error  trying to set invalid txopLimit : %d param",pAcQosParams->txopLimit)); 

		return (PARAM_VALUE_NOT_VALID);
	}


	whalParam.paramType = HAL_CTRL_AC_PARAMS; 

	acQosParams.ac = pAcQosParams->ac;
	acQosParams.aifsn =  pAcQosParams->aifsn;

	/* convert to TNET units */
	acQosParams.cwMax =  (1 << pAcQosParams->cwMax) - 1; /* CwMax = 2^CwMax - 1*/
	acQosParams.cwMin =  (1 << pAcQosParams->cwMin) - 1; /* CwMin = 2^CwMin - 1*/
	acQosParams.txopLimit =  pAcQosParams->txopLimit << 5; /* in us */



	/* set parameters */
	whalParam.content.configureCmdCBParams.CB_buf = (UINT8*)&acQosParams;
	whalParam.content.configureCmdCBParams.CB_Func = NULL;
	whalParam.content.configureCmdCBParams.CB_handle = NULL;

	return whalCtrl_SetParam(pQosMngr->hHalCtrl, &whalParam);
}

/************************************************************************
 *                        qosMngr_selectActiveProtocol    			            *
 ************************************************************************
DESCRIPTION: The function is called in order to set the active protocol in
             the qosMngr according to site capabilities and desired mode.
             called from SystemConfig.
                                                                                                   
INPUT:      

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/
TI_STATUS qosMngr_selectActiveProtocol(TI_HANDLE  hQosMngr)
{
   	qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

	/* decide qos protocol */
	/* NOTE: if both exc qnd wme supported wme is chosen */
	if(pQosMngr->WMESiteSupport && pQosMngr->WMEEnable)
	{
		pQosMngr->activeProtocol = WME;
	}
	else
    {
		pQosMngr->activeProtocol = NONE_QOS;
	}
	WLAN_REPORT_DEBUG_TX(pQosMngr->hReport,
	 (" qosMngr_selectActiveProtocol() : pQosMngr->activeProtocol %d\n",pQosMngr->activeProtocol));

    return OK;
}

/************************************************************************
 *                        qosMngr_setAcPsDeliveryMode    			            *
 ************************************************************************
DESCRIPTION: The function is called in order to set the upsd/ps_poll according 
             to the desired and current upsd mode (per AC as well).
             called from systemConfig.
                                                                                                   
INPUT:      

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/
TI_STATUS qosMngr_setAcPsDeliveryMode(TI_HANDLE  hQosMngr)
{
   UINT8 acID;
   qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;

	/* in case the current PS mode is not UPSD  - the IE is empty */
	if(pQosMngr->currentPsMode == PS_SCHEME_UPSD_TRIGGER)
	{
		for(acID = FIRST_AC_INDEX;acID < MAX_NUM_OF_AC; acID++)
		{
			if(pQosMngr->acParams[acID].desiredWmeAcPsMode == PS_SCHEME_UPSD_TRIGGER)
			{
				pQosMngr->acParams[acID].currentWmeAcPsMode = PS_SCHEME_UPSD_TRIGGER;
			}
		}
    }
	else {
        paramInfo_t param;

        // Setting params for PS Poll mode
        // This was done to enable voice delivery protocol when the AP doesn't
        // support UASPD.
        // Note these values have been taken from the default value table in 
        // TiCtrl.c -- see TiUAPSDConfig()
        
        os_memoryZero( pQosMngr->hOs, &param, sizeof(paramInfo_t) );
        param.paramType = QOS_MNGR_SET_OS_PARAMS;

        // Setting AC Best Effort settings
        param.content.qosOsParams.acID = QOS_AC_BE;
        param.content.qosOsParams.MaxLifeTime = 512;
        param.content.qosOsParams.VoiceDeliveryProtocol = FALSE;
        param.content.qosOsParams.PSDeliveryProtocol = PS_SCHEME_LEGACY_PSPOLL;
        qosMngr_setParams( pQosMngr, &param );


        // Setting AC Background settings
        param.content.qosOsParams.acID = QOS_AC_BK;
        param.content.qosOsParams.MaxLifeTime = 100;
        param.content.qosOsParams.VoiceDeliveryProtocol = FALSE;
        param.content.qosOsParams.PSDeliveryProtocol = PS_SCHEME_LEGACY_PSPOLL;
        qosMngr_setParams( pQosMngr, &param );


        // Setting AC Video settings
        param.content.qosOsParams.acID = QOS_AC_VI;
        param.content.qosOsParams.MaxLifeTime = 100;
        param.content.qosOsParams.VoiceDeliveryProtocol = FALSE;
        param.content.qosOsParams.PSDeliveryProtocol = PS_SCHEME_LEGACY_PSPOLL;
        qosMngr_setParams( pQosMngr, &param );

        // Setting AC Voice settings
        param.content.qosOsParams.acID = QOS_AC_VO;
        param.content.qosOsParams.MaxLifeTime = 60;
        param.content.qosOsParams.VoiceDeliveryProtocol = TRUE;
        param.content.qosOsParams.PSDeliveryProtocol = PS_SCHEME_LEGACY_PSPOLL;
        qosMngr_setParams( pQosMngr, &param );
    }
	
	return OK;

}


/************************************************************************
 *                        qosMngr_getQosCapabiltyInfeElement    			            *
 ************************************************************************
DESCRIPTION: The function is called in order to build the Qos Capability
			 IE for the associatiomn request.
                                                                                                   
INPUT:      

OUTPUT:		

RETURN:     OK on success, NOK otherwise

************************************************************************/
TI_STATUS qosMngr_getQosCapabiltyInfeElement(TI_HANDLE  hQosMngr, UINT8 *pQosIe, UINT8 *pLen)
{    
	qosMngr_t *pQosMngr = (qosMngr_t *)hQosMngr;
	dot11_QOS_CAPABILITY_IE_t *dot11_QOS_CAPABILITY_IE = (dot11_QOS_CAPABILITY_IE_t *)pQosIe;
	TI_STATUS status = OK;
	UINT8	extraIeLen = 0;
	
	if(pQosMngr->activeProtocol == WME)
	{
		dot11_QOS_CAPABILITY_IE->hdr.eleId    = DOT11_QOS_CAPABILITY_ELE_ID;
		dot11_QOS_CAPABILITY_IE->hdr.eleLen   = DOT11_QOS_CAPABILITY_ELE_LEN;
		
		/* The default configuration of QoS info Field is legacy PS for all ACs */
		dot11_QOS_CAPABILITY_IE->QosInfoField = 0;
		
		/* in case the current PS mode is not UPSD  - the IE is empty */
		if(pQosMngr->currentPsMode == PS_SCHEME_UPSD_TRIGGER)
		{
			if(pQosMngr->acParams[QOS_AC_VO].currentWmeAcPsMode == PS_SCHEME_UPSD_TRIGGER)
			{
				dot11_QOS_CAPABILITY_IE->QosInfoField |= (1 << AC_VO_APSD_FLAGS_SHIFT);
			}
			if(pQosMngr->acParams[QOS_AC_VI].currentWm