/*
* CmdBldCfgIE.c
*
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
* All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 or BSD License which accompanies
* this distribution. The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.
*
* 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 = TWD_RX_MEM_BLKS_NUM;
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,
TI_BOOL bFilteringEnabled,
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_UINT32)bFilteringEnabled;
/* 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), bFilteringEnabled);
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;
TI_STATUS status;
TI_BOOL bSendSleep = TI_FALSE;
/* 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
{
/* Remeber to change HW to sleep mode */
bSendSleep = TI_TRUE;
}
}
/* 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);
status = cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
if (bSendSleep) {
twIf_Sleep(pCmdBld->hTwIf);
}
return status;
}
/****************************************************************************
* 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;
ACXStatistics_t acx;
ACXStatistics_t *pCfg = &acx;
/* Set information element header */
pCfg->EleHdr.id = ACX_STATISTICS;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}
/****************************************************************************
* 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;
AcxRateAdaptParams RateMng;
AcxRateAdaptParams *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[0] = pRateMngParams->InverseCuriosityFactor[0];
pCfg->InverseCuriosityFactor[1] = pRateMngParams->InverseCuriosityFactor[1];
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;
pCfg->PerWeightShift[0] = pRateMngParams->PerWeightShift[0];
pCfg->PerWeightShift[1] = pRateMngParams->PerWeightShift[1];
pCfg->TpWeightShift[0] = pRateMngParams->TpWeightShift[0];
pCfg->TpWeightShift[1] = pRateMngParams->TpWeightShift[1];
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;
TTestCmd TestCmd;
TTestCmd *pTestCmd = &TestCmd;
pTestCmd->testCmdId = TEST_CMD_INI_FILE_RADIO_PARAM;
os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileRadioParams, pIniFileRadioParams, sizeof(IniFileRadioParam));
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_TEST,
(void *)pTestCmd,
sizeof(IniFileRadioParam) + 4,
fCb,
hCb,
(void*)pTestCmd);
}
TI_STATUS cmdBld_CfgPlatformGenParams (TI_HANDLE hCmdBld, IniFileGeneralParam *pGenParams, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TTestCmd TestCmd;
TTestCmd *pTestCmd = &TestCmd;
pTestCmd->testCmdId = TEST_CMD_INI_FILE_GENERAL_PARAM;
os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileGeneralParams, pGenParams, sizeof(IniFileGeneralParam));
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_TEST,
(void *)pTestCmd,
sizeof(IniFileGeneralParam) + 4,
fCb,
hCb,
(void*)pTestCmd);
}
/****************************************************************************
* 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_CfgIeSRstate()
****************************************************************************
* DESCRIPTION: Configure sart reflex state
*
* 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_CfgIeSRState (TI_HANDLE hCmdBld, uint8 SRstate, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXSmartReflexState_t tSmartReflexState;
ACXSmartReflexState_t *pCfg = &tSmartReflexState;
/* set IE header */
pCfg->EleHdr.id = ACX_SET_SMART_REFLEX_STATE;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
/* set smart refelx state */
pCfg->enable = SRstate;
/* send the command to the FW */
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CfgIeSRDebug()
****************************************************************************
* DESCRIPTION: Send debug param just if it's configured in ini file
* 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_CfgIeSRDebug (TI_HANDLE hCmdBld, ACXSmartReflexDebugParams_t *pSRDebug, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXSmartReflexDebugParams_t tSmartReflexDebug;
ACXSmartReflexDebugParams_t *pCfg = &tSmartReflexDebug;
/* send this command to FW just in case it's initialize in ini file */
if (pSRDebug->senNRN == 0) {
return TI_NOK;
}
/* copy smart reflex debug params*/
os_memoryCopy(pCmdBld->hOs, pCfg, pSRDebug, sizeof(ACXSmartReflexDebugParams_t));
/* set IE header */
pCfg->EleHdr.id = ACX_SET_SMART_REFLEX_DEBUG;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
/* 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);
}