/drivers/net/wireless/tiwlan1251/common/src/core/data_ctrl/Ctrl/Ctrl.c

Large files files are truncated, but you can click here to view the full file

/****************************************************************************
**+-----------------------------------------------------------------------+**
**|                                                                       |**
**| 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.  |**
**|                                                                       |**
**+-----------------------------------------------------------------------+**
****************************************************************************/
/***************************************************************************/
/*                                                                         */
/*      MODULE:     Ctrl.c                                                 */
/*      PURPOSE:    Control module functions                               */
/*                                                                         */
/***************************************************************************/
#include "Ctrl.h"
#include "802_11Defs.h"
#include "DataCtrl_Api.h"
#include "osApi.h"
#include "report.h" 
#include "utils.h"
#include "smeApi.h"
#include "siteMgrApi.h"
#include "Ethernet.h"
#include "tx.h"
#include "TrafficMonitorAPI.h"
#include "TI_IPC_Api.h"
#include "EvHandler.h"
#include "apConn.h"
#include "TNETW_Driver_api.h"
#include "Core_AdaptTx.h"
#include "whalCtrl_api.h"

static void selectRateTable(TI_HANDLE hCtrlData, UINT32 rateMask);
static void ctrlData_setTxRatePolicies(ctrlData_t *pCtrlData);
static void ctrlData_resetCounters(TI_HANDLE hCtrlData);

static void ctrlData_resetCounters(TI_HANDLE hCtrlData);

static void ctrlData_UnregisterTrafficIntensityEvents (TI_HANDLE hCtrlData);
static void ctrlData_RegisterTrafficIntensityEvents (TI_HANDLE hCtrlData);

static UINT32 ctrlData_buildHwBitMapFromArray(policyClassRatesArray_t *pArray);
static void ctrlData_storeTSRateSet(ctrlData_t *pCtrlData, txDataQosParams_t *tsrsParams);
static rate_e ctrlData_getClosestTSRate(ctrlData_t *pCtrlData, UINT32 ac, rate_e givenRate);

void ctrlData_TrafficThresholdCrossed(TI_HANDLE Context,UINT32 Cookie);


/* definitions for medium usage calculations - in uSec units*/
#define AVERAGE_ACK_TIME   10
#define AVERAGE_CTS_TIME   20
#define B_SIFS             10

#define SHORT_PREAMBLE_TIME   96
#define LONG_PREAMBLE_TIME    192

#define OFDM_PREAMBLE      12
#define OFDM_SIGNAL_EXT    6
#define OFDM_PLCP_HDR      24

#define OFDM_DURATION           (B_SIFS + OFDM_PLCP_HDR + OFDM_SIGNAL_EXT)
#define NONOFDM_SHORT_DURATION  (B_SIFS + SHORT_PREAMBLE_TIME)
#define NONOFDM_LONG_DURATION   (B_SIFS + LONG_PREAMBLE_TIME)

/*************************************************************************
*                        ctrlData_create                                 *
**************************************************************************
* DESCRIPTION:  This function initializes the Ctrl data module.                 
*                                                      
* INPUT:        hOs - handle to Os Abstraction Layer
*               
* OUTPUT:       TxCmplt_CB - call back function that return to configMngr
*               in order to register in the Hal
*
* RETURN:       Handle to the allocated Ctrl data control block
************************************************************************/
TI_HANDLE ctrlData_create(TI_HANDLE hOs)
{
    ctrlData_t*         hCtrlData;
    rateAdaptation_t*   pRateAdaptation;
#ifdef SUPPORT_4X
    fourX_t*            pFourX;
#endif
    classifier_t*       pClsfr;

    if( hOs  == NULL )
    {
        WLAN_OS_REPORT(("FATAL ERROR: ctrlData_create(): OS handle Error - Aborting\n"));
        return NULL;
    }

    /* alocate Control module control block */
    hCtrlData = os_memoryAlloc(hOs, (sizeof(ctrlData_t)));
    if(!hCtrlData)
        return NULL;

    /* create rate adaptation module */
    pRateAdaptation = rateAdaptation_create(hOs);
#ifdef SUPPORT_4X
    /* create 4X module */
    pFourX = fourX_create(hOs);
#endif
    /* create the classifier module */
    pClsfr = Classifier_create(hOs);
    
    if ( (!pRateAdaptation) 
#ifdef SUPPORT_4X
         || (!pFourX)
#endif
       )
    {
        utils_nullMemoryFree(hOs, pRateAdaptation, sizeof(rateAdaptation_t));
#ifdef SUPPORT_4X
        utils_nullMemoryFree(hOs, pFourX, sizeof(fourX_t));
#endif
        utils_nullMemoryFree(hOs, hCtrlData, sizeof(ctrlData_t));

        WLAN_OS_REPORT(("FATAL ERROR: ctrlData_create(): Error Creating Ctrl Module - Aborting\n"));
        return(NULL);
    }

    /* reset control module control block */
    os_memoryZero(hOs, hCtrlData, (sizeof(ctrlData_t)));

    hCtrlData->pRateAdaptation = pRateAdaptation;
#ifdef SUPPORT_4X
    hCtrlData->pFourX = pFourX;
#endif
    hCtrlData->pClsfr = pClsfr;

    hCtrlData->hOs = hOs;

    return(hCtrlData);
}

/***************************************************************************
*                           ctrlData_config                                *
****************************************************************************
* DESCRIPTION:  This function configures the Ctrl Data module       
* 
* INPUTS:       hCtrlData - The object
*               hWhalCtrl - Handle to the Whal Ctrl object
*               hSiteMgrHandle - Handle to the Site Mngr object
*               hTxData - Handle to the Tx Data object
*               hRxData - Handle to the Rx Data object
*               hOs - Handle to the Os Abstraction Layer
*               hReport - Handle to the Report object
*               ctrlDataInitParams - pointer to Ctrl module init parameters
* OUTPUT:       
* 
* RETURNS:      OK - Configuration succesfull
*               NOK - Configuration unsuccesfull
***************************************************************************/
TI_STATUS ctrlData_config(TI_HANDLE         hCtrlData,
                       TI_HANDLE            hWhalCtrl, 
                       TI_HANDLE            hSiteMgrHandle, 
                       TI_HANDLE            hTxData, 
                       TI_HANDLE            hRxData, 
                       TI_HANDLE            hOs, 
                       TI_HANDLE            hReport, 
                       TI_HANDLE            hMemMngr, 
                       TI_HANDLE            hEvHandler,
                       TI_HANDLE            hAPConnection,
                       TI_HANDLE            hTrafficMonitor,                       
                       disassocSentCB_t     disassocSentCBFunc,
                       TI_HANDLE            disassocSentCBObj,  
                       ctrlDataInitParams_t *ctrlDataInitParams)
{
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
    TI_STATUS Status = OK;
    rateClassClients_e clientIDindex;
    txRateClassId_e  TxRateIndex;
    UINT32 ac;

    /* check parameters validity */
    if( hCtrlData == NULL || hWhalCtrl == NULL || hSiteMgrHandle == NULL || hRxData == NULL ||
        hTxData == NULL || hOs == NULL || hReport == NULL || hMemMngr == NULL || ctrlDataInitParams == NULL)
    {
        WLAN_OS_REPORT(("FATAL ERROR: ctrlData_config(): Parameters Error - Aborting\n"));
        return NOK;
    }

    /* set objects handles */
    pCtrlData->hWhalCtrl =  hWhalCtrl;  
    pCtrlData->hSiteMgr =   hSiteMgrHandle;
    pCtrlData->hTxData =    hTxData;
    pCtrlData->hRxData =    hRxData;
    pCtrlData->hOs =        hOs;
    pCtrlData->hReport =    hReport;
    pCtrlData->hAPConn = hAPConnection;
    pCtrlData->hEvHandler = hEvHandler;
    pCtrlData->hTrafficMonitor  = hTrafficMonitor;

    pCtrlData->disassocSentCBObj = disassocSentCBObj;
    pCtrlData->disassocSentCBFunc = disassocSentCBFunc;

    /*  set Control module parameters */
    pCtrlData->ctrlDataRateControlEnable = ctrlDataInitParams->ctrlDataRateControlEnable;
    pCtrlData->ctrlDataIbssProtectionType = ctrlDataInitParams->ctrlDataDesiredIbssProtection;
    pCtrlData->ctrlDataRtsCtsStatus = ctrlDataInitParams->ctrlDataDesiredCtsRtsStatus;

#ifdef SUPPORT_4X
    pCtrlData->ctrlDataFourXEnable = ctrlDataInitParams->ctrlDataFourXEnable;
    pCtrlData->ctrlDataCerruentFourXstate = ctrlDataInitParams->ctrlDataFourXEnable;
#else
    pCtrlData->ctrlDataFourXEnable = FALSE;
    pCtrlData->ctrlDataCerruentFourXstate = FALSE;
#endif
    
    MAC_COPY(pCtrlData->hOs, (&pCtrlData->ctrlDataDeviceMacAddress), 
            (&ctrlDataInitParams->ctrlDataDeviceMacAddress));

    pCtrlData->ctrlDataStartStoplinkControlAlg = DEF_START_STOP_LINK_CTRL_ALG;
    pCtrlData->ctrlDataCurrentBasicRate = DEF_BASIC_RATE;
    pCtrlData->ctrlDataBasicRateBitMask = DEF_BASIC_RATE_MASK;
    pCtrlData->ctrlDataCurrentBasicModulationType = DRV_MODULATION_QPSK;
    pCtrlData->ctrlDataCurrentModulationType = DEF_CURRENT_MUDULATION_TYPE;
    pCtrlData->ctrlDataCurrentBssType = BSS_INFRASTRUCTURE;
    os_memoryCopy(pCtrlData->hOs, &pCtrlData->ctrlDataRateTables,
                                  &ctrlDataInitParams->rateTable,
                                  sizeof(rateTables_t) );

    for (clientIDindex = (rateClassClients_e)0 ; clientIDindex < NUM_OF_RATE_CLASS_CLIENTS ; clientIDindex++) 
    {
        pCtrlData->bIsClassAvailable[clientIDindex] = TRUE;
        /* by default all clients use all available rates */ 
        pCtrlData->currClientRateMask[clientIDindex] = ALL_RATES_AVAILABLE;
        pCtrlData->nextClientRateMask[clientIDindex] = ALL_RATES_AVAILABLE;

        /* Init Params are initialized for USER & SG policies only */
        /* Set short/long retry for all ACs */
        for (ac=0; ac < MAX_NUM_OF_AC; ac++) 
        {
            pCtrlData->ctrlDataTxRatePolicy.rateClass[clientIDindex*MAX_NUM_OF_AC+ac].longRetryLimit  = ctrlDataInitParams->ctrlDataTxRatePolicy[clientIDindex].longRetryLimit;
            pCtrlData->ctrlDataTxRatePolicy.rateClass[clientIDindex*MAX_NUM_OF_AC+ac].shortRetryLimit = ctrlDataInitParams->ctrlDataTxRatePolicy[clientIDindex].shortRetryLimit;
        }

        for (TxRateIndex = txPolicy54; TxRateIndex < MAX_NUM_OF_TX_RATES_IN_CLASS; TxRateIndex++)
        {
            pCtrlData->policyClassRatesArrayCck[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayCck[clientIDindex].txRate[TxRateIndex];
            pCtrlData->policyClassRatesArrayPbcc[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayPbcc[clientIDindex].txRate[TxRateIndex]; 
            pCtrlData->policyClassRatesArrayOfdm[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayOfdm[clientIDindex].txRate[TxRateIndex]; 
            pCtrlData->policyClassRatesArrayOfdmA[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayOfdmA[clientIDindex].txRate[TxRateIndex]; 
        }
    }
    /* By default use USER_RATE_CLASS */
    pCtrlData->currClientRateID = USER_RATE_CLASS;
    pCtrlData->configuredClientRateID = USER_RATE_CLASS;

    pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataCckRateTable;

    /* reset Counters */
    ctrlData_resetCounters(pCtrlData);
    
    /* Configure Rate Adaptation Module */
    rateAdaptation_config(pCtrlData->pRateAdaptation, hOs, hReport, pCtrlData, hEvHandler,
                          hAPConnection, &ctrlDataInitParams->rateAdaptationInitParam); 

#ifdef SUPPORT_4X
    /* configure fourX Module */
    fourX_config(pCtrlData->pFourX, hOs, hReport, hMemMngr, hWhalCtrl, hTxData,
                            &ctrlDataInitParams->fourXInitParams);
#endif

    /* configure the classifier Module */
    Status = Classifier_config(pCtrlData->pClsfr, hOs, hReport, &ctrlDataInitParams->ClsfrInitParam);
    if (Status != OK)
    {
        WLAN_OS_REPORT(("FATAL ERROR: ctrlData_config(): Classifier_config() failed - Aborting\n"));
        return Status;
    }

    /* Initialize traffic intensity threshold parameters */
    pCtrlData->ctrlDataTrafficIntensityEventsEnabled = ctrlDataInitParams->ctrlDataTrafficThresholdEnabled;
    pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold = ctrlDataInitParams->ctrlDataTrafficThreshold.uHighThreshold;
    pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold = ctrlDataInitParams->ctrlDataTrafficThreshold.uLowThreshold;
    pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval = ctrlDataInitParams->ctrlDataTrafficThreshold.TestInterval;

    WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
       ("\nTraffic Intensity parameters:\nEvents enabled = %d\nuHighThreshold = %d\nuLowThreshold = %d\nTestInterval = %d\n\n",
       pCtrlData->ctrlDataTrafficIntensityEventsEnabled,
       pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold,
       pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold,
       pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval));

    /* Register the traffic intensity events with the traffic monitor */
    ctrlData_RegisterTrafficIntensityEvents (pCtrlData);

    /* If the events are enabled, start notification, if disabled - then do nothing */
    ctrlData_ToggleTrafficIntensityNotification (pCtrlData, pCtrlData->ctrlDataTrafficIntensityEventsEnabled);

    WLAN_REPORT_INIT(pCtrlData->hReport, CTRL_DATA_MODULE_LOG, 
        (".....Ctrl Data configured successfully ...\n"));

    return OK;
}

/***************************************************************************
*                           ctrlData_unLoad                                *
****************************************************************************
* DESCRIPTION:  This function unload the Ctrl data module. 
* 
* INPUTS:       hCtrlData - the object
*       
* OUTPUT:       
* 
* RETURNS:      OK - Unload succesfull
*               NOK - Unload unsuccesfull
***************************************************************************/

TI_STATUS ctrlData_unLoad(TI_HANDLE hCtrlData)  
{
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;

    /* check parameters validity */
    if( pCtrlData == NULL )
    {
        WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
            (" ctrlData_unLoad() : parametrs value error \n"));
        return NOK;
    }


    rateAdaptation_destroy(pCtrlData->pRateAdaptation);
#ifdef SUPPORT_4X
    fourX_destroy(pCtrlData->pFourX);
#endif
    Classifier_destroy(pCtrlData->pClsfr);

    /* free timer */
    /* free control module controll block */
    os_memoryFree(pCtrlData->hOs, hCtrlData, sizeof(ctrlData_t));

    return OK;
}
/***************************************************************************
*                           ctrlData_getParam                              *
****************************************************************************
* DESCRIPTION:  get a specific parameter
* 
* INPUTS:       hCtrlData - the object
*               
*       
* OUTPUT:       pParamInfo - structure which include the value of 
*               the requested parameter
* 
* RETURNS:      OK
*               NOK
***************************************************************************/

TI_STATUS ctrlData_getParam(TI_HANDLE hCtrlData, paramInfo_t *pParamInfo)   
{
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
    
    /* WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG, 
        ("ctrlData_getParam() : param=0x%x \n", pParamInfo->paramType)); */

    switch (pParamInfo->paramType)
    {
    case CTRL_DATA_RATE_CONTROL_ENABLE_PARAM: 
        pParamInfo->content.ctrlDataRateControlEnable = pCtrlData->ctrlDataRateControlEnable;
        break; 
        
    case CTRL_DATA_FOUR_X_ENABLE_PARAM: 
        pParamInfo->content.ctrlDataFourXEnable = pCtrlData->ctrlDataFourXEnable;
        break; 

    case CTRL_DATA_FOUR_X_CURRRENT_STATUS_PARAM:
        if (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE)
        {
            pParamInfo->content.ctrlDataCerruentFourXstate = pCtrlData->ctrlDataCerruentFourXstate;
        } else {
            pParamInfo->content.ctrlDataCerruentFourXstate = pCtrlData->ctrlDataFourXEnable;
        }

        break; 

    case CTRL_DATA_CURRENT_BSSID_PARAM:          
        MAC_COPY(pCtrlData->hOs, (&pParamInfo->content.ctrlDataCurrentBSSID), 
                (&pCtrlData->ctrlDataCurrentBSSID));
        break; 

    case CTRL_DATA_CURRENT_BSS_TYPE_PARAM:  
        pParamInfo->content.ctrlDataCurrentBssType = pCtrlData->ctrlDataCurrentBssType;        
        break; 

    case CTRL_DATA_CURRENT_MODULATION_TYPE_PARAM: 
        pParamInfo->content.ctrlDataCurrentModulationType = pCtrlData->ctrlDataCurrentModulationType;      
        break; 

    case CTRL_DATA_CURRENT_PREAMBLE_TYPE_PARAM: 
        pParamInfo->content.ctrlDataCurrentPreambleType = pCtrlData->ctrlDataCurrentPreambleType;        
        break; 

    case CTRL_DATA_MAC_ADDRESS:    
        MAC_COPY(pCtrlData->hOs, (&pParamInfo->content.ctrlDataDeviceMacAddress), (&pCtrlData->ctrlDataDeviceMacAddress)); 
        break;

    case CTRL_DATA_CURRENT_BASIC_RATE_PARAM:             
        pParamInfo->content.ctrlDataCurrentBasicRate = pCtrlData->ctrlDataCurrentBasicRate;               
        break;

    case CTRL_DATA_CURRENT_BASIC_RATE_MASK_PARAM: 
        pParamInfo->content.ctrlDataBasicRateBitMask = pCtrlData->ctrlDataBasicRateBitMask;      
        break; 

    case CTRL_DATA_CURRENT_BASIC_MODULATION_PARAM: 
        pParamInfo->content.ctrlDataCurrentBasicModulationType = pCtrlData->ctrlDataCurrentBasicModulationType;      
        break; 

    case CTRL_DATA_COUNTERS_PARAM:
        os_memoryCopy(pCtrlData->hOs,&pParamInfo->content.ctrlDataCounters,
            &pCtrlData->ctrlDataCounters, sizeof(ctrlDataCounters_t));
        break; 

    case CTRL_DATA_CURRENT_SUPPORTED_RATE_MASK_PARAM: 
        pParamInfo->content.ctrlDataCurrentRateMask = pCtrlData->ctrlDataCurrentRateMask;
        break; 

    case CTRL_DATA_CURRENT_PROTECTION_STATUS_PARAM:
        pParamInfo->content.ctrlDataProtectionEnabled = pCtrlData->ctrlDataProtectionEnabled;
        break;

    case CTRL_DATA_CURRENT_IBSS_PROTECTION_PARAM:
        pParamInfo->content.ctrlDataIbssProtecionType = pCtrlData->ctrlDataIbssProtectionType;
        break;

    case CTRL_DATA_CURRENT_RTS_CTS_STATUS_PARAM:
        pParamInfo->content.ctrlDataRtsCtsStatus = pCtrlData->ctrlDataRtsCtsStatus;
        break;

    case CTRL_DATA_CLSFR_TYPE:
        Classifier_getClsfrType (pCtrlData->pClsfr,&pParamInfo->content.ctrlDataClsfrType);
        break;
        /*
         * NOTE: currently supporting only USER_RATE_CLASS!!!!!!!!!
         */
    case CTRL_DATA_SHORT_RETRY_LIMIT_PARAM:
        pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit;
        break;

        /*
         * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
         */
    case CTRL_DATA_LONG_RETRY_LIMIT_PARAM:
        pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit;
        break;


    case CTRL_DATA_TRAFFIC_INTENSITY_THRESHOLD:
        pParamInfo->content.ctrlDataTrafficIntensityThresholds.uHighThreshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold;
        pParamInfo->content.ctrlDataTrafficIntensityThresholds.uLowThreshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold;
        pParamInfo->content.ctrlDataTrafficIntensityThresholds.TestInterval = pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval;
        break;

    default:
        return (PARAM_NOT_SUPPORTED);
/*        WLAN_REPORT_ERROR(pCtrlData->hReport, TX_DATA_MODULE_LOG, 
            (" ctrlData_getParam() : PARAMETER NOT SUPPORTED \n"));
        return NOK;
        break; - unreachable */
    }

    return (OK);
}


/***************************************************************************
*                           ctrlData_getParam                              *
****************************************************************************
* DESCRIPTION:  get a specific parameter
* 
* INPUTS:       hCtrlData - the object
*               
*       
* OUTPUT:       pParamInfo - structure which include the value of 
*               the requested parameter
* 
* RETURNS:      OK
*               NOK
***************************************************************************/
/* note: ctrlData_getParamPartial() is part of ctrlData_getParam() it was implemented to reduce Stack usage */
TI_STATUS ctrlData_getParamPartial(TI_HANDLE hCtrlData, paramInfoPartial_t *pParamInfo)   
{
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
    
  switch (pParamInfo->paramType)
    {
    case CTRL_DATA_CURRENT_PREAMBLE_TYPE_PARAM: 
        pParamInfo->content.ctrlDataCurrentPreambleType = pCtrlData->ctrlDataCurrentPreambleType;        
        break; 

	default:
        return (PARAM_NOT_SUPPORTED);
    }

    return (OK);
}

/***************************************************************************
*                           ctrlData_buildSupportedHwRates                 *
****************************************************************************
* DESCRIPTION:  builds HwRatesBitMap (supported rates) for txRatePolicy using 4 elements :
*               1) AP support
*               2) Driver support
*               3) Client support (using currClientRateMask[clientIDindex] )
*               4) Policy rates   (retries per client)
* 
* OUTPUT:       
* 
* RETURNS:      OK
*               NOK
***************************************************************************/
static UINT32 ctrlData_buildSupportedHwRates(ctrlData_rateAdapt_t *pDriverTable,
                                             UINT32             APsupport,
                                             UINT32             clientSupport,
                                             UINT32             policySupport)
{
    UINT16  AppRateBitMap = 0;
    UINT32  HwRatesBitMap, DriverTableBitMap = 0;
    UINT32 i = 0;

    /* 1. Convert Rates table into bit mask */
    while (i <= pDriverTable->len)
    {
        DriverTableBitMap |= (1 << (pDriverTable->rateAdaptRatesTable[i++] - 1));
    }

    /* 2. AND with other masks */
    AppRateBitMap = (UINT16)(DriverTableBitMap & APsupport & clientSupport & policySupport);

    /* In case there are no mutual rates, try to ignore policy settings */
    if (AppRateBitMap == 0)
    {
        AppRateBitMap = (UINT16)(DriverTableBitMap & APsupport);
    }

    /* 3. Set total supported rates bit map for txRatePolicy */
    ConvertAppRatesToBitmap(AppRateBitMap, &HwRatesBitMap);

    return HwRatesBitMap;
}


/***************************************************************************
*                           ctrlData_setTxRatePolicies                     *
****************************************************************************
* DESCRIPTION:  This function sets rate fallback policies to be configured to FW
*               If TSRS is defined to specific AC, the policy is derived from it,
*               otherwise it is derived from pre-defined map
* 
* INPUTS:       pCtrlData - the object
*       
* RETURNS:      -
*               
***************************************************************************/
static void ctrlData_setTxRatePolicies(ctrlData_t *pCtrlData)
{
    UINT32 ac, policyClassRateMask, supportedHwRatesBitMap, clientIDindex, hwRateIndex;
    UINT32 fwPolicyID;
    UINT8 shortRetryLimit, longRetryLimit;
    txRateClassId_e  txRateIndex;
    whalParamInfo_t param;

    pCtrlData->currClientRateID = pCtrlData->configuredClientRateID;

    for (clientIDindex = 0, fwPolicyID = 0; clientIDindex < NUM_OF_RATE_CLASS_CLIENTS; clientIDindex++) 
    {
        /* Retrieve retry limits stored in first AC of current class */ 
        shortRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].shortRetryLimit;
        longRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].longRetryLimit;

        /* By default assume that this class can be enabled */
        pCtrlData->bIsClassAvailable[clientIDindex] = TRUE;

        /* Update the rate mask from nextClientRateMask, where it was stored untill now */
        pCtrlData->currClientRateMask[clientIDindex] = pCtrlData->nextClientRateMask[clientIDindex];

        for (ac = 0; ac < MAX_NUM_OF_AC; ac++)
        {
            /* 1. Check if there is special rate set defined for this access category, */
            /*    then verify that at least one rate is mutual between TSRS and class policy, */
            /*    otherwise use default settings for this class */
            if (pCtrlData->tsrsParameters[ac].supportedRatesMask[clientIDindex] != 0)
            {
                /* Check if at least one rate is mutual between TSRS and current class policy, */
                /* otherwise use default for this class */
                policyClassRateMask = pCtrlData->tsrsParameters[ac].policyClassRateMask[clientIDindex];
            }
            else
            {
                policyClassRateMask = ctrlData_buildHwBitMapFromArray(&(pCtrlData->pCurrPolicyClassRatesArray[clientIDindex]));
            }

            /* 2. Build a bitMap for the supported rates */
            supportedHwRatesBitMap = ctrlData_buildSupportedHwRates(
                                pCtrlData->ctrlDataCurrentRateTable,            /* according to radio mode */
                                pCtrlData->ctrlDataCurrentRateMask,             /* AP supported rates */
                                pCtrlData->currClientRateMask[clientIDindex],   /* STA supported rates */
                                policyClassRateMask);                           /* requested by class policy rates */

            if (supportedHwRatesBitMap == 0)
            {
                WLAN_REPORT_ERROR(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
                                  ("%s No supported rates for client %d, ac %d \n", __FUNCTION__, clientIDindex, ac));
                pCtrlData->bIsClassAvailable[clientIDindex] = FALSE;
                pCtrlData->currClientRateID = USER_RATE_CLASS;
            }

            /* 3. Configure retransmission for the rates */
            for (hwRateIndex = HW_BIT_RATE_54MBPS, txRateIndex = txPolicy54; 
                 txRateIndex < MAX_NUM_OF_TX_RATES_IN_CLASS; 
                 hwRateIndex >>= 1, txRateIndex++)
            {
                /* if supported rate */
                if (supportedHwRatesBitMap & hwRateIndex)
                {
                    /* if rate fall back is enabled */
                    if (pCtrlData->ctrlDataRateControlEnable)
                    {
                        /* Set retries as they were configured in ini file for this class; */
                        /* make sure at least one retransmission is defined, */
                        /* to take care of cases in which we ignored pre-defined policy */ 
                        pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex] = 
                            (pCtrlData->pCurrPolicyClassRatesArray[clientIDindex].txRate[txRateIndex] > 1) ? 
                            pCtrlData->pCurrPolicyClassRatesArray[clientIDindex].txRate[txRateIndex] : 1;
                    }
                    else /* no rate fallback */
                    {
                        /* set max reties because no fall back is implemented */
                        pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex] = 
                            (shortRetryLimit > longRetryLimit) ? shortRetryLimit : longRetryLimit;
                        pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].flags |= TX_POLICY_FLAGS_TRUNCATE;
                    }
                }
                else
                {
                    pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex] = 0;
                }

                WLAN_REPORT_INFORMATION(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
                    ("%s: AC %d, class %d, rate 0x%x[%d]\n", __FUNCTION__, ac, clientIDindex, hwRateIndex, pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex]));
            }

            /* Note that Long/Short retries are pre-set during configuration stage */

            /* 4. Finally, increase total number of policies */
            pCtrlData->tsrsParameters[ac].fwPolicyID[clientIDindex] = fwPolicyID++;
        }
    }

    /* Download policies to the FW. Num of policies is 8 - one for each AC for every class */
    WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
        ("%s: num of Rate policies: %d\n", __FUNCTION__, fwPolicyID));

    pCtrlData->ctrlDataTxRatePolicy.numOfRateClasses = fwPolicyID;
    param.paramType = HAL_CTRL_TX_RATE_CLASS_PARAMS;
    param.content.pTxRatePlicy = &pCtrlData->ctrlDataTxRatePolicy;

    whalCtrl_SetParam(pCtrlData->hWhalCtrl, &param);
}


/***************************************************************************
*                           ctrlData_setParam                              *
****************************************************************************
* DESCRIPTION:  set a specific parameter
* 
* INPUTS:       hCtrlData - the object
*               pParamInfo - structure which include the value to set for 
*               the requested parameter
*       
* OUTPUT:       
* 
* RETURNS:      OK
*               NOK
***************************************************************************/

TI_STATUS ctrlData_setParam(TI_HANDLE hCtrlData, paramInfo_t *pParamInfo)   
{
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
    whalParamInfo_t param;
    rateClassClients_e clientID;

    /* WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG, 
        ("ctrlData_setParam() : param=0x%x \n", pParamInfo->paramType)); */

    switch (pParamInfo->paramType)
    {
    case CTRL_DATA_RATE_CONTROL_ENABLE_PARAM:
        pCtrlData->ctrlDataRateControlEnable = pParamInfo->content.ctrlDataRateControlEnable;
        selectRateTable(pCtrlData, pCtrlData->ctrlDataCurrentRateMask);

        ctrlData_setTxRatePolicies(pCtrlData);

        rateAdaptation_buildRateMapTable(pCtrlData->pRateAdaptation,
                                                 pCtrlData->ctrlDataCurrentRateTable,
                                                 pCtrlData->ctrlDataCurrentRateMask,
                                                 pCtrlData->currClientRateMask[pCtrlData->currClientRateID],
                                                 pCtrlData->ctrlDataCurrentModulationType,
                                                 pCtrlData->ctrlDataCerruentFourXstate,
                                          pCtrlData->ctrlDataCurrentBssType);
    


    

             if(pCtrlData->ctrlDataRateControlEnable == TRUE )
             {
                 /* start rate adaptation algorithm */

                if( pCtrlData->ctrlDataStartStoplinkControlAlg == TRUE)
                {   

                rateAdaptation_start(pCtrlData->pRateAdaptation);
            }
            else 
            {    
                /* stop rate adaptation algorithm */
                rateAdaptation_stop(pCtrlData->pRateAdaptation);
            }
        }
        else 
        {
            rateAdaptation_stopTimer(pCtrlData->pRateAdaptation);
        }
        break; 
        
    case CTRL_DATA_FOUR_X_ENABLE_PARAM: 
#ifdef SUPPORT_4X
        pCtrlData->ctrlDataFourXEnable = pParamInfo->content.ctrlDataFourXEnable;
        if(pCtrlData->ctrlDataStartStoplinkControlAlg == TRUE)
        {
            if(pCtrlData->ctrlDataFourXEnable == TRUE)
            {   
                pCtrlData->ctrlDataCerruentFourXstate = TRUE;
            }
            else 
            {   
                pCtrlData->ctrlDataCerruentFourXstate = FALSE;
            }
        }
        rateAdaptation_update4xEnable(pCtrlData->pRateAdaptation,
                                      pCtrlData->ctrlDataCerruentFourXstate,
                                      pCtrlData->ctrlDataCurrentBssType );

#else 
        pCtrlData->ctrlDataFourXEnable = FALSE;
        pCtrlData->ctrlDataCerruentFourXstate = FALSE;
#endif
        break; 

    case CTRL_DATA_CURRENT_RATE_CLASS_CLIENT:
        /* set a new rate class client to be used on data packets */
        clientID = pParamInfo->content.ctrlDataRateClassID;
        /* always save the wanted configuration , even when not enabled */
        pCtrlData->configuredClientRateID = clientID;
        
        if (clientID == pCtrlData->currClientRateID)
        {       
            /* Do nothing - already configured */
            break;
        }
        else 
        {
            if (TRUE == pCtrlData->bIsClassAvailable[clientID])
            {       
                /* use the new clientID + reset rateAdaptation tables */
                pCtrlData->currClientRateID = clientID;
                selectRateTable(pCtrlData, pCtrlData->ctrlDataCurrentRateMask);
                rateAdaptation_buildRateMapTable(pCtrlData->pRateAdaptation,
                                                     pCtrlData->ctrlDataCurrentRateTable,
                                                     pCtrlData->ctrlDataCurrentRateMask,
                                                     pCtrlData->currClientRateMask[pCtrlData->currClientRateID],
                                                     pCtrlData->ctrlDataCurrentModulationType,
                                                     pCtrlData->ctrlDataCerruentFourXstate,
                                                     pCtrlData->ctrlDataCurrentBssType);
                break;

            }
            else
            {   
                /* The class could not be configured due to no rate support - don't use it */
                WLAN_REPORT_ERROR(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
                    ("%s: Can't enable rate class ID %d\n",__FUNCTION__,clientID));
                break;
            } 
        }

    case CTRL_DATA_NEXT_RATE_MASK_FOR_CLIENT:
        /* configure the next rate mask to be used for a specific client on the next connection */
        /* NOTE : changing USER_RATE_CLASS configuration is not advisable */
        pCtrlData->nextClientRateMask[pParamInfo->content.ctrlDataRateClassMask.clientID] = 
            pParamInfo->content.ctrlDataRateClassMask.clientRateMask;
        break;
        
    case CTRL_DATA_FOUR_X_CURRRENT_STATUS_PARAM: 
#ifdef SUPPORT_4X
        if((pCtrlData->ctrlDataFourXEnable == TRUE) &&
           (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE))
            pCtrlData->ctrlDataCerruentFourXstate = pParamInfo->content.ctrlDataCerruentFourXstate;
        else
            pCtrlData->ctrlDataCerruentFourXstate = FALSE;
#else 
        pCtrlData->ctrlDataCerruentFourXstate = FALSE;
#endif
        break; 

    case CTRL_DATA_CURRENT_BSSID_PARAM:          
        MAC_COPY(pCtrlData->hOs, (&pCtrlData->ctrlDataCurrentBSSID),
            (&pParamInfo->content.ctrlDataCurrentBSSID));
        break; 

    case CTRL_DATA_CURRENT_BSS_TYPE_PARAM:
        if( pParamInfo->content.ctrlDataCurrentBssType != BSS_INFRASTRUCTURE &&
            pParamInfo->content.ctrlDataCurrentBssType != BSS_INDEPENDENT )
            return(PARAM_VALUE_NOT_VALID);

        pCtrlData->ctrlDataCurrentBssType = pParamInfo->content.ctrlDataCurrentBssType;        
        break; 

    case CTRL_DATA_CURRENT_MODULATION_TYPE_PARAM: 
        pCtrlData->ctrlDataCurrentModulationType = pParamInfo->content.ctrlDataCurrentModulationType;   
        /* update rate modulatin table for Rate adaptation algorithm */

        rateAdaptation_updateModulation(pCtrlData->pRateAdaptation,
                                        pCtrlData->ctrlDataCurrentModulationType,
                                        pCtrlData->ctrlDataCurrentBssType);

        break; 

    case CTRL_DATA_CURRENT_PREAMBLE_TYPE_PARAM: 
        if( pParamInfo->content.ctrlDataCurrentPreambleType != PREAMBLE_LONG &&
            pParamInfo->content.ctrlDataCurrentPreambleType != PREAMBLE_SHORT )
            return(PARAM_VALUE_NOT_VALID);
 
        pCtrlData->ctrlDataCurrentPreambleType = pParamInfo->content.ctrlDataCurrentPreambleType;        

        break; 

    case CTRL_DATA_MAC_ADDRESS: 
        {
            int status;
			status = whalCtrl_SetMacAddress(pCtrlData->hWhalCtrl, &pParamInfo->content.ctrlDataDeviceMacAddress);
			WLAN_REPORT_ERROR(pCtrlData->hReport, TX_DATA_MODULE_LOG,  
							  (" ctrlData_setParam() : MAC ADDRESS SET STATUS: %d \n",status));
			if(status == OK)
				MAC_COPY(pCtrlData->hOs, (&pCtrlData->ctrlDataDeviceMacAddress),
						 (&pParamInfo->content.ctrlDataDeviceMacAddress)); 

        }
        break;

    case CTRL_DATA_CURRENT_BASIC_RATE_PARAM:             

        pCtrlData->ctrlDataCurrentBasicRate = pParamInfo->content.ctrlDataCurrentBasicRate;  
        /* for Basic Rate Set use the USER_RATE_CLASS (otherwise we could get 0 rates) */
        pCtrlData->ctrlDataBasicRateBitMask = rateAdaptation_Utils_buildRateBitMap(pCtrlData->pRateAdaptation,
                                                                                   pCtrlData->ctrlDataCurrentRateTable,
                                                                                   pCtrlData->ctrlDataCurrentBasicRate,         
                                                                                   pCtrlData->ctrlDataCurrentRateMask,
                                                                                   pCtrlData->currClientRateMask[USER_RATE_CLASS]);
        break;
 
    case CTRL_DATA_CURRENT_BASIC_RATE_MASK_PARAM: 
        pCtrlData->ctrlDataBasicRateBitMask = pParamInfo->content.ctrlDataBasicRateBitMask;
        break; 

    case CTRL_DATA_CURRENT_BASIC_MODULATION_PARAM: 
        pCtrlData->ctrlDataCurrentBasicModulationType = pParamInfo->content.ctrlDataCurrentBasicModulationType;
        break; 


    case CTRL_DATA_CURRENT_SUPPORTED_RATE_MASK_PARAM:
        pCtrlData->ctrlDataCurrentRateMask = pParamInfo->content.ctrlDataCurrentRateMask;
        selectRateTable(pCtrlData, pCtrlData->ctrlDataCurrentRateMask);
        rateAdaptation_buildRateMapTable(pCtrlData->pRateAdaptation,
                                         pCtrlData->ctrlDataCurrentRateTable,
                                         pCtrlData->ctrlDataCurrentRateMask,
                                         pCtrlData->currClientRateMask[pCtrlData->currClientRateID],
                                         (modulationType_e)pCtrlData->ctrlDataCerruentFourXstate,
                                         pCtrlData->ctrlDataCurrentModulationType,
                                         pCtrlData->ctrlDataCurrentBssType);


        break; 

    case CTRL_DATA_CURRENT_ACTIVE_RATE_PARAM:
        rateAdaptation_setCurrentRate(pCtrlData->pRateAdaptation, pParamInfo->content.ctrlDataCurrentActiveRate);

        break;

    case CTRL_DATA_TSRS_PARAM:
        ctrlData_storeTSRateSet(pCtrlData, &pParamInfo->content.txDataQosParams);

        break;

    case CTRL_DATA_CURRENT_PROTECTION_STATUS_PARAM:
        if (pCtrlData->ctrlDataProtectionEnabled != pParamInfo->content.ctrlDataProtectionEnabled)
        {
            pCtrlData->ctrlDataProtectionEnabled = pParamInfo->content.ctrlDataProtectionEnabled;

            /* set indication also to TNET */
            param.paramType = HAL_CTRL_CTS_TO_SELF_PARAM;
            if(pCtrlData->ctrlDataProtectionEnabled == TRUE)
                param.content.halCtrlCtsToSelf = CTS_TO_SELF_ENABLE;
            else
                param.content.halCtrlCtsToSelf = CTS_TO_SELF_DISABLE;

            whalCtrl_SetParam(pCtrlData->hWhalCtrl,&param);


            /* In case of using protection fragmentation should be disabled */
            param.paramType = HAL_CTRL_FRAG_THRESHOLD_PARAM;
            if(pCtrlData->ctrlDataProtectionEnabled == TRUE)
            {
                /* save last non-protection mode fragmentation threshold */
                whalCtrl_GetParam(pCtrlData->hWhalCtrl,&param);
                pCtrlData->lastFragmentThreshold = param.content.halCtrlFragThreshold;
                /* set fragmentation threshold to max (disable) */
                param.content.halCtrlFragThreshold = HAL_CTRL_FRAG_THRESHOLD_MAX;
            }
            else
                param.content.halCtrlFragThreshold = pCtrlData->lastFragmentThreshold;
            
            whalCtrl_SetParam(pCtrlData->hWhalCtrl,&param);
        }

        break;

    case CTRL_DATA_CURRENT_IBSS_PROTECTION_PARAM:
        pCtrlData->ctrlDataIbssProtectionType = pParamInfo->content.ctrlDataIbssProtecionType;

        /* set indication also to TNET */
        param.paramType = HAL_CTRL_CTS_TO_SELF_PARAM;
        if(pCtrlData->ctrlDataIbssProtectionType != ERP_PROTECTION_NONE)
            param.content.halCtrlCtsToSelf = CTS_TO_SELF_ENABLE;
        else
            param.content.halCtrlCtsToSelf = CTS_TO_SELF_DISABLE;
                
        whalCtrl_SetParam(pCtrlData->hWhalCtrl,&param);

        break;

    case CTRL_DATA_CURRENT_RTS_CTS_STATUS_PARAM:
        pCtrlData->ctrlDataRtsCtsStatus = pParamInfo->content.ctrlDataRtsCtsStatus;
        break;
    case CTRL_DATA_CLSFR_TYPE:
        ctrlData_clsfrSetClsfrType (pCtrlData->pClsfr,pParamInfo->content.ctrlDataClsfrType);
        break;

    case CTRL_DATA_CLSFR_CONFIG:
            Classifier_InsertClsfrEntry(pCtrlData->pClsfr, 1, &pParamInfo->content.ctrlDataClsfrInsertTable);
        break;

    case CTRL_DATA_CLSFR_REMOVE_ENTRY:
         classifier_RemoveClsfrEntry(pCtrlData->pClsfr, &pParamInfo->content.ctrlDataClsfrInsertTable);
       break;
       
    case CTRL_DATA_GET_USER_PRIORITY_OF_STREAM:
       Classifier_deriveUserPriorityFromStream (pCtrlData->pClsfr,&pParamInfo->content.ctrlDataUpOfStream);
       break;
            /*
         * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
         */
    case CTRL_DATA_SHORT_RETRY_LIMIT_PARAM:
        pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit = pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit;
        break;

        /*
         * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
         */
    case CTRL_DATA_LONG_RETRY_LIMIT_PARAM:
        pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit = pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit;
        break;

    case CTRL_DATA_TOGGLE_TRAFFIC_INTENSITY_EVENTS:

            /* Enable or disable events according to flag */
            ctrlData_ToggleTrafficIntensityNotification (pCtrlData, (BOOL)pParamInfo->content.ctrlDataTrafficIntensityEventsFlag);
        
        break;

    case CTRL_DATA_TRAFFIC_INTENSITY_THRESHOLD:
        {
            OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS *localParams = &pParamInfo->content.ctrlDataTrafficIntensityThresholds;
            BOOL savedEnableFlag;   /* Used to save previous enable/disable flag - before stopping/starting events for change in params */
        
            /* If any of the parameters has changed, we need to re-register with the Traffic Monitor */
            if ((localParams->uHighThreshold != pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold) ||
                (localParams->uLowThreshold != pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold) ||
                (localParams->TestInterval != pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval))
            {

                os_memoryCopy(pCtrlData->hOs, &pCtrlData->ctrlDataTrafficIntensityThresholds,
                                localParams,
                                sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS));

                savedEnableFlag = pCtrlData->ctrlDataTrafficIntensityEventsEnabled;

                /* Turn off traffic events */
                ctrlData_ToggleTrafficIntensityNotification (pCtrlData, FALSE);

                /* Unregister current events */
                ctrlData_UnregisterTrafficIntensityEvents (pCtrlData);
                
                /* And re-register with new thresholds */
                ctrlData_RegisterTrafficIntensityEvents (pCtrlData);

                /* Enable events if they were enabled  */
                ctrlData_ToggleTrafficIntensityNotification (pCtrlData, savedEnableFlag);

            }
        }
        
        break;

    default:
        WLAN_REPORT_ERROR(pCtrlData->hReport, TX_DATA_MODULE_LOG,  
            (" ctrlData_setParam() : PARAMETER NOT SUPPORTED \n"));
        return (PARAM_NOT_SUPPORTED);
/*        break; - unrechable */
    }

    return (OK);
}

/***************************************************************************
*                           ctrlData_getTspecsRateThresholds                                   *
****************************************************************************
* DESCRIPTION:  The function retrieves the current low/high phy rate thresholds.
*
* INPUTS:       hCtrlData - the object
*               uAC       - The AC number.
*               
* OUTPUT:       pHighThreshold - The current phy rate high threshold
*               pHighThreshold - The current phy rate low threshold
*
* RETURNS:      
***************************************************************************/
void ctrlData_getTspecsRateThresholds(TI_HANDLE hCtrlData, UINT8 uAC, UINT32* pHighThreshold, UINT32* pLowThreshold)
{
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
    rateAdaptation_t* pRateAdaptation = (rateAdaptation_t*)pCtrlData->pRateAdaptation;
    
    *pHighThreshold = hostToUtilityRate(RateNumberToHost(pRateAdaptation->tspecsRateParameters[uAC].highRateThreshold));
    *pLowThreshold = hostToUtilityRate(RateNumberToHost(pRateAdaptation->tspecsRateParameters[uAC].lowRateThreshold));
}

/***************************************************************************
*                           selectRateTable                                *
****************************************************************************
* DESCRIPTION:  
*
* INPUTS:       hCtrlData - the object
*               
* OUTPUT:       
*
* RETURNS:      
***************************************************************************/

static void selectRateTable(TI_HANDLE hCtrlData, UINT32 rateMask)
{
    paramInfo_t param;
    rate_e      rate;
    
    ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;

    rate = getMaxRatefromBitmap(rateMask);

    param.paramType = SITE_MGR_OPERATIONAL_MODE_PARAM;
    siteMgr_getParam(pCtrlData->hSiteMgr, &param);

    switch(param.content.siteMgrDot11OperationalMode)
    {
        case DOT11_B_MODE:
        {
            if(rate == DRV_RATE_22M)
            {
                pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataPbccRateTable;
                pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayPbcc;
            }
            else
            {
                pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataCckRateTable;
                pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayCck;

            }
        }
        break;

        case DOT11_G_MODE:
            if( (rate == DRV_RATE_22M) ||
                (rate == DRV_RATE_11M) || 
                (rate == DRV_RATE_5_5M)|| 
                (rate == DRV_RATE_2M)  || 
                (rate == DRV_RATE_1M)    )
            {
                pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataPbccRateTable;
                pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayPbcc;
            }
            else
            {
                pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataOfdmRateTable ;
                pCtrlData->pCurrPolicyClassRatesArra…

Large files files are truncated, but you can click here to view the full file