TWD/Ctrl/CmdBldCfg.c

/*
 * CmdBldCfg.c
 *
 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Texas Instruments nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


/** \file  CmdBldCfg.c
 *  \brief Command builder. Configuration commands
 *
 *  \see   CmdBld.h
 */
#define __FILE_ID__  FILE_ID_91
#include "osApi.h"
#include "tidef.h"
#include "report.h"
#include "CmdBld.h"
#include "CmdBldCfgIE.h"
#include "TWDriverInternal.h"


/****************************************************************************
 *                      cmdBld_setRxFilters()
 ****************************************************************************
 * DESCRIPTION: Sets the filters according to the given configuration.
 *
 * INPUTS:  RxConfigOption  - The given Rx filters configuration
 *          RxFilterOption  - The given Rx filters options
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgRx (TI_HANDLE hCmdBld, TI_UINT32 uRxConfigOption, TI_UINT32 uRxFilterOption, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).RxConfigOption = uRxConfigOption;
    DB_WLAN(hCmdBld).RxFilterOption = uRxFilterOption;
    DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_ENABLE_PHY_HEADER_PLCP;
  #if defined (TNETW_MASTER_MODE) || defined (TNETW_USB_MODE)
    DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_COPY_RX_STATUS;
  #endif

    if (DB_WLAN(hCmdBld).RxDisableBroadcast)
    {
        DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_DISABLE_BCAST;
    }

    return cmdBld_CfgIeRx (hCmdBld,
                           DB_WLAN(hCmdBld).RxConfigOption,
                           DB_WLAN(hCmdBld).RxFilterOption,
                           fCb,
                           hCb);
}


/****************************************************************************
 *                      cmdBld_SetarpIpAddressesTable()
 ****************************************************************************
 * DESCRIPTION: Sets the ARP IP table according to the given configuration.
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgArpIpAddrTable (TI_HANDLE hCmdBld, TIpAddr tIpAddr, TI_BOOL bEnabled, EIpVer eIpVer, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).arp_IP_ver = eIpVer;

    /* no support for IPV6 */
    if (eIpVer == IP_VER_4)
    {
        IP_COPY (DB_WLAN(hCmdBld).arp_IP_addr, tIpAddr);
    }

    DB_WLAN(hCmdBld).isArpIpFilteringEnabled = bEnabled;

    /* Set the new ip with the current state (e/d) */
    return cmdBld_CfgIeArpIpFilter (hCmdBld, tIpAddr, bEnabled, fCb, hCb);
}


 /****************************************************************************
 *                      cmdBld_SetarpIpFilterEnabled()
 ****************************************************************************
 * DESCRIPTION: Enable\Disable the ARP filter
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgArpIpFilter (TI_HANDLE hCmdBld, TI_BOOL bEnabled, void *fCb, TI_HANDLE hCb)
{
    /* Set the current ip address with the new state (e/d) */
    DB_WLAN(hCmdBld).isArpIpFilteringEnabled = bEnabled;

    return cmdBld_CfgIeArpIpFilter (hCmdBld,
                                    DB_WLAN(hCmdBld).arp_IP_addr,
                                    bEnabled,
                                    fCb,
                                    hCb);
}


/****************************************************************************
 *                      cmdBld_SetGroupAddressesTable()
 ****************************************************************************
 * DESCRIPTION: Sets the Group table according to the given configuration.
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgGroupAddressTable (TI_HANDLE        hCmdBld,
                                       TI_UINT8         uNumGroupAddr,
                                       TMacAddr         *pGroupAddr,
                                       TI_BOOL          bEnabled,
                                       void             *fCb,
                                       TI_HANDLE        hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TI_UINT32    i;

    if (uNumGroupAddr > MAX_MULTICAST_GROUP_ADDRS)
    {
        TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CfgGroupAddressTable: numGroupAddrs=%d\n", uNumGroupAddr);
        return PARAM_VALUE_NOT_VALID;
    }

    if (NULL == pGroupAddr)
    {
        TRACE2(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_SetGroupAddressesTable: numGroupAddrs=%d Group_addr=0x%x  !!!\n", uNumGroupAddr, pGroupAddr);
        return PARAM_VALUE_NOT_VALID;
    }

    /* Keeps the parameters in the db */
    DB_WLAN(hCmdBld).numGroupAddrs = uNumGroupAddr;
    DB_WLAN(hCmdBld).isMacAddrFilteringnabled = bEnabled;

    for (i = 0; i < uNumGroupAddr; i++)
    {
        MAC_COPY (DB_WLAN(hCmdBld).aGroupAddr[i], *(pGroupAddr + i));
    }

    return cmdBld_CfgIeGroupAdressTable (hCmdBld, uNumGroupAddr, pGroupAddr, bEnabled, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_SetRtsThreshold()
 ****************************************************************************
 * DESCRIPTION: Sets the Rts Threshold.
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK  pWlanParams->RtsThreshold
 ****************************************************************************/
TI_STATUS cmdBld_CfgRtsThreshold (TI_HANDLE hCmdBld, TI_UINT16 threshold, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeRtsThreshold (hCmdBld, threshold, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_CfgFragmentThreshold()
 ****************************************************************************
 * DESCRIPTION: Sets the tx fragmentation Threshold.
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgFragmentThreshold (TI_HANDLE hCmdBld, TI_UINT16 uFragmentThreshold, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).FragmentThreshold = uFragmentThreshold;

    return cmdBld_CfgIeFragmentThreshold (hCmdBld, uFragmentThreshold, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_SetPreamble()
 ****************************************************************************
 * DESCRIPTION: Set the preamble in ?????? hardware register
 *
 * INPUTS:
 *      preambleVal
 *
 * OUTPUT:  None
 *
 * RETURNS: None
 ****************************************************************************/
TI_STATUS cmdBld_CfgPreamble (TI_HANDLE hCmdBld, Preamble_e ePreamble, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).preamble = ePreamble;

    return cmdBld_CfgIePreamble (hCmdBld, (TI_UINT8)ePreamble, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_BcnBrcOptions()
 ****************************************************************************
 * DESCRIPTION: Configure the wlan hardware
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgBcnBrcOptions (TI_HANDLE hCmdBld, TPowerMgmtConfig *pPMConfig, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeBcnBrcOptions (hCmdBld, pPMConfig, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_wakeUpCondition()
 ****************************************************************************
 * DESCRIPTION: Configure the wlan hardware
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgWakeUpCondition (TI_HANDLE hCmdBld, TPowerMgmtConfig *pPMConfig, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeWakeUpCondition (hCmdBld, pPMConfig, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_MinPowerLevelSet ()
 ****************************************************************************
 * DESCRIPTION: Set the min power level
 *
 * INPUTS:
 *
 * OUTPUT:
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgSleepAuth (TI_HANDLE hCmdBld, EPowerPolicy eMinPowerLevel, void *fCb, TI_HANDLE hCb)
{
    /* Save th parameter in database */
    DB_WLAN(hCmdBld).minPowerLevel = eMinPowerLevel;

    return cmdBld_CfgIeSleepAuth (hCmdBld, eMinPowerLevel, fCb, hCb);
}


typedef enum { HW_CLOCK_40_MHZ = 40, HW_CLOCK_80_MHZ = 80 } EHwClock;


/****************************************************************************
 *                      cmdBld_ArmClockSet()
 ****************************************************************************
 * DESCRIPTION: Configure the arm clock
 *  !!! Note that the firmware will set the slot time according to the new clock
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgArmClock (TI_HANDLE hCmdBld, TI_UINT32 uArmClock, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);

    pWlanParams->ArmClock = uArmClock;

    /* Illegal combination Mac=80, Arm=40 ==> force setting 40/40*/
    if (pWlanParams->MacClock == HW_CLOCK_80_MHZ && pWlanParams->ArmClock == HW_CLOCK_40_MHZ)
    {
        TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_ArmClockSet: Illegal combination Mac=80, Arm=40 ==> force setting 40/40\n");
        pWlanParams->MacClock = HW_CLOCK_40_MHZ;
    }

    return cmdBld_CfgIeFeatureConfig (hCmdBld,
                                      pWlanParams->FeatureOptions,
                                      pWlanParams->FeatureDataFlowOptions,
                                      fCb,
                                      hCb);
}


/****************************************************************************
 *                      cmdBld_MacClockSet()
 ****************************************************************************
 * DESCRIPTION: Configure the mac clock
 *  !!! Note that the firmware will set the slot time according to the new clock
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgMacClock (TI_HANDLE hCmdBld, TI_UINT32 uMacClock, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);

    pWlanParams->MacClock = uMacClock;

    /* Force same clock - for printing */
    pWlanParams->ArmClock = uMacClock;

    /* Illegal combination Mac=80, Arm=40 ==> force setting 40/40*/
    if (pWlanParams->MacClock == HW_CLOCK_80_MHZ && pWlanParams->ArmClock == HW_CLOCK_40_MHZ)
    {
        TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_MacClockSet: Illegal combination Mac=80, Arm=40 ==> force setting 40/40\n");
        pWlanParams->MacClock = HW_CLOCK_40_MHZ;
    }

    return cmdBld_CfgIeFeatureConfig (hCmdBld,
                                      pWlanParams->FeatureOptions,
                                      pWlanParams->FeatureDataFlowOptions,
                                      fCb,
                                      hCb);
}


/****************************************************************************
 *                      cmdBld_AidSet()
 ****************************************************************************
 * DESCRIPTION: Set the AID
 *
 * INPUTS:
 *
 * OUTPUT:
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgAid (TI_HANDLE hCmdBld, TI_UINT16 uAidVal, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeAid (hCmdBld, uAidVal, fCb, hCb);
}

TI_STATUS cmdBld_CfgClkRun (TI_HANDLE hCmdBld, TI_BOOL aClkRunEnable, void *fCb, TI_HANDLE hCb)
{
    TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);

    if (aClkRunEnable)
    {
        pWlanParams->FeatureDataFlowOptions |= FEAT_PCI_CLK_RUN_ENABLE;
    }
    else
    {
        pWlanParams->FeatureDataFlowOptions &= ~FEAT_PCI_CLK_RUN_ENABLE;
    }

    return cmdBld_CfgIeFeatureConfig (hCmdBld,
                                      pWlanParams->FeatureOptions,
                                      pWlanParams->FeatureDataFlowOptions,
                                      fCb,
                                      hCb);
}


TI_STATUS cmdBld_CfgRxMsduFormat (TI_HANDLE hCmdBld, TI_BOOL bRxMsduForamtEnable, void *fCb, TI_HANDLE hCb)
{
#if 1
    /* WARNING:  Have to check how to control the Rx Frame format select (which bit)
                 and then access the HW*/
    return TI_OK;
#else
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);

    if (aRxMsduForamtEnable)
    {
        pWlanParams->FeatureDataFlowOptions |= DATA_FLOW_RX_MSDU_FRAME;
    }
    else
    {
        pWlanParams->FeatureDataFlowOptions &= ~DATA_FLOW_RX_MSDU_FRAME;
    }

    return cmdBld_CfgIeFeatureConfig (hCmdBld,
                                      pWlanParams->FeatureOptions,
                                      pWlanParams->FeatureDataFlowOptions,
                                      fCb,
                                      hCb);
#endif
}


/****************************************************************************
 *                      cmdBld_TrafficConf()
 ****************************************************************************
 * DESCRIPTION: configure Queue traffic params
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgTid (TI_HANDLE hCmdBld, TQueueTrafficParams *pQtrafficParams, void *fCb, TI_HANDLE hCb)
{
    DB_QUEUES(hCmdBld).isQueueConfigured[pQtrafficParams->queueID] = TI_TRUE;
    DB_QUEUES(hCmdBld).queues[pQtrafficParams->queueID] = *pQtrafficParams;

    return cmdBld_CfgIeTid (hCmdBld, pQtrafficParams, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_AcParamsConf()
 ****************************************************************************
 * DESCRIPTION: configure AC params
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgAcParams (TI_HANDLE hCmdBld, TAcQosParams *pAcQosParams, void *fCb, TI_HANDLE hCb)
{
    DB_AC(hCmdBld).isAcConfigured[pAcQosParams->ac] = TI_TRUE;
    DB_AC(hCmdBld).ac[pAcQosParams->ac] = *pAcQosParams;

    return cmdBld_CfgIeAcParams (hCmdBld, pAcQosParams, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_CfgPsRxStreaming()
 ****************************************************************************
 * DESCRIPTION: configure PS-Rx-Streaming params
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgPsRxStreaming (TI_HANDLE hCmdBld, TPsRxStreaming *pPsRxStreaming, void *fCb, TI_HANDLE hCb)
{
    DB_PS_STREAM(hCmdBld).tid[pPsRxStreaming->uTid] = *pPsRxStreaming;

    return cmdBld_CfgIePsRxStreaming (hCmdBld, pPsRxStreaming, fCb, hCb);
}


/****************************************************************************
 *                     cmdBld_CfgPacketDetectionThreshold
 ****************************************************************************
 * DESCRIPTION: Sets Packet Detection Threshold
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgPacketDetectionThreshold (TI_HANDLE hCmdBld, TI_UINT32 threshold, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).PacketDetectionThreshold = threshold;

    return cmdBld_CfgIePacketDetectionThreshold (hCmdBld, threshold, fCb, hCb);
}


/****************************************************************************
 *                     cmdBld_SetBeaconFiltering
 ****************************************************************************
 * DESCRIPTION: Sets Beacon filtering state
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgBeaconFilterOpt (TI_HANDLE  hCmdBld,
                                     TI_UINT8   uBeaconFilteringStatus,
                                     TI_UINT8   uNumOfBeaconsToBuffer,
                                     void       *fCb,
                                     TI_HANDLE  hCb)
{
    DB_WLAN(hCmdBld).beaconFilterParams.desiredState = uBeaconFilteringStatus;
    DB_WLAN(hCmdBld).beaconFilterParams.numOfElements = uNumOfBeaconsToBuffer;

    return cmdBld_CfgIeBeaconFilterOpt (hCmdBld,
                                        uBeaconFilteringStatus,
                                        uNumOfBeaconsToBuffer,
                                        fCb,
                                        hCb);
}


/****************************************************************************
 *                     cmdBld_SetBeaconFilterIETable
 ****************************************************************************
 * DESCRIPTION: Sets Beacon filtering state
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgBeaconFilterTable (TI_HANDLE    hCmdBld,
                                       TI_UINT8     uNumberOfIEs,
                                       TI_UINT8     *pIETable,
                                       TI_UINT8     uIETableSize,
                                       void         *fCb,
                                       TI_HANDLE    hCb)
{
    TCmdBld   *pCmdBld = (TCmdBld *)hCmdBld;

    if (uIETableSize > BEACON_FILTER_TABLE_MAX_SIZE)
    {
        TRACE2(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CfgBeaconFilterTable: Table size is too big %d (>%d)\n", uIETableSize, BEACON_FILTER_TABLE_MAX_SIZE);

        return PARAM_VALUE_NOT_VALID;
    }

    os_memoryZero (pCmdBld->hOs,
                   (void *)DB_WLAN(hCmdBld).beaconFilterIETable.IETable,
                   BEACON_FILTER_TABLE_MAX_SIZE);
    os_memoryCopy (pCmdBld->hOs,
                   (void *)DB_WLAN(hCmdBld).beaconFilterIETable.IETable,
                   (void *)pIETable,
                   uIETableSize);
    DB_WLAN(hCmdBld).beaconFilterIETable.numberOfIEs = uNumberOfIEs;
    DB_WLAN(hCmdBld).beaconFilterIETable.IETableSize = uIETableSize;

    return cmdBld_CfgIeBeaconFilterTable (hCmdBld, uNumberOfIEs, pIETable, uIETableSize, fCb, hCb);
}


/*----------------------------------------*/
/* Roaming Trigger Configuration Commands */
/*----------------------------------------*/

/****************************************************************************
 *                      cmdBld_CfgRssiSnrTrigger()
 ****************************************************************************
 * DESCRIPTION: Set the RSSI/SNR Trigger parameters.
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: None
 ****************************************************************************/
TI_STATUS cmdBld_CfgRssiSnrTrigger (TI_HANDLE hCmdBld, RssiSnrTriggerCfg_t *pTriggerParam, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].index     = pTriggerParam->index;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].threshold = pTriggerParam->threshold;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].pacing    = pTriggerParam->pacing;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].metric    = pTriggerParam->metric;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].type      = pTriggerParam->type;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].direction = pTriggerParam->direction;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].hystersis = pTriggerParam->hystersis;
    DB_WLAN(hCmdBld).tRssiSnrTrigger[pTriggerParam->index].enable    = pTriggerParam->enable;

    return cmdBld_CfgIeRssiSnrTrigger (hCmdBld, pTriggerParam, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_CfgRssiSnrWeights()
 ****************************************************************************
 * DESCRIPTION: Set RSSI/SNR Weights for Average calculations.
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: None
 ****************************************************************************/
TI_STATUS cmdBld_CfgRssiSnrWeights (TI_HANDLE hCmdBld, RssiSnrAverageWeights_t *pWeightsParam, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "\n cmdBld_CfgRssiSnrWeights :\n                             uRssiBeaconAverageWeight = %d\n                             uRssiPacketAverageWeight = %d\n                             uSnrBeaconAverageWeight  = %d\n                             uSnrPacketAverageWeight = %d \n ", pWeightsParam->rssiBeaconAverageWeight, pWeightsParam->rssiPacketAverageWeight, pWeightsParam->snrBeaconAverageWeight , pWeightsParam->snrPacketAverageWeight  );

    DB_WLAN(hCmdBld).tRssiSnrWeights.rssiBeaconAverageWeight = pWeightsParam->rssiBeaconAverageWeight;
    DB_WLAN(hCmdBld).tRssiSnrWeights.rssiPacketAverageWeight = pWeightsParam->rssiPacketAverageWeight;
    DB_WLAN(hCmdBld).tRssiSnrWeights.snrBeaconAverageWeight  = pWeightsParam->snrBeaconAverageWeight ;
    DB_WLAN(hCmdBld).tRssiSnrWeights.snrPacketAverageWeight  = pWeightsParam->snrPacketAverageWeight ;

    return cmdBld_CfgIeRssiSnrWeights (hCmdBld, pWeightsParam, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_SetMaxTxRetryParameters()
 ****************************************************************************
 * DESCRIPTION: Set Max Tx retry parmaters.
 *
 * INPUTS:
 *      maxTxRetry             max Tx Retry
 *
 * OUTPUT:  None
 *
 * RETURNS: None
 ****************************************************************************/
TI_STATUS cmdBld_CfgMaxTxRetry (TI_HANDLE hCmdBld, TRroamingTriggerParams *pRoamingTriggerCmd, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).roamTriggers.maxTxRetry = pRoamingTriggerCmd->maxTxRetry;

    return cmdBld_CfgIeMaxTxRetry (hCmdBld, pRoamingTriggerCmd, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_SoftGeminiEnable()
 ****************************************************************************
 * DESCRIPTION: Save Soft Gemini enable parameter
 *
 * INPUTS:
 *
 * OUTPUT:
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgSgEnable (TI_HANDLE hCmdBld, ESoftGeminiEnableModes eSgEnable, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).SoftGeminiEnable = eSgEnable;

    return cmdBld_CfgIeSgEnable (hCmdBld, eSgEnable, fCb, hCb);
}


/****************************************************************************
 *                      cmdBld_SetSoftGeminiParams()
 ****************************************************************************
 * DESCRIPTION: Save Soft Gemini config parameter
 *
 * INPUTS:
 *
 * OUTPUT:
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgSg (TI_HANDLE hCmdBld, TSoftGeminiParams *pSgParam, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

    /* Copy params for recovery */
    os_memoryCopy (pCmdBld->hOs,
                   (void*)&DB_WLAN(hCmdBld).SoftGeminiParams,
                   (void*)pSgParam,
                   sizeof(TSoftGeminiParams));

    return cmdBld_CfgIeSg (hCmdBld, pSgParam, fCb, hCb);
}

/****************************************************************************
 *                      cmdBld_SetCoexActivityTable()
 ****************************************************************************
 * DESCRIPTION: Sets the CoexActivity table.
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK  pWlanParams->RtsThreshold
 ****************************************************************************/
TI_STATUS cmdBld_CfgCoexActivity (TI_HANDLE hCmdBld, TCoexActivity *pCoexActivity, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);
    TCoexActivity *pSaveCoex = &pWlanParams->tWlanParamsCoexActivityTable.entry[0];
    int numOfElements = pWlanParams->tWlanParamsCoexActivityTable.numOfElements;
    int i;

    /* Check if to overwrite existing entry or put on last index */
    for (i=0; i<numOfElements; i++)
    {
        if ((pSaveCoex[i].activityId == pCoexActivity->activityId) && (pSaveCoex->coexIp == pCoexActivity->coexIp))
        {
            break;
        }
    }

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_CfgCoexActivity: save Param %d in index %d, %d %d\n", 0, i, pCoexActivity->coexIp, pCoexActivity->activityId);
    /* save in WlanParams for recovery */
    pSaveCoex[i].coexIp          = pCoexActivity->coexIp;
    pSaveCoex[i].activityId      = pCoexActivity->activityId;
    pSaveCoex[i].defaultPriority = pCoexActivity->defaultPriority;
    pSaveCoex[i].raisedPriority  = pCoexActivity->raisedPriority;
    pSaveCoex[i].minService      = pCoexActivity->minService;
    pSaveCoex[i].maxService      = pCoexActivity->maxService;

    if (i == numOfElements)
    {
        /* no existing entry overwrite, increment number of elements */
        pWlanParams->tWlanParamsCoexActivityTable.numOfElements++;
    }

    return cmdBld_CfgIeCoexActivity (hCmdBld, pCoexActivity, fCb, hCb);
}

/****************************************************************************
 *                      cmdBld_TxRatePolicy()
 ****************************************************************************
 * DESCRIPTION: configure TxRatePolicy params
 *
 * INPUTS: None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgTxRatePolicy (TI_HANDLE hCmdBld, TTxRatePolicy *pTxRatePolicy, void *fCb, TI_HANDLE hCb)
{
    TCmdBld       *pCmdBld      = (TCmdBld *)hCmdBld;
    TTxRateClass  *pTxRateClass = pTxRatePolicy->rateClass;
    TI_UINT8       index;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "_1, Num of classes = 0x%x\n", pTxRatePolicy->numOfRateClasses);

    DB_BSS(hCmdBld).TxRateClassParams.numOfRateClasses = pTxRatePolicy->numOfRateClasses;

    for (index = 0; index < pTxRatePolicy->numOfRateClasses; index++, pTxRateClass++)
    {
        TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "_2loop, Index = %d, Short R = 0x%x, Long R = 0x%x, Rates = 0x%x\n", index, pTxRateClass->shortRetryLimit, pTxRateClass->longRetryLimit, pTxRateClass->txEnabledRates);

        DB_BSS(hCmdBld).TxRateClassParams.rateClass[index] = *pTxRateClass;
    }

    return cmdBld_CfgIeTxRatePolicy (hCmdBld, pTxRatePolicy, fCb, hCb);
}


TI_STATUS cmdBld_CfgSlotTime (TI_HANDLE hCmdBld, ESlotTime eSlotTime, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

    DB_WLAN(hCmdBld).SlotTime = eSlotTime;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "TWD_SetSlotTime : Slot time = %d\n", eSlotTime);

    /* Configure the new Slot-Time value to the FW. */
    return cmdBld_CfgIeSlotTime (hCmdBld, (TI_UINT8)eSlotTime, fCb, hCb);
}


TI_STATUS cmdBld_CfgEventMask (TI_HANDLE hCmdBld, TI_UINT32 uEventMask, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeEventMask (hCmdBld, uEventMask, fCb, hCb);
}


/*
 * ----------------------------------------------------------------------------
 * Function : cmdBld_CfgHwEncEnable
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :
 * -----------------------------------------------------------------------------
 */
TI_STATUS cmdBld_CfgHwEncEnable (TI_HANDLE hCmdBld, TI_BOOL bHwEncEnable, TI_BOOL bHwDecEnable, void *fCb, TI_HANDLE hCb)
{
    TCmdBld     *pCmdBld = (TCmdBld *)hCmdBld;
    TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);

    /* Store the HW encryption Enable flag for reconfigure time (FW reload)*/
    DB_KEYS(pCmdBld).bReconfHwEncEnable = bHwEncEnable;
    DB_KEYS(pCmdBld).bHwEncDecrEnableValid = TI_TRUE;

    if (bHwEncEnable)
    {
        pWlanParams->FeatureDataFlowOptions &= ~DF_ENCRYPTION_DISABLE;
    }
    else
    {
        pWlanParams->FeatureDataFlowOptions |= DF_ENCRYPTION_DISABLE;
    }

    /* Set bit DF_SNIFF_MODE_ENABLE to enable or prevent decryption in fw */
    /* WARNING: Have to check how to control the decryption (which bit) and then set/reset
                the  appropriate bit*/
    if (bHwDecEnable)
    {
        pWlanParams->FeatureDataFlowOptions &= ~DF_SNIFF_MODE_ENABLE;
    }
    else
    {
        pWlanParams->FeatureDataFlowOptions |= DF_SNIFF_MODE_ENABLE;
    }

    return cmdBld_CfgIeFeatureConfig (hCmdBld,
                                      pWlanParams->FeatureOptions,
                                      pWlanParams->FeatureDataFlowOptions,
                                      fCb,
                                      hCb);
}


TI_STATUS cmdBld_CfgHwEncDecEnable (TI_HANDLE hCmdBld, TI_BOOL bHwEncEnable, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgHwEncEnable (hCmdBld, bHwEncEnable, bHwEncEnable, fCb, hCb);
}


/*
 * ----------------------------------------------------------------------------
 * Function : cmdBld_CfgSecureMode
 *
 * Input    :
 * Output   :
 * Process  :
 * Note(s)  :
 * -----------------------------------------------------------------------------
 */
TI_STATUS cmdBld_CfgSecureMode (TI_HANDLE hCmdBld, ECipherSuite eSecurMode, void *fCb, TI_HANDLE hCb)
{
    TCmdBld  *pCmdBld = (TCmdBld *)hCmdBld;
    TI_UINT32     index;

    if (eSecurMode < TWD_CIPHER_MAX)
    {
        TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_CfgSecureMode: change tSecurity mode from %d --> %d\n", pCmdBld->tSecurity.eSecurityMode, eSecurMode);
        /* check if tSecurity mode is equal to previous one*/
        if (pCmdBld->tSecurity.eSecurityMode == eSecurMode)
        {
            return TI_OK;
        }

        /* Reset all reconfig valid fields*/
        DB_KEYS(pCmdBld).bHwEncDecrEnableValid = TI_FALSE;
        DB_KEYS(pCmdBld).bDefaultKeyIdValid = TI_FALSE;
        for (index = 0;
             index < pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS;
             index++)
        {
            (DB_KEYS(pCmdBld).pReconfKeys + index)->keyType = KEY_NULL;
        }

        /* set the new tSecurity mode*/
        pCmdBld->tSecurity.eSecurityMode = eSecurMode;

        /* disable defrag, duplicate detection on TNETW+XCC on chip level*/
        /* YV- to add fragmentation control (if there is- artur ?)*/
        return cmdBld_CfgRxMsduFormat (hCmdBld,
                                       pCmdBld->tSecurity.eSecurityMode != TWD_CIPHER_CKIP,
                                       fCb,
                                       hCb);
    }
    else
    {
        return TI_NOK;
    }
}


TI_STATUS cmdBld_CfgConnMonitParams (TI_HANDLE  hCmdBld,
                                     TRroamingTriggerParams *pRoamingTriggerCmd,
                                     void       *fCb,
                                     TI_HANDLE  hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "SetBssLossTsfThresholdParamsCmd :\n                             BssLossTimeout = %d\n                             TsfMissThreshold = %d \n ", pRoamingTriggerCmd->BssLossTimeout, pRoamingTriggerCmd->TsfMissThreshold);

    DB_WLAN(hCmdBld).roamTriggers.BssLossTimeout = pRoamingTriggerCmd->BssLossTimeout;
    DB_WLAN(hCmdBld).roamTriggers.TsfMissThreshold = pRoamingTriggerCmd->TsfMissThreshold;

    return cmdBld_CfgIeConnMonitParams (hCmdBld, pRoamingTriggerCmd, fCb, hCb);
}


/****************************************************************************
 *                 cmdBld_CfgEnableRxDataFilter()
 ****************************************************************************
 * DESCRIPTION: Enables or disables Rx data filtering.
 *
 * INPUTS:  enabled             - 0 to disable data filtering, any other value to enable.
 *          defaultAction       - The default action to take on non-matching packets.
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgEnableRxDataFilter (TI_HANDLE   hCmdBld,
                                        TI_BOOL     bEnabled,
                                        filter_e    eDefaultAction,
                                        void        *fCb,
                                        TI_HANDLE   hCb)
{
    /* Save parameters for reconfig phase */
    DB_RX_DATA_FLTR(hCmdBld).bEnabled       = bEnabled;
    DB_RX_DATA_FLTR(hCmdBld).eDefaultAction = eDefaultAction;

    return cmdBld_CfgIeEnableRxDataFilter (hCmdBld, bEnabled, eDefaultAction, fCb, hCb);
}


/****************************************************************************
*                      cmdBld_CfgRxDataFilter()
*****************************************************************************
* DESCRIPTION: Add/remove Rx Data filter information element.
*
* INPUTS:  index               - Index of the Rx Data filter
*          command             - Add or remove the filter
*          action              - Action to take on packets matching the pattern
*          numFieldPatterns    - Number of field patterns in the filter
*          lenFieldPatterns    - Length of the field pattern series
*          fieldPatterns       - Series of field patterns
*
* OUTPUT:  None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CfgRxDataFilter (TI_HANDLE hCmdBld,
                                  TI_UINT8     index,
                                  TI_UINT8     command,
                                  filter_e  eAction,
                                  TI_UINT8     uNumFieldPatterns,
                                  TI_UINT8     uLenFieldPatterns,
                                  TI_UINT8  *pFieldPatterns,
                                  void      *fCb,
                                  TI_HANDLE hCb)
{
    TCmdBld         *pCmdBld  = (TCmdBld *)hCmdBld;
    TRxDataFilter   *pFilters = &(DB_RX_DATA_FLTR(hCmdBld).aRxDataFilter[index]);


    /* Save parameters for reconfig phase */
    pFilters->uIndex            = index;
    pFilters->uCommand          = command;
    pFilters->eAction           = eAction;
    pFilters->uNumFieldPatterns = uNumFieldPatterns;
    pFilters->uLenFieldPatterns = uLenFieldPatterns;
    os_memoryCopy(pCmdBld->hOs, pFilters->aFieldPattern, pFieldPatterns, uLenFieldPatterns);


    return cmdBld_CfgIeRxDataFilter (hCmdBld,
                                     index,
                                     command,
                                     eAction,
                                     uNumFieldPatterns,
                                     uLenFieldPatterns,
                                     pFieldPatterns,
                                     fCb,
                                     hCb);
}


TI_STATUS cmdBld_CfgCtsProtection (TI_HANDLE hCmdBld, TI_UINT8 uCtsProtection, void *fCb, TI_HANDLE hCb)
    {
        DB_WLAN(hCmdBld).CtsToSelf = uCtsProtection;

    return cmdBld_CfgIeCtsProtection (hCmdBld, uCtsProtection, fCb, hCb);
}


TI_STATUS cmdBld_CfgServicePeriodTimeout (TI_HANDLE hCmdBld, TRxTimeOut *pRxTimeOut, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeServicePeriodTimeout (hCmdBld, pRxTimeOut, fCb, hCb);
}


TI_STATUS cmdBld_CfgRxMsduLifeTime (TI_HANDLE hCmdBld, TI_UINT32 uRxMsduLifeTime, void *fCb, TI_HANDLE hCb)
    {
        DB_WLAN(hCmdBld).MaxRxMsduLifetime = uRxMsduLifeTime;

    return cmdBld_CfgIeRxMsduLifeTime (hCmdBld, uRxMsduLifeTime, fCb, hCb);
}


TI_STATUS cmdBld_CfgStatisitics (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeStatisitics (hCmdBld, fCb, hCb);
}


TI_STATUS cmdBld_CfgTxPowerDbm (TI_HANDLE hCmdBld, TI_UINT8 uTxPowerDbm, void *fCb, TI_HANDLE hCb)
{
    return cmdBld_CfgIeTxPowerDbm (hCmdBld, uTxPowerDbm, fCb, hCb);
}

 /*
 * ----------------------------------------------------------------------------
 * Function : cmdBld_setBetParams
 *
 * Input    :   enabled               - 0 to disable BET, 0 to disable BET
 *              MaximumConsecutiveET  - Max number of consecutive beacons
 *                                      that may be early terminated.
 * Output   : TI_STATUS
 * Process  :  Configures Beacon Early Termination information element.
 * Note(s)  :  None
 * -----------------------------------------------------------------------------
 */
TI_STATUS cmdBld_CfgBet (TI_HANDLE hCmdBld, TI_UINT8 Enable, TI_UINT8 MaximumConsecutiveET, void *fCb, TI_HANDLE hCb)
{
    DB_WLAN(hCmdBld).BetEnable              = Enable;
    DB_WLAN(hCmdBld).MaximumConsecutiveET   = MaximumConsecutiveET;

    return cmdBld_CfgIeBet (hCmdBld, Enable, MaximumConsecutiveET, fCb, hCb);
}

/****************************************************************************
 *                      cmdBld_CmdKeepAlive()
 ****************************************************************************
 * DESCRIPTION: Set keep-alive paramters for a single index
 *
 * INPUTS: Paramters and CB
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgKeepAlive (TI_HANDLE hCmdBld, TKeepAliveParams *pKeepAliveParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld   *pCmdBld = (TCmdBld *)hCmdBld;

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "CmdBld: Seeting keep-alive params, index=%d, interval=%d msec, trigType=%d, enaFlag=%d\n", pKeepAliveParams->index, pKeepAliveParams->interval, pKeepAliveParams->trigType, pKeepAliveParams->enaDisFlag);

    os_memoryCopy (pCmdBld->hOs,
                   (void *)&DB_KLV(hCmdBld).keepAliveParams[ pKeepAliveParams->index ],
                   (void *)pKeepAliveParams,
                   sizeof (TKeepAliveParams));

    return cmdBld_CmdIeConfigureKeepAliveParams (hCmdBld,
                                                 pKeepAliveParams->index,
                                                 pKeepAliveParams->enaDisFlag,
                                                 (TI_UINT8)pKeepAliveParams->trigType,
                                                 pKeepAliveParams->interval,
                                                 fCb,
                                                 hCb);
}

/****************************************************************************
 *                      cmdBld_CfgKeepAliveEnaDis()
 ****************************************************************************
 * DESCRIPTION: Set global keep-alive enable / disable flag
 *
 * INPUTS: Paramters and CB
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgKeepAliveEnaDis(TI_HANDLE hCmdBld, TI_UINT8 enaDisFlag, void *fCb, TI_HANDLE hCb)
{
    TCmdBld   *pCmdBld = (TCmdBld *)hCmdBld;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "CmdBld: Seeting keep-alive Global ena / dis flag to %d\n", (TI_UINT32)enaDisFlag);

    DB_KLV(hCmdBld).enaDisFlag = enaDisFlag;

    return cmdBld_CmdIeConfigureKeepAliveEnaDis (hCmdBld, enaDisFlag, fCb, hCb);
}

/**
 * \fn     cmdBld_CfgSetFwHtCapabilities
 * \brief  set the current AP HT Capabilities to the FW.
 *
 * \note
 * \return TI_OK on success or TI_NOK on failure
 * \sa
 */
TI_STATUS cmdBld_CfgSetFwHtCapabilities (TI_HANDLE hCmdBld,
                                         TI_UINT32 uHtCapabilites,
                                         TMacAddr  tMacAddress,
                                         TI_UINT8  uAmpduMaxLeng,
                                         TI_UINT8  uAmpduMinSpac,
                                         void      *fCb,
                                         TI_HANDLE hCb)
{

    DB_BSS(hCmdBld).bHtCap = TI_TRUE;
    DB_BSS(hCmdBld).uHtCapabilites = uHtCapabilites;
    MAC_COPY ((DB_BSS(hCmdBld).tMacAddress), tMacAddress);
    DB_BSS(hCmdBld).uAmpduMaxLeng = uAmpduMaxLeng;
    DB_BSS(hCmdBld).uAmpduMinSpac = uAmpduMinSpac;

    return cmdBld_CfgIeSetFwHtCapabilities (hCmdBld,
                                            uHtCapabilites,
                                            tMacAddress,
                                            uAmpduMaxLeng,
                                            uAmpduMinSpac,
                                            fCb,
                                            hCb);
}

/**
 * \fn     cmdBld_CfgSetFwHtInformation
 * \brief  set the current AP HT Information to the FW.
 *
 * \note
 * \return TI_OK on success or TI_NOK on failure
 * \sa
 */
TI_STATUS cmdBld_CfgSetFwHtInformation (TI_HANDLE hCmdBld,
                                        TI_UINT8  uRifsMode,
                                        TI_UINT8  uHtProtection,
                                        TI_UINT8  uGfProtection,
                                        TI_UINT8  uHtTxBurstLimit,
                                        TI_UINT8  uDualCtsProtection,
                                        void      *fCb,
                                        TI_HANDLE hCb)
{

    DB_BSS(hCmdBld).bHtInf = TI_TRUE;
    DB_BSS(hCmdBld).uRifsMode = uRifsMode;
    DB_BSS(hCmdBld).uHtProtection = uHtProtection;
    DB_BSS(hCmdBld).uGfProtection = uGfProtection;
    DB_BSS(hCmdBld).uHtTxBurstLimit = uHtTxBurstLimit;
    DB_BSS(hCmdBld).uDualCtsProtection = uDualCtsProtection;

    return cmdBld_CfgIeSetFwHtInformation (hCmdBld,
                                           uRifsMode,
                                           uHtProtection,
                                           uGfProtection,
                                           uHtTxBurstLimit,
                                           uDualCtsProtection,
                                           fCb,
                                           hCb);
}

/**
 * \fn     cmdBld_CfgSetBaInitiator
 * \brief  configure BA session initiator\receiver parameters setting in the FW.
 *
 * \note
 * \return TI_OK on success or TI_NOK on failure
 * \sa
 */
TI_STATUS cmdBld_CfgSetBaSession (TI_HANDLE hCmdBld,
                                  InfoElement_e eBaType,
                                  TI_UINT8 uTid,
                                  TI_UINT8 uState,
                                  TMacAddr tRa,
                                  TI_UINT16 uWinSize,
                                  TI_UINT16 uInactivityTimeout,
                                  void *fCb,
                                  TI_HANDLE hCb)
{
    if (ACX_BA_SESSION_INITIATOR_POLICY == eBaType)
    {
        DB_BSS(hCmdBld).bBaInitiator[uTid] = TI_TRUE;
        DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uTid = uTid;
        DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uPolicy = uState;
        MAC_COPY ((DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].aMacAddress),tRa);
        DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uWinSize = uWinSize;
        DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uInactivityTimeout = uInactivityTimeout;
    }
    else
    {
        DB_BSS(hCmdBld).bBaResponder[uTid] = TI_TRUE;
        DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uTid = uTid;
        DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uPolicy = uState;
        MAC_COPY ((DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].aMacAddress),tRa);
        DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uWinSize = uWinSize;
        DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uInactivityTimeout = uInactivityTimeout;
    }

    return cmdBld_CfgIeSetBaSession (hCmdBld,
                                     eBaType,
                                     uTid,
                                     uState,
                                     tRa,
                                     uWinSize,
                                     uInactivityTimeout,
                                     fCb,
                                     hCb);
}


TI_STATUS cmdBld_CfgBurstMode (TI_HANDLE hCmdBld, TI_BOOL bEnabled, void *fCb, TI_HANDLE hCb)
{
	DB_AC(hCmdBld).isBurstModeEnabled = bEnabled;
	return cmdBld_CfgIeBurstMode (hCmdBld, bEnabled, fCb, hCb);
}