diff -r 000000000000 -r 10c42ec6c05f TWD/Ctrl/CmdBldCfgIE.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TWD/Ctrl/CmdBldCfgIE.c Tue Jun 29 12:34:26 2010 +0100 @@ -0,0 +1,2043 @@ +/* + * 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); +} + + +