xref: /hardware/ti/wlan/wl1271/TWD/Ctrl/CmdBldCfgIE.c

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


/** \file  CmdBldCfgIE.c
 *  \brief Command builder. Configuration commands information elements
 *
 *  \see   CmdBld.h
 */
#define __FILE_ID__  FILE_ID_92
#include "osApi.h"
#include "report.h"
#include "CmdBld.h"
#include "CmdQueue_api.h"
#include "rate.h"
#include "TwIf.h"

/****************************************************************************
 *                      cmdBld_CfgIeConfigMemory()
 ****************************************************************************
 * DESCRIPTION: Configure wlan hardware memory
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeConfigMemory (TI_HANDLE hCmdBld, TDmaParams *pDmaParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXConfigMemory_t AcxElm_ConfigMemory;
    ACXConfigMemory_t *pCfg = &AcxElm_ConfigMemory;

    os_memoryZero(pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));

    /*
     * Set information element header
     */
    pCfg->EleHdr.id = ACX_MEM_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /*
     * Set configuration fields
     */
    pCfg->numStations             = pDmaParams->NumStations;
    pCfg->rxMemblockNumber        = pDmaParams->NumRxBlocks;
    pCfg->txMinimumMemblockNumber = TWD_TX_MIN_MEM_BLKS_NUM;
    pCfg->numSsidProfiles         = 1;
    pCfg->totalTxDescriptors      = ENDIAN_HANDLE_LONG(NUM_TX_DESCRIPTORS);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/* WoneIndex value when running as station */
#define STATION_WONE_INDEX                  0


/****************************************************************************
 *                      cmdBld_CfgIeSlotTime()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the Slot Time
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeSlotTime (TI_HANDLE hCmdBld, TI_UINT8 apSlotTime, void *fCb, TI_HANDLE hCb)
{
    TCmdBld    *pCmdBld = (TCmdBld *)hCmdBld;
    ACXSlot_t   AcxElm_SlotTime;
    ACXSlot_t   *pCfg = &AcxElm_SlotTime;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_SLOT;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set configuration fields */
    /* woneIndex is not relevant to station implementation */
    pCfg->woneIndex = STATION_WONE_INDEX;
    pCfg->slotTime = apSlotTime;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, Slot Time = %d\n", (TI_UINT8)pCfg->slotTime);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIePreamble()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the Preamble
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIePreamble (TI_HANDLE hCmdBld, TI_UINT8 preamble, void *fCb, TI_HANDLE hCb)
{
    TCmdBld        *pCmdBld = (TCmdBld *)hCmdBld;
    ACXPreamble_t   AcxElm_Preamble;
    ACXPreamble_t   *pCfg = &AcxElm_Preamble;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_PREAMBLE_TYPE;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set configuration fields */
    /* woneIndex is not relevant to station implementation */
    pCfg->preamble = preamble;

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: preamble=%u\n", pCfg->EleHdr.id, preamble);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeRx()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate RxConfig information element
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeRx (TI_HANDLE hCmdBld, TI_UINT32 apRxConfigOption, TI_UINT32 apRxFilterOption, void *fCb, TI_HANDLE hCb)
{
    TCmdBld       *pCmdBld = (TCmdBld *)hCmdBld;
    ACXRxConfig_t   AcxElm_RxConfig;
    ACXRxConfig_t  *pCfg = &AcxElm_RxConfig;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_RX_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set configuration fields */
    pCfg->ConfigOptions = ENDIAN_HANDLE_LONG(apRxConfigOption);
    pCfg->FilterOptions = ENDIAN_HANDLE_LONG(apRxFilterOption);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}

/****************************************************************************
*                 cmdBld_CfgIeEnableRxDataFilter()
*****************************************************************************
* 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_CfgIeEnableRxDataFilter (TI_HANDLE hCmdBld, TI_BOOL enabled, filter_e defaultAction, void *fCb, TI_HANDLE hCb)
{
    TCmdBld       *pCmdBld = (TCmdBld *)hCmdBld;
    DataFilterDefault_t dataFilterDefault;
    DataFilterDefault_t * pCfg = &dataFilterDefault;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_ENABLE_RX_DATA_FILTER;
    pCfg->EleHdr.len = 0;

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Rx Data Filter configuration:\n");
    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": enabled = %d, defaultAction = %d\n", enabled, defaultAction);

    /* Set information element configuration fields */
    pCfg->enable = enabled;
    pCfg->action = defaultAction;
    pCfg->EleHdr.len += sizeof(pCfg->enable) + sizeof(pCfg->action);

    TRACE_INFO_HEX(pCmdBld->hReport, (TI_UINT8 *) pCfg, sizeof(dataFilterDefault));

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}

/****************************************************************************
*                      cmdBld_CfgIeRxDataFilter()
*****************************************************************************
* 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_CfgIeRxDataFilter (TI_HANDLE hCmdBld,
                                    TI_UINT8 index,
                                    TI_UINT8 command,
                                    filter_e action,
                                    TI_UINT8 numFieldPatterns,
                                    TI_UINT8 lenFieldPatterns,
                                    TI_UINT8 *pFieldPatterns,
                                    void *fCb,
                                    TI_HANDLE hCb)
{
    TCmdBld       *pCmdBld = (TCmdBld *)hCmdBld;
    TI_UINT8 dataFilterConfig[sizeof(DataFilterConfig_t) + MAX_DATA_FILTER_SIZE];
    DataFilterConfig_t * pCfg = (DataFilterConfig_t *) &dataFilterConfig;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_SET_RX_DATA_FILTER;
    pCfg->EleHdr.len = 0;

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Rx Data Filter configuration:\n");
    TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": command = %d, index = %d, action = %d, numFieldPatterns = %d, lenFieldPatterns = %d\n", command, index, action, numFieldPatterns, lenFieldPatterns);

    /* Set information element configuration fields */
    pCfg->command = command;
    pCfg->index = index;
    pCfg->EleHdr.len += sizeof(pCfg->command) + sizeof(pCfg->index);

    /* When removing a filter only the index and command are to be sent */
    if (command == ADD_FILTER)
    {
        pCfg->action = action;
        pCfg->numOfFields = numFieldPatterns;
        pCfg->EleHdr.len += sizeof(pCfg->action) + sizeof(pCfg->numOfFields);

        if (pFieldPatterns == NULL)
        {
            TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, ": Null pattern table argument received!\n");

            return PARAM_VALUE_NOT_VALID;
        }

        os_memoryCopy(pCmdBld->hOs, &pCfg->FPTable, pFieldPatterns, lenFieldPatterns);
        pCfg->EleHdr.len += lenFieldPatterns;
    }

    TRACE_INFO_HEX(pCmdBld->hReport, (TI_UINT8 *) pCfg, sizeof(dataFilterConfig));

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(dataFilterConfig), fCb, hCb, NULL);
}

/****************************************************************************
 *                      cmdBld_CfgIeArpIpFilter()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate ARP addr table information element for
 *              ipV4 only
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeArpIpFilter (TI_HANDLE hCmdBld,
                                   TIpAddr   tIpAddr,
                                   EArpFilterType  filterType,
                                   void      *fCb,
                                   TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXConfigureIP_t AcxElm_CmdConfigureIP;
    ACXConfigureIP_t *pCfg = &AcxElm_CmdConfigureIP;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_ARP_IP_FILTER;
    pCfg->EleHdr.len = sizeof(ACXConfigureIP_t) - sizeof(EleHdrStruct);

    pCfg->arpFilterEnable = (TI_UINT8)filterType;

    /* IP address */
    /* Note that in the case of IPv4 it is assumed that the extra two bytes are zero */
    IP_COPY (pCfg->address, tIpAddr);

    TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: ip=%x, enable=%u\n", pCfg->EleHdr.id, *((TI_UINT32*)pCfg->address), filterType);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXConfigureIP_t), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeGroupAdressTable()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate Group addr table information element
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeGroupAdressTable (TI_HANDLE       hCmdBld,
                                        TI_UINT8        numGroupAddrs,
                                        TMacAddr        *pGroupAddr,
                                        TI_BOOL         bEnabled,
                                        void            *fCb,
                                        TI_HANDLE       hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TI_UINT32   i = 0;
    TI_UINT8   *tmpLoc = NULL;
    dot11MulticastGroupAddrStart_t  AcxElm_CmdConfigureMulticastIp;
    dot11MulticastGroupAddrStart_t* pCfg = &AcxElm_CmdConfigureMulticastIp;

    os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(dot11MulticastGroupAddrStart_t));

    /* Set information element header */
    pCfg->EleHdr.id = DOT11_GROUP_ADDRESS_TBL;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->numOfGroups = numGroupAddrs;
    pCfg->fltrState = bEnabled;
    tmpLoc = pCfg->dataLocation;

    if (NULL != pGroupAddr)
    {
        for (i = 0; i < numGroupAddrs; i++)
        {
            MAC_COPY (&tmpLoc[MAC_ADDR_LEN * i], *(pGroupAddr + i));

            TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeGroupAdressTable: MAC %x: %x:%x:%x:%x:%x:%x\n", i, tmpLoc[MAC_ADDR_LEN*i+0] , tmpLoc[MAC_ADDR_LEN*i+1] , tmpLoc[MAC_ADDR_LEN*i+2] , tmpLoc[MAC_ADDR_LEN*i+3] , tmpLoc[MAC_ADDR_LEN*i+4] , tmpLoc[MAC_ADDR_LEN*i+5]);
        }
    }

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(dot11MulticastGroupAddrStart_t), fCb, hCb, NULL);

}


/****************************************************************************
 *                      cmdBld_CfgIeSgEnable()
 ****************************************************************************
 * DESCRIPTION: Enable/Disable the BTH-WLAN
 *
 * INPUTS:  Enable flag
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeSgEnable (TI_HANDLE hCmdBld, ESoftGeminiEnableModes SoftGeminiEnableModes, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXBluetoothWlanCoEnableStruct  AcxElm_BluetoothWlanEnable;
    ACXBluetoothWlanCoEnableStruct* pCfg = &AcxElm_BluetoothWlanEnable;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSgEnable: Enable flag = %d\n", SoftGeminiEnableModes);

    /* Set information element header */
    pCfg->EleHdr.id = ACX_SG_ENABLE;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set enable field */
    pCfg->coexOperationMode = (TI_UINT8)SoftGeminiEnableModes;

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeSg()
 ****************************************************************************
 * DESCRIPTION: Configure the BTH-WLAN co-exsistance
 *
 * INPUTS:  Configuration structure pointer
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeSg (TI_HANDLE hCmdBld, TSoftGeminiParams *pSoftGeminiParam, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXBluetoothWlanCoParamsStruct  AcxElm_BluetoothWlanEnable;
    ACXBluetoothWlanCoParamsStruct *pCfg = &AcxElm_BluetoothWlanEnable;
	int i=0;

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSg. \n");

    /* Set information element header */
    pCfg->EleHdr.id      		= ACX_SG_CFG;
    pCfg->EleHdr.len     		= sizeof(*pCfg) - sizeof(EleHdrStruct);

	pCfg->softGeminiParams.paramIdx = pSoftGeminiParam->paramIdx;


	for (i=0; i< SOFT_GEMINI_PARAMS_MAX ; i++)
	{
		pCfg->softGeminiParams.coexParams[i] = pSoftGeminiParam->coexParams[i];
	}

    /* Rate conversion is done in the HAL */
    pCfg->softGeminiParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] = rateNumberToBitmap((TI_UINT8)pSoftGeminiParam->coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH]);

	if (pCfg->softGeminiParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] == 0)
    {
        TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "coexAPRateAdapationThr is 0, convert to 1MBPS. \n");
        pCfg->softGeminiParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] = HW_BIT_RATE_1MBPS;
    }

    /* Send the configuration command */
    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeFmCoex()
 ****************************************************************************
 * DESCRIPTION: Configure the FM-WLAN co-exsistance parameters
 *
 * INPUTS:  Configuration structure pointer
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeFmCoex (TI_HANDLE hCmdBld, TFmCoexParams *pFmCoexParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXWlanFmCoexStruct  tFmWlanCoex;
    ACXWlanFmCoexStruct *pCfg = &tFmWlanCoex;

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeFmCoex\n");

    /* Set information element header */
    pCfg->EleHdr.id  = ACX_FM_COEX_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set parameters with endianess handling */
    pCfg->enable                   = pFmCoexParams->uEnable;
    pCfg->swallowPeriod            = pFmCoexParams->uSwallowPeriod;
    pCfg->nDividerFrefSet1         = pFmCoexParams->uNDividerFrefSet1;
    pCfg->nDividerFrefSet2         = pFmCoexParams->uNDividerFrefSet2;
    pCfg->mDividerFrefSet1         = ENDIAN_HANDLE_WORD(pFmCoexParams->uMDividerFrefSet1);
    pCfg->mDividerFrefSet2         = ENDIAN_HANDLE_WORD(pFmCoexParams->uMDividerFrefSet2);
    pCfg->coexPllStabilizationTime = ENDIAN_HANDLE_LONG(pFmCoexParams->uCoexPllStabilizationTime);
    pCfg->ldoStabilizationTime     = ENDIAN_HANDLE_WORD(pFmCoexParams->uLdoStabilizationTime);
    pCfg->fmDisturbedBandMargin    = pFmCoexParams->uFmDisturbedBandMargin;
    pCfg->swallowClkDif            = pFmCoexParams->uSwallowClkDif;

    /* Send the configuration command */
    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeMemoryMap ()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate MemoryMap information element
 *
 * INPUTS:
 *      AcxElm_MemoryMap_T *apMap   pointer to the memory map structure
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeMemoryMap (TI_HANDLE hCmdBld, MemoryMap_t *apMap, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    MemoryMap_t SwapMap;
    TI_UINT32 *pSwap, *pOrig, i, uMemMapNumFields;

    /* Set information element header */
    SwapMap.EleHdr.id  = ACX_MEM_MAP;
    SwapMap.EleHdr.len = sizeof(MemoryMap_t) - sizeof(EleHdrStruct);

    /* Solve endian problem (all fields are 32 bit) */
    pOrig = (TI_UINT32* )&apMap->codeStart;
    pSwap = (TI_UINT32* )&SwapMap.codeStart;
    uMemMapNumFields = (sizeof(MemoryMap_t) - sizeof(EleHdrStruct)) % 4;
    for (i = 0; i < uMemMapNumFields; i++)
        pSwap[i] = ENDIAN_HANDLE_LONG(pOrig[i]);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, &SwapMap, sizeof(SwapMap), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeAid()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the AID info element
 *
 * INPUTS:
 *      TI_UINT16* apAidVal     The AID value
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeAid (TI_HANDLE hCmdBld, TI_UINT16 apAidVal, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXAid_t    WlanElm_AID;
    ACXAid_t    *pCfg = &WlanElm_AID;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_AID;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->Aid = ENDIAN_HANDLE_WORD(apAidVal);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeWakeUpCondition()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the power management option
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeWakeUpCondition (TI_HANDLE hCmdBld, TPowerMgmtConfig *pPMConfig, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    WakeUpCondition_t WakeUpCondition;
    WakeUpCondition_t *pCfg = &WakeUpCondition;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "WakeUpCondition :\n                             listenInterval = 0x%X\n", pPMConfig->listenInterval);

    switch (pPMConfig->tnetWakeupOn)
    {
        case TNET_WAKE_ON_BEACON:
            pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_BEACON_BITMAP;
            break;
        case TNET_WAKE_ON_DTIM:
            pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_DTIM_BITMAP;
            break;
        case TNET_WAKE_ON_N_BEACON:
            pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_N_BEACONS_BITMAP;
            break;
        case TNET_WAKE_ON_N_DTIM:
            pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_N_DTIM_BITMAP;
            break;
        default:
            pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_BEACON_BITMAP;
            break;
    }

    pCfg->listenInterval = pPMConfig->listenInterval;

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_wakeUpCondition  tnetWakeupOn=0x%x listenInterval=%d\n",pCfg->wakeUpConditionBitmap,pCfg->listenInterval);

    /* Set information element header */
    pCfg->EleHdr.id = ACX_WAKE_UP_CONDITIONS;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeSleepAuth()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the power management option
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeSleepAuth (TI_HANDLE hCmdBld, EPowerPolicy eMinPowerLevel, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXSleepAuth_t ACXSleepAuth;
    ACXSleepAuth_t *pCfg = &ACXSleepAuth;
    EElpCtrlMode eElpCtrlMode;

    /* Set the ELP control according to the new power policy */
    switch (eMinPowerLevel)
    {
    case POWERAUTHO_POLICY_AWAKE:   eElpCtrlMode = ELPCTRL_MODE_KEEP_AWAKE;  break;
    case POWERAUTHO_POLICY_PD:      eElpCtrlMode = ELPCTRL_MODE_KEEP_AWAKE;  break;
    case POWERAUTHO_POLICY_ELP:     eElpCtrlMode = ELPCTRL_MODE_NORMAL;      break;
    default:
        TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, " - Param value is not supported, %d\n", eMinPowerLevel);
        return TI_NOK;

    }

    /* Set the ELP mode only if there is a change */
    if (pCmdBld->uLastElpCtrlMode != eElpCtrlMode)
    {
        pCmdBld->uLastElpCtrlMode = eElpCtrlMode;
		if (eElpCtrlMode == ELPCTRL_MODE_KEEP_AWAKE)
		{
			twIf_Awake(pCmdBld->hTwIf);
		}
		else
		{
			twIf_Sleep(pCmdBld->hTwIf);
		}
    }

    /* In the info element the enums are in reverse */
    switch (eMinPowerLevel)
    {
        case POWERAUTHO_POLICY_ELP:
            pCfg->sleepAuth = 2;
            break;
        case POWERAUTHO_POLICY_AWAKE:
            pCfg->sleepAuth = 0;
            break;
        default:
            pCfg->sleepAuth = eMinPowerLevel;
    }

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_MinPowerLevelSet  sleepAuth=%d\n", eMinPowerLevel);

    /* Set information element header*/
    pCfg->EleHdr.id = ACX_SLEEP_AUTH;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeBcnBrcOptions()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the power management option
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeBcnBrcOptions (TI_HANDLE hCmdBld, TPowerMgmtConfig *pPMConfig, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXBeaconAndBroadcastOptions_t ACXBeaconAndBroadcastOptions;
    ACXBeaconAndBroadcastOptions_t *pCfg = &ACXBeaconAndBroadcastOptions;

    pCfg->beaconRxTimeOut = pPMConfig->BcnBrcOptions.BeaconRxTimeout;
    pCfg->broadcastTimeOut = pPMConfig->BcnBrcOptions.BroadcastRxTimeout;
    pCfg->rxBroadcastInPS = pPMConfig->BcnBrcOptions.RxBroadcastInPs;
	pCfg->consecutivePsPollDeliveryFailureThr = pPMConfig->ConsecutivePsPollDeliveryFailureThreshold;


    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_BcnBrcOptions  BeaconRxTimeout=%d BroadcastRxTimeout=%d RxBroadcastInPs=0x%x, consecutivePsPollDeliveryFailureThr=%d\n",							 pCfg->beaconRxTimeOut,pCfg->broadcastTimeOut,							 pCfg->rxBroadcastInPS, pCfg->consecutivePsPollDeliveryFailureThr);

    /* Set information element header */
    pCfg->EleHdr.id = ACX_BCN_DTIM_OPTIONS;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeFeatureConfig()
                                    ACXBeaconAndBroadcastOptions_t* pWlanElm_BcnBrcOptions,
 ****************************************************************************
 * DESCRIPTION: Configure the feature config info element
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeFeatureConfig (TI_HANDLE hCmdBld, TI_UINT32 options, TI_UINT32 uDataFlowOptions, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXFeatureConfig_t  WlanElm_FeatureConfig;
    ACXFeatureConfig_t  *pCfg = &WlanElm_FeatureConfig;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_FEATURE_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set fields */
    pCfg->Options = ENDIAN_HANDLE_LONG(options);
    pCfg->dataflowOptions = ENDIAN_HANDLE_LONG(uDataFlowOptions);

    TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: option=0x%x, def.option=0x%x\n", pCfg->EleHdr.id, options, uDataFlowOptions);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeTxPowerDbm ()
 ****************************************************************************
 * DESCRIPTION: Set the Tx power in Dbm units.
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeTxPowerDbm (TI_HANDLE hCmdBld, TI_UINT8 uTxPowerDbm , void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    dot11CurrentTxPowerStruct dot11CurrentTxPower;
    dot11CurrentTxPowerStruct *pCfg = &dot11CurrentTxPower;

   TRACE1( pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " uTxPowerDbm = %d\n", uTxPowerDbm);


    /* Set information element header*/
    pCfg->EleHdr.id = DOT11_CUR_TX_PWR;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->dot11CurrentTxPower = uTxPowerDbm;

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeStatisitics ()
 ****************************************************************************
 * DESCRIPTION: Set the ACX statistics counters to zero.
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeStatisitics (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TI_STATUS status = TI_NOK;
    ACXStatistics_t  *pCfg;

    pCfg = os_memoryAlloc(pCmdBld->hOs, sizeof(ACXStatistics_t));
    if (!pCfg)
    {
        return status;
    }

    /* Set information element header */
    pCfg->EleHdr.id  = ACX_STATISTICS;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    status = cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
    os_memoryFree(pCmdBld->hOs, pCfg, sizeof(ACXStatistics_t));
    return status;
}


/****************************************************************************
 *                      cmdBld_CfgIeTid()
 ****************************************************************************
 * DESCRIPTION: Write the Queue configuration (For Quality Of Service)
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeTid (TI_HANDLE hCmdBld, TQueueTrafficParams* pQtrafficParams, void *fCb, TI_HANDLE hCb)

{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXTIDConfig_t    TrafficCategoryCfg;
    ACXTIDConfig_t   *pCfg = &TrafficCategoryCfg;

    os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));

    /*
     * Set information element header
     * ==============================
     */
    pCfg->EleHdr.id = ACX_TID_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /*
     * Set information element Data
     * ==============================
     */
    pCfg->queueID       = pQtrafficParams->queueID;
    pCfg->channelType   = pQtrafficParams->channelType;
    pCfg->tsid          = pQtrafficParams->tsid;
    pCfg->psScheme      = pQtrafficParams->psScheme;
    pCfg->APSDConf[0]   = pQtrafficParams->APSDConf[0];
    pCfg->APSDConf[1]   = pQtrafficParams->APSDConf[1];

    TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: queue-id=%u, chan-type=%u, tsid=%u, ps-scheme=%u, apsd-1=0x%x, apsd-2=0x%x\n", pCfg->EleHdr.id, pCfg->queueID, pCfg->channelType, pCfg->tsid, pCfg->psScheme, pCfg->APSDConf[0], pCfg->APSDConf[1]);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeAcParams()
 ****************************************************************************
 * DESCRIPTION: Write the AC configuration (For Quality Of Service)
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeAcParams (TI_HANDLE hCmdBld, TAcQosParams *pAcQosParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXAcCfg_t     AcCfg;
    ACXAcCfg_t    *pCfg  = &AcCfg;

    os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));

    /*
     * Set information element header
     * ==============================
     */
    pCfg->EleHdr.id = ACX_AC_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /*
     * Set information element Data
     * ==============================
     */

    pCfg->ac        = pAcQosParams->ac;
    pCfg->aifsn     = pAcQosParams->aifsn;
    pCfg->cwMax     = ENDIAN_HANDLE_WORD(pAcQosParams->cwMax);
    pCfg->cwMin     = pAcQosParams->cwMin;
    pCfg->txopLimit = ENDIAN_HANDLE_WORD(pAcQosParams->txopLimit);

    TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: ac= %u, aifsn=%u, cw-max=%u, cw-min=%u, txop=%u\n", pCfg->EleHdr.id, pAcQosParams->ac, pAcQosParams->aifsn, pAcQosParams->cwMax, pAcQosParams->cwMin, pAcQosParams->txopLimit);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIePsRxStreaming()
 ****************************************************************************
 * DESCRIPTION: Write the AC PS-Rx-Streaming
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIePsRxStreaming (TI_HANDLE hCmdBld, TPsRxStreaming *pPsRxStreaming, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXPsRxStreaming_t  tStreamingCfg;
    ACXPsRxStreaming_t *pCfg  = &tStreamingCfg;

    os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));

    /*
     * Set information element header
     * ==============================
     */
    pCfg->EleHdr.id = ACX_PS_RX_STREAMING;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /*
     * Set information element Data
     * ============================
     */
    pCfg->TID          = (TI_UINT8)pPsRxStreaming->uTid;
    pCfg->rxPSDEnabled = (TI_UINT8)pPsRxStreaming->bEnabled;
    pCfg->streamPeriod = (TI_UINT8)pPsRxStreaming->uStreamPeriod;
    pCfg->txTimeout    = (TI_UINT8)pPsRxStreaming->uTxTimeout;

    TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: tid= %u, enable=%u, streamPeriod=%u, txTimeout=%u\n", pCfg->EleHdr.id, pCfg->TID, pCfg->rxPSDEnabled, pCfg->streamPeriod, pCfg->txTimeout);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIePacketDetectionThreshold()
 ****************************************************************************
 * DESCRIPTION:  Set the PacketDetection threshold
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIePacketDetectionThreshold (TI_HANDLE hCmdBld, TI_UINT32 pdThreshold, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXPacketDetection_t  PacketDetectionThresholdCfg;
    ACXPacketDetection_t *pCfg = &PacketDetectionThresholdCfg;

    /*
     * Set information element header
     * ==============================
     */
    pCfg->EleHdr.id = ACX_PD_THRESHOLD;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /*
     * Set information element Data
     * ==============================
     */
    pCfg->pdThreshold = ENDIAN_HANDLE_LONG(pdThreshold);

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": pdThreshold = 0x%x , len = 0x%x \n",pCfg->pdThreshold,pCfg->EleHdr.len);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}




/****************************************************************************
 *                      cmdBld_CfgIeBeaconFilterOpt()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the beacon filtering option
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeBeaconFilterOpt (TI_HANDLE hCmdBld, TI_UINT8 beaconFilteringStatus, TI_UINT8 numOfBeaconsToBuffer, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXBeaconFilterOptions_t  ACXBeaconFilterOptions;
    ACXBeaconFilterOptions_t *pCfg = &ACXBeaconFilterOptions;

    pCfg->enable = beaconFilteringStatus;
    pCfg->maxNumOfBeaconsStored = numOfBeaconsToBuffer;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_BEACON_FILTER_OPT;
    pCfg->EleHdr.len = sizeof(ACXBeaconFilterOptions_t) - sizeof(EleHdrStruct);

    TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: enable=%u, num-stored=%u\n", pCfg->EleHdr.id, beaconFilteringStatus, numOfBeaconsToBuffer);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXBeaconFilterOptions_t), fCb, hCb, NULL);
}
/****************************************************************************
 *                      cmdBld_CfgIeRateMngDbg()
 ****************************************************************************
 * DESCRIPTION: Configure the rate managment params
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/

TI_STATUS cmdBld_CfgIeRateMngDbg (TI_HANDLE hCmdBld, RateMangeParams_t *pRateMngParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    AcxRateMangeParams  RateMng;
    AcxRateMangeParams *pCfg = &RateMng;
	int i;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_SET_RATE_MAMAGEMENT_PARAMS;
    pCfg->EleHdr.len = sizeof(AcxRateMangeParams) - sizeof(EleHdrStruct);


    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u, index=%d \n",pCfg->EleHdr.id,pRateMngParams->paramIndex);

	pCfg->paramIndex = pRateMngParams->paramIndex;

	pCfg->InverseCuriosityFactor = pRateMngParams->InverseCuriosityFactor;
    pCfg->MaxPer = pRateMngParams->MaxPer;
	pCfg->PerAdd = pRateMngParams->PerAdd;
	pCfg->PerAddShift = pRateMngParams->PerAddShift;
	pCfg->PerAlphaShift = pRateMngParams->PerAlphaShift;
	pCfg->PerBeta1Shift = pRateMngParams->PerBeta1Shift;
	pCfg->PerBeta2Shift = pRateMngParams->PerBeta2Shift;
	pCfg->PerTh1 = pRateMngParams->PerTh1;
	pCfg->PerTh2 = pRateMngParams->PerTh2;
	pCfg->RateCheckDown = pRateMngParams->RateCheckDown;
	pCfg->RateCheckUp = pRateMngParams->RateCheckUp;
	pCfg->RateRetryScore = pRateMngParams->RateRetryScore;
	pCfg->TxFailHighTh = pRateMngParams->TxFailHighTh;
	pCfg->TxFailLowTh = pRateMngParams->TxFailLowTh;

	for (i=0 ; i< 13 ; i++)
	{
		pCfg->RateRetryPolicy[i] = pRateMngParams->RateRetryPolicy[i];
	}

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(AcxRateMangeParams), fCb, hCb, NULL);
}



/****************************************************************************
 *                     cmdBld_CfgIeBeaconFilterTable
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the beacon filter IE table
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeBeaconFilterTable (TI_HANDLE hCmdBld,
                                         TI_UINT8   uNumberOfIEs,
                                         TI_UINT8  *pIETable,
                                         TI_UINT8   uIETableSize,
                                         void      *fCb,
                                         TI_HANDLE  hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXBeaconFilterIETable_t beaconFilterIETableStruct;
    ACXBeaconFilterIETable_t *pCfg = &beaconFilterIETableStruct;
    TI_UINT32 counter;

    if (NULL == pIETable)
    {
        return PARAM_VALUE_NOT_VALID;
    }

    pCfg->EleHdr.id = ACX_BEACON_FILTER_TABLE;
    pCfg->EleHdr.len = uIETableSize + 1;
    pCfg->NumberOfIEs = uNumberOfIEs;

    os_memoryZero (pCmdBld->hOs, (void *)pCfg->IETable, BEACON_FILTER_TABLE_MAX_SIZE);
    os_memoryCopy (pCmdBld->hOs, (void *)pCfg->IETable, (void *)pIETable, uIETableSize);

    TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: num-ie=%u, table-size=%u\n", pCfg->EleHdr.id, uNumberOfIEs, uIETableSize);

TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "Beacon IE Table:\n");
    for (counter = 0; counter < uIETableSize; counter++)
    {
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "%2x ", pIETable[counter]);
	}
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "\n");

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXBeaconFilterIETable_t), fCb, hCb, NULL);
}

/****************************************************************************
 *                     cmdBld_CfgCoexActivity
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the Coex activity IE
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeCoexActivity (TI_HANDLE hCmdBld,
                                         TCoexActivity  *pCoexActivity,
                                         void      *fCb,
                                         TI_HANDLE  hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXCoexActivityIE_t coexActivityIEStruct;
    ACXCoexActivityIE_t *pCfg = &coexActivityIEStruct;

    if (NULL == pCoexActivity)
    {
        return PARAM_VALUE_NOT_VALID;
    }

    pCfg->EleHdr.id = ACX_COEX_ACTIVITY;
    pCfg->EleHdr.len = sizeof(ACXCoexActivityIE_t) - sizeof(EleHdrStruct);

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "CoexActivity: ID=0x%x\n", pCfg->EleHdr.id);

    pCfg->coexIp          = pCoexActivity->coexIp;
    pCfg->activityId      = pCoexActivity->activityId;
    pCfg->defaultPriority = pCoexActivity->defaultPriority;
    pCfg->raisedPriority  = pCoexActivity->raisedPriority;
    pCfg->minService      = ENDIAN_HANDLE_WORD(pCoexActivity->minService);
    pCfg->maxService      = ENDIAN_HANDLE_WORD(pCoexActivity->maxService);

    TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "CoexActivity: 0x%02x 0x%02x - 0x%02x 0x%02x 0x%04x 0x%04x\n",
            pCfg->coexIp,
            pCfg->activityId,
            pCfg->defaultPriority,
            pCfg->raisedPriority,
            pCfg->minService,
            pCfg->maxService);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}

/****************************************************************************
 *                      cmdBld_CfgIeCcaThreshold()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the Slot Time
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeCcaThreshold (TI_HANDLE hCmdBld, TI_UINT16 ccaThreshold, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXEnergyDetection_t AcxElm_CcaThreshold;
    ACXEnergyDetection_t *pCfg = &AcxElm_CcaThreshold;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_CCA_THRESHOLD;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->rxCCAThreshold = ENDIAN_HANDLE_WORD(ccaThreshold);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeEventMask()
 ****************************************************************************
 * DESCRIPTION: Change the Event Vector Mask in the FW
 *
 * INPUTS: MaskVector   The Updated Vector Mask
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeEventMask (TI_HANDLE hCmdBld, TI_UINT32 mask, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

    ACXEventMboxMask_t EventMboxData;
    ACXEventMboxMask_t *pCfg = &EventMboxData;

    /* Set information element header*/
    pCfg->EleHdr.id = ACX_EVENT_MBOX_MASK;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
    pCfg->lowEventMask = ENDIAN_HANDLE_LONG(mask);
    pCfg->highEventMask = ENDIAN_HANDLE_LONG(0xffffffff); /* Not in Use */

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_CfgIeEventMask:\n");

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeMaxTxRetry()
 ****************************************************************************
 * DESCRIPTION: Configure the Max Tx Retry parameters
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeMaxTxRetry (TI_HANDLE hCmdBld,
                                  TRroamingTriggerParams *pRoamingTriggerCmd,
                                  void      *fCb,
                                  TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXConsTxFailureTriggerParameters_t AcxElm_SetMaxTxRetry;
    ACXConsTxFailureTriggerParameters_t* pCfg = &AcxElm_SetMaxTxRetry;

    pCfg->maxTxRetry = pRoamingTriggerCmd->maxTxRetry;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_CONS_TX_FAILURE;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeConnMonitParams()
 ****************************************************************************
 * DESCRIPTION: Configure the Bss Lost Timeout & TSF miss threshold
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeConnMonitParams (TI_HANDLE hCmdBld, TRroamingTriggerParams *pRoamingTriggerCmd, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    AcxConnectionMonitorOptions  AcxElm_SetBssLossTsfThreshold;
    AcxConnectionMonitorOptions* pCfg = &AcxElm_SetBssLossTsfThreshold;

    pCfg->BSSLossTimeout     = ENDIAN_HANDLE_LONG(pRoamingTriggerCmd->BssLossTimeout);
    pCfg->TSFMissedThreshold = ENDIAN_HANDLE_LONG(pRoamingTriggerCmd->TsfMissThreshold);

    /* Set information element header */
    pCfg->EleHdr.id  = ACX_CONN_MONIT_PARAMS;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeTxRatePolicy()
 ****************************************************************************
 * DESCRIPTION: Write the TxRateClass configuration
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeTxRatePolicy (TI_HANDLE hCmdBld, TTxRatePolicy *pTxRatePolicy, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXTxAttrClasses_t  TxClassCfg;
    ACXTxAttrClasses_t *pCfg  = &TxClassCfg;
    TI_UINT8 PolicyId;

    os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));

    /*
     * Set information element header
     * ==============================
     */
    pCfg->EleHdr.id = ACX_RATE_POLICY;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
    pCfg->numOfClasses = pTxRatePolicy->numOfRateClasses;

    for (PolicyId = 0; PolicyId < pTxRatePolicy->numOfRateClasses; PolicyId++)
    {
        os_memoryCopy (pCmdBld->hOs,
                       (void *)&(pCfg->rateClasses[PolicyId]),
                       (void *)&(pTxRatePolicy->rateClass[PolicyId]),
                       sizeof(TTxRateClass));
    }

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeRtsThreshold()
 ****************************************************************************
 * DESCRIPTION: Configure the RTS threshold
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeRtsThreshold (TI_HANDLE hCmdBld, TI_UINT16 uRtsThreshold, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    dot11RTSThreshold_t AcxElm_RtsThreshold;
    dot11RTSThreshold_t *pCfg = &AcxElm_RtsThreshold;

    /* Set information element header */
    pCfg->EleHdr.id = DOT11_RTS_THRESHOLD;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->RTSThreshold = ENDIAN_HANDLE_WORD(uRtsThreshold);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeRtsThreshold()
 ****************************************************************************
 * DESCRIPTION: Configure the tx fragmentation threshold
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeFragmentThreshold (TI_HANDLE hCmdBld, TI_UINT16 uFragmentThreshold, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXFRAGThreshold_t AcxElm_FragmentThreshold;
    ACXFRAGThreshold_t *pCfg = &AcxElm_FragmentThreshold;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_FRAG_CFG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->fragThreshold = ENDIAN_HANDLE_WORD(uFragmentThreshold);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIePmConfig()
 ****************************************************************************
 * DESCRIPTION: Configure PM parameters
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIePmConfig (TI_HANDLE   hCmdBld,
                                TI_UINT32   uHostClkSettlingTime,
                                TI_UINT8    uHostFastWakeupSupport,
                                void *      fCb,
                                TI_HANDLE   hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXPMConfig_t tPmConfig;
    ACXPMConfig_t *pCfg = &tPmConfig;

    /* Set information element header*/
    pCfg->EleHdr.id  = ACX_PM_CONFIG;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->hostClkSettlingTime   = uHostClkSettlingTime;
    pCfg->hostFastWakeupSupport = uHostFastWakeupSupport;

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeTxCmpltPacing()
 ****************************************************************************
 * DESCRIPTION: Configure Tx-Complete interrupt pacing to FW
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeTxCmpltPacing (TI_HANDLE  hCmdBld,
                                     TI_UINT16  uTxCompletePacingThreshold,
                                     TI_UINT16  uTxCompletePacingTimeout,
                                     void *     fCb,
                                     TI_HANDLE  hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXTxConfigOptions_t  tTxCmpltPacing;
    ACXTxConfigOptions_t  *pCfg = &tTxCmpltPacing;

    /* Set information element header */
    pCfg->EleHdr.id  = ACX_TX_CONFIG_OPT;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->txCompleteThreshold = ENDIAN_HANDLE_WORD(uTxCompletePacingThreshold);
    pCfg->txCompleteTimeout   = ENDIAN_HANDLE_WORD(uTxCompletePacingTimeout);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeRxIntrPacing()
 ****************************************************************************
 * DESCRIPTION: Configure Rx-Complete interrupt pacing to FW
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeRxIntrPacing (TI_HANDLE  hCmdBld,
                                    TI_UINT16  uRxIntrPacingThreshold,
                                    TI_UINT16  uRxIntrPacingTimeout,
                                    void *     fCb,
                                    TI_HANDLE  hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXRxBufferingConfig_t  tRxIntrPacing;
    ACXRxBufferingConfig_t  *pCfg = &tRxIntrPacing;

    /* Set information element header */
    pCfg->EleHdr.id  = ACX_RX_CONFIG_OPT;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->rxPktThreshold    = ENDIAN_HANDLE_WORD(uRxIntrPacingThreshold);
    pCfg->rxCompleteTimeout = ENDIAN_HANDLE_WORD(uRxIntrPacingTimeout);
    pCfg->rxMblkThreshold   = ENDIAN_HANDLE_WORD(0xFFFF);    /* Set to maximum so it has no effect (only the PktThreshold is used) */
    pCfg->rxQueueType       = RX_QUEUE_TYPE_RX_LOW_PRIORITY; /* Only low priority data packets are buffered */

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
*                      cmdBld_CfgIeCtsProtection()
 ****************************************************************************
 * DESCRIPTION: Configure The Cts to self feature
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeCtsProtection (TI_HANDLE hCmdBld, TI_UINT8 ctsProtection, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXCtsProtection_t AcxElm_CtsToSelf;
    ACXCtsProtection_t *pCfg = &AcxElm_CtsToSelf;

    /* Set information element header*/
    pCfg->EleHdr.id = ACX_CTS_PROTECTION;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->ctsProtectMode = ctsProtection;

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeRxMsduLifeTime()
 ****************************************************************************
 * DESCRIPTION: Configure The Cts to self feature
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeRxMsduLifeTime (TI_HANDLE hCmdBld, TI_UINT32 RxMsduLifeTime, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    dot11RxMsduLifeTime_t   AcxElm_RxMsduLifeTime;
    dot11RxMsduLifeTime_t *pCfg = &AcxElm_RxMsduLifeTime;

    /* Set information element header*/
    pCfg->EleHdr.id = DOT11_RX_MSDU_LIFE_TIME;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
    pCfg->RxMsduLifeTime = RxMsduLifeTime;

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": RxMsduLifeTime = 0x%x, len = 0x%x\n",pCfg->RxMsduLifeTime,pCfg->EleHdr.len);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeServicePeriodTimeout()
 ****************************************************************************
 * DESCRIPTION: Configure The Rx Time Out
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeServicePeriodTimeout (TI_HANDLE hCmdBld, TRxTimeOut* pRxTimeOut, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXRxTimeout_t AcxElm_rxTimeOut;
    ACXRxTimeout_t *pCfg = &AcxElm_rxTimeOut;

    /* Set information element header*/
    pCfg->EleHdr.id = ACX_SERVICE_PERIOD_TIMEOUT;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->PsPollTimeout = pRxTimeOut->psPoll;
    pCfg->UpsdTimeout   = pRxTimeOut->UPSD;

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIePsWmm()
 ****************************************************************************
 * DESCRIPTION: Configure The PS for WMM
 *
 * INPUTS:   TI_TRUE  - Configure PS to work on WMM mode - do not send the NULL/PS_POLL
 *                   packets even if TIM is set.
 *           TI_FALSE - Configure PS to work on Non-WMM mode - work according to the
 *                   standard
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIePsWmm (TI_HANDLE hCmdBld, TI_BOOL enableWA, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXConfigPsWmm_t  ConfigPsWmm;
    ACXConfigPsWmm_t *pCfg = &ConfigPsWmm;

    /*
     * Set information element header
     */
    pCfg->EleHdr.id = ACX_CONFIG_PS_WMM;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    pCfg->ConfigPsOnWmmMode = enableWA;

    /* Report the meesage only if we are using the WiFi patch */
    if (enableWA)
    {
        TRACE0(pCmdBld->hReport, REPORT_SEVERITY_CONSOLE, "cmdBld_CfgIePsWmm: PS is on WMM mode\n");
        WLAN_OS_REPORT(("%s PS is on WMM mode\n",__FUNCTION__));
    }

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}

/****************************************************************************
 *                      cmdBld_CfgIeRssiSnrTrigger()
 ****************************************************************************
 * DESCRIPTION: Configure the RSSI/SNR Trigger parameters
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeRssiSnrTrigger (TI_HANDLE hCmdBld, RssiSnrTriggerCfg_t *pTriggerParam, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXRssiSnrTriggerCfg_t  tAcxTriggerParameters;
    ACXRssiSnrTriggerCfg_t *pCfg = &tAcxTriggerParameters;

    pCfg->param.index       = pTriggerParam->index    ;
    pCfg->param.threshold   = pTriggerParam->threshold;
    pCfg->param.pacing      = pTriggerParam->pacing   ;
    pCfg->param.metric      = pTriggerParam->metric   ;
    pCfg->param.type        = pTriggerParam->type     ;
    pCfg->param.direction   = pTriggerParam->direction;
    pCfg->param.hystersis   = pTriggerParam->hystersis;
    pCfg->param.enable      = pTriggerParam->enable   ;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_RSSI_SNR_TRIGGER;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    TRACE8(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: threshold=%u, pacing=%u, metric=%u, type=%u, dir=%u, hyst=%u, enable=%u\n", pTriggerParam->index, pTriggerParam->threshold, pTriggerParam->pacing, pTriggerParam->metric, pTriggerParam->type, pTriggerParam->direction, pTriggerParam->hystersis, pTriggerParam->enable);

    /* Send the configuration command */
    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}

/****************************************************************************
 *                      cmdBld_CfgIeRssiSnrWeights()
 ****************************************************************************
 * DESCRIPTION: Configure the RSSI/SNR Trigger parameters
 *
 * INPUTS:  None
 *
 * OUTPUT:  None
 *
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeRssiSnrWeights (TI_HANDLE hCmdBld, RssiSnrAverageWeights_t *pWeightsParam, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXRssiSnrAverageWeights_t  tAcxAverageWeights;
    ACXRssiSnrAverageWeights_t *pCfg = &tAcxAverageWeights;

    pCfg->param.rssiBeaconAverageWeight = pWeightsParam->rssiBeaconAverageWeight;
    pCfg->param.rssiPacketAverageWeight = pWeightsParam->rssiPacketAverageWeight;
    pCfg->param.snrBeaconAverageWeight  = pWeightsParam->snrBeaconAverageWeight ;
    pCfg->param.snrPacketAverageWeight  = pWeightsParam->snrPacketAverageWeight ;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_RSSI_SNR_WEIGHTS;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "rssi-beacon-avg-weight=%u, rssi-packet-avg-weight=%u, snr-beacon-avg-weight=%u, snr-packet-avg-weight=%u", pWeightsParam->rssiBeaconAverageWeight, pWeightsParam->rssiPacketAverageWeight, pWeightsParam->snrBeaconAverageWeight, pWeightsParam->snrPacketAverageWeight);

    /* Send the configuration command */
    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


 /*
 * ----------------------------------------------------------------------------
 * Function : cmdBld_CfgIeBet
 *
 * 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_CfgIeBet (TI_HANDLE hCmdBld, TI_UINT8 Enable, TI_UINT8 MaximumConsecutiveET, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

    ACXBet_Enable_t ACXBet_Enable;
    ACXBet_Enable_t* pCfg = &ACXBet_Enable;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_BET_ENABLE;
    pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

    /* Set configuration fields */
    pCfg->Enable = Enable;
    pCfg->MaximumConsecutiveET = MaximumConsecutiveET;

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, Enable=%d, MaximumConsecutiveET=%d\n", (TI_UINT32)pCfg->Enable, (TI_UINT32)pCfg->MaximumConsecutiveET);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}

/****************************************************************************
 *                      cmdBld_CmdIeConfigureKeepAliveParams()
 ****************************************************************************
 * DESCRIPTION: Configure keep-alive parameters for a single template
 *
 * INPUTS:  hCmdBld     - handle to command builder object
 *          uIndex      - keep-alive index
 *          uEnaDisFlag - whether keep-alive is enabled or disables
 *          trigType    - send keep alive when TX is idle or always
 *          interval    - keep-alive interval
 *          fCB         - callback function for command complete
 *          hCb         - handle to be apssed to callback function
 *
 * OUTPUT:  None
 *
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS cmdBld_CmdIeConfigureKeepAliveParams (TI_HANDLE hCmdBld, TI_UINT8 uIndex,
                                                TI_UINT8 uEnaDisFlag, TI_UINT8 trigType,
                                                TI_UINT32 interval, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    AcxSetKeepAliveConfig_t ACXKeepAlive;

    /* set IE header */
    ACXKeepAlive.EleHdr.id = ACX_SET_KEEP_ALIVE_CONFIG;
    ACXKeepAlive.EleHdr.len = sizeof (AcxSetKeepAliveConfig_t) - sizeof (EleHdrStruct);

    /* set Keep-Alive values */
    ACXKeepAlive.index = uIndex;
    ACXKeepAlive.period = interval;
    ACXKeepAlive.trigger = trigType;
    ACXKeepAlive.valid = uEnaDisFlag;

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, index=%d, enaDis=%d, trigType=%d, interval=%d\n", (TI_UINT32)ACXKeepAlive.index, (TI_UINT32)ACXKeepAlive.valid, (TI_UINT32)ACXKeepAlive.trigger, (TI_UINT32)ACXKeepAlive.period);

    /* send the command to the FW */
    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, &ACXKeepAlive, sizeof(AcxSetKeepAliveConfig_t), fCb, hCb, NULL);
}

/****************************************************************************
 *                      cmdBld_CmdIeConfigureKeepAliveParams()
 ****************************************************************************
 * DESCRIPTION: Configure keep-alive global enable / disable flag
 *
 * INPUTS:  enable / disable flag
 *
 * OUTPUT:  None
 *
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS cmdBld_CmdIeConfigureKeepAliveEnaDis (TI_HANDLE hCmdBld, TI_UINT8 enaDisFlag,
                                                void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    AcxKeepAliveMode ACXKeepAliveMode;

    /* set IE header */
    ACXKeepAliveMode.EleHdr.id = ACX_KEEP_ALIVE_MODE;
    ACXKeepAliveMode.EleHdr.len = sizeof (AcxKeepAliveMode) - sizeof (EleHdrStruct);

    /* set Keep-Alive mode */
    ACXKeepAliveMode.modeEnabled = enaDisFlag;

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, enaDis=%d\n", (TI_UINT32)ACXKeepAliveMode.modeEnabled);

    /* send the command to the FW */
    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, &ACXKeepAliveMode, sizeof(AcxKeepAliveMode), fCb, hCb, NULL);
}

/**
 * \fn     cmdBld_CfgIeSetFwHtCapabilities
 * \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_CfgIeSetFwHtCapabilities (TI_HANDLE hCmdBld,
                                           TI_UINT32 uHtCapabilites,
                                           TMacAddr  tMacAddress,
                                           TI_UINT8  uAmpduMaxLeng,
                                           TI_UINT8  uAmpduMinSpac,
                                           void      *fCb,
                                           TI_HANDLE hCb)
{
    TCmdBld                         *pCmdBld = (TCmdBld *)hCmdBld;
    TAxcHtCapabilitiesIeFwInterface tAcxFwHtCap;
    TAxcHtCapabilitiesIeFwInterface *pCfg    = &tAcxFwHtCap;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_PEER_HT_CAP;
    pCfg->EleHdr.len = sizeof(tAcxFwHtCap) - sizeof(EleHdrStruct);

    MAC_COPY (pCfg->aMacAddress, tMacAddress);
    pCfg->uHtCapabilites = uHtCapabilites;
    pCfg->uAmpduMaxLength = uAmpduMaxLeng;
    pCfg->uAmpduMinSpacing = uAmpduMinSpac;

    TRACE9(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSetFwHtCapabilities: HtCapabilites=0x%x, AmpduMaxLength=%d, AmpduMinSpac=%d, MAC: %x:%x:%x:%x:%x:%x\n", uHtCapabilites, uAmpduMaxLeng, uAmpduMinSpac, pCfg->aMacAddress[0], pCfg->aMacAddress[1], pCfg->aMacAddress[2], pCfg->aMacAddress[3], pCfg->aMacAddress[4], pCfg->aMacAddress[5]);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(TAxcHtCapabilitiesIeFwInterface), fCb, hCb, NULL);

}

/**
 * \fn     cmdBld_CfgIeSetFwHtInformation
 * \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_CfgIeSetFwHtInformation (TI_HANDLE hCmdBld,
                                          TI_UINT8  uRifsMode,
                                          TI_UINT8  uHtProtection,
                                          TI_UINT8  uGfProtection,
                                          TI_UINT8  uHtTxBurstLimit,
                                          TI_UINT8  uDualCtsProtection,
                                          void      *fCb,
                                          TI_HANDLE hCb)
{
    TCmdBld                        *pCmdBld = (TCmdBld *)hCmdBld;
    TAxcHtInformationIeFwInterface tAcxFwHtInf;
    TAxcHtInformationIeFwInterface *pCfg = &tAcxFwHtInf;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_HT_BSS_OPERATION;
    pCfg->EleHdr.len = sizeof(tAcxFwHtInf) - sizeof(EleHdrStruct);

    pCfg->uRifsMode = uRifsMode;
    pCfg->uHtProtection = uHtProtection;
    pCfg->uGfProtection = uGfProtection;
    pCfg->uHtTxBurstLimit = uHtTxBurstLimit;
    pCfg->uDualCtsProtection = uDualCtsProtection;

    TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSetFwHtInformation: RifsMode=0x%x, HtProtection=0x%x, GfProtection=0x%x, HtTxBurstLimit=0x%x, DualCtsProtection=0x%x\n", uRifsMode, uHtProtection, uGfProtection, uHtTxBurstLimit, uDualCtsProtection);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(TAxcHtInformationIeFwInterface), fCb, hCb, NULL);
}

/**
 * \fn     cmdBld_CfgIeSetBaSession
 * \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_CfgIeSetBaSession (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)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TAxcBaSessionInitiatorResponderPolicy tAcxBaSessionPrm;
    TAxcBaSessionInitiatorResponderPolicy *pCfg = &tAcxBaSessionPrm;

    /* Set information element header */
    pCfg->EleHdr.id = eBaType;
    pCfg->EleHdr.len = sizeof(tAcxBaSessionPrm) - sizeof(EleHdrStruct);

    MAC_COPY (pCfg->aMacAddress, tRa);
    pCfg->uTid = uTid;
    pCfg->uPolicy = uState;
    pCfg->uWinSize = uWinSize;

    if (eBaType == ACX_BA_SESSION_INITIATOR_POLICY)
    {
        pCfg->uInactivityTimeout = uInactivityTimeout;
    }
    else
    {
        if (eBaType == ACX_BA_SESSION_RESPONDER_POLICY)
        {
            pCfg->uInactivityTimeout = 0;
        }
        else
        {
            TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CfgIeSetBaSession: error ID=%u\n", pCfg->EleHdr.id);
            return TI_NOK;
        }
    }

    TRACE10(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSetBaSession: ID=, TID=%u, Policy=%u, MAC: %x:%x:%x:%x:%x:%x, uWinSize=%u, Timeout=%u\n", pCfg->uTid, pCfg->uPolicy, pCfg->aMacAddress[0], pCfg->aMacAddress[1], pCfg->aMacAddress[2], pCfg->aMacAddress[3], pCfg->aMacAddress[4], pCfg->aMacAddress[5], pCfg->uWinSize, pCfg->uInactivityTimeout);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(TAxcBaSessionInitiatorResponderPolicy), fCb, hCb, NULL);
}

/**
 * \fn     cmdBld_CfgIeRadioParams
 * \brief  configure radio parameters setting in the FW.
 *
 * \note
 * \return TI_OK on success or TI_NOK on failure
 * \sa
 */
TI_STATUS cmdBld_CfgIeRadioParams (TI_HANDLE hCmdBld, IniFileRadioParam *pIniFileRadioParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TI_STATUS status = TI_NOK;
    TTestCmd *pTestCmd;

    pTestCmd = os_memoryAlloc(pCmdBld->hOs, sizeof(TTestCmd));
    if (!pTestCmd)
    {
        return status;
    }

    pTestCmd->testCmdId = TEST_CMD_INI_FILE_RADIO_PARAM;

    os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileRadioParams, pIniFileRadioParams, sizeof(IniFileRadioParam));

    status = cmdQueue_SendCommand (pCmdBld->hCmdQueue,
                             CMD_TEST,
                             (void *)pTestCmd,
                             sizeof(IniFileRadioParam) + 4,
                             fCb,
                             hCb,
                             NULL);
    os_memoryFree(pCmdBld->hOs, pTestCmd, sizeof(TTestCmd));
    return status;
}


/**
 * \fn     cmdBld_CfgIeExtendedRadioParams
 * \brief  configure extended radio parameters setting in the
 * FW.
 *
 * \note
 * \return TI_OK on success or TI_NOK on failure
 * \sa
 */
TI_STATUS cmdBld_CfgIeExtendedRadioParams (TI_HANDLE hCmdBld,
										   IniFileExtendedRadioParam *pIniFileExtRadioParams,
										   void *fCb,
										   TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TI_STATUS status = TI_NOK;
    TTestCmd *pTestCmd;

    pTestCmd = os_memoryAlloc(pCmdBld->hOs, sizeof(TTestCmd));
    if (!pTestCmd)
    {
        return status;
    }

    pTestCmd->testCmdId = TEST_CMD_INI_FILE_RF_EXTENDED_PARAM;

    os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileExtendedRadioParams,
				  pIniFileExtRadioParams, sizeof(IniFileExtendedRadioParam));

    status = cmdQueue_SendCommand (pCmdBld->hCmdQueue,
                             CMD_TEST,
                             (void *)pTestCmd,
                             sizeof(IniFileExtendedRadioParam) + 4,
                             fCb,
                             hCb,
                             NULL);
    os_memoryFree(pCmdBld->hOs, pTestCmd, sizeof(TTestCmd));
    return status;
}


TI_STATUS cmdBld_CfgPlatformGenParams (TI_HANDLE hCmdBld, IniFileGeneralParam *pGenParams, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    TI_STATUS status = TI_NOK;
    TTestCmd *pTestCmd;

    pTestCmd = os_memoryAlloc(pCmdBld->hOs, sizeof(TTestCmd));
    if (!pTestCmd)
    {
        return status;
    }

    pTestCmd->testCmdId = TEST_CMD_INI_FILE_GENERAL_PARAM;

    os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileGeneralParams, pGenParams, sizeof(IniFileGeneralParam));

    status = cmdQueue_SendCommand (pCmdBld->hCmdQueue,
                              CMD_TEST,
                              (void *)pTestCmd,
                              sizeof(IniFileGeneralParam),
                              fCb,
                              hCb,
                              NULL);
    os_memoryFree(pCmdBld->hOs, pTestCmd, sizeof(TTestCmd));
    return status;
}


/****************************************************************************
 *                      cmdBld_CfgIeBurstMode()
 ****************************************************************************
 * DESCRIPTION: Configure burst mode
 *
 * INPUTS:  hCmdBld     - handle to command builder object
 *          bEnabled    - is enabled flag
 *          fCB         - callback function for command complete
 *          hCb         - handle to be apssed to callback function
 *
 * OUTPUT:  None
 *
 * RETURNS: OK or NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeBurstMode (TI_HANDLE hCmdBld, TI_BOOL bEnabled, void *fCb, TI_HANDLE hCb)
{
	TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
	AcxBurstMode tAcxBurstMode;
	AcxBurstMode *pCfg = &tAcxBurstMode;

	/* set IE header */
	pCfg->EleHdr.id = ACX_BURST_MODE;
	pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);

	/* set burst mode value */
	pCfg->enable = (uint8)bEnabled;

	/* send the command to the FW */
	return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}


/****************************************************************************
 *                      cmdBld_CfgIeDcoItrimParams()
 ****************************************************************************
 * DESCRIPTION: Configure/Interrogate the DCO Itrim parameters
 *
 * INPUTS:
 *
 * OUTPUT:  None
 *
 * RETURNS: TI_OK or TI_NOK
 ****************************************************************************/
TI_STATUS cmdBld_CfgIeDcoItrimParams (TI_HANDLE hCmdBld, TI_BOOL enable, TI_UINT32 moderationTimeoutUsec, void *fCb, TI_HANDLE hCb)
{
    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
    ACXDCOItrimParams_t ACXBeaconFilterOptions;
    ACXDCOItrimParams_t *pCfg = &ACXBeaconFilterOptions;

    pCfg->enable = enable;
    pCfg->moderation_timeout_usec = moderationTimeoutUsec;

    /* Set information element header */
    pCfg->EleHdr.id = ACX_SET_DCO_ITRIM_PARAMS;
    pCfg->EleHdr.len = sizeof(ACXDCOItrimParams_t) - sizeof(EleHdrStruct);

    TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: enable=%u, moderation_timeout_usec=%u\n", pCfg->EleHdr.id, enable, moderationTimeoutUsec);

    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXDCOItrimParams_t), fCb, hCb, NULL);
}