/*
* CmdBld.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 CmdBld.c
* \brief Command builder main
*
* \see CmdBld.h
*/
#define __FILE_ID__ FILE_ID_90
#include "TWDriver.h"
#include "osApi.h"
#include "tidef.h"
#include "report.h"
#include "public_infoele.h"
#include "CmdBld.h"
#include "txResult_api.h"
#include "CmdBldCmdIE.h"
#include "CmdBldCfgIE.h"
#include "CmdBldItrIE.h"
#include "CmdQueue_api.h"
#include "eventMbox_api.h"
#include "TWDriverInternal.h"
#include "HwInit_api.h"
#define DEFAULT_TRACE_ENABLE 0
#define DEFAULT_TRACE_OUT 0
#define DEFAULT_PBCC_DYNAMIC_ENABLE_VAL 0
#define DEFAULT_PBCC_DYNAMIC_INTERVAL 500
#define DEFAULT_PBCC_DYNAMIC_IGNORE_MCAST 0
#define DEFAULT_HW_RADIO_CHANNEL 11
#define DEFAULT_CW_MIN 15
#define DEFAULT_USE_DEVICE_ERROR_INTERRUPT 1
#define DEFAULT_UCAST_PRIORITY 0
#define DEFAULT_NUM_STATIONS 1
/* only for AP */
/* 8 increase number of BC frames */
#define DEFAULT_NUM_BCAST_TX_DESC 16
#define DEFAULT_BCAST_PRIORITY 0x81
/* hw access method*/
typedef enum
{
HW_ACCESS_BUS_SLAVE_INDIRECT = 0,
HW_ACCESS_BUS_SLAVE_DIRECT = 1,
HW_ACCESS_BUS_MASTER = 2
} EHwAccessMethod;
typedef int (*TConfigFwCb) (TI_HANDLE, TI_STATUS);
static TI_STATUS cmdBld_ConfigSeq (TI_HANDLE hCmdBld);
static TI_STATUS cmdBld_GetCurrentAssociationId (TI_HANDLE hCmdBld, TI_UINT16 *pAidVal);
static TI_STATUS cmdBld_GetArpIpAddressesTable (TI_HANDLE hCmdBld, TIpAddr *pIpAddr, TI_UINT8 *pEnabled , EIpVer *pIpVer);
static TI_STATUS cmdBld_JoinCmpltForReconfigCb (TI_HANDLE hCmdBld);
static TI_STATUS cmdBld_DummyCb (TI_HANDLE hCmdBld);
TI_HANDLE cmdBld_Create (TI_HANDLE hOs)
{
TCmdBld *pCmdBld;
TI_UINT32 uNumOfStations;
TI_UINT32 i;
/* Allocate the command builder */
pCmdBld = (TCmdBld *)os_memoryAlloc (hOs, sizeof(TCmdBld),MemoryNormal);
if (pCmdBld == NULL)
{
WLAN_OS_REPORT(("cmdBld_Create: Error memory allocation\n"));
return NULL;
}
os_memoryZero (hOs, (void *)pCmdBld, sizeof(TCmdBld));
pCmdBld->hOs = hOs;
/* Create the Params object */
/* make this code flat, move it to configure */
{
TWlanParams *pWlanParams = &DB_WLAN(pCmdBld);
TDmaParams *pDmaParams = &DB_DMA(pCmdBld);
TBssInfoParams *pBssInfoParams = &DB_BSS(pCmdBld);
TGenCounters *pGenCounters = &DB_CNT(pCmdBld);
/* General counters */
pGenCounters->FcsErrCnt = 0;
/* BSS info paramaters */
pBssInfoParams->RadioChannel = DEFAULT_HW_RADIO_CHANNEL;
pBssInfoParams->Ctrl = 0;
/*
* Intilaize the ctrl field in the BSS join structure
* Only bit_7 in the ctrl field is vurrently in use.
* If bit_7 is on => Doing Tx flash before joining new AP
*/
pBssInfoParams->Ctrl |= JOIN_CMD_CTRL_TX_FLUSH;
/* WLAN parameters*/
/* Init filters as station (start/join with BssType will overwrite the values) */
cmdBld_SetRxFilter ((TI_HANDLE)pCmdBld, RX_CONFIG_OPTION_MY_DST_MY_BSS, RX_FILTER_OPTION_FILTER_ALL);
pWlanParams->UseDeviceErrorInterrupt = DEFAULT_USE_DEVICE_ERROR_INTERRUPT;
/* Initialize the params object database fields */
pWlanParams->hwAccessMethod = HW_ACCESS_BUS_SLAVE_INDIRECT;
pWlanParams->maxSitesFragCollect = TWD_SITE_FRAG_COLLECT_DEF;
pWlanParams->RtsThreshold = TWD_RTS_THRESHOLD_DEF;
pWlanParams->bJoin = TI_FALSE;
/* Soft Gemini defaults */
pWlanParams->SoftGeminiEnable = SG_DISABLE;
/* Beacon filter defaults */
pWlanParams->beaconFilterParams.desiredState = TI_FALSE;
pWlanParams->beaconFilterParams.numOfElements = DEF_NUM_STORED_FILTERS;
pWlanParams->beaconFilterIETable.numberOfIEs = DEF_BEACON_FILTER_IE_TABLE_NUM;
pWlanParams->beaconFilterIETable.IETableSize = BEACON_FILTER_IE_TABLE_DEF_SIZE;
/* Roaming parameters */
pWlanParams->roamTriggers.BssLossTimeout = NO_BEACON_DEFAULT_TIMEOUT;
pWlanParams->roamTriggers.TsfMissThreshold = OUT_OF_SYNC_DEFAULT_THRESHOLD;
/* CoexActivity table */
pWlanParams->tWlanParamsCoexActivityTable.numOfElements = COEX_ACTIVITY_TABLE_DEF_NUM;
/* DMA parameters */
/* Initialize the Params object database fields*/
pDmaParams->NumStations = DEFAULT_NUM_STATIONS;
uNumOfStations = (TI_UINT32)pDmaParams->NumStations;
/*
* loop an all rssi_snr triggers and initialize only index number.
* Reason: 'index' not initialized --> 'index = 0' --> triggers 1..7 will overrun trigger '0' in cmdBld_ConfigSeq
*/
for (i = 0; i < NUM_OF_RSSI_SNR_TRIGGERS ; i++)
{
pWlanParams->tRssiSnrTrigger[i].index = i;
}
}
pCmdBld->uLastElpCtrlMode = ELPCTRL_MODE_NORMAL;
/* Create security objects */
pCmdBld->tSecurity.eSecurityMode = TWD_CIPHER_NONE;
pCmdBld->tSecurity.uNumOfStations = uNumOfStations;
DB_KEYS(pCmdBld).pReconfKeys = (TSecurityKeys*)os_memoryAlloc (hOs,
sizeof(TSecurityKeys) * (uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS),MemoryNormal);
os_memoryZero (hOs,
(void *)(DB_KEYS(pCmdBld).pReconfKeys),
sizeof(TSecurityKeys) * (uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS));
WLAN_INIT_REPORT(("cmdBld_Create end %x\n",(TI_HANDLE)pCmdBld));
return (TI_HANDLE)pCmdBld;
}
TI_STATUS cmdBld_Destroy (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TDmaParams *pDmaParams = NULL;
TI_UINT32 uNumOfStations;
if (pCmdBld == NULL)
{
return TI_OK;
}
pDmaParams = &DB_DMA(hCmdBld);
uNumOfStations = (TI_UINT32)pDmaParams->NumStations;
if (DB_KEYS(pCmdBld).pReconfKeys)
{
os_memoryFree (pCmdBld->hOs,
DB_KEYS(pCmdBld).pReconfKeys,
sizeof(TSecurityKeys) * (uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS));
}
/* free the whalCtrl data structure */
os_memoryFree (pCmdBld->hOs, pCmdBld, sizeof(TCmdBld));
return TI_OK;
}
TI_STATUS cmdBld_Restart (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
/* This init is for recovery stage */
pCmdBld->uLastElpCtrlMode = ELPCTRL_MODE_NORMAL;
/*
* This call is to have the recovery process in AWAKE mode
* Prevent move to sleep mode between Hw_Init and Fw_Init
*/
cmdBld_CfgIeSleepAuth (hCmdBld, DB_WLAN(hCmdBld).minPowerLevel, NULL, NULL);
return TI_OK;
}
TI_STATUS cmdBld_Config (TI_HANDLE hCmdBld,
TI_HANDLE hReport,
void *fFinalizeDownload,
TI_HANDLE hFinalizeDownload,
TI_HANDLE hEventMbox,
TI_HANDLE hCmdQueue,
TI_HANDLE hTwIf)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT32 index;
pCmdBld->hReport = hReport;
pCmdBld->fFinalizeDownload = fFinalizeDownload;
pCmdBld->hFinalizeDownload = hFinalizeDownload;
pCmdBld->hEventMbox = hEventMbox;
pCmdBld->hCmdQueue = hCmdQueue;
pCmdBld->hTwIf = hTwIf;
/* Reset all reconfig valid fields*/
DB_KEYS(pCmdBld).bHwEncDecrEnableValid = TI_FALSE;
DB_KEYS(pCmdBld).bDefaultKeyIdValid = TI_FALSE;
for (index = 0;
index < pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS;
index++)
(DB_KEYS(pCmdBld).pReconfKeys + index)->keyType = KEY_NULL;
return TI_OK;
}
static void cmdBld_ConfigFwCb (TI_HANDLE hCmdBld, TI_STATUS status, void *pData)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
MemoryMap_t *pMemMap = &pCmdBld->tMemMap;
TDmaParams *pDmaParams = &DB_DMA(hCmdBld);
/* Arrived from callback */
if (pData)
{
TI_UINT32 *pSwap, i, uMemMapNumFields;
/* Solve endian problem (all fields are 32 bit) */
uMemMapNumFields = (sizeof(MemoryMap_t) - sizeof(EleHdrStruct)) % 4;
pSwap = (TI_UINT32* )&(pMemMap->codeStart);
for (i = 0; i < uMemMapNumFields; i++)
{
pSwap[i] = ENDIAN_HANDLE_LONG(pSwap[i]);
}
}
/* Save number of TX blocks */
pDmaParams->NumTxBlocks = pMemMap->numTxMemBlks;
/* Firmware Control block is internally pointing to TxResultInterface structure */
pDmaParams->fwTxResultInterface = pMemMap->trqBlock.controlBlock;
pDmaParams->fwRxCBufPtr = pMemMap->rxCBufPtr;
pDmaParams->fwTxCBufPtr = pMemMap->txCBufPtr;
pDmaParams->fwRxControlPtr = pMemMap->rxControlPtr;
pDmaParams->fwTxControlPtr = pMemMap->txControlPtr;
pDmaParams->PacketMemoryPoolStart = (TI_UINT32)pMemMap->packetMemoryPoolStart;
/* Call the upper layer callback */
(*((TConfigFwCb)pCmdBld->fConfigFwCb)) (pCmdBld->hConfigFwCb, TI_OK);
}
/****************************************************************************
* cmdBld_ConfigFw()
****************************************************************************
* DESCRIPTION: Configure the WLAN firmware
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ConfigFw (TI_HANDLE hCmdBld, void *fConfigFwCb, TI_HANDLE hConfigFwCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
pCmdBld->fConfigFwCb = fConfigFwCb;
pCmdBld->hConfigFwCb = hConfigFwCb;
pCmdBld->uIniSeq = 0;
/* should be re-initialized for recovery, pCmdBld->uLastElpCtrlMode = ELPCTRL_MODE_KEEP_AWAKE; */
/* Start configuration sequence */
return cmdBld_ConfigSeq (hCmdBld);
}
typedef TI_STATUS (*TCmdCfgFunc) (TI_HANDLE);
static TI_STATUS __cmd_probe_req (TI_HANDLE hCmdBld)
{
TI_STATUS tStatus = TI_OK;
/* keep space for 2.4 GHz probe request */
tStatus = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).probeRequestTemplateSize,
CFG_TEMPLATE_PROBE_REQ_2_4,
0,
NULL,
NULL);
if (TI_OK != tStatus)
{
return tStatus;
}
/* keep space for 5.0 GHz probe request */
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).probeRequestTemplateSize,
CFG_TEMPLATE_PROBE_REQ_5,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_null_data (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).nullTemplateSize,
TEMPLATE_NULL_DATA,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_burst_mode_enable (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeBurstMode (hCmdBld,
DB_AC(hCmdBld).isBurstModeEnabled,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
/*
static TI_STATUS __cmd_smart_reflex_debug (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeSRDebug (hCmdBld,
&(DB_SR(hCmdBld).tSmartReflexDebugParams),
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_smart_reflex_state (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeSRState (hCmdBld,
(uint8) DB_SR(hCmdBld).tSmartReflexState.enable,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
*/
static TI_STATUS __cmd_disconn (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).disconnTemplateSize,
TEMPLATE_DISCONNECT,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_ps_poll (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).PsPollTemplateSize,
TEMPLATE_PS_POLL,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_qos_null_data (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).qosNullDataTemplateSize,
TEMPLATE_QOS_NULL_DATA,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_probe_resp (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).probeResponseTemplateSize,
TEMPLATE_PROBE_RESPONSE,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_beacon (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
DB_WLAN(hCmdBld).beaconTemplateSize,
TEMPLATE_BEACON,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_keep_alive_tmpl (TI_HANDLE hCmdBld)
{
TI_UINT32 index;
TI_STATUS status = TI_NOK;
/*
* config templates
* fisr configure all indexes but the last one with no CB, and than configure the last one
* with a CB to continue configuration.
*/
for (index = 0; index < KLV_MAX_TMPL_NUM - 1; index++)
{
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
MAX_TEMPLATES_SIZE,
TEMPLATE_KLV,
index,
NULL,
NULL);
if (TI_OK != status)
{
return status;
}
}
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
NULL,
MAX_TEMPLATES_SIZE,
TEMPLATE_KLV,
index,
(void *)cmdBld_ConfigSeq,
hCmdBld);
return status;
}
static TI_STATUS __cfg_mem (TI_HANDLE hCmdBld)
{
/* Configure the weight among the different hardware queues */
return cmdBld_CfgIeConfigMemory (hCmdBld, &DB_DMA(hCmdBld), (void *)cmdBld_ConfigSeq, hCmdBld);
}
static TI_STATUS __cfg_rx_msdu_life_time (TI_HANDLE hCmdBld)
{
/* Configure the Rx Msdu Life Time (expiry time of de-fragmentation in FW) */
return cmdBld_CfgIeRxMsduLifeTime (hCmdBld,
DB_WLAN(hCmdBld).MaxRxMsduLifetime,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rx (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeRx (hCmdBld,
DB_WLAN(hCmdBld).RxConfigOption,
DB_WLAN(hCmdBld).RxFilterOption,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_ac_params_0 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_AC(hCmdBld).isAcConfigured[0])
{
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[0], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_ac_params_1 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_AC(hCmdBld).isAcConfigured[1])
{
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[1], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_ac_params_2 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_AC(hCmdBld).isAcConfigured[2])
{
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[2], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_ac_params_3 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_AC(hCmdBld).isAcConfigured[3])
{
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[3], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_tid_0 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_QUEUES(hCmdBld).isQueueConfigured[0])
{
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[0], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_tid_1 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_QUEUES(hCmdBld).isQueueConfigured[1])
{
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[1], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_tid_2 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_QUEUES(hCmdBld).isQueueConfigured[2])
{
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[2], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_tid_3 (TI_HANDLE hCmdBld)
{
/*
* NOTE: Set following parameter only if configured.
* Otherwise, is contains garbage.
*/
if (DB_QUEUES(hCmdBld).isQueueConfigured[3])
{
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[3], (void *)cmdBld_ConfigSeq, hCmdBld);
}
else
{
return TI_NOK;
}
}
static TI_STATUS __cfg_ps_rx_streaming (TI_HANDLE hCmdBld)
{
TI_UINT32 index;
TI_STATUS eStatus;
TPsRxStreaming *pPsRxStreaming;
if (!DB_WLAN(hCmdBld).bJoin)
{
return TI_NOK;
}
/* Config enabled streams (disable is the FW default). */
for (index = 0; index < MAX_NUM_OF_802_1d_TAGS - 1; index++)
{
pPsRxStreaming = &(DB_PS_STREAM(hCmdBld).tid[index]);
if (pPsRxStreaming->bEnabled)
{
eStatus = cmdBld_CfgPsRxStreaming (hCmdBld, pPsRxStreaming, NULL, NULL);
if (eStatus != TI_OK)
{
return eStatus;
}
}
}
/* Set NOK for a case the following config is skipped, to indicate that no callback is expected */
eStatus = TI_NOK;
pPsRxStreaming = &(DB_PS_STREAM(hCmdBld).tid[MAX_NUM_OF_802_1d_TAGS - 1]);
if (pPsRxStreaming->bEnabled)
{
eStatus = cmdBld_CfgPsRxStreaming (hCmdBld, pPsRxStreaming, (void *)cmdBld_ConfigSeq, hCmdBld);
if (eStatus != TI_OK)
{
return eStatus;
}
}
return eStatus;
}
static TI_STATUS __cfg_rx_data_filter (TI_HANDLE hCmdBld)
{
TI_UINT32 index;
TI_STATUS eStatus;
TRxDataFilter *pFilters;
if (DB_RX_DATA_FLTR(hCmdBld).bEnabled)
{
eStatus = cmdBld_CfgIeEnableRxDataFilter (hCmdBld,
DB_RX_DATA_FLTR(hCmdBld).bEnabled,
DB_RX_DATA_FLTR(hCmdBld).eDefaultAction,
NULL,
NULL);
if (eStatus != TI_OK)
{
return eStatus;
}
}
/*
* Config enabled filters (last one is separated to use the callback)
*/
for (index = 0; index < MAX_DATA_FILTERS - 1; index++)
{
pFilters = &(DB_RX_DATA_FLTR(hCmdBld).aRxDataFilter[index]);
if (pFilters->uCommand == ADD_FILTER)
{
eStatus = cmdBld_CfgIeRxDataFilter (hCmdBld,
pFilters->uIndex,
pFilters->uCommand,
pFilters->eAction,
pFilters->uNumFieldPatterns,
pFilters->uLenFieldPatterns,
pFilters->aFieldPattern,
NULL,
NULL);
if (eStatus != TI_OK)
{
return eStatus;
}
}
}
/* Set NOK for a case the following config is skipped, to indicate that no callback is expected */
eStatus = TI_NOK;
pFilters = &(DB_RX_DATA_FLTR(hCmdBld).aRxDataFilter[MAX_DATA_FILTERS - 1]);
if (pFilters->uCommand == ADD_FILTER)
{
eStatus = cmdBld_CfgIeRxDataFilter (hCmdBld,
pFilters->uIndex,
pFilters->uCommand,
pFilters->eAction,
pFilters->uNumFieldPatterns,
pFilters->uLenFieldPatterns,
pFilters->aFieldPattern,
(void *)cmdBld_ConfigSeq,
hCmdBld);
if (eStatus != TI_OK)
{
return eStatus;
}
}
return eStatus;
}
static TI_STATUS __cfg_pd_threshold (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIePacketDetectionThreshold (hCmdBld,
DB_WLAN(hCmdBld).PacketDetectionThreshold,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_slot_time (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeSlotTime (hCmdBld, DB_WLAN(hCmdBld).SlotTime, (void *)cmdBld_ConfigSeq, hCmdBld);
}
static TI_STATUS __cfg_arp_ip_filter (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeArpIpFilter (hCmdBld,
DB_WLAN(hCmdBld).arp_IP_addr,
(TI_BOOL)DB_WLAN(hCmdBld).isArpIpFilteringEnabled,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_group_address_table (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeGroupAdressTable (hCmdBld,
DB_WLAN(hCmdBld).numGroupAddrs,
DB_WLAN(hCmdBld).aGroupAddr,
DB_WLAN(hCmdBld).isMacAddrFilteringnabled,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_service_period_timeout (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeServicePeriodTimeout (hCmdBld,
&DB_WLAN(hCmdBld).rxTimeOut,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rts_threshold (TI_HANDLE hCmdBld)
{
return cmdBld_CfgRtsThreshold (hCmdBld,
DB_WLAN(hCmdBld).RtsThreshold,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_dco_itrim_params (TI_HANDLE hCmdBld)
{
return cmdBld_CfgDcoItrimParams (hCmdBld,
DB_WLAN(hCmdBld).dcoItrimEnabled,
DB_WLAN(hCmdBld).dcoItrimModerationTimeoutUsec,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_fragment_threshold (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeFragmentThreshold (hCmdBld,
DB_WLAN(hCmdBld).FragmentThreshold,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_pm_config (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIePmConfig (hCmdBld,
DB_WLAN(hCmdBld).uHostClkSettlingTime,
DB_WLAN(hCmdBld).uHostFastWakeupSupport,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_beacon_filter_opt (TI_HANDLE hCmdBld)
{
/* Set The Beacon Filter in HAL */
return cmdBld_CfgIeBeaconFilterOpt (hCmdBld,
DB_WLAN(hCmdBld).beaconFilterParams.desiredState,
DB_WLAN(hCmdBld).beaconFilterParams.numOfElements,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_beacon_filter_table (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeBeaconFilterTable (hCmdBld,
DB_WLAN(hCmdBld).beaconFilterIETable.numberOfIEs,
DB_WLAN(hCmdBld).beaconFilterIETable.IETable,
DB_WLAN(hCmdBld).beaconFilterIETable.IETableSize,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_tx_cmplt_pacing (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeTxCmpltPacing (hCmdBld,
DB_WLAN(hCmdBld).TxCompletePacingThreshold,
DB_WLAN(hCmdBld).TxCompletePacingTimeout,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rx_intr_pacing (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeRxIntrPacing (hCmdBld,
DB_WLAN(hCmdBld).RxIntrPacingThreshold,
DB_WLAN(hCmdBld).RxIntrPacingTimeout,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
#if 0
#ifdef TI_TEST
static TI_STATUS __cfg_coex_activity_table (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT32 uNumberOfIEs = DB_WLAN(hCmdBld).tWlanParamsCoexActivityTable.numOfElements;
TCoexActivity *CoexActivityTable = DB_WLAN(hCmdBld).tWlanParamsCoexActivityTable.entry;
TI_STATUS status = TI_NOK;
TI_UINT32 index;
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " CoexActivity, uNumberOfIEs=%d\n", uNumberOfIEs);
if (uNumberOfIEs == 0)
{
return status;
}
/*
* config CoexActivity table
* first configure all indexes but the last one with no CB, and than configure the last one
* with a CB to continue configuration.
*/
for (index = 0; index < uNumberOfIEs-1; index++)
{
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " CoexActivity, send %d\n", index);
status = cmdBld_CfgIeCoexActivity (hCmdBld, &CoexActivityTable[index],
NULL, NULL);
if (TI_OK != status)
{
return status;
}
}
/* Send last activity with a callback to continue config sequence */
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " CoexActivity, send last %d\n", index);
status = cmdBld_CfgIeCoexActivity (hCmdBld, &CoexActivityTable[index],
(void *)cmdBld_ConfigSeq, hCmdBld);
return status;
}
#endif
#endif
static TI_STATUS __cfg_cca_threshold (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeCcaThreshold (hCmdBld,
DB_WLAN(hCmdBld).EnergyDetection,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_bcn_brc_options (TI_HANDLE hCmdBld)
{
TPowerMgmtConfig powerMgmtConfig;
/* Beacon broadcast options */
powerMgmtConfig.BcnBrcOptions = DB_WLAN(hCmdBld).BcnBrcOptions;
powerMgmtConfig.ConsecutivePsPollDeliveryFailureThreshold = DB_WLAN(hCmdBld).ConsecutivePsPollDeliveryFailureThreshold;
return cmdBld_CfgIeBcnBrcOptions (hCmdBld,
&powerMgmtConfig,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_enable_rx (TI_HANDLE hCmdBld)
{
/* Enable rx path on the hardware */
return cmdBld_CmdEnableRx (hCmdBld, (void *)cmdBld_ConfigSeq, hCmdBld);
}
static TI_STATUS __cmd_enable_tx (TI_HANDLE hCmdBld)
{
/* Enable tx path on the hardware */
return cmdBld_CmdEnableTx (hCmdBld,
DB_DEFAULT_CHANNEL(hCmdBld),
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_ps_wmm (TI_HANDLE hCmdBld)
{
/* ACX for a work around for Wi-Fi test */
return cmdBld_CfgIePsWmm (hCmdBld,
DB_WLAN(hCmdBld).WiFiWmmPS,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_weights (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Weights for Average calculations */
return cmdBld_CfgIeRssiSnrWeights (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrWeights,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_event_scan_cmplt (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
/* Enable the scan complete interrupt source */
return eventMbox_UnMaskEvent (pCmdBld->hEventMbox,
TWD_OWN_EVENT_SCAN_CMPLT,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_event_sps_scan_cmplt (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return eventMbox_UnMaskEvent (pCmdBld->hEventMbox,
TWD_OWN_EVENT_SPS_SCAN_CMPLT,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_event_plt_rx_calibration_cmplt (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return eventMbox_UnMaskEvent (pCmdBld->hEventMbox,
TWD_OWN_EVENT_PLT_RX_CALIBRATION_COMPLETE,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_hw_enc_dec_enable (TI_HANDLE hCmdBld)
{
return cmdBld_CfgHwEncDecEnable (hCmdBld, TI_TRUE, (void *)cmdBld_ConfigSeq, hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_0 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[0],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_1 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[1],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_2 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[2],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_3 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[3],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_4 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[4],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_5 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[5],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_6 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[6],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rssi_snr_trigger_7 (TI_HANDLE hCmdBld)
{
/* RSSI/SNR Troggers */
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
&DB_WLAN(hCmdBld).tRssiSnrTrigger[7],
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_max_tx_retry (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeMaxTxRetry (hCmdBld,
&DB_WLAN(hCmdBld).roamTriggers,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_split_scan_timeout (TI_HANDLE hCmdBld)
{
return cmdBld_CmdIeSetSplitScanTimeOut (hCmdBld,
DB_WLAN(hCmdBld).uSlicedScanTimeOut,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_conn_monit_params (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeConnMonitParams (hCmdBld,
&DB_WLAN(hCmdBld).roamTriggers,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_bet (TI_HANDLE hCmdBld)
{
return cmdBld_CfgBet (hCmdBld,
DB_WLAN(hCmdBld).BetEnable,
DB_WLAN(hCmdBld).MaximumConsecutiveET,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_cts_protection (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeCtsProtection (hCmdBld,
DB_WLAN(hCmdBld).CtsToSelf,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_radio_params (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeRadioParams (hCmdBld,
&DB_RADIO(hCmdBld),
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_platform_params (TI_HANDLE hCmdBld)
{
return cmdBld_CfgPlatformGenParams(hCmdBld,
&DB_GEN(hCmdBld),
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_tx_rate_policy (TI_HANDLE hCmdBld)
{
/*
* JOIN (use the local parameters), otherwize the CORE will reconnect
*/
if (DB_WLAN(hCmdBld).bJoin)
{
/* Set TxRatePolicy */
return cmdBld_CfgTxRatePolicy (hCmdBld,
&DB_BSS(hCmdBld).TxRateClassParams,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_beacon_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).Beacon.Size != 0)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).Beacon),
(TI_UINT16)DB_TEMP(hCmdBld).Beacon.Size,
TEMPLATE_BEACON,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_probe_resp_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).ProbeResp.Size != 0)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).ProbeResp),
(TI_UINT16)DB_TEMP(hCmdBld).ProbeResp.Size,
TEMPLATE_PROBE_RESPONSE,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_probe_req_join (TI_HANDLE hCmdBld)
{
TI_STATUS tStatus;
/* set Probe Req template also if join == false ! */
if (DB_TEMP(hCmdBld).ProbeReq24.Size != 0)
{
tStatus = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).ProbeReq24),
(TI_UINT16)DB_TEMP(hCmdBld).ProbeReq24.Size,
CFG_TEMPLATE_PROBE_REQ_2_4,
0,
NULL,
NULL);
if (TI_OK != tStatus)
{
return tStatus;
}
}
/* set Probe Req template also if join == false ! */
if (DB_TEMP(hCmdBld).ProbeReq50.Size != 0)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).ProbeReq50),
(TI_UINT16)DB_TEMP(hCmdBld).ProbeReq50.Size,
CFG_TEMPLATE_PROBE_REQ_5,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_null_data_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).NullData.Size != 0)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).NullData),
(TI_UINT16)DB_TEMP(hCmdBld).NullData.Size,
TEMPLATE_NULL_DATA,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_disconn_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).Disconn.Size != 0)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).Disconn),
(TI_UINT16)DB_TEMP(hCmdBld).Disconn.Size,
TEMPLATE_DISCONNECT,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_ps_poll_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).PsPoll.Size != 0)
{
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).PsPoll),
(TI_UINT16)DB_TEMP(hCmdBld).PsPoll.Size,
TEMPLATE_PS_POLL,
0,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_keep_alive_tmpl_join (TI_HANDLE hCmdBld)
{
TI_UINT32 index;
TI_STATUS status = TI_NOK;
/*
* config templates
* first configure all indexes but the last one with no CB, and than configure the last one
* with a CB to continue configuration.
*/
for (index = 0; index < KLV_MAX_TMPL_NUM - 1; index++)
{
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).KeepAlive[ index ].Size != 0)
{
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).KeepAlive[index]),
(TI_UINT16)DB_TEMP(hCmdBld).KeepAlive[index].Size,
TEMPLATE_KLV,
index,
NULL,
NULL);
if (TI_OK != status)
{
return status;
}
}
}
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).KeepAlive[ index ].Size != 0)
{
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
&(DB_TEMP(hCmdBld).KeepAlive[index]),
(TI_UINT16)DB_TEMP(hCmdBld).KeepAlive[index].Size,
TEMPLATE_KLV,
index,
(void *)cmdBld_ConfigSeq,
hCmdBld);
if (TI_OK != status)
{
return status;
}
}
return status;
}
static TI_STATUS __cmd_keep_alive_params(TI_HANDLE hCmdBld)
{
TI_UINT32 index;
TI_STATUS status;
/* config gloabl enable / disable flag */
cmdBld_CfgKeepAliveEnaDis (hCmdBld, DB_KLV(hCmdBld).enaDisFlag, NULL, NULL);
/*
* config per-template params
* fisr configure all indexes but the last one with no CB, and than configure the last one
* with a CB to continue configuration.
*/
for (index = 0; index < KLV_MAX_TMPL_NUM - 1; index++)
{
if (DB_WLAN(hCmdBld).bJoin && DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag != 0)
{
status = cmdBld_CmdIeConfigureKeepAliveParams (hCmdBld,
index,
DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag,
DB_KLV(hCmdBld).keepAliveParams[ index ].trigType,
DB_KLV(hCmdBld).keepAliveParams[ index ].interval,
NULL,
NULL);
if (TI_OK != status)
{
return status;
}
}
}
/* Set NOK for a case the following config is skipped, to indicate that no callback is expected */
status = TI_NOK;
if (DB_WLAN(hCmdBld).bJoin && DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag != 0)
{
status = cmdBld_CmdIeConfigureKeepAliveParams (hCmdBld,
index,
DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag,
DB_KLV(hCmdBld).keepAliveParams[ index ].trigType,
DB_KLV(hCmdBld).keepAliveParams[ index ].interval,
(void *)cmdBld_ConfigSeq,
hCmdBld);
if (TI_OK != status)
{
return status;
}
}
return status;
}
static TI_STATUS __cmd_power_auth (TI_HANDLE hCmdBld)
{
return cmdBld_CfgIeSleepAuth (hCmdBld,
DB_WLAN(hCmdBld).minPowerLevel,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cmd_start_join (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
if (DB_WLAN(hCmdBld).bJoin)
{
/*
* Replace the Join-Complete event CB by a local function.
* Thus, the reconfig sequence will not continue until the Join is completed!
* The original CB is restored after Join-Complete.
*/
eventMbox_ReplaceEvent (pCmdBld->hEventMbox,
TWD_OWN_EVENT_JOIN_CMPLT,
(void *)cmdBld_JoinCmpltForReconfigCb,
hCmdBld,
&pCmdBld->fJoinCmpltOriginalCbFunc,
&pCmdBld->hJoinCmpltOriginalCbHndl);
/*
* Call the hardware to start/join the bss
*/
return cmdBld_CmdStartJoin (hCmdBld,
DB_BSS(hCmdBld).ReqBssType,
(void *)cmdBld_DummyCb,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cmd_sta_state (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bStaConnected)
{
return cmdBld_CmdSetStaState (hCmdBld,
STA_STATE_CONNECTED,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_aid (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin)
{
return cmdBld_CfgAid (hCmdBld, DB_WLAN(hCmdBld).Aid, (void *)cmdBld_ConfigSeq, hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_slot_time_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin)
{
/* Slot time must be setting after doing join */
return cmdBld_CfgSlotTime (hCmdBld, (ESlotTime)(DB_WLAN(hCmdBld).SlotTime), (void *)cmdBld_ConfigSeq, hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_preamble_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin)
{
/* Preamble type must be set after doing join */
return cmdBld_CfgPreamble (hCmdBld, DB_WLAN(hCmdBld).preamble, (void *)cmdBld_ConfigSeq, hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_ht_capabilities (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_BSS(hCmdBld).bHtCap)
{
/* HT capabilities must be set after doing join */
return cmdBld_CfgIeSetFwHtCapabilities (hCmdBld,
DB_BSS(hCmdBld).uHtCapabilites,
DB_BSS(hCmdBld).tMacAddress,
DB_BSS(hCmdBld).uAmpduMaxLeng,
DB_BSS(hCmdBld).uAmpduMinSpac,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_ht_information (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin && DB_BSS(hCmdBld).bHtInf)
{
/* HT Information must be set after doing join */
return cmdBld_CfgIeSetFwHtInformation (hCmdBld,
DB_BSS(hCmdBld).uRifsMode,
DB_BSS(hCmdBld).uHtProtection,
DB_BSS(hCmdBld).uGfProtection,
DB_BSS(hCmdBld).uHtTxBurstLimit,
DB_BSS(hCmdBld).uDualCtsProtection,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_ba_set_session (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin)
{
TI_UINT32 uTid;
for (uTid = 0; uTid < MAX_NUM_OF_802_1d_TAGS; ++uTid)
{
/* set BA initiator */
if (DB_BSS(hCmdBld).bBaInitiator[uTid])
{
return cmdBld_CfgIeSetBaSession (hCmdBld,
ACX_BA_SESSION_INITIATOR_POLICY,
uTid,
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uPolicy,
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].aMacAddress,
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uWinSize,
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uInactivityTimeout,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
/* set BA Responder */
if (DB_BSS(hCmdBld).bBaResponder[uTid])
{
return cmdBld_CfgIeSetBaSession (hCmdBld,
ACX_BA_SESSION_RESPONDER_POLICY,
uTid,
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uPolicy,
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].aMacAddress,
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uWinSize,
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uInactivityTimeout,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
}
}
return TI_NOK;
}
static TI_STATUS __cfg_tx_power_join (TI_HANDLE hCmdBld)
{
if (DB_WLAN(hCmdBld).bJoin)
{
/* Tx-power must be set after doing join */
return cmdBld_CfgTxPowerDbm (hCmdBld, DB_WLAN(hCmdBld).TxPowerDbm, (void *)cmdBld_ConfigSeq, hCmdBld);
}
return TI_NOK;
}
static TI_STATUS __cfg_keys (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT32 index;
if (!DB_WLAN(hCmdBld).bJoin)
{
return TI_NOK;
}
if (pCmdBld->tSecurity.eSecurityMode != TWD_CIPHER_NONE)
{
/*
* We are doing recovery during security so increase security-sequence-number by 255 just to ensure
* the AP will see progress from last Tx before the recovery (actually needed only for TKIP and AES).
* Decrementing the low byte by one is handled like it wrpped around, i.e. increment total number by 255.
*/
cmdBld_SetSecuritySeqNum (hCmdBld, (TI_UINT8)(pCmdBld->uSecuritySeqNumLow - 1));
/* set the keys to the HW*/
for (index = 0;
index < pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS;
index++)
{
if ((DB_KEYS(pCmdBld).pReconfKeys + index)->keyType != KEY_NULL)
{
if (cmdBld_CmdAddKey (hCmdBld, DB_KEYS(pCmdBld).pReconfKeys + index, TI_TRUE, NULL, NULL) != TI_OK)
{
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "__cfg_keys: ERROR cmdBld_CmdAddKey failure index=%d\n", index);
return TI_NOK;
}
}
}
if (DB_KEYS(pCmdBld).bDefaultKeyIdValid)
{
/* Set the deafult key ID to the HW*/
if (cmdBld_CmdSetWepDefaultKeyId (hCmdBld, DB_KEYS(pCmdBld).uReconfDefaultKeyId, NULL, NULL) != TI_OK)
{
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "__cfg_keys: ERROR cmdBld_CmdSetWepDefaultKeyId failure\n");
return TI_NOK;
}
}
}
/* Set the encryption/decryption control on the HW */
if (cmdBld_CfgHwEncDecEnable (hCmdBld,
DB_KEYS(pCmdBld).bReconfHwEncEnable,
(void *)cmdBld_ConfigSeq,
hCmdBld) != TI_OK)
{
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "__cfg_keys: ERROR cmdBld_CfgHwEncDecEnable failure \n");
return TI_NOK;
}
return TI_OK;
}
static TI_STATUS __cfg_sg_enable (TI_HANDLE hCmdBld)
{
/* Set the Soft Gemini state */
return cmdBld_CfgSgEnable (hCmdBld,
DB_WLAN(hCmdBld).SoftGeminiEnable,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_sg (TI_HANDLE hCmdBld)
{
/* Set the Soft Gemini params */
/* signals the FW to config all the paramters from the DB*/
DB_WLAN(hCmdBld).SoftGeminiParams.paramIdx = 0xFF;
return cmdBld_CfgSg (hCmdBld,
&DB_WLAN(hCmdBld).SoftGeminiParams,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_fm_coex (TI_HANDLE hCmdBld)
{
/* Set the FM Coexistence params */
return cmdBld_CfgIeFmCoex (hCmdBld,
&DB_WLAN(hCmdBld).tFmCoexParams,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
static TI_STATUS __cfg_rate_management (TI_HANDLE hCmdBld)
{
DB_RM(hCmdBld).rateMngParams.paramIndex = 0xFF;
return cmdBld_CfgIeRateMngDbg(hCmdBld,
&DB_RM(hCmdBld).rateMngParams,
(void *)cmdBld_ConfigSeq,
hCmdBld);
}
TI_STATUS __itr_memory_map (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
WLAN_OS_REPORT(("Interrogate TX/RX parameters\n"));
/* Interrogate TX/RX parameters */
return cmdBld_ItrIeMemoryMap (hCmdBld,
&pCmdBld->tMemMap,
(void *)cmdBld_ConfigFwCb,
hCmdBld);
}
static const TCmdCfgFunc aCmdIniSeq [] =
{
__cfg_platform_params,
__cfg_radio_params,
__cmd_probe_req,
__cmd_null_data,
__cmd_disconn,
__cmd_ps_poll,
__cmd_qos_null_data,
__cmd_probe_resp,
__cmd_beacon,
__cmd_keep_alive_tmpl,
__cfg_mem,
__cfg_rx_msdu_life_time,
__cfg_rx,
__cfg_ac_params_0,
__cfg_tid_0,
__cfg_ac_params_1,
__cfg_tid_1,
__cfg_ac_params_2,
__cfg_tid_2,
__cfg_ac_params_3,
__cfg_tid_3,
__cfg_pd_threshold,
__cfg_slot_time,
__cfg_arp_ip_filter,
__cfg_group_address_table,
__cfg_service_period_timeout,
__cfg_rts_threshold,
__cfg_dco_itrim_params,
__cfg_fragment_threshold,
__cfg_pm_config,
__cfg_beacon_filter_opt,
__cfg_beacon_filter_table,
__cfg_tx_cmplt_pacing,
__cfg_rx_intr_pacing,
__cfg_sg,
__cfg_sg_enable,
__cfg_fm_coex,
__cfg_cca_threshold,
__cfg_bcn_brc_options,
__cmd_enable_rx,
__cmd_enable_tx,
__cfg_ps_wmm,
__cfg_event_scan_cmplt,
__cfg_event_sps_scan_cmplt,
__cfg_event_plt_rx_calibration_cmplt,
__cfg_hw_enc_dec_enable,
__cfg_rssi_snr_weights,
__cfg_rssi_snr_trigger_0,
__cfg_rssi_snr_trigger_1,
__cfg_rssi_snr_trigger_2,
__cfg_rssi_snr_trigger_3,
__cfg_rssi_snr_trigger_4,
__cfg_rssi_snr_trigger_5,
__cfg_rssi_snr_trigger_6,
__cfg_rssi_snr_trigger_7,
__cfg_max_tx_retry,
__cfg_split_scan_timeout,
/* Re-join sequence */
__cfg_tx_rate_policy,
__cmd_beacon_join,
__cmd_probe_resp_join,
__cmd_probe_req_join,
__cmd_null_data_join,
__cmd_disconn_join,
__cmd_ps_poll_join,
__cmd_keep_alive_tmpl_join,
__cfg_slot_time_join,
__cfg_preamble_join,
__cfg_ht_capabilities,
__cfg_ht_information,
__cmd_start_join,
__cfg_aid,
__cfg_ba_set_session,
__cfg_tx_power_join,
__cfg_keys,
__cmd_keep_alive_params,
__cfg_conn_monit_params,
__cfg_bet,
__cfg_cts_protection,
__cfg_ps_rx_streaming,
__cfg_rx_data_filter,
__cmd_sta_state,
__cmd_power_auth,
__cmd_burst_mode_enable,
//__cmd_smart_reflex_state,
//__cmd_smart_reflex_debug,
__cfg_rate_management,
/* Interrogate command -> must be last!! */
__itr_memory_map,
NULL
};
/****************************************************************************
* cmdBld_ConfigSeq()
****************************************************************************
* DESCRIPTION: Configuration sequence engine
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ConfigSeq (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
do
{
if (aCmdIniSeq [pCmdBld->uIniSeq++] == NULL)
{
return TI_NOK;
}
}
while ((*aCmdIniSeq [pCmdBld->uIniSeq - 1])(hCmdBld) != TI_OK);
return TI_OK;
}
/****************************************************************************
* cmdBld_FinalizeDownload()
****************************************************************************
* DESCRIPTION: Finalize all the remaining initialization after the download has finished
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: void
****************************************************************************/
void cmdBld_FinalizeDownload (TI_HANDLE hCmdBld, TBootAttr *pBootAttr, FwStaticData_t *pFwInfo)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT8 *pMacAddr = pFwInfo->dot11StationID;
TI_UINT32 i;
TI_UINT8 uTmp;
/* Save FW version */
os_memoryCopy (pCmdBld->hOs,
(void *)DB_HW(hCmdBld).fwVer,
(void *)pFwInfo->FWVersion,
sizeof(DB_HW(hCmdBld).fwVer));
/* Save MAC adress (correct the bytes order first) */
for (i = 0; i < 3; i++)
{
uTmp = pMacAddr[i];
pMacAddr[i] = pMacAddr[5 - i];
pMacAddr[5 - i] = uTmp;
}
MAC_COPY (DB_HW(hCmdBld).macAddress, pMacAddr);
/* Save chip ID */
os_memoryCopy (pCmdBld->hOs,
(void *)&(DB_HW(hCmdBld).uHardWareVersion),
(void *)&(pFwInfo->HardWareVersion),
sizeof(DB_HW(hCmdBld).uHardWareVersion));
/* Save power-levels table */
os_memoryCopy (pCmdBld->hOs,
(void *)DB_HW(hCmdBld).txPowerTable,
(void *)pFwInfo->txPowerTable,
sizeof(DB_HW(hCmdBld).txPowerTable));
/* Call the upper layer callback */
(*((TFinalizeCb)pCmdBld->fFinalizeDownload)) (pCmdBld->hFinalizeDownload);
}
TI_STATUS cmdBld_GetParam (TI_HANDLE hCmdBld, TTwdParamInfo *pParamInfo)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);
switch (pParamInfo->paramType)
{
case TWD_RTS_THRESHOLD_PARAM_ID:
pParamInfo->content.halCtrlRtsThreshold = pWlanParams->RtsThreshold;
break;
case TWD_FRAG_THRESHOLD_PARAM_ID:
pParamInfo->content.halCtrlFragThreshold = pWlanParams->FragmentThreshold;
break;
case TWD_COUNTERS_PARAM_ID:
/* Constant zero because the ACX last buffer next pointer is always pointed
to itself, so it's like an endless buffer*/
pParamInfo->content.halCtrlCounters.RecvNoBuffer = 0;
pParamInfo->content.halCtrlCounters.FragmentsRecv = 0; /* not supported;*/
pParamInfo->content.halCtrlCounters.FrameDuplicates = 0;/* not supported*/
pParamInfo->content.halCtrlCounters.FcsErrors = DB_CNT(hCmdBld).FcsErrCnt;
pParamInfo->content.halCtrlCounters.RecvError = DB_CNT(hCmdBld).FcsErrCnt;
break;
case TWD_LISTEN_INTERVAL_PARAM_ID:
pParamInfo->content.halCtrlListenInterval = pWlanParams->ListenInterval;
break;
case TWD_RSN_DEFAULT_KEY_ID_PARAM_ID:
/* Not implemented */
return TI_NOK;
case TWD_RSN_SECURITY_MODE_PARAM_ID:
pParamInfo->content.rsnEncryptionStatus = pCmdBld->tSecurity.eSecurityMode;
break;
case TWD_ACX_STATISTICS_PARAM_ID:
/* Not implemented */
#if 0
{
acxStatisitcs_t acxStatisitics;
pParamInfo->content.acxStatisitics.FWpacketReceived = acxStatisitics.FWpacketReceived;
/* Not supported */
pParamInfo->content.acxStatisitics.HALpacketReceived = 0;
}
#endif
return TI_NOK;
case TWD_MEDIUM_OCCUPANCY_PARAM_ID:
if (cmdBld_ItrIeMediumOccupancy (hCmdBld, pParamInfo->content.interogateCmdCBParams) != TI_OK)
return TI_NOK;
break;
case TWD_TSF_DTIM_MIB_PARAM_ID:
if (cmdBld_ItrIeTfsDtim (hCmdBld, pParamInfo->content.interogateCmdCBParams) != TI_OK)
return TI_NOK;
break;
case TWD_AID_PARAM_ID:
if (cmdBld_GetCurrentAssociationId (hCmdBld, &pParamInfo->content.halCtrlAid) != TI_OK)
return TI_NOK;
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " AID 2 %d\n", pParamInfo->content.halCtrlAid);
break;
case TWD_NOISE_HISTOGRAM_PARAM_ID:
if (cmdBld_ItrIeNoiseHistogramResults (hCmdBld, pParamInfo->content.interogateCmdCBParams) != TI_OK)
{
return TI_NOK;
}
break;
case TWD_CURRENT_CHANNEL_PARAM_ID:
/* Get current channel number */
pParamInfo->content.halCtrlCurrentChannel = DB_BSS(hCmdBld).RadioChannel;
break;
/* SNR and RSSI belongs to the same MIB, and the relevant CB is passed here*/
case TWD_RSSI_LEVEL_PARAM_ID:
case TWD_SNR_RATIO_PARAM_ID:
/* Retrive the Callback function and read buffer pointer that are in fact stored in the TIWLAN_ADAPTER and then send it to the Command Mailbox */
cmdBld_ItrRSSI (hCmdBld,
pParamInfo->content.interogateCmdCBParams.fCb,
pParamInfo->content.interogateCmdCBParams.hCb,
pParamInfo->content.interogateCmdCBParams.pCb);
break;
case TWD_BCN_BRC_OPTIONS_PARAM_ID:
pParamInfo->content.BcnBrcOptions.BeaconRxTimeout = pWlanParams->BcnBrcOptions.BeaconRxTimeout;
pParamInfo->content.BcnBrcOptions.BroadcastRxTimeout = pWlanParams->BcnBrcOptions.BroadcastRxTimeout;
pParamInfo->content.BcnBrcOptions.RxBroadcastInPs = pWlanParams->BcnBrcOptions.RxBroadcastInPs;
break;
case TWD_MAX_RX_MSDU_LIFE_TIME_PARAM_ID:
pParamInfo->content.halCtrlMaxRxMsduLifetime = pWlanParams->MaxRxMsduLifetime;
break;
case TWD_TX_RATE_CLASS_PARAM_ID:
pParamInfo->content.pTxRatePlicy = &DB_BSS(hCmdBld).TxRateClassParams;
break;
case TWD_SG_CONFIG_PARAM_ID:
return cmdBld_ItrSg (hCmdBld,
pParamInfo->content.interogateCmdCBParams.fCb,
pParamInfo->content.interogateCmdCBParams.hCb,
(void*)pParamInfo->content.interogateCmdCBParams.pCb);
case TWD_TX_POWER_PARAM_ID:
pParamInfo->content.halCtrlTxPowerDbm = DB_WLAN(hCmdBld).TxPowerDbm;
break;
case TWD_RADIO_TEST_PARAM_ID:
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Radio Test\n");
return cmdBld_CmdTest (hCmdBld,
pParamInfo->content.interogateCmdCBParams.fCb,
pParamInfo->content.interogateCmdCBParams.hCb,
(TTestCmd*)pParamInfo->content.interogateCmdCBParams.pCb);
case TWD_DCO_ITRIM_PARAMS_ID:
pParamInfo->content.tDcoItrimParams.enable = pWlanParams->dcoItrimEnabled;
pParamInfo->content.tDcoItrimParams.moderationTimeoutUsec = pWlanParams->dcoItrimModerationTimeoutUsec;
break;
default:
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_GetParam - ERROR - Param is not supported, %d\n\n", pParamInfo->paramType);
return (PARAM_NOT_SUPPORTED);
}
return TI_OK;
}
static TI_STATUS cmdBld_ReadMibBeaconFilterIETable (TI_HANDLE hCmdBld, TI_HANDLE hCb, void* fCb, void* pCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TMib *pMib = (TMib*)pCb;
TCmdQueueInterrogateCb RetFunc = (TCmdQueueInterrogateCb)fCb;
TI_UINT8 IETableSize = 0;
/*Get params*/
pMib->aData.BeaconFilter.iNumberOfIEs = DB_WLAN(hCmdBld).beaconFilterIETable.numberOfIEs;
IETableSize = DB_WLAN(hCmdBld).beaconFilterIETable.IETableSize;
os_memoryZero (pCmdBld->hOs,
pMib->aData.BeaconFilter.iIETable,
sizeof(pMib->aData.BeaconFilter.iIETable));
os_memoryCopy (pCmdBld->hOs,
pMib->aData.BeaconFilter.iIETable,
DB_WLAN(hCmdBld).beaconFilterIETable.IETable,
IETableSize);
pMib->Length = IETableSize + 1;
RetFunc(hCb, TI_OK, pCb);
return TI_OK;
}
/**
* \author \n
* \date \n
* \brief Coordinates between legacy TxRatePolicy implementation and the MIB format: \n
* Converts the pGwsi_txRatePolicy back to whal commands
* Activates the whal whalCtrl_set function
* Function Scope \e Public.\n
* \param - \n
* \return \n
*/
static TI_STATUS cmdBld_ReadMibTxRatePolicy (TI_HANDLE hCmdBld, TI_HANDLE hCb, void* fCb, void* pCb)
{
TMib* pMib = (TMib*)pCb;
TCmdQueueInterrogateCb RetFunc = (TCmdQueueInterrogateCb)fCb;
TTwdParamInfo param;
TI_STATUS status = TI_OK;
param.paramType = TWD_TX_RATE_CLASS_PARAM_ID;
cmdBld_GetParam (hCmdBld, ¶m);
if (param.content.pTxRatePlicy == NULL)
return TI_NOK;
/*Copy the data form the param to the MIB*/
pMib->aData.txRatePolicy = *param.content.pTxRatePlicy;
pMib->Length = pMib->aData.txRatePolicy.numOfRateClasses * sizeof(pMib->aData.txRatePolicy.rateClass[0]) +
sizeof(pMib->aData.txRatePolicy.numOfRateClasses);
RetFunc (hCb, status, pCb);
return status;
}
TI_STATUS cmdBld_ReadMib (TI_HANDLE hCmdBld, TI_HANDLE hCb, void* fCb, void* pCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TMib *pMibBuf = (TMib*)pCb;
TCmdQueueInterrogateCb RetFunc = (TCmdQueueInterrogateCb)fCb;
TI_STATUS Status = TI_OK;
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ReadMib :pMibBuf %p:\n",pMibBuf);
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ReadMib :aMib %x:\n", pMibBuf->aMib);
switch (pMibBuf->aMib)
{
case MIB_dot11MaxReceiveLifetime:
{
TTwdParamInfo ParamInfo;
ParamInfo.paramType = TWD_MAX_RX_MSDU_LIFE_TIME_PARAM_ID;
ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlMaxRxMsduLifetime);
Status = cmdBld_GetParam (hCmdBld, &ParamInfo);
pMibBuf->aData.MaxReceiveLifeTime = ParamInfo.content.halCtrlMaxRxMsduLifetime / 1024; /* converting from usecs to TUs*/
pMibBuf->Length = sizeof(pMibBuf->aData.MaxReceiveLifeTime);
}
break;
case MIB_dot11GroupAddressesTable:
{
Status = cmdBld_GetGroupAddressTable (hCmdBld,
&pMibBuf->aData.GroupAddressTable.bFilteringEnable,
&pMibBuf->aData.GroupAddressTable.nNumberOfAddresses,
pMibBuf->aData.GroupAddressTable.aGroupTable);
pMibBuf->Length = sizeof(pMibBuf->aData.GroupAddressTable.bFilteringEnable) +
sizeof(pMibBuf->aData.GroupAddressTable.nNumberOfAddresses) +
pMibBuf->aData.GroupAddressTable.nNumberOfAddresses * sizeof(TMacAddr);
}
break;
case MIB_ctsToSelf:
{
TTwdParamInfo ParamInfo;
ParamInfo.paramType = TWD_CTS_TO_SELF_PARAM_ID;
ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlCtsToSelf);
Status = cmdBld_GetParam (hCmdBld, &ParamInfo);
pMibBuf->aData.CTSToSelfEnable = ParamInfo.content.halCtrlCtsToSelf;
pMibBuf->Length = sizeof(pMibBuf->aData.CTSToSelfEnable);
}
break;
case MIB_arpIpAddressesTable:
{
TIpAddr IpAddress;
EIpVer IPver;
TI_UINT8 Enable;
pMibBuf->Length = sizeof(TMibArpIpAddressesTable);
Status = cmdBld_GetArpIpAddressesTable (hCmdBld, &IpAddress, &Enable, &IPver);
if (Status == TI_OK)
{
pMibBuf->aData.ArpIpAddressesTable.FilteringEnable = Enable;
if (IP_VER_4 == IPver) /* IP_VER_4 only */
{
IP_COPY (pMibBuf->aData.ArpIpAddressesTable.addr, IpAddress);
}
else
{
Status = TI_NOK;
}
}
return Status;
}
case MIB_rxFilter:
{
TI_UINT32 RxConfigOption;
TI_UINT32 RxFilterOption;
pMibBuf->Length = 1;
pMibBuf->aData.RxFilter = 0;
/* Get RX filter data */
Status = cmdBld_GetRxFilters (hCmdBld, &RxConfigOption, &RxFilterOption);
if (TI_OK == Status)
{
/*Translate to MIB bitmap*/
if ((RxConfigOption & RX_CFG_MAC) == RX_CFG_ENABLE_ANY_DEST_MAC)
pMibBuf->aData.RxFilter |= MIB_RX_FILTER_PROMISCOUS_SET;
if ((RxConfigOption & RX_CFG_BSSID) == RX_CFG_ENABLE_ONLY_MY_BSSID)
pMibBuf->aData.RxFilter |= MIB_RX_FILTER_BSSID_SET;
}
}
break;
case MIB_beaconFilterIETable:
return cmdBld_ReadMibBeaconFilterIETable (hCmdBld, hCb, fCb, pCb);
case MIB_txRatePolicy:
return cmdBld_ReadMibTxRatePolicy (hCmdBld, hCb, fCb, pCb);
case MIB_countersTable:
return cmdBld_ItrErrorCnt (hCmdBld, fCb, hCb, pCb);
case MIB_statisticsTable:
return cmdBld_ItrRoamimgStatisitics (hCmdBld, fCb, hCb, pCb);
default:
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "TWD_ReadMib:MIB aMib 0x%x Not supported\n",pMibBuf->aMib);
return TI_NOK;
}
if(RetFunc)
RetFunc(hCb, Status, pCb);
return TI_OK;
}
TI_STATUS cmdBld_GetGroupAddressTable (TI_HANDLE hCmdBld, TI_UINT8* pEnabled, TI_UINT8* pNumGroupAddrs, TMacAddr *pGroupAddr)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT32 i;
if (NULL == pEnabled || NULL == pNumGroupAddrs || NULL == pGroupAddr)
{
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_GetGroupAddressTable: pisEnabled=0x%p pnumGroupAddrs=0x%p Group_addr=0x%p !!!\n", pEnabled, pNumGroupAddrs, pGroupAddr);
return PARAM_VALUE_NOT_VALID;
}
*pNumGroupAddrs = DB_WLAN(hCmdBld).numGroupAddrs;
*pEnabled = DB_WLAN(hCmdBld).isMacAddrFilteringnabled;
os_memoryZero (pCmdBld->hOs, pGroupAddr, sizeof(pGroupAddr));
for (i = 0; i < *pNumGroupAddrs; i++)
{
os_memoryCopy (pCmdBld->hOs,
(void *)&((*pGroupAddr)[MAC_ADDR_LEN*i]),
&DB_WLAN(hCmdBld).aGroupAddr[i],
MAC_ADDR_LEN);
}
return TI_OK;
}
TI_STATUS cmdBld_GetRxFilters (TI_HANDLE hCmdBld, TI_UINT32* pRxConfigOption, TI_UINT32* pRxFilterOption)
{
*pRxConfigOption = DB_WLAN(hCmdBld).RxConfigOption;
*pRxFilterOption = DB_WLAN(hCmdBld).RxFilterOption;
return TI_OK;
}
TFwInfo * cmdBld_GetFWInfo (TI_HANDLE hCmdBld)
{
return &DB_HW(hCmdBld);
}
TI_STATUS cmdBld_SetRadioBand (TI_HANDLE hCmdBld, ERadioBand eRadioBand)
{
DB_WLAN(hCmdBld).RadioBand = eRadioBand;
return TI_OK;
}
/****************************************************************************
* cmdBld_CurrentAssociationIdGet()
****************************************************************************
* DESCRIPTION: Get the current TX antenna
*
* INPUTS:
*
* OUTPUT:
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_GetCurrentAssociationId (TI_HANDLE hCmdBld, TI_UINT16 *pAidVal)
{
*pAidVal = DB_WLAN(hCmdBld).Aid;
return TI_OK;
}
/****************************************************************************
* cmdBld_GetArpIpAddressesTable()
****************************************************************************
* DESCRIPTION: Sets the Group table according to the given configuration.
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_GetArpIpAddressesTable (TI_HANDLE hCmdBld, TIpAddr *pIp, TI_UINT8* pbEnabled, EIpVer *pIpVer)
{
*pIpVer = (EIpVer)DB_WLAN(hCmdBld).arp_IP_ver;
IP_COPY (*pIp, DB_WLAN(hCmdBld).arp_IP_addr);
*pbEnabled = DB_WLAN(hCmdBld).isArpIpFilteringEnabled;
return TI_OK;
}
TI_STATUS cmdBld_ConvertAppRatesBitmap (TI_UINT32 uAppRatesBitmap, TI_UINT32 uAppModulation, EHwRateBitFiled *pHwRatesBitmap)
{
EHwRateBitFiled uRatesBitmap = 0;
if (uAppRatesBitmap & DRV_RATE_MASK_1_BARKER) uRatesBitmap |= HW_BIT_RATE_1MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_2_BARKER) uRatesBitmap |= HW_BIT_RATE_2MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_5_5_CCK) uRatesBitmap |= HW_BIT_RATE_5_5MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_11_CCK) uRatesBitmap |= HW_BIT_RATE_11MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_22_PBCC) uRatesBitmap |= HW_BIT_RATE_22MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_6_OFDM) uRatesBitmap |= HW_BIT_RATE_6MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_9_OFDM) uRatesBitmap |= HW_BIT_RATE_9MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_12_OFDM) uRatesBitmap |= HW_BIT_RATE_12MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_18_OFDM) uRatesBitmap |= HW_BIT_RATE_18MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_24_OFDM) uRatesBitmap |= HW_BIT_RATE_24MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_36_OFDM) uRatesBitmap |= HW_BIT_RATE_36MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_48_OFDM) uRatesBitmap |= HW_BIT_RATE_48MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_54_OFDM) uRatesBitmap |= HW_BIT_RATE_54MBPS;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_0_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_0;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_1_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_1;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_2_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_2;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_3_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_3;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_4_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_4;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_5_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_5;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_6_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_6;
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_7_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_7;
*pHwRatesBitmap = uRatesBitmap;
return TI_OK;
}
EHwRateBitFiled rateNumberToBitmap(TI_UINT8 uRate)
{
switch(uRate)
{
case 1: return HW_BIT_RATE_1MBPS;
case 2: return HW_BIT_RATE_2MBPS;
case 5: return HW_BIT_RATE_5_5MBPS;
case 6: return HW_BIT_RATE_6MBPS;
case 9: return HW_BIT_RATE_9MBPS;
case 11: return HW_BIT_RATE_11MBPS;
case 12: return HW_BIT_RATE_12MBPS;
case 18: return HW_BIT_RATE_18MBPS;
case 22: return HW_BIT_RATE_22MBPS;
case 24: return HW_BIT_RATE_24MBPS;
case 36: return HW_BIT_RATE_36MBPS;
case 48: return HW_BIT_RATE_48MBPS;
case 54: return HW_BIT_RATE_54MBPS;
default:
return 0;
}
}
TI_STATUS cmdBld_ConvertAppRate (ERate AppRate, TI_UINT8 *pHwRate)
{
TI_UINT8 Rate = 0;
TI_STATUS status = TI_OK;
switch (AppRate)
{
/*
* The handle for 5.5/11/22 PBCC was removed !!!
*/
case DRV_RATE_1M: Rate = txPolicy1; break;
case DRV_RATE_2M: Rate = txPolicy2; break;
case DRV_RATE_5_5M: Rate = txPolicy5_5; break;
case DRV_RATE_11M: Rate = txPolicy11; break;
case DRV_RATE_22M: Rate = txPolicy22; break;
case DRV_RATE_6M: Rate = txPolicy6; break;
case DRV_RATE_9M: Rate = txPolicy9; break;
case DRV_RATE_12M: Rate = txPolicy12; break;
case DRV_RATE_18M: Rate = txPolicy18; break;
case DRV_RATE_24M: Rate = txPolicy24; break;
case DRV_RATE_36M: Rate = txPolicy36; break;
case DRV_RATE_48M: Rate = txPolicy48; break;
case DRV_RATE_54M: Rate = txPolicy54; break;
case DRV_RATE_MCS_0: Rate = txPolicyMcs0; break;
case DRV_RATE_MCS_1: Rate = txPolicyMcs1; break;
case DRV_RATE_MCS_2: Rate = txPolicyMcs2; break;
case DRV_RATE_MCS_3: Rate = txPolicyMcs3; break;
case DRV_RATE_MCS_4: Rate = txPolicyMcs4; break;
case DRV_RATE_MCS_5: Rate = txPolicyMcs5; break;
case DRV_RATE_MCS_6: Rate = txPolicyMcs6; break;
case DRV_RATE_MCS_7: Rate = txPolicyMcs7; break;
default:
WLAN_OS_REPORT(("%s wrong app rate = %d\n",__FUNCTION__,AppRate));
status = TI_NOK;
break;
}
if (status == TI_OK)
*pHwRate = Rate;
else
*pHwRate = txPolicy1;
return status;
}
TI_STATUS cmdBld_SetRxFilter (TI_HANDLE hCmdBld, TI_UINT32 uRxConfigOption, TI_UINT32 uRxFilterOption)
{
DB_WLAN(hCmdBld).RxConfigOption = uRxConfigOption;
DB_WLAN(hCmdBld).RxFilterOption = uRxFilterOption;
DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_ENABLE_PHY_HEADER_PLCP;
if (DB_WLAN(hCmdBld).RxDisableBroadcast)
{
DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_DISABLE_BCAST;
}
return TI_OK;
}
TI_UINT8 cmdBld_GetBssType (TI_HANDLE hCmdBld)
{
return DB_BSS(hCmdBld).ReqBssType;
}
TI_UINT32 cmdBld_GetAckPolicy (TI_HANDLE hCmdBld, TI_UINT32 uQueueId)
{
return (TI_UINT32)DB_QUEUES(hCmdBld).queues[uQueueId].ackPolicy;
}
TI_STATUS cmdBld_SetSecuritySeqNum (TI_HANDLE hCmdBld, TI_UINT8 securitySeqNumLsByte)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
/* If 8 lsb wrap around occurred (new < old). */
if ((TI_UINT16)securitySeqNumLsByte < (pCmdBld->uSecuritySeqNumLow & 0xFF))
{
/* Increment the upper byte of the 16 lsb. */
pCmdBld->uSecuritySeqNumLow += 0x100;
/* If 16 bit wrap around occurred, increment the upper 32 bit. */
if (!(pCmdBld->uSecuritySeqNumLow & 0xFF00))
pCmdBld->uSecuritySeqNumHigh++;
}
/* Save new sequence number 8 lsb (received from the FW). */
pCmdBld->uSecuritySeqNumLow &= 0xFF00;
pCmdBld->uSecuritySeqNumLow |= (TI_UINT16)securitySeqNumLsByte;
return TI_OK;
}
/****************************************************************************
* cmdBld_JoinCmpltForReconfigCb()
****************************************************************************
* DESCRIPTION: The Join-Complete callback used by the reconfig sequenc (see __cmd_start_join()).
* It restores the original Join-Complete CB and continues the sequence.
* It is needed so the reconfig sequence won't progress before the Join
* command is completed (otherwise the FW may drop the other commands).
*
* INPUTS: hCmdBld - The module object
*
* OUTPUT: None
*
* RETURNS: TI_OK
****************************************************************************/
static TI_STATUS cmdBld_JoinCmpltForReconfigCb (TI_HANDLE hCmdBld)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
void *fDummyCb;
TI_HANDLE hDummyHndl;
/* Restored the original Join-Complete callback function */
eventMbox_ReplaceEvent (pCmdBld->hEventMbox,
TWD_OWN_EVENT_JOIN_CMPLT,
pCmdBld->fJoinCmpltOriginalCbFunc,
pCmdBld->hJoinCmpltOriginalCbHndl,
&fDummyCb,
&hDummyHndl);
/* Call the reconfig sequence to continue the configuration after Join completion */
cmdBld_ConfigSeq (hCmdBld);
return TI_OK;
}
static TI_STATUS cmdBld_DummyCb (TI_HANDLE hCmdBld)
{
return TI_OK;
}
#ifdef TI_DBG
void cmdBld_DbgForceTemplatesRates (TI_HANDLE hCmdBld, TI_UINT32 uRateMask)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
pCmdBld->uDbgTemplatesRateMask = uRateMask;
}
#endif /* TI_DBG */