0
|
1 |
/*
|
|
2 |
* CmdBld.c
|
|
3 |
*
|
|
4 |
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
|
|
5 |
* All rights reserved.
|
|
6 |
*
|
|
7 |
* This program and the accompanying materials are made available under the
|
|
8 |
* terms of the Eclipse Public License v1.0 or BSD License which accompanies
|
|
9 |
* this distribution. The Eclipse Public License is available at
|
|
10 |
* http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.
|
|
11 |
*
|
|
12 |
* Redistribution and use in source and binary forms, with or without
|
|
13 |
* modification, are permitted provided that the following conditions
|
|
14 |
* are met:
|
|
15 |
*
|
|
16 |
* * Redistributions of source code must retain the above copyright
|
|
17 |
* notice, this list of conditions and the following disclaimer.
|
|
18 |
* * Redistributions in binary form must reproduce the above copyright
|
|
19 |
* notice, this list of conditions and the following disclaimer in
|
|
20 |
* the documentation and/or other materials provided with the
|
|
21 |
* distribution.
|
|
22 |
* * Neither the name Texas Instruments nor the names of its
|
|
23 |
* contributors may be used to endorse or promote products derived
|
|
24 |
* from this software without specific prior written permission.
|
|
25 |
*
|
|
26 |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
27 |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
28 |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
29 |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
30 |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
31 |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
32 |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
33 |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
34 |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
35 |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
36 |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
37 |
*/
|
|
38 |
|
|
39 |
|
|
40 |
/** \file CmdBld.c
|
|
41 |
* \brief Command builder main
|
|
42 |
*
|
|
43 |
* \see CmdBld.h
|
|
44 |
*/
|
|
45 |
#define __FILE_ID__ FILE_ID_90
|
|
46 |
#include "TWDriver.h"
|
|
47 |
#include "osApi.h"
|
|
48 |
#include "tidef.h"
|
|
49 |
#include "report.h"
|
|
50 |
#include "public_infoele.h"
|
|
51 |
#include "CmdBld.h"
|
|
52 |
#include "txResult_api.h"
|
|
53 |
#include "CmdBldCmdIE.h"
|
|
54 |
#include "CmdBldCfgIE.h"
|
|
55 |
#include "CmdBldItrIE.h"
|
|
56 |
#include "CmdQueue_api.h"
|
|
57 |
#include "eventMbox_api.h"
|
|
58 |
#include "TWDriverInternal.h"
|
|
59 |
#include "HwInit_api.h"
|
|
60 |
|
|
61 |
#define DEFAULT_TRACE_ENABLE 0
|
|
62 |
#define DEFAULT_TRACE_OUT 0
|
|
63 |
|
|
64 |
#define DEFAULT_PBCC_DYNAMIC_ENABLE_VAL 0
|
|
65 |
#define DEFAULT_PBCC_DYNAMIC_INTERVAL 500
|
|
66 |
#define DEFAULT_PBCC_DYNAMIC_IGNORE_MCAST 0
|
|
67 |
|
|
68 |
#define DEFAULT_HW_RADIO_CHANNEL 11
|
|
69 |
|
|
70 |
#define DEFAULT_CW_MIN 15
|
|
71 |
|
|
72 |
#define DEFAULT_USE_DEVICE_ERROR_INTERRUPT 1
|
|
73 |
|
|
74 |
#define DEFAULT_UCAST_PRIORITY 0
|
|
75 |
|
|
76 |
#define DEFAULT_NUM_STATIONS 1
|
|
77 |
|
|
78 |
/* only for AP */
|
|
79 |
/* 8 increase number of BC frames */
|
|
80 |
#define DEFAULT_NUM_BCAST_TX_DESC 16
|
|
81 |
|
|
82 |
#define DEFAULT_BCAST_PRIORITY 0x81
|
|
83 |
|
|
84 |
/* hw access method*/
|
|
85 |
typedef enum
|
|
86 |
{
|
|
87 |
HW_ACCESS_BUS_SLAVE_INDIRECT = 0,
|
|
88 |
HW_ACCESS_BUS_SLAVE_DIRECT = 1,
|
|
89 |
HW_ACCESS_BUS_MASTER = 2
|
|
90 |
|
|
91 |
} EHwAccessMethod;
|
|
92 |
|
|
93 |
typedef int (*TConfigFwCb) (TI_HANDLE, TI_STATUS);
|
|
94 |
|
|
95 |
|
|
96 |
static TI_STATUS cmdBld_ConfigSeq (TI_HANDLE hCmdBld);
|
|
97 |
static TI_STATUS cmdBld_GetCurrentAssociationId (TI_HANDLE hCmdBld, TI_UINT16 *pAidVal);
|
|
98 |
static TI_STATUS cmdBld_GetArpIpAddressesTable (TI_HANDLE hCmdBld, TIpAddr *pIpAddr, TI_UINT8 *pEnabled , EIpVer *pIpVer);
|
|
99 |
static TI_STATUS cmdBld_JoinCmpltForReconfigCb (TI_HANDLE hCmdBld);
|
|
100 |
static TI_STATUS cmdBld_DummyCb (TI_HANDLE hCmdBld);
|
|
101 |
|
|
102 |
|
|
103 |
|
|
104 |
|
|
105 |
TI_HANDLE cmdBld_Create (TI_HANDLE hOs)
|
|
106 |
{
|
|
107 |
TCmdBld *pCmdBld;
|
|
108 |
TI_UINT32 uNumOfStations;
|
|
109 |
TI_UINT32 i;
|
|
110 |
|
|
111 |
/* Allocate the command builder */
|
|
112 |
pCmdBld = (TCmdBld *)os_memoryAlloc (hOs, sizeof(TCmdBld),MemoryNormal);
|
|
113 |
if (pCmdBld == NULL)
|
|
114 |
{
|
|
115 |
WLAN_OS_REPORT(("cmdBld_Create: Error memory allocation\n"));
|
|
116 |
return NULL;
|
|
117 |
}
|
|
118 |
os_memoryZero (hOs, (void *)pCmdBld, sizeof(TCmdBld));
|
|
119 |
|
|
120 |
pCmdBld->hOs = hOs;
|
|
121 |
|
|
122 |
/* Create the Params object */
|
|
123 |
/* make this code flat, move it to configure */
|
|
124 |
{
|
|
125 |
TWlanParams *pWlanParams = &DB_WLAN(pCmdBld);
|
|
126 |
TDmaParams *pDmaParams = &DB_DMA(pCmdBld);
|
|
127 |
TBssInfoParams *pBssInfoParams = &DB_BSS(pCmdBld);
|
|
128 |
TGenCounters *pGenCounters = &DB_CNT(pCmdBld);
|
|
129 |
|
|
130 |
/* General counters */
|
|
131 |
pGenCounters->FcsErrCnt = 0;
|
|
132 |
|
|
133 |
/* BSS info paramaters */
|
|
134 |
pBssInfoParams->RadioChannel = DEFAULT_HW_RADIO_CHANNEL;
|
|
135 |
pBssInfoParams->Ctrl = 0;
|
|
136 |
/*
|
|
137 |
* Intilaize the ctrl field in the BSS join structure
|
|
138 |
* Only bit_7 in the ctrl field is vurrently in use.
|
|
139 |
* If bit_7 is on => Doing Tx flash before joining new AP
|
|
140 |
*/
|
|
141 |
pBssInfoParams->Ctrl |= JOIN_CMD_CTRL_TX_FLUSH;
|
|
142 |
|
|
143 |
/* WLAN parameters*/
|
|
144 |
|
|
145 |
/* Init filters as station (start/join with BssType will overwrite the values) */
|
|
146 |
cmdBld_SetRxFilter ((TI_HANDLE)pCmdBld, RX_CONFIG_OPTION_MY_DST_MY_BSS, RX_FILTER_OPTION_FILTER_ALL);
|
|
147 |
pWlanParams->UseDeviceErrorInterrupt = DEFAULT_USE_DEVICE_ERROR_INTERRUPT;
|
|
148 |
/* Initialize the params object database fields */
|
|
149 |
pWlanParams->hwAccessMethod = HW_ACCESS_BUS_SLAVE_INDIRECT;
|
|
150 |
pWlanParams->maxSitesFragCollect = TWD_SITE_FRAG_COLLECT_DEF;
|
|
151 |
pWlanParams->RtsThreshold = TWD_RTS_THRESHOLD_DEF;
|
|
152 |
pWlanParams->bJoin = TI_FALSE;
|
|
153 |
/* Soft Gemini defaults */
|
|
154 |
pWlanParams->SoftGeminiEnable = SG_DISABLE;
|
|
155 |
/* Beacon filter defaults */
|
|
156 |
pWlanParams->beaconFilterParams.desiredState = TI_FALSE;
|
|
157 |
pWlanParams->beaconFilterParams.numOfElements = DEF_NUM_STORED_FILTERS;
|
|
158 |
pWlanParams->beaconFilterIETable.numberOfIEs = DEF_BEACON_FILTER_IE_TABLE_NUM;
|
|
159 |
pWlanParams->beaconFilterIETable.IETableSize = BEACON_FILTER_IE_TABLE_DEF_SIZE;
|
|
160 |
/* Roaming parameters */
|
|
161 |
pWlanParams->roamTriggers.BssLossTimeout = NO_BEACON_DEFAULT_TIMEOUT;
|
|
162 |
pWlanParams->roamTriggers.TsfMissThreshold = OUT_OF_SYNC_DEFAULT_THRESHOLD;
|
|
163 |
/* CoexActivity table */
|
|
164 |
pWlanParams->tWlanParamsCoexActivityTable.numOfElements = COEX_ACTIVITY_TABLE_DEF_NUM;
|
|
165 |
|
|
166 |
/* DMA parameters */
|
|
167 |
/* Initialize the Params object database fields*/
|
|
168 |
pDmaParams->NumStations = DEFAULT_NUM_STATIONS;
|
|
169 |
uNumOfStations = (TI_UINT32)pDmaParams->NumStations;
|
|
170 |
/*
|
|
171 |
* loop an all rssi_snr triggers and initialize only index number.
|
|
172 |
* Reason: 'index' not initialized --> 'index = 0' --> triggers 1..7 will overrun trigger '0' in cmdBld_ConfigSeq
|
|
173 |
*/
|
|
174 |
for (i = 0; i < NUM_OF_RSSI_SNR_TRIGGERS ; i++)
|
|
175 |
{
|
|
176 |
pWlanParams->tRssiSnrTrigger[i].index = i;
|
|
177 |
}
|
|
178 |
}
|
|
179 |
|
|
180 |
pCmdBld->uLastElpCtrlMode = ELPCTRL_MODE_NORMAL;
|
|
181 |
|
|
182 |
/* Create security objects */
|
|
183 |
pCmdBld->tSecurity.eSecurityMode = TWD_CIPHER_NONE;
|
|
184 |
pCmdBld->tSecurity.uNumOfStations = uNumOfStations;
|
|
185 |
DB_KEYS(pCmdBld).pReconfKeys = (TSecurityKeys*)os_memoryAlloc (hOs,
|
|
186 |
sizeof(TSecurityKeys) * (uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS),MemoryNormal);
|
|
187 |
os_memoryZero (hOs,
|
|
188 |
(void *)(DB_KEYS(pCmdBld).pReconfKeys),
|
|
189 |
sizeof(TSecurityKeys) * (uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS));
|
|
190 |
|
|
191 |
|
|
192 |
WLAN_INIT_REPORT(("cmdBld_Create end %x\n",(TI_HANDLE)pCmdBld));
|
|
193 |
|
|
194 |
return (TI_HANDLE)pCmdBld;
|
|
195 |
}
|
|
196 |
|
|
197 |
|
|
198 |
TI_STATUS cmdBld_Destroy (TI_HANDLE hCmdBld)
|
|
199 |
{
|
|
200 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
201 |
TDmaParams *pDmaParams = NULL;
|
|
202 |
TI_UINT32 uNumOfStations;
|
|
203 |
|
|
204 |
if (pCmdBld == NULL)
|
|
205 |
{
|
|
206 |
return TI_OK;
|
|
207 |
}
|
|
208 |
|
|
209 |
pDmaParams = &DB_DMA(hCmdBld);
|
|
210 |
|
|
211 |
uNumOfStations = (TI_UINT32)pDmaParams->NumStations;
|
|
212 |
|
|
213 |
if (DB_KEYS(pCmdBld).pReconfKeys)
|
|
214 |
{
|
|
215 |
os_memoryFree (pCmdBld->hOs,
|
|
216 |
DB_KEYS(pCmdBld).pReconfKeys,
|
|
217 |
sizeof(TSecurityKeys) * (uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS));
|
|
218 |
}
|
|
219 |
|
|
220 |
/* free the whalCtrl data structure */
|
|
221 |
os_memoryFree (pCmdBld->hOs, pCmdBld, sizeof(TCmdBld));
|
|
222 |
|
|
223 |
return TI_OK;
|
|
224 |
}
|
|
225 |
|
|
226 |
TI_STATUS cmdBld_Restart (TI_HANDLE hCmdBld)
|
|
227 |
{
|
|
228 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
229 |
|
|
230 |
/* This init is for recovery stage */
|
|
231 |
pCmdBld->uLastElpCtrlMode = ELPCTRL_MODE_NORMAL;
|
|
232 |
|
|
233 |
/*
|
|
234 |
* This call is to have the recovery process in AWAKE mode
|
|
235 |
* Prevent move to sleep mode between Hw_Init and Fw_Init
|
|
236 |
*/
|
|
237 |
cmdBld_CfgIeSleepAuth (hCmdBld, DB_WLAN(hCmdBld).minPowerLevel, NULL, NULL);
|
|
238 |
|
|
239 |
return TI_OK;
|
|
240 |
}
|
|
241 |
|
|
242 |
TI_STATUS cmdBld_Config (TI_HANDLE hCmdBld,
|
|
243 |
TI_HANDLE hReport,
|
|
244 |
void *fFinalizeDownload,
|
|
245 |
TI_HANDLE hFinalizeDownload,
|
|
246 |
TI_HANDLE hEventMbox,
|
|
247 |
TI_HANDLE hCmdQueue,
|
|
248 |
TI_HANDLE hTwIf)
|
|
249 |
{
|
|
250 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
251 |
TI_UINT32 index;
|
|
252 |
|
|
253 |
pCmdBld->hReport = hReport;
|
|
254 |
pCmdBld->fFinalizeDownload = fFinalizeDownload;
|
|
255 |
pCmdBld->hFinalizeDownload = hFinalizeDownload;
|
|
256 |
pCmdBld->hEventMbox = hEventMbox;
|
|
257 |
pCmdBld->hCmdQueue = hCmdQueue;
|
|
258 |
pCmdBld->hTwIf = hTwIf;
|
|
259 |
|
|
260 |
/* Reset all reconfig valid fields*/
|
|
261 |
DB_KEYS(pCmdBld).bHwEncDecrEnableValid = TI_FALSE;
|
|
262 |
DB_KEYS(pCmdBld).bDefaultKeyIdValid = TI_FALSE;
|
|
263 |
for (index = 0;
|
|
264 |
index < pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS;
|
|
265 |
index++)
|
|
266 |
(DB_KEYS(pCmdBld).pReconfKeys + index)->keyType = KEY_NULL;
|
|
267 |
|
|
268 |
|
|
269 |
return TI_OK;
|
|
270 |
}
|
|
271 |
|
|
272 |
|
|
273 |
|
|
274 |
static void cmdBld_ConfigFwCb (TI_HANDLE hCmdBld, TI_STATUS status, void *pData)
|
|
275 |
{
|
|
276 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
277 |
MemoryMap_t *pMemMap = &pCmdBld->tMemMap;
|
|
278 |
TDmaParams *pDmaParams = &DB_DMA(hCmdBld);
|
|
279 |
|
|
280 |
/* Arrived from callback */
|
|
281 |
if (pData)
|
|
282 |
{
|
|
283 |
TI_UINT32 *pSwap, i, uMemMapNumFields;
|
|
284 |
|
|
285 |
/* Solve endian problem (all fields are 32 bit) */
|
|
286 |
uMemMapNumFields = (sizeof(MemoryMap_t) - sizeof(EleHdrStruct)) % 4;
|
|
287 |
pSwap = (TI_UINT32* )&(pMemMap->codeStart);
|
|
288 |
for (i = 0; i < uMemMapNumFields; i++)
|
|
289 |
{
|
|
290 |
pSwap[i] = ENDIAN_HANDLE_LONG(pSwap[i]);
|
|
291 |
}
|
|
292 |
}
|
|
293 |
|
|
294 |
/* Save number of TX blocks */
|
|
295 |
pDmaParams->NumTxBlocks = pMemMap->numTxMemBlks;
|
|
296 |
/* Firmware Control block is internally pointing to TxResultInterface structure */
|
|
297 |
pDmaParams->fwTxResultInterface = pMemMap->trqBlock.controlBlock;
|
|
298 |
pDmaParams->fwRxCBufPtr = pMemMap->rxCBufPtr;
|
|
299 |
pDmaParams->fwTxCBufPtr = pMemMap->txCBufPtr;
|
|
300 |
pDmaParams->fwRxControlPtr = pMemMap->rxControlPtr;
|
|
301 |
pDmaParams->fwTxControlPtr = pMemMap->txControlPtr;
|
|
302 |
|
|
303 |
pDmaParams->PacketMemoryPoolStart = (TI_UINT32)pMemMap->packetMemoryPoolStart;
|
|
304 |
|
|
305 |
/* Call the upper layer callback */
|
|
306 |
(*((TConfigFwCb)pCmdBld->fConfigFwCb)) (pCmdBld->hConfigFwCb, TI_OK);
|
|
307 |
}
|
|
308 |
|
|
309 |
|
|
310 |
/****************************************************************************
|
|
311 |
* cmdBld_ConfigFw()
|
|
312 |
****************************************************************************
|
|
313 |
* DESCRIPTION: Configure the WLAN firmware
|
|
314 |
*
|
|
315 |
* INPUTS: None
|
|
316 |
*
|
|
317 |
* OUTPUT: None
|
|
318 |
*
|
|
319 |
* RETURNS: TI_OK or TI_NOK
|
|
320 |
****************************************************************************/
|
|
321 |
TI_STATUS cmdBld_ConfigFw (TI_HANDLE hCmdBld, void *fConfigFwCb, TI_HANDLE hConfigFwCb)
|
|
322 |
{
|
|
323 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
324 |
|
|
325 |
pCmdBld->fConfigFwCb = fConfigFwCb;
|
|
326 |
pCmdBld->hConfigFwCb = hConfigFwCb;
|
|
327 |
pCmdBld->uIniSeq = 0;
|
|
328 |
/* should be re-initialized for recovery, pCmdBld->uLastElpCtrlMode = ELPCTRL_MODE_KEEP_AWAKE; */
|
|
329 |
|
|
330 |
/* Start configuration sequence */
|
|
331 |
return cmdBld_ConfigSeq (hCmdBld);
|
|
332 |
}
|
|
333 |
|
|
334 |
|
|
335 |
typedef TI_STATUS (*TCmdCfgFunc) (TI_HANDLE);
|
|
336 |
|
|
337 |
|
|
338 |
static TI_STATUS __cmd_probe_req (TI_HANDLE hCmdBld)
|
|
339 |
{
|
|
340 |
TI_STATUS tStatus = TI_OK;
|
|
341 |
|
|
342 |
/* keep space for 2.4 GHz probe request */
|
|
343 |
tStatus = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
344 |
NULL,
|
|
345 |
DB_WLAN(hCmdBld).probeRequestTemplateSize,
|
|
346 |
CFG_TEMPLATE_PROBE_REQ_2_4,
|
|
347 |
0,
|
|
348 |
NULL,
|
|
349 |
NULL);
|
|
350 |
if (TI_OK != tStatus)
|
|
351 |
{
|
|
352 |
return tStatus;
|
|
353 |
}
|
|
354 |
|
|
355 |
/* keep space for 5.0 GHz probe request */
|
|
356 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
357 |
NULL,
|
|
358 |
DB_WLAN(hCmdBld).probeRequestTemplateSize,
|
|
359 |
CFG_TEMPLATE_PROBE_REQ_5,
|
|
360 |
0,
|
|
361 |
(void *)cmdBld_ConfigSeq,
|
|
362 |
hCmdBld);
|
|
363 |
}
|
|
364 |
|
|
365 |
|
|
366 |
static TI_STATUS __cmd_null_data (TI_HANDLE hCmdBld)
|
|
367 |
{
|
|
368 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
369 |
NULL,
|
|
370 |
DB_WLAN(hCmdBld).nullTemplateSize,
|
|
371 |
TEMPLATE_NULL_DATA,
|
|
372 |
0,
|
|
373 |
(void *)cmdBld_ConfigSeq,
|
|
374 |
hCmdBld);
|
|
375 |
}
|
|
376 |
|
|
377 |
static TI_STATUS __cmd_burst_mode_enable (TI_HANDLE hCmdBld)
|
|
378 |
{
|
|
379 |
return cmdBld_CfgIeBurstMode (hCmdBld,
|
|
380 |
DB_AC(hCmdBld).isBurstModeEnabled,
|
|
381 |
(void *)cmdBld_ConfigSeq,
|
|
382 |
hCmdBld);
|
|
383 |
}
|
|
384 |
|
|
385 |
/*
|
|
386 |
static TI_STATUS __cmd_smart_reflex_debug (TI_HANDLE hCmdBld)
|
|
387 |
{
|
|
388 |
return cmdBld_CfgIeSRDebug (hCmdBld,
|
|
389 |
&(DB_SR(hCmdBld).tSmartReflexDebugParams),
|
|
390 |
(void *)cmdBld_ConfigSeq,
|
|
391 |
hCmdBld);
|
|
392 |
}
|
|
393 |
|
|
394 |
|
|
395 |
static TI_STATUS __cmd_smart_reflex_state (TI_HANDLE hCmdBld)
|
|
396 |
{
|
|
397 |
return cmdBld_CfgIeSRState (hCmdBld,
|
|
398 |
(uint8) DB_SR(hCmdBld).tSmartReflexState.enable,
|
|
399 |
(void *)cmdBld_ConfigSeq,
|
|
400 |
hCmdBld);
|
|
401 |
}
|
|
402 |
*/
|
|
403 |
static TI_STATUS __cmd_disconn (TI_HANDLE hCmdBld)
|
|
404 |
{
|
|
405 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
406 |
NULL,
|
|
407 |
DB_WLAN(hCmdBld).disconnTemplateSize,
|
|
408 |
TEMPLATE_DISCONNECT,
|
|
409 |
0,
|
|
410 |
(void *)cmdBld_ConfigSeq,
|
|
411 |
hCmdBld);
|
|
412 |
}
|
|
413 |
|
|
414 |
static TI_STATUS __cmd_ps_poll (TI_HANDLE hCmdBld)
|
|
415 |
{
|
|
416 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
417 |
NULL,
|
|
418 |
DB_WLAN(hCmdBld).PsPollTemplateSize,
|
|
419 |
TEMPLATE_PS_POLL,
|
|
420 |
0,
|
|
421 |
(void *)cmdBld_ConfigSeq,
|
|
422 |
hCmdBld);
|
|
423 |
}
|
|
424 |
|
|
425 |
|
|
426 |
static TI_STATUS __cmd_qos_null_data (TI_HANDLE hCmdBld)
|
|
427 |
{
|
|
428 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
429 |
NULL,
|
|
430 |
DB_WLAN(hCmdBld).qosNullDataTemplateSize,
|
|
431 |
TEMPLATE_QOS_NULL_DATA,
|
|
432 |
0,
|
|
433 |
(void *)cmdBld_ConfigSeq,
|
|
434 |
hCmdBld);
|
|
435 |
}
|
|
436 |
|
|
437 |
|
|
438 |
static TI_STATUS __cmd_probe_resp (TI_HANDLE hCmdBld)
|
|
439 |
{
|
|
440 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
441 |
NULL,
|
|
442 |
DB_WLAN(hCmdBld).probeResponseTemplateSize,
|
|
443 |
TEMPLATE_PROBE_RESPONSE,
|
|
444 |
0,
|
|
445 |
(void *)cmdBld_ConfigSeq,
|
|
446 |
hCmdBld);
|
|
447 |
}
|
|
448 |
|
|
449 |
|
|
450 |
static TI_STATUS __cmd_beacon (TI_HANDLE hCmdBld)
|
|
451 |
{
|
|
452 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
453 |
NULL,
|
|
454 |
DB_WLAN(hCmdBld).beaconTemplateSize,
|
|
455 |
TEMPLATE_BEACON,
|
|
456 |
0,
|
|
457 |
(void *)cmdBld_ConfigSeq,
|
|
458 |
hCmdBld);
|
|
459 |
}
|
|
460 |
|
|
461 |
static TI_STATUS __cmd_keep_alive_tmpl (TI_HANDLE hCmdBld)
|
|
462 |
{
|
|
463 |
TI_UINT32 index;
|
|
464 |
TI_STATUS status = TI_NOK;
|
|
465 |
|
|
466 |
/*
|
|
467 |
* config templates
|
|
468 |
* fisr configure all indexes but the last one with no CB, and than configure the last one
|
|
469 |
* with a CB to continue configuration.
|
|
470 |
*/
|
|
471 |
for (index = 0; index < KLV_MAX_TMPL_NUM - 1; index++)
|
|
472 |
{
|
|
473 |
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
474 |
NULL,
|
|
475 |
MAX_TEMPLATES_SIZE,
|
|
476 |
TEMPLATE_KLV,
|
|
477 |
index,
|
|
478 |
NULL,
|
|
479 |
NULL);
|
|
480 |
if (TI_OK != status)
|
|
481 |
{
|
|
482 |
return status;
|
|
483 |
}
|
|
484 |
}
|
|
485 |
|
|
486 |
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
487 |
NULL,
|
|
488 |
MAX_TEMPLATES_SIZE,
|
|
489 |
TEMPLATE_KLV,
|
|
490 |
index,
|
|
491 |
(void *)cmdBld_ConfigSeq,
|
|
492 |
hCmdBld);
|
|
493 |
|
|
494 |
return status;
|
|
495 |
}
|
|
496 |
|
|
497 |
|
|
498 |
static TI_STATUS __cfg_mem (TI_HANDLE hCmdBld)
|
|
499 |
{
|
|
500 |
/* Configure the weight among the different hardware queues */
|
|
501 |
return cmdBld_CfgIeConfigMemory (hCmdBld, &DB_DMA(hCmdBld), (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
502 |
}
|
|
503 |
|
|
504 |
|
|
505 |
static TI_STATUS __cfg_rx_msdu_life_time (TI_HANDLE hCmdBld)
|
|
506 |
{
|
|
507 |
/* Configure the Rx Msdu Life Time (expiry time of de-fragmentation in FW) */
|
|
508 |
return cmdBld_CfgIeRxMsduLifeTime (hCmdBld,
|
|
509 |
DB_WLAN(hCmdBld).MaxRxMsduLifetime,
|
|
510 |
(void *)cmdBld_ConfigSeq,
|
|
511 |
hCmdBld);
|
|
512 |
}
|
|
513 |
|
|
514 |
|
|
515 |
static TI_STATUS __cfg_rx (TI_HANDLE hCmdBld)
|
|
516 |
{
|
|
517 |
return cmdBld_CfgIeRx (hCmdBld,
|
|
518 |
DB_WLAN(hCmdBld).RxConfigOption,
|
|
519 |
DB_WLAN(hCmdBld).RxFilterOption,
|
|
520 |
(void *)cmdBld_ConfigSeq,
|
|
521 |
hCmdBld);
|
|
522 |
}
|
|
523 |
|
|
524 |
|
|
525 |
static TI_STATUS __cfg_ac_params_0 (TI_HANDLE hCmdBld)
|
|
526 |
{
|
|
527 |
/*
|
|
528 |
* NOTE: Set following parameter only if configured.
|
|
529 |
* Otherwise, is contains garbage.
|
|
530 |
*/
|
|
531 |
|
|
532 |
if (DB_AC(hCmdBld).isAcConfigured[0])
|
|
533 |
{
|
|
534 |
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[0], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
535 |
}
|
|
536 |
else
|
|
537 |
{
|
|
538 |
return TI_NOK;
|
|
539 |
}
|
|
540 |
}
|
|
541 |
|
|
542 |
|
|
543 |
static TI_STATUS __cfg_ac_params_1 (TI_HANDLE hCmdBld)
|
|
544 |
{
|
|
545 |
/*
|
|
546 |
* NOTE: Set following parameter only if configured.
|
|
547 |
* Otherwise, is contains garbage.
|
|
548 |
*/
|
|
549 |
|
|
550 |
if (DB_AC(hCmdBld).isAcConfigured[1])
|
|
551 |
{
|
|
552 |
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[1], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
553 |
}
|
|
554 |
else
|
|
555 |
{
|
|
556 |
return TI_NOK;
|
|
557 |
}
|
|
558 |
}
|
|
559 |
|
|
560 |
|
|
561 |
static TI_STATUS __cfg_ac_params_2 (TI_HANDLE hCmdBld)
|
|
562 |
{
|
|
563 |
/*
|
|
564 |
* NOTE: Set following parameter only if configured.
|
|
565 |
* Otherwise, is contains garbage.
|
|
566 |
*/
|
|
567 |
|
|
568 |
if (DB_AC(hCmdBld).isAcConfigured[2])
|
|
569 |
{
|
|
570 |
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[2], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
571 |
}
|
|
572 |
else
|
|
573 |
{
|
|
574 |
return TI_NOK;
|
|
575 |
}
|
|
576 |
}
|
|
577 |
|
|
578 |
|
|
579 |
static TI_STATUS __cfg_ac_params_3 (TI_HANDLE hCmdBld)
|
|
580 |
{
|
|
581 |
/*
|
|
582 |
* NOTE: Set following parameter only if configured.
|
|
583 |
* Otherwise, is contains garbage.
|
|
584 |
*/
|
|
585 |
|
|
586 |
if (DB_AC(hCmdBld).isAcConfigured[3])
|
|
587 |
{
|
|
588 |
return cmdBld_CfgAcParams (hCmdBld, &DB_AC(hCmdBld).ac[3], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
589 |
}
|
|
590 |
else
|
|
591 |
{
|
|
592 |
return TI_NOK;
|
|
593 |
}
|
|
594 |
}
|
|
595 |
|
|
596 |
|
|
597 |
static TI_STATUS __cfg_tid_0 (TI_HANDLE hCmdBld)
|
|
598 |
{
|
|
599 |
/*
|
|
600 |
* NOTE: Set following parameter only if configured.
|
|
601 |
* Otherwise, is contains garbage.
|
|
602 |
*/
|
|
603 |
if (DB_QUEUES(hCmdBld).isQueueConfigured[0])
|
|
604 |
{
|
|
605 |
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[0], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
606 |
}
|
|
607 |
else
|
|
608 |
{
|
|
609 |
return TI_NOK;
|
|
610 |
}
|
|
611 |
}
|
|
612 |
|
|
613 |
|
|
614 |
static TI_STATUS __cfg_tid_1 (TI_HANDLE hCmdBld)
|
|
615 |
{
|
|
616 |
/*
|
|
617 |
* NOTE: Set following parameter only if configured.
|
|
618 |
* Otherwise, is contains garbage.
|
|
619 |
*/
|
|
620 |
if (DB_QUEUES(hCmdBld).isQueueConfigured[1])
|
|
621 |
{
|
|
622 |
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[1], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
623 |
}
|
|
624 |
else
|
|
625 |
{
|
|
626 |
return TI_NOK;
|
|
627 |
}
|
|
628 |
}
|
|
629 |
|
|
630 |
|
|
631 |
static TI_STATUS __cfg_tid_2 (TI_HANDLE hCmdBld)
|
|
632 |
{
|
|
633 |
/*
|
|
634 |
* NOTE: Set following parameter only if configured.
|
|
635 |
* Otherwise, is contains garbage.
|
|
636 |
*/
|
|
637 |
if (DB_QUEUES(hCmdBld).isQueueConfigured[2])
|
|
638 |
{
|
|
639 |
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[2], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
640 |
}
|
|
641 |
else
|
|
642 |
{
|
|
643 |
return TI_NOK;
|
|
644 |
}
|
|
645 |
}
|
|
646 |
|
|
647 |
|
|
648 |
static TI_STATUS __cfg_tid_3 (TI_HANDLE hCmdBld)
|
|
649 |
{
|
|
650 |
/*
|
|
651 |
* NOTE: Set following parameter only if configured.
|
|
652 |
* Otherwise, is contains garbage.
|
|
653 |
*/
|
|
654 |
if (DB_QUEUES(hCmdBld).isQueueConfigured[3])
|
|
655 |
{
|
|
656 |
return cmdBld_CfgTid (hCmdBld, &DB_QUEUES(hCmdBld).queues[3], (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
657 |
}
|
|
658 |
else
|
|
659 |
{
|
|
660 |
return TI_NOK;
|
|
661 |
}
|
|
662 |
}
|
|
663 |
|
|
664 |
|
|
665 |
static TI_STATUS __cfg_ps_rx_streaming (TI_HANDLE hCmdBld)
|
|
666 |
{
|
|
667 |
TI_UINT32 index;
|
|
668 |
TI_STATUS eStatus;
|
|
669 |
TPsRxStreaming *pPsRxStreaming;
|
|
670 |
|
|
671 |
|
|
672 |
if (!DB_WLAN(hCmdBld).bJoin)
|
|
673 |
{
|
|
674 |
return TI_NOK;
|
|
675 |
}
|
|
676 |
|
|
677 |
/* Config enabled streams (disable is the FW default). */
|
|
678 |
for (index = 0; index < MAX_NUM_OF_802_1d_TAGS - 1; index++)
|
|
679 |
{
|
|
680 |
pPsRxStreaming = &(DB_PS_STREAM(hCmdBld).tid[index]);
|
|
681 |
|
|
682 |
if (pPsRxStreaming->bEnabled)
|
|
683 |
{
|
|
684 |
eStatus = cmdBld_CfgPsRxStreaming (hCmdBld, pPsRxStreaming, NULL, NULL);
|
|
685 |
if (eStatus != TI_OK)
|
|
686 |
{
|
|
687 |
return eStatus;
|
|
688 |
}
|
|
689 |
}
|
|
690 |
}
|
|
691 |
|
|
692 |
/* Set NOK for a case the following config is skipped, to indicate that no callback is expected */
|
|
693 |
eStatus = TI_NOK;
|
|
694 |
|
|
695 |
pPsRxStreaming = &(DB_PS_STREAM(hCmdBld).tid[MAX_NUM_OF_802_1d_TAGS - 1]);
|
|
696 |
if (pPsRxStreaming->bEnabled)
|
|
697 |
{
|
|
698 |
eStatus = cmdBld_CfgPsRxStreaming (hCmdBld, pPsRxStreaming, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
699 |
if (eStatus != TI_OK)
|
|
700 |
{
|
|
701 |
return eStatus;
|
|
702 |
}
|
|
703 |
}
|
|
704 |
|
|
705 |
return eStatus;
|
|
706 |
}
|
|
707 |
|
|
708 |
|
|
709 |
static TI_STATUS __cfg_rx_data_filter (TI_HANDLE hCmdBld)
|
|
710 |
{
|
|
711 |
TI_UINT32 index;
|
|
712 |
TI_STATUS eStatus;
|
|
713 |
TRxDataFilter *pFilters;
|
|
714 |
|
|
715 |
|
|
716 |
if (DB_RX_DATA_FLTR(hCmdBld).bEnabled)
|
|
717 |
{
|
|
718 |
eStatus = cmdBld_CfgIeEnableRxDataFilter (hCmdBld,
|
|
719 |
DB_RX_DATA_FLTR(hCmdBld).bEnabled,
|
|
720 |
DB_RX_DATA_FLTR(hCmdBld).eDefaultAction,
|
|
721 |
NULL,
|
|
722 |
NULL);
|
|
723 |
if (eStatus != TI_OK)
|
|
724 |
{
|
|
725 |
return eStatus;
|
|
726 |
}
|
|
727 |
}
|
|
728 |
|
|
729 |
/*
|
|
730 |
* Config enabled filters (last one is separated to use the callback)
|
|
731 |
*/
|
|
732 |
for (index = 0; index < MAX_DATA_FILTERS - 1; index++)
|
|
733 |
{
|
|
734 |
pFilters = &(DB_RX_DATA_FLTR(hCmdBld).aRxDataFilter[index]);
|
|
735 |
|
|
736 |
if (pFilters->uCommand == ADD_FILTER)
|
|
737 |
{
|
|
738 |
eStatus = cmdBld_CfgIeRxDataFilter (hCmdBld,
|
|
739 |
pFilters->uIndex,
|
|
740 |
pFilters->uCommand,
|
|
741 |
pFilters->eAction,
|
|
742 |
pFilters->uNumFieldPatterns,
|
|
743 |
pFilters->uLenFieldPatterns,
|
|
744 |
pFilters->aFieldPattern,
|
|
745 |
NULL,
|
|
746 |
NULL);
|
|
747 |
if (eStatus != TI_OK)
|
|
748 |
{
|
|
749 |
return eStatus;
|
|
750 |
}
|
|
751 |
}
|
|
752 |
}
|
|
753 |
|
|
754 |
/* Set NOK for a case the following config is skipped, to indicate that no callback is expected */
|
|
755 |
eStatus = TI_NOK;
|
|
756 |
|
|
757 |
pFilters = &(DB_RX_DATA_FLTR(hCmdBld).aRxDataFilter[MAX_DATA_FILTERS - 1]);
|
|
758 |
if (pFilters->uCommand == ADD_FILTER)
|
|
759 |
{
|
|
760 |
eStatus = cmdBld_CfgIeRxDataFilter (hCmdBld,
|
|
761 |
pFilters->uIndex,
|
|
762 |
pFilters->uCommand,
|
|
763 |
pFilters->eAction,
|
|
764 |
pFilters->uNumFieldPatterns,
|
|
765 |
pFilters->uLenFieldPatterns,
|
|
766 |
pFilters->aFieldPattern,
|
|
767 |
(void *)cmdBld_ConfigSeq,
|
|
768 |
hCmdBld);
|
|
769 |
if (eStatus != TI_OK)
|
|
770 |
{
|
|
771 |
return eStatus;
|
|
772 |
}
|
|
773 |
}
|
|
774 |
|
|
775 |
return eStatus;
|
|
776 |
}
|
|
777 |
|
|
778 |
|
|
779 |
static TI_STATUS __cfg_pd_threshold (TI_HANDLE hCmdBld)
|
|
780 |
{
|
|
781 |
return cmdBld_CfgIePacketDetectionThreshold (hCmdBld,
|
|
782 |
DB_WLAN(hCmdBld).PacketDetectionThreshold,
|
|
783 |
(void *)cmdBld_ConfigSeq,
|
|
784 |
hCmdBld);
|
|
785 |
}
|
|
786 |
|
|
787 |
|
|
788 |
static TI_STATUS __cfg_slot_time (TI_HANDLE hCmdBld)
|
|
789 |
{
|
|
790 |
return cmdBld_CfgIeSlotTime (hCmdBld, DB_WLAN(hCmdBld).SlotTime, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
791 |
}
|
|
792 |
|
|
793 |
|
|
794 |
static TI_STATUS __cfg_arp_ip_filter (TI_HANDLE hCmdBld)
|
|
795 |
{
|
|
796 |
return cmdBld_CfgIeArpIpFilter (hCmdBld,
|
|
797 |
DB_WLAN(hCmdBld).arp_IP_addr,
|
|
798 |
(TI_BOOL)DB_WLAN(hCmdBld).isArpIpFilteringEnabled,
|
|
799 |
(void *)cmdBld_ConfigSeq,
|
|
800 |
hCmdBld);
|
|
801 |
}
|
|
802 |
|
|
803 |
static TI_STATUS __cfg_group_address_table (TI_HANDLE hCmdBld)
|
|
804 |
{
|
|
805 |
return cmdBld_CfgIeGroupAdressTable (hCmdBld,
|
|
806 |
DB_WLAN(hCmdBld).numGroupAddrs,
|
|
807 |
DB_WLAN(hCmdBld).aGroupAddr,
|
|
808 |
DB_WLAN(hCmdBld).isMacAddrFilteringnabled,
|
|
809 |
(void *)cmdBld_ConfigSeq,
|
|
810 |
hCmdBld);
|
|
811 |
}
|
|
812 |
|
|
813 |
|
|
814 |
static TI_STATUS __cfg_service_period_timeout (TI_HANDLE hCmdBld)
|
|
815 |
{
|
|
816 |
return cmdBld_CfgIeServicePeriodTimeout (hCmdBld,
|
|
817 |
&DB_WLAN(hCmdBld).rxTimeOut,
|
|
818 |
(void *)cmdBld_ConfigSeq,
|
|
819 |
hCmdBld);
|
|
820 |
}
|
|
821 |
|
|
822 |
|
|
823 |
static TI_STATUS __cfg_rts_threshold (TI_HANDLE hCmdBld)
|
|
824 |
{
|
|
825 |
return cmdBld_CfgRtsThreshold (hCmdBld,
|
|
826 |
DB_WLAN(hCmdBld).RtsThreshold,
|
|
827 |
(void *)cmdBld_ConfigSeq,
|
|
828 |
hCmdBld);
|
|
829 |
}
|
|
830 |
|
|
831 |
static TI_STATUS __cfg_dco_itrim_params (TI_HANDLE hCmdBld)
|
|
832 |
{
|
|
833 |
return cmdBld_CfgDcoItrimParams (hCmdBld,
|
|
834 |
DB_WLAN(hCmdBld).dcoItrimEnabled,
|
|
835 |
DB_WLAN(hCmdBld).dcoItrimModerationTimeoutUsec,
|
|
836 |
(void *)cmdBld_ConfigSeq,
|
|
837 |
hCmdBld);
|
|
838 |
}
|
|
839 |
|
|
840 |
static TI_STATUS __cfg_fragment_threshold (TI_HANDLE hCmdBld)
|
|
841 |
{
|
|
842 |
return cmdBld_CfgIeFragmentThreshold (hCmdBld,
|
|
843 |
DB_WLAN(hCmdBld).FragmentThreshold,
|
|
844 |
(void *)cmdBld_ConfigSeq,
|
|
845 |
hCmdBld);
|
|
846 |
}
|
|
847 |
|
|
848 |
|
|
849 |
static TI_STATUS __cfg_pm_config (TI_HANDLE hCmdBld)
|
|
850 |
{
|
|
851 |
return cmdBld_CfgIePmConfig (hCmdBld,
|
|
852 |
DB_WLAN(hCmdBld).uHostClkSettlingTime,
|
|
853 |
DB_WLAN(hCmdBld).uHostFastWakeupSupport,
|
|
854 |
(void *)cmdBld_ConfigSeq,
|
|
855 |
hCmdBld);
|
|
856 |
}
|
|
857 |
|
|
858 |
|
|
859 |
static TI_STATUS __cfg_beacon_filter_opt (TI_HANDLE hCmdBld)
|
|
860 |
{
|
|
861 |
/* Set The Beacon Filter in HAL */
|
|
862 |
return cmdBld_CfgIeBeaconFilterOpt (hCmdBld,
|
|
863 |
DB_WLAN(hCmdBld).beaconFilterParams.desiredState,
|
|
864 |
DB_WLAN(hCmdBld).beaconFilterParams.numOfElements,
|
|
865 |
(void *)cmdBld_ConfigSeq,
|
|
866 |
hCmdBld);
|
|
867 |
}
|
|
868 |
|
|
869 |
|
|
870 |
static TI_STATUS __cfg_beacon_filter_table (TI_HANDLE hCmdBld)
|
|
871 |
{
|
|
872 |
return cmdBld_CfgIeBeaconFilterTable (hCmdBld,
|
|
873 |
DB_WLAN(hCmdBld).beaconFilterIETable.numberOfIEs,
|
|
874 |
DB_WLAN(hCmdBld).beaconFilterIETable.IETable,
|
|
875 |
DB_WLAN(hCmdBld).beaconFilterIETable.IETableSize,
|
|
876 |
(void *)cmdBld_ConfigSeq,
|
|
877 |
hCmdBld);
|
|
878 |
}
|
|
879 |
|
|
880 |
|
|
881 |
static TI_STATUS __cfg_tx_cmplt_pacing (TI_HANDLE hCmdBld)
|
|
882 |
{
|
|
883 |
return cmdBld_CfgIeTxCmpltPacing (hCmdBld,
|
|
884 |
DB_WLAN(hCmdBld).TxCompletePacingThreshold,
|
|
885 |
DB_WLAN(hCmdBld).TxCompletePacingTimeout,
|
|
886 |
(void *)cmdBld_ConfigSeq,
|
|
887 |
hCmdBld);
|
|
888 |
}
|
|
889 |
|
|
890 |
|
|
891 |
static TI_STATUS __cfg_rx_intr_pacing (TI_HANDLE hCmdBld)
|
|
892 |
{
|
|
893 |
return cmdBld_CfgIeRxIntrPacing (hCmdBld,
|
|
894 |
DB_WLAN(hCmdBld).RxIntrPacingThreshold,
|
|
895 |
DB_WLAN(hCmdBld).RxIntrPacingTimeout,
|
|
896 |
(void *)cmdBld_ConfigSeq,
|
|
897 |
hCmdBld);
|
|
898 |
}
|
|
899 |
|
|
900 |
#if 0
|
|
901 |
#ifdef TI_TEST
|
|
902 |
static TI_STATUS __cfg_coex_activity_table (TI_HANDLE hCmdBld)
|
|
903 |
{
|
|
904 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
905 |
TI_UINT32 uNumberOfIEs = DB_WLAN(hCmdBld).tWlanParamsCoexActivityTable.numOfElements;
|
|
906 |
TCoexActivity *CoexActivityTable = DB_WLAN(hCmdBld).tWlanParamsCoexActivityTable.entry;
|
|
907 |
TI_STATUS status = TI_NOK;
|
|
908 |
TI_UINT32 index;
|
|
909 |
|
|
910 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " CoexActivity, uNumberOfIEs=%d\n", uNumberOfIEs);
|
|
911 |
if (uNumberOfIEs == 0)
|
|
912 |
{
|
|
913 |
return status;
|
|
914 |
}
|
|
915 |
/*
|
|
916 |
* config CoexActivity table
|
|
917 |
* first configure all indexes but the last one with no CB, and than configure the last one
|
|
918 |
* with a CB to continue configuration.
|
|
919 |
*/
|
|
920 |
for (index = 0; index < uNumberOfIEs-1; index++)
|
|
921 |
{
|
|
922 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " CoexActivity, send %d\n", index);
|
|
923 |
status = cmdBld_CfgIeCoexActivity (hCmdBld, &CoexActivityTable[index],
|
|
924 |
NULL, NULL);
|
|
925 |
if (TI_OK != status)
|
|
926 |
{
|
|
927 |
return status;
|
|
928 |
}
|
|
929 |
}
|
|
930 |
|
|
931 |
/* Send last activity with a callback to continue config sequence */
|
|
932 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " CoexActivity, send last %d\n", index);
|
|
933 |
status = cmdBld_CfgIeCoexActivity (hCmdBld, &CoexActivityTable[index],
|
|
934 |
(void *)cmdBld_ConfigSeq, hCmdBld);
|
|
935 |
|
|
936 |
return status;
|
|
937 |
}
|
|
938 |
#endif
|
|
939 |
#endif
|
|
940 |
|
|
941 |
static TI_STATUS __cfg_cca_threshold (TI_HANDLE hCmdBld)
|
|
942 |
{
|
|
943 |
return cmdBld_CfgIeCcaThreshold (hCmdBld,
|
|
944 |
DB_WLAN(hCmdBld).EnergyDetection,
|
|
945 |
(void *)cmdBld_ConfigSeq,
|
|
946 |
hCmdBld);
|
|
947 |
}
|
|
948 |
|
|
949 |
|
|
950 |
static TI_STATUS __cfg_bcn_brc_options (TI_HANDLE hCmdBld)
|
|
951 |
{
|
|
952 |
TPowerMgmtConfig powerMgmtConfig;
|
|
953 |
|
|
954 |
/* Beacon broadcast options */
|
|
955 |
powerMgmtConfig.BcnBrcOptions = DB_WLAN(hCmdBld).BcnBrcOptions;
|
|
956 |
powerMgmtConfig.ConsecutivePsPollDeliveryFailureThreshold = DB_WLAN(hCmdBld).ConsecutivePsPollDeliveryFailureThreshold;
|
|
957 |
|
|
958 |
return cmdBld_CfgIeBcnBrcOptions (hCmdBld,
|
|
959 |
&powerMgmtConfig,
|
|
960 |
(void *)cmdBld_ConfigSeq,
|
|
961 |
hCmdBld);
|
|
962 |
}
|
|
963 |
|
|
964 |
|
|
965 |
static TI_STATUS __cmd_enable_rx (TI_HANDLE hCmdBld)
|
|
966 |
{
|
|
967 |
/* Enable rx path on the hardware */
|
|
968 |
return cmdBld_CmdEnableRx (hCmdBld, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
969 |
}
|
|
970 |
|
|
971 |
|
|
972 |
static TI_STATUS __cmd_enable_tx (TI_HANDLE hCmdBld)
|
|
973 |
{
|
|
974 |
/* Enable tx path on the hardware */
|
|
975 |
return cmdBld_CmdEnableTx (hCmdBld,
|
|
976 |
DB_DEFAULT_CHANNEL(hCmdBld),
|
|
977 |
(void *)cmdBld_ConfigSeq,
|
|
978 |
hCmdBld);
|
|
979 |
}
|
|
980 |
|
|
981 |
|
|
982 |
static TI_STATUS __cfg_ps_wmm (TI_HANDLE hCmdBld)
|
|
983 |
{
|
|
984 |
/* ACX for a work around for Wi-Fi test */
|
|
985 |
return cmdBld_CfgIePsWmm (hCmdBld,
|
|
986 |
DB_WLAN(hCmdBld).WiFiWmmPS,
|
|
987 |
(void *)cmdBld_ConfigSeq,
|
|
988 |
hCmdBld);
|
|
989 |
}
|
|
990 |
|
|
991 |
|
|
992 |
static TI_STATUS __cfg_rssi_snr_weights (TI_HANDLE hCmdBld)
|
|
993 |
{
|
|
994 |
/* RSSI/SNR Weights for Average calculations */
|
|
995 |
return cmdBld_CfgIeRssiSnrWeights (hCmdBld,
|
|
996 |
&DB_WLAN(hCmdBld).tRssiSnrWeights,
|
|
997 |
(void *)cmdBld_ConfigSeq,
|
|
998 |
hCmdBld);
|
|
999 |
}
|
|
1000 |
|
|
1001 |
|
|
1002 |
static TI_STATUS __cfg_event_scan_cmplt (TI_HANDLE hCmdBld)
|
|
1003 |
{
|
|
1004 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1005 |
|
|
1006 |
/* Enable the scan complete interrupt source */
|
|
1007 |
return eventMbox_UnMaskEvent (pCmdBld->hEventMbox,
|
|
1008 |
TWD_OWN_EVENT_SCAN_CMPLT,
|
|
1009 |
(void *)cmdBld_ConfigSeq,
|
|
1010 |
hCmdBld);
|
|
1011 |
}
|
|
1012 |
|
|
1013 |
static TI_STATUS __cfg_event_sps_scan_cmplt (TI_HANDLE hCmdBld)
|
|
1014 |
{
|
|
1015 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1016 |
|
|
1017 |
return eventMbox_UnMaskEvent (pCmdBld->hEventMbox,
|
|
1018 |
TWD_OWN_EVENT_SPS_SCAN_CMPLT,
|
|
1019 |
(void *)cmdBld_ConfigSeq,
|
|
1020 |
hCmdBld);
|
|
1021 |
}
|
|
1022 |
|
|
1023 |
static TI_STATUS __cfg_event_plt_rx_calibration_cmplt (TI_HANDLE hCmdBld)
|
|
1024 |
{
|
|
1025 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1026 |
|
|
1027 |
return eventMbox_UnMaskEvent (pCmdBld->hEventMbox,
|
|
1028 |
TWD_OWN_EVENT_PLT_RX_CALIBRATION_COMPLETE,
|
|
1029 |
(void *)cmdBld_ConfigSeq,
|
|
1030 |
hCmdBld);
|
|
1031 |
}
|
|
1032 |
|
|
1033 |
|
|
1034 |
static TI_STATUS __cfg_hw_enc_dec_enable (TI_HANDLE hCmdBld)
|
|
1035 |
{
|
|
1036 |
return cmdBld_CfgHwEncDecEnable (hCmdBld, TI_TRUE, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
1037 |
}
|
|
1038 |
|
|
1039 |
|
|
1040 |
static TI_STATUS __cfg_rssi_snr_trigger_0 (TI_HANDLE hCmdBld)
|
|
1041 |
{
|
|
1042 |
/* RSSI/SNR Troggers */
|
|
1043 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1044 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[0],
|
|
1045 |
(void *)cmdBld_ConfigSeq,
|
|
1046 |
hCmdBld);
|
|
1047 |
}
|
|
1048 |
|
|
1049 |
|
|
1050 |
static TI_STATUS __cfg_rssi_snr_trigger_1 (TI_HANDLE hCmdBld)
|
|
1051 |
{
|
|
1052 |
/* RSSI/SNR Troggers */
|
|
1053 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1054 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[1],
|
|
1055 |
(void *)cmdBld_ConfigSeq,
|
|
1056 |
hCmdBld);
|
|
1057 |
}
|
|
1058 |
|
|
1059 |
|
|
1060 |
static TI_STATUS __cfg_rssi_snr_trigger_2 (TI_HANDLE hCmdBld)
|
|
1061 |
{
|
|
1062 |
/* RSSI/SNR Troggers */
|
|
1063 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1064 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[2],
|
|
1065 |
(void *)cmdBld_ConfigSeq,
|
|
1066 |
hCmdBld);
|
|
1067 |
}
|
|
1068 |
|
|
1069 |
|
|
1070 |
static TI_STATUS __cfg_rssi_snr_trigger_3 (TI_HANDLE hCmdBld)
|
|
1071 |
{
|
|
1072 |
/* RSSI/SNR Troggers */
|
|
1073 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1074 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[3],
|
|
1075 |
(void *)cmdBld_ConfigSeq,
|
|
1076 |
hCmdBld);
|
|
1077 |
}
|
|
1078 |
|
|
1079 |
|
|
1080 |
static TI_STATUS __cfg_rssi_snr_trigger_4 (TI_HANDLE hCmdBld)
|
|
1081 |
{
|
|
1082 |
/* RSSI/SNR Troggers */
|
|
1083 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1084 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[4],
|
|
1085 |
(void *)cmdBld_ConfigSeq,
|
|
1086 |
hCmdBld);
|
|
1087 |
}
|
|
1088 |
|
|
1089 |
|
|
1090 |
static TI_STATUS __cfg_rssi_snr_trigger_5 (TI_HANDLE hCmdBld)
|
|
1091 |
{
|
|
1092 |
/* RSSI/SNR Troggers */
|
|
1093 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1094 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[5],
|
|
1095 |
(void *)cmdBld_ConfigSeq,
|
|
1096 |
hCmdBld);
|
|
1097 |
}
|
|
1098 |
|
|
1099 |
|
|
1100 |
static TI_STATUS __cfg_rssi_snr_trigger_6 (TI_HANDLE hCmdBld)
|
|
1101 |
{
|
|
1102 |
/* RSSI/SNR Troggers */
|
|
1103 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1104 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[6],
|
|
1105 |
(void *)cmdBld_ConfigSeq,
|
|
1106 |
hCmdBld);
|
|
1107 |
}
|
|
1108 |
|
|
1109 |
|
|
1110 |
static TI_STATUS __cfg_rssi_snr_trigger_7 (TI_HANDLE hCmdBld)
|
|
1111 |
{
|
|
1112 |
/* RSSI/SNR Troggers */
|
|
1113 |
return cmdBld_CfgIeRssiSnrTrigger (hCmdBld,
|
|
1114 |
&DB_WLAN(hCmdBld).tRssiSnrTrigger[7],
|
|
1115 |
(void *)cmdBld_ConfigSeq,
|
|
1116 |
hCmdBld);
|
|
1117 |
}
|
|
1118 |
|
|
1119 |
|
|
1120 |
static TI_STATUS __cfg_max_tx_retry (TI_HANDLE hCmdBld)
|
|
1121 |
{
|
|
1122 |
return cmdBld_CfgIeMaxTxRetry (hCmdBld,
|
|
1123 |
&DB_WLAN(hCmdBld).roamTriggers,
|
|
1124 |
(void *)cmdBld_ConfigSeq,
|
|
1125 |
hCmdBld);
|
|
1126 |
}
|
|
1127 |
|
|
1128 |
|
|
1129 |
|
|
1130 |
static TI_STATUS __cfg_split_scan_timeout (TI_HANDLE hCmdBld)
|
|
1131 |
{
|
|
1132 |
return cmdBld_CmdIeSetSplitScanTimeOut (hCmdBld,
|
|
1133 |
DB_WLAN(hCmdBld).uSlicedScanTimeOut,
|
|
1134 |
(void *)cmdBld_ConfigSeq,
|
|
1135 |
hCmdBld);
|
|
1136 |
}
|
|
1137 |
|
|
1138 |
|
|
1139 |
static TI_STATUS __cfg_conn_monit_params (TI_HANDLE hCmdBld)
|
|
1140 |
{
|
|
1141 |
return cmdBld_CfgIeConnMonitParams (hCmdBld,
|
|
1142 |
&DB_WLAN(hCmdBld).roamTriggers,
|
|
1143 |
(void *)cmdBld_ConfigSeq,
|
|
1144 |
hCmdBld);
|
|
1145 |
}
|
|
1146 |
|
|
1147 |
|
|
1148 |
static TI_STATUS __cfg_bet (TI_HANDLE hCmdBld)
|
|
1149 |
{
|
|
1150 |
return cmdBld_CfgBet (hCmdBld,
|
|
1151 |
DB_WLAN(hCmdBld).BetEnable,
|
|
1152 |
DB_WLAN(hCmdBld).MaximumConsecutiveET,
|
|
1153 |
(void *)cmdBld_ConfigSeq,
|
|
1154 |
hCmdBld);
|
|
1155 |
}
|
|
1156 |
|
|
1157 |
|
|
1158 |
static TI_STATUS __cfg_cts_protection (TI_HANDLE hCmdBld)
|
|
1159 |
{
|
|
1160 |
return cmdBld_CfgIeCtsProtection (hCmdBld,
|
|
1161 |
DB_WLAN(hCmdBld).CtsToSelf,
|
|
1162 |
(void *)cmdBld_ConfigSeq,
|
|
1163 |
hCmdBld);
|
|
1164 |
}
|
|
1165 |
|
|
1166 |
|
|
1167 |
static TI_STATUS __cfg_radio_params (TI_HANDLE hCmdBld)
|
|
1168 |
{
|
|
1169 |
return cmdBld_CfgIeRadioParams (hCmdBld,
|
|
1170 |
&DB_RADIO(hCmdBld),
|
|
1171 |
(void *)cmdBld_ConfigSeq,
|
|
1172 |
hCmdBld);
|
|
1173 |
}
|
|
1174 |
|
|
1175 |
static TI_STATUS __cfg_platform_params (TI_HANDLE hCmdBld)
|
|
1176 |
{
|
|
1177 |
return cmdBld_CfgPlatformGenParams(hCmdBld,
|
|
1178 |
&DB_GEN(hCmdBld),
|
|
1179 |
(void *)cmdBld_ConfigSeq,
|
|
1180 |
hCmdBld);
|
|
1181 |
}
|
|
1182 |
|
|
1183 |
|
|
1184 |
|
|
1185 |
static TI_STATUS __cfg_tx_rate_policy (TI_HANDLE hCmdBld)
|
|
1186 |
{
|
|
1187 |
/*
|
|
1188 |
* JOIN (use the local parameters), otherwize the CORE will reconnect
|
|
1189 |
*/
|
|
1190 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1191 |
{
|
|
1192 |
/* Set TxRatePolicy */
|
|
1193 |
return cmdBld_CfgTxRatePolicy (hCmdBld,
|
|
1194 |
&DB_BSS(hCmdBld).TxRateClassParams,
|
|
1195 |
(void *)cmdBld_ConfigSeq,
|
|
1196 |
hCmdBld);
|
|
1197 |
}
|
|
1198 |
|
|
1199 |
return TI_NOK;
|
|
1200 |
}
|
|
1201 |
|
|
1202 |
|
|
1203 |
static TI_STATUS __cmd_beacon_join (TI_HANDLE hCmdBld)
|
|
1204 |
{
|
|
1205 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).Beacon.Size != 0)
|
|
1206 |
{
|
|
1207 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1208 |
&(DB_TEMP(hCmdBld).Beacon),
|
|
1209 |
(TI_UINT16)DB_TEMP(hCmdBld).Beacon.Size,
|
|
1210 |
TEMPLATE_BEACON,
|
|
1211 |
0,
|
|
1212 |
(void *)cmdBld_ConfigSeq,
|
|
1213 |
hCmdBld);
|
|
1214 |
}
|
|
1215 |
|
|
1216 |
return TI_NOK;
|
|
1217 |
}
|
|
1218 |
|
|
1219 |
static TI_STATUS __cmd_probe_resp_join (TI_HANDLE hCmdBld)
|
|
1220 |
{
|
|
1221 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).ProbeResp.Size != 0)
|
|
1222 |
{
|
|
1223 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1224 |
&(DB_TEMP(hCmdBld).ProbeResp),
|
|
1225 |
(TI_UINT16)DB_TEMP(hCmdBld).ProbeResp.Size,
|
|
1226 |
TEMPLATE_PROBE_RESPONSE,
|
|
1227 |
0,
|
|
1228 |
(void *)cmdBld_ConfigSeq,
|
|
1229 |
hCmdBld);
|
|
1230 |
}
|
|
1231 |
|
|
1232 |
return TI_NOK;
|
|
1233 |
}
|
|
1234 |
|
|
1235 |
|
|
1236 |
static TI_STATUS __cmd_probe_req_join (TI_HANDLE hCmdBld)
|
|
1237 |
{
|
|
1238 |
TI_STATUS tStatus;
|
|
1239 |
|
|
1240 |
/* set Probe Req template also if join == false ! */
|
|
1241 |
if (DB_TEMP(hCmdBld).ProbeReq24.Size != 0)
|
|
1242 |
{
|
|
1243 |
tStatus = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1244 |
&(DB_TEMP(hCmdBld).ProbeReq24),
|
|
1245 |
(TI_UINT16)DB_TEMP(hCmdBld).ProbeReq24.Size,
|
|
1246 |
CFG_TEMPLATE_PROBE_REQ_2_4,
|
|
1247 |
0,
|
|
1248 |
NULL,
|
|
1249 |
NULL);
|
|
1250 |
if (TI_OK != tStatus)
|
|
1251 |
{
|
|
1252 |
return tStatus;
|
|
1253 |
}
|
|
1254 |
}
|
|
1255 |
|
|
1256 |
/* set Probe Req template also if join == false ! */
|
|
1257 |
if (DB_TEMP(hCmdBld).ProbeReq50.Size != 0)
|
|
1258 |
{
|
|
1259 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1260 |
&(DB_TEMP(hCmdBld).ProbeReq50),
|
|
1261 |
(TI_UINT16)DB_TEMP(hCmdBld).ProbeReq50.Size,
|
|
1262 |
CFG_TEMPLATE_PROBE_REQ_5,
|
|
1263 |
0,
|
|
1264 |
(void *)cmdBld_ConfigSeq,
|
|
1265 |
hCmdBld);
|
|
1266 |
}
|
|
1267 |
|
|
1268 |
return TI_NOK;
|
|
1269 |
}
|
|
1270 |
|
|
1271 |
|
|
1272 |
static TI_STATUS __cmd_null_data_join (TI_HANDLE hCmdBld)
|
|
1273 |
{
|
|
1274 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).NullData.Size != 0)
|
|
1275 |
{
|
|
1276 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1277 |
&(DB_TEMP(hCmdBld).NullData),
|
|
1278 |
(TI_UINT16)DB_TEMP(hCmdBld).NullData.Size,
|
|
1279 |
TEMPLATE_NULL_DATA,
|
|
1280 |
0,
|
|
1281 |
(void *)cmdBld_ConfigSeq,
|
|
1282 |
hCmdBld);
|
|
1283 |
}
|
|
1284 |
|
|
1285 |
return TI_NOK;
|
|
1286 |
}
|
|
1287 |
|
|
1288 |
static TI_STATUS __cmd_disconn_join (TI_HANDLE hCmdBld)
|
|
1289 |
{
|
|
1290 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).Disconn.Size != 0)
|
|
1291 |
{
|
|
1292 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1293 |
&(DB_TEMP(hCmdBld).Disconn),
|
|
1294 |
(TI_UINT16)DB_TEMP(hCmdBld).Disconn.Size,
|
|
1295 |
TEMPLATE_DISCONNECT,
|
|
1296 |
0,
|
|
1297 |
(void *)cmdBld_ConfigSeq,
|
|
1298 |
hCmdBld);
|
|
1299 |
}
|
|
1300 |
|
|
1301 |
return TI_NOK;
|
|
1302 |
}
|
|
1303 |
|
|
1304 |
static TI_STATUS __cmd_ps_poll_join (TI_HANDLE hCmdBld)
|
|
1305 |
{
|
|
1306 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).PsPoll.Size != 0)
|
|
1307 |
{
|
|
1308 |
return cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1309 |
&(DB_TEMP(hCmdBld).PsPoll),
|
|
1310 |
(TI_UINT16)DB_TEMP(hCmdBld).PsPoll.Size,
|
|
1311 |
TEMPLATE_PS_POLL,
|
|
1312 |
0,
|
|
1313 |
(void *)cmdBld_ConfigSeq,
|
|
1314 |
hCmdBld);
|
|
1315 |
}
|
|
1316 |
|
|
1317 |
return TI_NOK;
|
|
1318 |
}
|
|
1319 |
|
|
1320 |
|
|
1321 |
static TI_STATUS __cmd_keep_alive_tmpl_join (TI_HANDLE hCmdBld)
|
|
1322 |
{
|
|
1323 |
TI_UINT32 index;
|
|
1324 |
TI_STATUS status = TI_NOK;
|
|
1325 |
|
|
1326 |
/*
|
|
1327 |
* config templates
|
|
1328 |
* first configure all indexes but the last one with no CB, and than configure the last one
|
|
1329 |
* with a CB to continue configuration.
|
|
1330 |
*/
|
|
1331 |
for (index = 0; index < KLV_MAX_TMPL_NUM - 1; index++)
|
|
1332 |
{
|
|
1333 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).KeepAlive[ index ].Size != 0)
|
|
1334 |
{
|
|
1335 |
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1336 |
&(DB_TEMP(hCmdBld).KeepAlive[index]),
|
|
1337 |
(TI_UINT16)DB_TEMP(hCmdBld).KeepAlive[index].Size,
|
|
1338 |
TEMPLATE_KLV,
|
|
1339 |
index,
|
|
1340 |
NULL,
|
|
1341 |
NULL);
|
|
1342 |
if (TI_OK != status)
|
|
1343 |
{
|
|
1344 |
return status;
|
|
1345 |
}
|
|
1346 |
}
|
|
1347 |
}
|
|
1348 |
|
|
1349 |
if (DB_WLAN(hCmdBld).bJoin && DB_TEMP(hCmdBld).KeepAlive[ index ].Size != 0)
|
|
1350 |
{
|
|
1351 |
status = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld,
|
|
1352 |
&(DB_TEMP(hCmdBld).KeepAlive[index]),
|
|
1353 |
(TI_UINT16)DB_TEMP(hCmdBld).KeepAlive[index].Size,
|
|
1354 |
TEMPLATE_KLV,
|
|
1355 |
index,
|
|
1356 |
(void *)cmdBld_ConfigSeq,
|
|
1357 |
hCmdBld);
|
|
1358 |
if (TI_OK != status)
|
|
1359 |
{
|
|
1360 |
return status;
|
|
1361 |
}
|
|
1362 |
}
|
|
1363 |
|
|
1364 |
return status;
|
|
1365 |
}
|
|
1366 |
|
|
1367 |
|
|
1368 |
static TI_STATUS __cmd_keep_alive_params(TI_HANDLE hCmdBld)
|
|
1369 |
{
|
|
1370 |
TI_UINT32 index;
|
|
1371 |
TI_STATUS status;
|
|
1372 |
|
|
1373 |
/* config gloabl enable / disable flag */
|
|
1374 |
cmdBld_CfgKeepAliveEnaDis (hCmdBld, DB_KLV(hCmdBld).enaDisFlag, NULL, NULL);
|
|
1375 |
|
|
1376 |
/*
|
|
1377 |
* config per-template params
|
|
1378 |
* fisr configure all indexes but the last one with no CB, and than configure the last one
|
|
1379 |
* with a CB to continue configuration.
|
|
1380 |
*/
|
|
1381 |
for (index = 0; index < KLV_MAX_TMPL_NUM - 1; index++)
|
|
1382 |
{
|
|
1383 |
if (DB_WLAN(hCmdBld).bJoin && DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag != 0)
|
|
1384 |
{
|
|
1385 |
status = cmdBld_CmdIeConfigureKeepAliveParams (hCmdBld,
|
|
1386 |
index,
|
|
1387 |
DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag,
|
|
1388 |
DB_KLV(hCmdBld).keepAliveParams[ index ].trigType,
|
|
1389 |
DB_KLV(hCmdBld).keepAliveParams[ index ].interval,
|
|
1390 |
NULL,
|
|
1391 |
NULL);
|
|
1392 |
if (TI_OK != status)
|
|
1393 |
{
|
|
1394 |
return status;
|
|
1395 |
}
|
|
1396 |
}
|
|
1397 |
}
|
|
1398 |
|
|
1399 |
/* Set NOK for a case the following config is skipped, to indicate that no callback is expected */
|
|
1400 |
status = TI_NOK;
|
|
1401 |
|
|
1402 |
if (DB_WLAN(hCmdBld).bJoin && DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag != 0)
|
|
1403 |
{
|
|
1404 |
status = cmdBld_CmdIeConfigureKeepAliveParams (hCmdBld,
|
|
1405 |
index,
|
|
1406 |
DB_KLV(hCmdBld).keepAliveParams[ index ].enaDisFlag,
|
|
1407 |
DB_KLV(hCmdBld).keepAliveParams[ index ].trigType,
|
|
1408 |
DB_KLV(hCmdBld).keepAliveParams[ index ].interval,
|
|
1409 |
(void *)cmdBld_ConfigSeq,
|
|
1410 |
hCmdBld);
|
|
1411 |
if (TI_OK != status)
|
|
1412 |
{
|
|
1413 |
return status;
|
|
1414 |
}
|
|
1415 |
}
|
|
1416 |
|
|
1417 |
return status;
|
|
1418 |
}
|
|
1419 |
|
|
1420 |
static TI_STATUS __cmd_power_auth (TI_HANDLE hCmdBld)
|
|
1421 |
{
|
|
1422 |
return cmdBld_CfgIeSleepAuth (hCmdBld,
|
|
1423 |
DB_WLAN(hCmdBld).minPowerLevel,
|
|
1424 |
(void *)cmdBld_ConfigSeq,
|
|
1425 |
hCmdBld);
|
|
1426 |
}
|
|
1427 |
|
|
1428 |
static TI_STATUS __cmd_start_join (TI_HANDLE hCmdBld)
|
|
1429 |
{
|
|
1430 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1431 |
|
|
1432 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1433 |
{
|
|
1434 |
/*
|
|
1435 |
* Replace the Join-Complete event CB by a local function.
|
|
1436 |
* Thus, the reconfig sequence will not continue until the Join is completed!
|
|
1437 |
* The original CB is restored after Join-Complete.
|
|
1438 |
*/
|
|
1439 |
eventMbox_ReplaceEvent (pCmdBld->hEventMbox,
|
|
1440 |
TWD_OWN_EVENT_JOIN_CMPLT,
|
|
1441 |
(void *)cmdBld_JoinCmpltForReconfigCb,
|
|
1442 |
hCmdBld,
|
|
1443 |
&pCmdBld->fJoinCmpltOriginalCbFunc,
|
|
1444 |
&pCmdBld->hJoinCmpltOriginalCbHndl);
|
|
1445 |
/*
|
|
1446 |
* Call the hardware to start/join the bss
|
|
1447 |
*/
|
|
1448 |
return cmdBld_CmdStartJoin (hCmdBld,
|
|
1449 |
DB_BSS(hCmdBld).ReqBssType,
|
|
1450 |
(void *)cmdBld_DummyCb,
|
|
1451 |
hCmdBld);
|
|
1452 |
}
|
|
1453 |
|
|
1454 |
return TI_NOK;
|
|
1455 |
}
|
|
1456 |
|
|
1457 |
static TI_STATUS __cmd_sta_state (TI_HANDLE hCmdBld)
|
|
1458 |
{
|
|
1459 |
if (DB_WLAN(hCmdBld).bStaConnected)
|
|
1460 |
{
|
|
1461 |
return cmdBld_CmdSetStaState (hCmdBld,
|
|
1462 |
STA_STATE_CONNECTED,
|
|
1463 |
(void *)cmdBld_ConfigSeq,
|
|
1464 |
hCmdBld);
|
|
1465 |
}
|
|
1466 |
|
|
1467 |
return TI_NOK;
|
|
1468 |
}
|
|
1469 |
|
|
1470 |
static TI_STATUS __cfg_aid (TI_HANDLE hCmdBld)
|
|
1471 |
{
|
|
1472 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1473 |
{
|
|
1474 |
return cmdBld_CfgAid (hCmdBld, DB_WLAN(hCmdBld).Aid, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
1475 |
}
|
|
1476 |
|
|
1477 |
return TI_NOK;
|
|
1478 |
}
|
|
1479 |
|
|
1480 |
|
|
1481 |
static TI_STATUS __cfg_slot_time_join (TI_HANDLE hCmdBld)
|
|
1482 |
{
|
|
1483 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1484 |
{
|
|
1485 |
/* Slot time must be setting after doing join */
|
|
1486 |
return cmdBld_CfgSlotTime (hCmdBld, (ESlotTime)(DB_WLAN(hCmdBld).SlotTime), (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
1487 |
}
|
|
1488 |
|
|
1489 |
return TI_NOK;
|
|
1490 |
}
|
|
1491 |
|
|
1492 |
|
|
1493 |
static TI_STATUS __cfg_preamble_join (TI_HANDLE hCmdBld)
|
|
1494 |
{
|
|
1495 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1496 |
{
|
|
1497 |
/* Preamble type must be set after doing join */
|
|
1498 |
return cmdBld_CfgPreamble (hCmdBld, DB_WLAN(hCmdBld).preamble, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
1499 |
}
|
|
1500 |
|
|
1501 |
return TI_NOK;
|
|
1502 |
}
|
|
1503 |
|
|
1504 |
|
|
1505 |
static TI_STATUS __cfg_ht_capabilities (TI_HANDLE hCmdBld)
|
|
1506 |
{
|
|
1507 |
if (DB_WLAN(hCmdBld).bJoin && DB_BSS(hCmdBld).bHtCap)
|
|
1508 |
{
|
|
1509 |
/* HT capabilities must be set after doing join */
|
|
1510 |
return cmdBld_CfgIeSetFwHtCapabilities (hCmdBld,
|
|
1511 |
DB_BSS(hCmdBld).uHtCapabilites,
|
|
1512 |
DB_BSS(hCmdBld).tMacAddress,
|
|
1513 |
DB_BSS(hCmdBld).uAmpduMaxLeng,
|
|
1514 |
DB_BSS(hCmdBld).uAmpduMinSpac,
|
|
1515 |
(void *)cmdBld_ConfigSeq,
|
|
1516 |
hCmdBld);
|
|
1517 |
}
|
|
1518 |
|
|
1519 |
return TI_NOK;
|
|
1520 |
}
|
|
1521 |
|
|
1522 |
|
|
1523 |
static TI_STATUS __cfg_ht_information (TI_HANDLE hCmdBld)
|
|
1524 |
{
|
|
1525 |
if (DB_WLAN(hCmdBld).bJoin && DB_BSS(hCmdBld).bHtInf)
|
|
1526 |
{
|
|
1527 |
/* HT Information must be set after doing join */
|
|
1528 |
return cmdBld_CfgIeSetFwHtInformation (hCmdBld,
|
|
1529 |
DB_BSS(hCmdBld).uRifsMode,
|
|
1530 |
DB_BSS(hCmdBld).uHtProtection,
|
|
1531 |
DB_BSS(hCmdBld).uGfProtection,
|
|
1532 |
DB_BSS(hCmdBld).uHtTxBurstLimit,
|
|
1533 |
DB_BSS(hCmdBld).uDualCtsProtection,
|
|
1534 |
(void *)cmdBld_ConfigSeq,
|
|
1535 |
hCmdBld);
|
|
1536 |
}
|
|
1537 |
|
|
1538 |
return TI_NOK;
|
|
1539 |
}
|
|
1540 |
|
|
1541 |
|
|
1542 |
static TI_STATUS __cfg_ba_set_session (TI_HANDLE hCmdBld)
|
|
1543 |
{
|
|
1544 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1545 |
{
|
|
1546 |
TI_UINT32 uTid;
|
|
1547 |
|
|
1548 |
for (uTid = 0; uTid < MAX_NUM_OF_802_1d_TAGS; ++uTid)
|
|
1549 |
{
|
|
1550 |
/* set BA initiator */
|
|
1551 |
if (DB_BSS(hCmdBld).bBaInitiator[uTid])
|
|
1552 |
{
|
|
1553 |
return cmdBld_CfgIeSetBaSession (hCmdBld,
|
|
1554 |
ACX_BA_SESSION_INITIATOR_POLICY,
|
|
1555 |
uTid,
|
|
1556 |
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uPolicy,
|
|
1557 |
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].aMacAddress,
|
|
1558 |
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uWinSize,
|
|
1559 |
DB_BSS(hCmdBld).tBaSessionInitiatorPolicy[uTid].uInactivityTimeout,
|
|
1560 |
(void *)cmdBld_ConfigSeq,
|
|
1561 |
hCmdBld);
|
|
1562 |
}
|
|
1563 |
|
|
1564 |
/* set BA Responder */
|
|
1565 |
if (DB_BSS(hCmdBld).bBaResponder[uTid])
|
|
1566 |
{
|
|
1567 |
return cmdBld_CfgIeSetBaSession (hCmdBld,
|
|
1568 |
ACX_BA_SESSION_RESPONDER_POLICY,
|
|
1569 |
uTid,
|
|
1570 |
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uPolicy,
|
|
1571 |
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].aMacAddress,
|
|
1572 |
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uWinSize,
|
|
1573 |
DB_BSS(hCmdBld).tBaSessionResponderPolicy[uTid].uInactivityTimeout,
|
|
1574 |
(void *)cmdBld_ConfigSeq,
|
|
1575 |
hCmdBld);
|
|
1576 |
}
|
|
1577 |
}
|
|
1578 |
}
|
|
1579 |
|
|
1580 |
return TI_NOK;
|
|
1581 |
}
|
|
1582 |
|
|
1583 |
|
|
1584 |
static TI_STATUS __cfg_tx_power_join (TI_HANDLE hCmdBld)
|
|
1585 |
{
|
|
1586 |
if (DB_WLAN(hCmdBld).bJoin)
|
|
1587 |
{
|
|
1588 |
/* Tx-power must be set after doing join */
|
|
1589 |
return cmdBld_CfgTxPowerDbm (hCmdBld, DB_WLAN(hCmdBld).TxPowerDbm, (void *)cmdBld_ConfigSeq, hCmdBld);
|
|
1590 |
}
|
|
1591 |
|
|
1592 |
return TI_NOK;
|
|
1593 |
}
|
|
1594 |
|
|
1595 |
|
|
1596 |
static TI_STATUS __cfg_keys (TI_HANDLE hCmdBld)
|
|
1597 |
{
|
|
1598 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1599 |
TI_UINT32 index;
|
|
1600 |
|
|
1601 |
if (!DB_WLAN(hCmdBld).bJoin)
|
|
1602 |
{
|
|
1603 |
return TI_NOK;
|
|
1604 |
}
|
|
1605 |
|
|
1606 |
if (pCmdBld->tSecurity.eSecurityMode != TWD_CIPHER_NONE)
|
|
1607 |
{
|
|
1608 |
/*
|
|
1609 |
* We are doing recovery during security so increase security-sequence-number by 255 just to ensure
|
|
1610 |
* the AP will see progress from last Tx before the recovery (actually needed only for TKIP and AES).
|
|
1611 |
* Decrementing the low byte by one is handled like it wrpped around, i.e. increment total number by 255.
|
|
1612 |
*/
|
|
1613 |
cmdBld_SetSecuritySeqNum (hCmdBld, (TI_UINT8)(pCmdBld->uSecuritySeqNumLow - 1));
|
|
1614 |
|
|
1615 |
|
|
1616 |
/* set the keys to the HW*/
|
|
1617 |
for (index = 0;
|
|
1618 |
index < pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS;
|
|
1619 |
index++)
|
|
1620 |
{
|
|
1621 |
if ((DB_KEYS(pCmdBld).pReconfKeys + index)->keyType != KEY_NULL)
|
|
1622 |
{
|
|
1623 |
if (cmdBld_CmdAddKey (hCmdBld, DB_KEYS(pCmdBld).pReconfKeys + index, TI_TRUE, NULL, NULL) != TI_OK)
|
|
1624 |
{
|
|
1625 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "__cfg_keys: ERROR cmdBld_CmdAddKey failure index=%d\n", index);
|
|
1626 |
return TI_NOK;
|
|
1627 |
}
|
|
1628 |
}
|
|
1629 |
}
|
|
1630 |
|
|
1631 |
if (DB_KEYS(pCmdBld).bDefaultKeyIdValid)
|
|
1632 |
{
|
|
1633 |
/* Set the deafult key ID to the HW*/
|
|
1634 |
if (cmdBld_CmdSetWepDefaultKeyId (hCmdBld, DB_KEYS(pCmdBld).uReconfDefaultKeyId, NULL, NULL) != TI_OK)
|
|
1635 |
{
|
|
1636 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "__cfg_keys: ERROR cmdBld_CmdSetWepDefaultKeyId failure\n");
|
|
1637 |
return TI_NOK;
|
|
1638 |
}
|
|
1639 |
}
|
|
1640 |
}
|
|
1641 |
|
|
1642 |
/* Set the encryption/decryption control on the HW */
|
|
1643 |
if (cmdBld_CfgHwEncDecEnable (hCmdBld,
|
|
1644 |
DB_KEYS(pCmdBld).bReconfHwEncEnable,
|
|
1645 |
(void *)cmdBld_ConfigSeq,
|
|
1646 |
hCmdBld) != TI_OK)
|
|
1647 |
{
|
|
1648 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "__cfg_keys: ERROR cmdBld_CfgHwEncDecEnable failure \n");
|
|
1649 |
return TI_NOK;
|
|
1650 |
}
|
|
1651 |
|
|
1652 |
return TI_OK;
|
|
1653 |
}
|
|
1654 |
|
|
1655 |
static TI_STATUS __cfg_sg_enable (TI_HANDLE hCmdBld)
|
|
1656 |
{
|
|
1657 |
/* Set the Soft Gemini state */
|
|
1658 |
return cmdBld_CfgSgEnable (hCmdBld,
|
|
1659 |
DB_WLAN(hCmdBld).SoftGeminiEnable,
|
|
1660 |
(void *)cmdBld_ConfigSeq,
|
|
1661 |
hCmdBld);
|
|
1662 |
}
|
|
1663 |
|
|
1664 |
|
|
1665 |
static TI_STATUS __cfg_sg (TI_HANDLE hCmdBld)
|
|
1666 |
{
|
|
1667 |
/* Set the Soft Gemini params */
|
|
1668 |
|
|
1669 |
/* signals the FW to config all the paramters from the DB*/
|
|
1670 |
DB_WLAN(hCmdBld).SoftGeminiParams.paramIdx = 0xFF;
|
|
1671 |
|
|
1672 |
return cmdBld_CfgSg (hCmdBld,
|
|
1673 |
&DB_WLAN(hCmdBld).SoftGeminiParams,
|
|
1674 |
(void *)cmdBld_ConfigSeq,
|
|
1675 |
hCmdBld);
|
|
1676 |
}
|
|
1677 |
|
|
1678 |
|
|
1679 |
static TI_STATUS __cfg_fm_coex (TI_HANDLE hCmdBld)
|
|
1680 |
{
|
|
1681 |
/* Set the FM Coexistence params */
|
|
1682 |
return cmdBld_CfgIeFmCoex (hCmdBld,
|
|
1683 |
&DB_WLAN(hCmdBld).tFmCoexParams,
|
|
1684 |
(void *)cmdBld_ConfigSeq,
|
|
1685 |
hCmdBld);
|
|
1686 |
}
|
|
1687 |
|
|
1688 |
|
|
1689 |
static TI_STATUS __cfg_rate_management (TI_HANDLE hCmdBld)
|
|
1690 |
{
|
|
1691 |
DB_RM(hCmdBld).rateMngParams.paramIndex = 0xFF;
|
|
1692 |
|
|
1693 |
return cmdBld_CfgIeRateMngDbg(hCmdBld,
|
|
1694 |
&DB_RM(hCmdBld).rateMngParams,
|
|
1695 |
(void *)cmdBld_ConfigSeq,
|
|
1696 |
hCmdBld);
|
|
1697 |
|
|
1698 |
}
|
|
1699 |
|
|
1700 |
|
|
1701 |
TI_STATUS __itr_memory_map (TI_HANDLE hCmdBld)
|
|
1702 |
{
|
|
1703 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1704 |
|
|
1705 |
WLAN_OS_REPORT(("Interrogate TX/RX parameters\n"));
|
|
1706 |
|
|
1707 |
/* Interrogate TX/RX parameters */
|
|
1708 |
return cmdBld_ItrIeMemoryMap (hCmdBld,
|
|
1709 |
&pCmdBld->tMemMap,
|
|
1710 |
(void *)cmdBld_ConfigFwCb,
|
|
1711 |
hCmdBld);
|
|
1712 |
}
|
|
1713 |
|
|
1714 |
|
|
1715 |
static const TCmdCfgFunc aCmdIniSeq [] =
|
|
1716 |
{
|
|
1717 |
__cfg_platform_params,
|
|
1718 |
__cfg_radio_params,
|
|
1719 |
__cmd_probe_req,
|
|
1720 |
__cmd_null_data,
|
|
1721 |
__cmd_disconn,
|
|
1722 |
__cmd_ps_poll,
|
|
1723 |
__cmd_qos_null_data,
|
|
1724 |
__cmd_probe_resp,
|
|
1725 |
__cmd_beacon,
|
|
1726 |
__cmd_keep_alive_tmpl,
|
|
1727 |
__cfg_mem,
|
|
1728 |
__cfg_rx_msdu_life_time,
|
|
1729 |
__cfg_rx,
|
|
1730 |
__cfg_ac_params_0,
|
|
1731 |
__cfg_tid_0,
|
|
1732 |
__cfg_ac_params_1,
|
|
1733 |
__cfg_tid_1,
|
|
1734 |
__cfg_ac_params_2,
|
|
1735 |
__cfg_tid_2,
|
|
1736 |
__cfg_ac_params_3,
|
|
1737 |
__cfg_tid_3,
|
|
1738 |
__cfg_pd_threshold,
|
|
1739 |
__cfg_slot_time,
|
|
1740 |
__cfg_arp_ip_filter,
|
|
1741 |
__cfg_group_address_table,
|
|
1742 |
__cfg_service_period_timeout,
|
|
1743 |
__cfg_rts_threshold,
|
|
1744 |
__cfg_dco_itrim_params,
|
|
1745 |
__cfg_fragment_threshold,
|
|
1746 |
__cfg_pm_config,
|
|
1747 |
__cfg_beacon_filter_opt,
|
|
1748 |
__cfg_beacon_filter_table,
|
|
1749 |
__cfg_tx_cmplt_pacing,
|
|
1750 |
__cfg_rx_intr_pacing,
|
|
1751 |
__cfg_sg,
|
|
1752 |
__cfg_sg_enable,
|
|
1753 |
__cfg_fm_coex,
|
|
1754 |
__cfg_cca_threshold,
|
|
1755 |
__cfg_bcn_brc_options,
|
|
1756 |
__cmd_enable_rx,
|
|
1757 |
__cmd_enable_tx,
|
|
1758 |
__cfg_ps_wmm,
|
|
1759 |
__cfg_event_scan_cmplt,
|
|
1760 |
__cfg_event_sps_scan_cmplt,
|
|
1761 |
__cfg_event_plt_rx_calibration_cmplt,
|
|
1762 |
__cfg_hw_enc_dec_enable,
|
|
1763 |
__cfg_rssi_snr_weights,
|
|
1764 |
__cfg_rssi_snr_trigger_0,
|
|
1765 |
__cfg_rssi_snr_trigger_1,
|
|
1766 |
__cfg_rssi_snr_trigger_2,
|
|
1767 |
__cfg_rssi_snr_trigger_3,
|
|
1768 |
__cfg_rssi_snr_trigger_4,
|
|
1769 |
__cfg_rssi_snr_trigger_5,
|
|
1770 |
__cfg_rssi_snr_trigger_6,
|
|
1771 |
__cfg_rssi_snr_trigger_7,
|
|
1772 |
__cfg_max_tx_retry,
|
|
1773 |
__cfg_split_scan_timeout,
|
|
1774 |
|
|
1775 |
/* Re-join sequence */
|
|
1776 |
__cfg_tx_rate_policy,
|
|
1777 |
__cmd_beacon_join,
|
|
1778 |
__cmd_probe_resp_join,
|
|
1779 |
__cmd_probe_req_join,
|
|
1780 |
__cmd_null_data_join,
|
|
1781 |
__cmd_disconn_join,
|
|
1782 |
__cmd_ps_poll_join,
|
|
1783 |
__cmd_keep_alive_tmpl_join,
|
|
1784 |
__cfg_slot_time_join,
|
|
1785 |
__cfg_preamble_join,
|
|
1786 |
__cfg_ht_capabilities,
|
|
1787 |
__cfg_ht_information,
|
|
1788 |
__cmd_start_join,
|
|
1789 |
__cfg_aid,
|
|
1790 |
__cfg_ba_set_session,
|
|
1791 |
__cfg_tx_power_join,
|
|
1792 |
__cfg_keys,
|
|
1793 |
__cmd_keep_alive_params,
|
|
1794 |
__cfg_conn_monit_params,
|
|
1795 |
__cfg_bet,
|
|
1796 |
__cfg_cts_protection,
|
|
1797 |
__cfg_ps_rx_streaming,
|
|
1798 |
__cfg_rx_data_filter,
|
|
1799 |
__cmd_sta_state,
|
|
1800 |
__cmd_power_auth,
|
|
1801 |
__cmd_burst_mode_enable,
|
|
1802 |
//__cmd_smart_reflex_state,
|
|
1803 |
//__cmd_smart_reflex_debug,
|
|
1804 |
__cfg_rate_management,
|
|
1805 |
/* Interrogate command -> must be last!! */
|
|
1806 |
__itr_memory_map,
|
|
1807 |
|
|
1808 |
NULL
|
|
1809 |
};
|
|
1810 |
|
|
1811 |
|
|
1812 |
/****************************************************************************
|
|
1813 |
* cmdBld_ConfigSeq()
|
|
1814 |
****************************************************************************
|
|
1815 |
* DESCRIPTION: Configuration sequence engine
|
|
1816 |
*
|
|
1817 |
* INPUTS: None
|
|
1818 |
*
|
|
1819 |
* OUTPUT: None
|
|
1820 |
*
|
|
1821 |
* RETURNS: TI_OK or TI_NOK
|
|
1822 |
****************************************************************************/
|
|
1823 |
TI_STATUS cmdBld_ConfigSeq (TI_HANDLE hCmdBld)
|
|
1824 |
{
|
|
1825 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1826 |
|
|
1827 |
do
|
|
1828 |
{
|
|
1829 |
if (aCmdIniSeq [pCmdBld->uIniSeq++] == NULL)
|
|
1830 |
{
|
|
1831 |
return TI_NOK;
|
|
1832 |
}
|
|
1833 |
}
|
|
1834 |
while ((*aCmdIniSeq [pCmdBld->uIniSeq - 1])(hCmdBld) != TI_OK);
|
|
1835 |
|
|
1836 |
return TI_OK;
|
|
1837 |
}
|
|
1838 |
|
|
1839 |
/****************************************************************************
|
|
1840 |
* cmdBld_FinalizeDownload()
|
|
1841 |
****************************************************************************
|
|
1842 |
* DESCRIPTION: Finalize all the remaining initialization after the download has finished
|
|
1843 |
*
|
|
1844 |
* INPUTS:
|
|
1845 |
*
|
|
1846 |
* OUTPUT: None
|
|
1847 |
*
|
|
1848 |
* RETURNS: void
|
|
1849 |
****************************************************************************/
|
|
1850 |
void cmdBld_FinalizeDownload (TI_HANDLE hCmdBld, TBootAttr *pBootAttr, FwStaticData_t *pFwInfo)
|
|
1851 |
{
|
|
1852 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1853 |
TI_UINT8 *pMacAddr = pFwInfo->dot11StationID;
|
|
1854 |
TI_UINT32 i;
|
|
1855 |
TI_UINT8 uTmp;
|
|
1856 |
|
|
1857 |
/* Save FW version */
|
|
1858 |
os_memoryCopy (pCmdBld->hOs,
|
|
1859 |
(void *)DB_HW(hCmdBld).fwVer,
|
|
1860 |
(void *)pFwInfo->FWVersion,
|
|
1861 |
sizeof(DB_HW(hCmdBld).fwVer));
|
|
1862 |
|
|
1863 |
/* Save MAC adress (correct the bytes order first) */
|
|
1864 |
for (i = 0; i < 3; i++)
|
|
1865 |
{
|
|
1866 |
uTmp = pMacAddr[i];
|
|
1867 |
pMacAddr[i] = pMacAddr[5 - i];
|
|
1868 |
pMacAddr[5 - i] = uTmp;
|
|
1869 |
}
|
|
1870 |
MAC_COPY (DB_HW(hCmdBld).macAddress, pMacAddr);
|
|
1871 |
|
|
1872 |
/* Save chip ID */
|
|
1873 |
os_memoryCopy (pCmdBld->hOs,
|
|
1874 |
(void *)&(DB_HW(hCmdBld).uHardWareVersion),
|
|
1875 |
(void *)&(pFwInfo->HardWareVersion),
|
|
1876 |
sizeof(DB_HW(hCmdBld).uHardWareVersion));
|
|
1877 |
|
|
1878 |
/* Save power-levels table */
|
|
1879 |
os_memoryCopy (pCmdBld->hOs,
|
|
1880 |
(void *)DB_HW(hCmdBld).txPowerTable,
|
|
1881 |
(void *)pFwInfo->txPowerTable,
|
|
1882 |
sizeof(DB_HW(hCmdBld).txPowerTable));
|
|
1883 |
|
|
1884 |
/* Call the upper layer callback */
|
|
1885 |
(*((TFinalizeCb)pCmdBld->fFinalizeDownload)) (pCmdBld->hFinalizeDownload);
|
|
1886 |
}
|
|
1887 |
|
|
1888 |
|
|
1889 |
TI_STATUS cmdBld_GetParam (TI_HANDLE hCmdBld, TTwdParamInfo *pParamInfo)
|
|
1890 |
{
|
|
1891 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1892 |
TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);
|
|
1893 |
|
|
1894 |
switch (pParamInfo->paramType)
|
|
1895 |
{
|
|
1896 |
case TWD_RTS_THRESHOLD_PARAM_ID:
|
|
1897 |
pParamInfo->content.halCtrlRtsThreshold = pWlanParams->RtsThreshold;
|
|
1898 |
break;
|
|
1899 |
|
|
1900 |
case TWD_FRAG_THRESHOLD_PARAM_ID:
|
|
1901 |
pParamInfo->content.halCtrlFragThreshold = pWlanParams->FragmentThreshold;
|
|
1902 |
break;
|
|
1903 |
|
|
1904 |
case TWD_COUNTERS_PARAM_ID:
|
|
1905 |
/* Constant zero because the ACX last buffer next pointer is always pointed
|
|
1906 |
to itself, so it's like an endless buffer*/
|
|
1907 |
pParamInfo->content.halCtrlCounters.RecvNoBuffer = 0;
|
|
1908 |
pParamInfo->content.halCtrlCounters.FragmentsRecv = 0; /* not supported;*/
|
|
1909 |
pParamInfo->content.halCtrlCounters.FrameDuplicates = 0;/* not supported*/
|
|
1910 |
pParamInfo->content.halCtrlCounters.FcsErrors = DB_CNT(hCmdBld).FcsErrCnt;
|
|
1911 |
pParamInfo->content.halCtrlCounters.RecvError = DB_CNT(hCmdBld).FcsErrCnt;
|
|
1912 |
break;
|
|
1913 |
|
|
1914 |
case TWD_LISTEN_INTERVAL_PARAM_ID:
|
|
1915 |
pParamInfo->content.halCtrlListenInterval = pWlanParams->ListenInterval;
|
|
1916 |
break;
|
|
1917 |
|
|
1918 |
case TWD_RSN_DEFAULT_KEY_ID_PARAM_ID:
|
|
1919 |
/* Not implemented */
|
|
1920 |
return TI_NOK;
|
|
1921 |
|
|
1922 |
case TWD_RSN_SECURITY_MODE_PARAM_ID:
|
|
1923 |
pParamInfo->content.rsnEncryptionStatus = pCmdBld->tSecurity.eSecurityMode;
|
|
1924 |
break;
|
|
1925 |
|
|
1926 |
case TWD_ACX_STATISTICS_PARAM_ID:
|
|
1927 |
/* Not implemented */
|
|
1928 |
#if 0
|
|
1929 |
{
|
|
1930 |
acxStatisitcs_t acxStatisitics;
|
|
1931 |
pParamInfo->content.acxStatisitics.FWpacketReceived = acxStatisitics.FWpacketReceived;
|
|
1932 |
/* Not supported */
|
|
1933 |
pParamInfo->content.acxStatisitics.HALpacketReceived = 0;
|
|
1934 |
}
|
|
1935 |
#endif
|
|
1936 |
return TI_NOK;
|
|
1937 |
|
|
1938 |
case TWD_MEDIUM_OCCUPANCY_PARAM_ID:
|
|
1939 |
if (cmdBld_ItrIeMediumOccupancy (hCmdBld, pParamInfo->content.interogateCmdCBParams) != TI_OK)
|
|
1940 |
return TI_NOK;
|
|
1941 |
break;
|
|
1942 |
|
|
1943 |
case TWD_TSF_DTIM_MIB_PARAM_ID:
|
|
1944 |
if (cmdBld_ItrIeTfsDtim (hCmdBld, pParamInfo->content.interogateCmdCBParams) != TI_OK)
|
|
1945 |
return TI_NOK;
|
|
1946 |
break;
|
|
1947 |
|
|
1948 |
case TWD_AID_PARAM_ID:
|
|
1949 |
if (cmdBld_GetCurrentAssociationId (hCmdBld, &pParamInfo->content.halCtrlAid) != TI_OK)
|
|
1950 |
return TI_NOK;
|
|
1951 |
|
|
1952 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , " AID 2 %d\n", pParamInfo->content.halCtrlAid);
|
|
1953 |
break;
|
|
1954 |
|
|
1955 |
case TWD_NOISE_HISTOGRAM_PARAM_ID:
|
|
1956 |
if (cmdBld_ItrIeNoiseHistogramResults (hCmdBld, pParamInfo->content.interogateCmdCBParams) != TI_OK)
|
|
1957 |
{
|
|
1958 |
return TI_NOK;
|
|
1959 |
}
|
|
1960 |
break;
|
|
1961 |
|
|
1962 |
case TWD_CURRENT_CHANNEL_PARAM_ID:
|
|
1963 |
/* Get current channel number */
|
|
1964 |
pParamInfo->content.halCtrlCurrentChannel = DB_BSS(hCmdBld).RadioChannel;
|
|
1965 |
break;
|
|
1966 |
|
|
1967 |
/* SNR and RSSI belongs to the same MIB, and the relevant CB is passed here*/
|
|
1968 |
case TWD_RSSI_LEVEL_PARAM_ID:
|
|
1969 |
case TWD_SNR_RATIO_PARAM_ID:
|
|
1970 |
/* 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 */
|
|
1971 |
cmdBld_ItrRSSI (hCmdBld,
|
|
1972 |
pParamInfo->content.interogateCmdCBParams.fCb,
|
|
1973 |
pParamInfo->content.interogateCmdCBParams.hCb,
|
|
1974 |
pParamInfo->content.interogateCmdCBParams.pCb);
|
|
1975 |
break;
|
|
1976 |
|
|
1977 |
case TWD_BCN_BRC_OPTIONS_PARAM_ID:
|
|
1978 |
pParamInfo->content.BcnBrcOptions.BeaconRxTimeout = pWlanParams->BcnBrcOptions.BeaconRxTimeout;
|
|
1979 |
pParamInfo->content.BcnBrcOptions.BroadcastRxTimeout = pWlanParams->BcnBrcOptions.BroadcastRxTimeout;
|
|
1980 |
pParamInfo->content.BcnBrcOptions.RxBroadcastInPs = pWlanParams->BcnBrcOptions.RxBroadcastInPs;
|
|
1981 |
break;
|
|
1982 |
|
|
1983 |
case TWD_MAX_RX_MSDU_LIFE_TIME_PARAM_ID:
|
|
1984 |
pParamInfo->content.halCtrlMaxRxMsduLifetime = pWlanParams->MaxRxMsduLifetime;
|
|
1985 |
break;
|
|
1986 |
|
|
1987 |
case TWD_TX_RATE_CLASS_PARAM_ID:
|
|
1988 |
pParamInfo->content.pTxRatePlicy = &DB_BSS(hCmdBld).TxRateClassParams;
|
|
1989 |
break;
|
|
1990 |
|
|
1991 |
case TWD_SG_CONFIG_PARAM_ID:
|
|
1992 |
return cmdBld_ItrSg (hCmdBld,
|
|
1993 |
pParamInfo->content.interogateCmdCBParams.fCb,
|
|
1994 |
pParamInfo->content.interogateCmdCBParams.hCb,
|
|
1995 |
(void*)pParamInfo->content.interogateCmdCBParams.pCb);
|
|
1996 |
|
|
1997 |
case TWD_TX_POWER_PARAM_ID:
|
|
1998 |
pParamInfo->content.halCtrlTxPowerDbm = DB_WLAN(hCmdBld).TxPowerDbm;
|
|
1999 |
break;
|
|
2000 |
|
|
2001 |
case TWD_RADIO_TEST_PARAM_ID:
|
|
2002 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Radio Test\n");
|
|
2003 |
return cmdBld_CmdTest (hCmdBld,
|
|
2004 |
pParamInfo->content.interogateCmdCBParams.fCb,
|
|
2005 |
pParamInfo->content.interogateCmdCBParams.hCb,
|
|
2006 |
(TTestCmd*)pParamInfo->content.interogateCmdCBParams.pCb);
|
|
2007 |
|
|
2008 |
case TWD_DCO_ITRIM_PARAMS_ID:
|
|
2009 |
pParamInfo->content.tDcoItrimParams.enable = pWlanParams->dcoItrimEnabled;
|
|
2010 |
pParamInfo->content.tDcoItrimParams.moderationTimeoutUsec = pWlanParams->dcoItrimModerationTimeoutUsec;
|
|
2011 |
break;
|
|
2012 |
|
|
2013 |
default:
|
|
2014 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_GetParam - ERROR - Param is not supported, %d\n\n", pParamInfo->paramType);
|
|
2015 |
return (PARAM_NOT_SUPPORTED);
|
|
2016 |
}
|
|
2017 |
|
|
2018 |
return TI_OK;
|
|
2019 |
}
|
|
2020 |
|
|
2021 |
|
|
2022 |
static TI_STATUS cmdBld_ReadMibBeaconFilterIETable (TI_HANDLE hCmdBld, TI_HANDLE hCb, void* fCb, void* pCb)
|
|
2023 |
{
|
|
2024 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2025 |
TMib *pMib = (TMib*)pCb;
|
|
2026 |
TCmdQueueInterrogateCb RetFunc = (TCmdQueueInterrogateCb)fCb;
|
|
2027 |
TI_UINT8 IETableSize = 0;
|
|
2028 |
|
|
2029 |
/*Get params*/
|
|
2030 |
pMib->aData.BeaconFilter.iNumberOfIEs = DB_WLAN(hCmdBld).beaconFilterIETable.numberOfIEs;
|
|
2031 |
IETableSize = DB_WLAN(hCmdBld).beaconFilterIETable.IETableSize;
|
|
2032 |
|
|
2033 |
os_memoryZero (pCmdBld->hOs,
|
|
2034 |
pMib->aData.BeaconFilter.iIETable,
|
|
2035 |
sizeof(pMib->aData.BeaconFilter.iIETable));
|
|
2036 |
|
|
2037 |
os_memoryCopy (pCmdBld->hOs,
|
|
2038 |
pMib->aData.BeaconFilter.iIETable,
|
|
2039 |
DB_WLAN(hCmdBld).beaconFilterIETable.IETable,
|
|
2040 |
IETableSize);
|
|
2041 |
|
|
2042 |
pMib->Length = IETableSize + 1;
|
|
2043 |
|
|
2044 |
RetFunc(hCb, TI_OK, pCb);
|
|
2045 |
|
|
2046 |
return TI_OK;
|
|
2047 |
}
|
|
2048 |
|
|
2049 |
/**
|
|
2050 |
* \author \n
|
|
2051 |
* \date \n
|
|
2052 |
* \brief Coordinates between legacy TxRatePolicy implementation and the MIB format: \n
|
|
2053 |
* Converts the pGwsi_txRatePolicy back to whal commands
|
|
2054 |
* Activates the whal whalCtrl_set function
|
|
2055 |
* Function Scope \e Public.\n
|
|
2056 |
* \param - \n
|
|
2057 |
* \return \n
|
|
2058 |
*/
|
|
2059 |
static TI_STATUS cmdBld_ReadMibTxRatePolicy (TI_HANDLE hCmdBld, TI_HANDLE hCb, void* fCb, void* pCb)
|
|
2060 |
{
|
|
2061 |
TMib* pMib = (TMib*)pCb;
|
|
2062 |
TCmdQueueInterrogateCb RetFunc = (TCmdQueueInterrogateCb)fCb;
|
|
2063 |
TTwdParamInfo param;
|
|
2064 |
TI_STATUS status = TI_OK;
|
|
2065 |
|
|
2066 |
param.paramType = TWD_TX_RATE_CLASS_PARAM_ID;
|
|
2067 |
cmdBld_GetParam (hCmdBld, ¶m);
|
|
2068 |
if (param.content.pTxRatePlicy == NULL)
|
|
2069 |
return TI_NOK;
|
|
2070 |
|
|
2071 |
/*Copy the data form the param to the MIB*/
|
|
2072 |
pMib->aData.txRatePolicy = *param.content.pTxRatePlicy;
|
|
2073 |
pMib->Length = pMib->aData.txRatePolicy.numOfRateClasses * sizeof(pMib->aData.txRatePolicy.rateClass[0]) +
|
|
2074 |
sizeof(pMib->aData.txRatePolicy.numOfRateClasses);
|
|
2075 |
RetFunc (hCb, status, pCb);
|
|
2076 |
return status;
|
|
2077 |
}
|
|
2078 |
|
|
2079 |
|
|
2080 |
TI_STATUS cmdBld_ReadMib (TI_HANDLE hCmdBld, TI_HANDLE hCb, void* fCb, void* pCb)
|
|
2081 |
{
|
|
2082 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2083 |
TMib *pMibBuf = (TMib*)pCb;
|
|
2084 |
TCmdQueueInterrogateCb RetFunc = (TCmdQueueInterrogateCb)fCb;
|
|
2085 |
TI_STATUS Status = TI_OK;
|
|
2086 |
|
|
2087 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ReadMib :pMibBuf %p:\n",pMibBuf);
|
|
2088 |
|
|
2089 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ReadMib :aMib %x:\n", pMibBuf->aMib);
|
|
2090 |
|
|
2091 |
switch (pMibBuf->aMib)
|
|
2092 |
{
|
|
2093 |
case MIB_dot11MaxReceiveLifetime:
|
|
2094 |
{
|
|
2095 |
TTwdParamInfo ParamInfo;
|
|
2096 |
ParamInfo.paramType = TWD_MAX_RX_MSDU_LIFE_TIME_PARAM_ID;
|
|
2097 |
ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlMaxRxMsduLifetime);
|
|
2098 |
Status = cmdBld_GetParam (hCmdBld, &ParamInfo);
|
|
2099 |
pMibBuf->aData.MaxReceiveLifeTime = ParamInfo.content.halCtrlMaxRxMsduLifetime / 1024; /* converting from usecs to TUs*/
|
|
2100 |
pMibBuf->Length = sizeof(pMibBuf->aData.MaxReceiveLifeTime);
|
|
2101 |
}
|
|
2102 |
break;
|
|
2103 |
|
|
2104 |
case MIB_dot11GroupAddressesTable:
|
|
2105 |
{
|
|
2106 |
Status = cmdBld_GetGroupAddressTable (hCmdBld,
|
|
2107 |
&pMibBuf->aData.GroupAddressTable.bFilteringEnable,
|
|
2108 |
&pMibBuf->aData.GroupAddressTable.nNumberOfAddresses,
|
|
2109 |
pMibBuf->aData.GroupAddressTable.aGroupTable);
|
|
2110 |
|
|
2111 |
pMibBuf->Length = sizeof(pMibBuf->aData.GroupAddressTable.bFilteringEnable) +
|
|
2112 |
sizeof(pMibBuf->aData.GroupAddressTable.nNumberOfAddresses) +
|
|
2113 |
pMibBuf->aData.GroupAddressTable.nNumberOfAddresses * sizeof(TMacAddr);
|
|
2114 |
}
|
|
2115 |
break;
|
|
2116 |
|
|
2117 |
case MIB_ctsToSelf:
|
|
2118 |
{
|
|
2119 |
TTwdParamInfo ParamInfo;
|
|
2120 |
ParamInfo.paramType = TWD_CTS_TO_SELF_PARAM_ID;
|
|
2121 |
ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlCtsToSelf);
|
|
2122 |
Status = cmdBld_GetParam (hCmdBld, &ParamInfo);
|
|
2123 |
pMibBuf->aData.CTSToSelfEnable = ParamInfo.content.halCtrlCtsToSelf;
|
|
2124 |
pMibBuf->Length = sizeof(pMibBuf->aData.CTSToSelfEnable);
|
|
2125 |
}
|
|
2126 |
break;
|
|
2127 |
|
|
2128 |
case MIB_arpIpAddressesTable:
|
|
2129 |
{
|
|
2130 |
TIpAddr IpAddress;
|
|
2131 |
EIpVer IPver;
|
|
2132 |
TI_UINT8 Enable;
|
|
2133 |
|
|
2134 |
pMibBuf->Length = sizeof(TMibArpIpAddressesTable);
|
|
2135 |
Status = cmdBld_GetArpIpAddressesTable (hCmdBld, &IpAddress, &Enable, &IPver);
|
|
2136 |
if (Status == TI_OK)
|
|
2137 |
{
|
|
2138 |
pMibBuf->aData.ArpIpAddressesTable.FilteringEnable = Enable;
|
|
2139 |
|
|
2140 |
if (IP_VER_4 == IPver) /* IP_VER_4 only */
|
|
2141 |
{
|
|
2142 |
IP_COPY (pMibBuf->aData.ArpIpAddressesTable.addr, IpAddress);
|
|
2143 |
}
|
|
2144 |
else
|
|
2145 |
{
|
|
2146 |
Status = TI_NOK;
|
|
2147 |
}
|
|
2148 |
}
|
|
2149 |
return Status;
|
|
2150 |
}
|
|
2151 |
|
|
2152 |
case MIB_rxFilter:
|
|
2153 |
{
|
|
2154 |
TI_UINT32 RxConfigOption;
|
|
2155 |
TI_UINT32 RxFilterOption;
|
|
2156 |
|
|
2157 |
pMibBuf->Length = 1;
|
|
2158 |
pMibBuf->aData.RxFilter = 0;
|
|
2159 |
|
|
2160 |
/* Get RX filter data */
|
|
2161 |
Status = cmdBld_GetRxFilters (hCmdBld, &RxConfigOption, &RxFilterOption);
|
|
2162 |
if (TI_OK == Status)
|
|
2163 |
{
|
|
2164 |
/*Translate to MIB bitmap*/
|
|
2165 |
if ((RxConfigOption & RX_CFG_MAC) == RX_CFG_ENABLE_ANY_DEST_MAC)
|
|
2166 |
pMibBuf->aData.RxFilter |= MIB_RX_FILTER_PROMISCOUS_SET;
|
|
2167 |
|
|
2168 |
if ((RxConfigOption & RX_CFG_BSSID) == RX_CFG_ENABLE_ONLY_MY_BSSID)
|
|
2169 |
pMibBuf->aData.RxFilter |= MIB_RX_FILTER_BSSID_SET;
|
|
2170 |
}
|
|
2171 |
}
|
|
2172 |
break;
|
|
2173 |
|
|
2174 |
case MIB_beaconFilterIETable:
|
|
2175 |
return cmdBld_ReadMibBeaconFilterIETable (hCmdBld, hCb, fCb, pCb);
|
|
2176 |
|
|
2177 |
case MIB_txRatePolicy:
|
|
2178 |
return cmdBld_ReadMibTxRatePolicy (hCmdBld, hCb, fCb, pCb);
|
|
2179 |
|
|
2180 |
case MIB_countersTable:
|
|
2181 |
return cmdBld_ItrErrorCnt (hCmdBld, fCb, hCb, pCb);
|
|
2182 |
|
|
2183 |
case MIB_statisticsTable:
|
|
2184 |
return cmdBld_ItrRoamimgStatisitics (hCmdBld, fCb, hCb, pCb);
|
|
2185 |
|
|
2186 |
default:
|
|
2187 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "TWD_ReadMib:MIB aMib 0x%x Not supported\n",pMibBuf->aMib);
|
|
2188 |
return TI_NOK;
|
|
2189 |
}
|
|
2190 |
|
|
2191 |
if(RetFunc)
|
|
2192 |
RetFunc(hCb, Status, pCb);
|
|
2193 |
|
|
2194 |
return TI_OK;
|
|
2195 |
}
|
|
2196 |
|
|
2197 |
|
|
2198 |
TI_STATUS cmdBld_GetGroupAddressTable (TI_HANDLE hCmdBld, TI_UINT8* pEnabled, TI_UINT8* pNumGroupAddrs, TMacAddr *pGroupAddr)
|
|
2199 |
{
|
|
2200 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2201 |
TI_UINT32 i;
|
|
2202 |
|
|
2203 |
if (NULL == pEnabled || NULL == pNumGroupAddrs || NULL == pGroupAddr)
|
|
2204 |
{
|
|
2205 |
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_GetGroupAddressTable: pisEnabled=0x%p pnumGroupAddrs=0x%p Group_addr=0x%p !!!\n", pEnabled, pNumGroupAddrs, pGroupAddr);
|
|
2206 |
return PARAM_VALUE_NOT_VALID;
|
|
2207 |
}
|
|
2208 |
|
|
2209 |
*pNumGroupAddrs = DB_WLAN(hCmdBld).numGroupAddrs;
|
|
2210 |
*pEnabled = DB_WLAN(hCmdBld).isMacAddrFilteringnabled;
|
|
2211 |
|
|
2212 |
os_memoryZero (pCmdBld->hOs, pGroupAddr, sizeof(pGroupAddr));
|
|
2213 |
for (i = 0; i < *pNumGroupAddrs; i++)
|
|
2214 |
{
|
|
2215 |
os_memoryCopy (pCmdBld->hOs,
|
|
2216 |
(void *)&((*pGroupAddr)[MAC_ADDR_LEN*i]),
|
|
2217 |
&DB_WLAN(hCmdBld).aGroupAddr[i],
|
|
2218 |
MAC_ADDR_LEN);
|
|
2219 |
}
|
|
2220 |
|
|
2221 |
return TI_OK;
|
|
2222 |
}
|
|
2223 |
|
|
2224 |
|
|
2225 |
TI_STATUS cmdBld_GetRxFilters (TI_HANDLE hCmdBld, TI_UINT32* pRxConfigOption, TI_UINT32* pRxFilterOption)
|
|
2226 |
{
|
|
2227 |
*pRxConfigOption = DB_WLAN(hCmdBld).RxConfigOption;
|
|
2228 |
*pRxFilterOption = DB_WLAN(hCmdBld).RxFilterOption;
|
|
2229 |
|
|
2230 |
return TI_OK;
|
|
2231 |
}
|
|
2232 |
|
|
2233 |
|
|
2234 |
TFwInfo * cmdBld_GetFWInfo (TI_HANDLE hCmdBld)
|
|
2235 |
{
|
|
2236 |
return &DB_HW(hCmdBld);
|
|
2237 |
}
|
|
2238 |
|
|
2239 |
|
|
2240 |
|
|
2241 |
TI_STATUS cmdBld_SetRadioBand (TI_HANDLE hCmdBld, ERadioBand eRadioBand)
|
|
2242 |
{
|
|
2243 |
DB_WLAN(hCmdBld).RadioBand = eRadioBand;
|
|
2244 |
|
|
2245 |
return TI_OK;
|
|
2246 |
}
|
|
2247 |
|
|
2248 |
|
|
2249 |
/****************************************************************************
|
|
2250 |
* cmdBld_CurrentAssociationIdGet()
|
|
2251 |
****************************************************************************
|
|
2252 |
* DESCRIPTION: Get the current TX antenna
|
|
2253 |
*
|
|
2254 |
* INPUTS:
|
|
2255 |
*
|
|
2256 |
* OUTPUT:
|
|
2257 |
*
|
|
2258 |
* RETURNS: TI_OK or TI_NOK
|
|
2259 |
****************************************************************************/
|
|
2260 |
TI_STATUS cmdBld_GetCurrentAssociationId (TI_HANDLE hCmdBld, TI_UINT16 *pAidVal)
|
|
2261 |
{
|
|
2262 |
*pAidVal = DB_WLAN(hCmdBld).Aid;
|
|
2263 |
|
|
2264 |
return TI_OK;
|
|
2265 |
}
|
|
2266 |
|
|
2267 |
|
|
2268 |
/****************************************************************************
|
|
2269 |
* cmdBld_GetArpIpAddressesTable()
|
|
2270 |
****************************************************************************
|
|
2271 |
* DESCRIPTION: Sets the Group table according to the given configuration.
|
|
2272 |
*
|
|
2273 |
* OUTPUT: None
|
|
2274 |
*
|
|
2275 |
* RETURNS: TI_OK or TI_NOK
|
|
2276 |
****************************************************************************/
|
|
2277 |
TI_STATUS cmdBld_GetArpIpAddressesTable (TI_HANDLE hCmdBld, TIpAddr *pIp, TI_UINT8* pbEnabled, EIpVer *pIpVer)
|
|
2278 |
{
|
|
2279 |
*pIpVer = (EIpVer)DB_WLAN(hCmdBld).arp_IP_ver;
|
|
2280 |
|
|
2281 |
IP_COPY (*pIp, DB_WLAN(hCmdBld).arp_IP_addr);
|
|
2282 |
|
|
2283 |
*pbEnabled = DB_WLAN(hCmdBld).isArpIpFilteringEnabled;
|
|
2284 |
|
|
2285 |
return TI_OK;
|
|
2286 |
}
|
|
2287 |
|
|
2288 |
|
|
2289 |
TI_STATUS cmdBld_ConvertAppRatesBitmap (TI_UINT32 uAppRatesBitmap, TI_UINT32 uAppModulation, EHwRateBitFiled *pHwRatesBitmap)
|
|
2290 |
{
|
|
2291 |
EHwRateBitFiled uRatesBitmap = 0;
|
|
2292 |
|
|
2293 |
if (uAppRatesBitmap & DRV_RATE_MASK_1_BARKER) uRatesBitmap |= HW_BIT_RATE_1MBPS;
|
|
2294 |
if (uAppRatesBitmap & DRV_RATE_MASK_2_BARKER) uRatesBitmap |= HW_BIT_RATE_2MBPS;
|
|
2295 |
if (uAppRatesBitmap & DRV_RATE_MASK_5_5_CCK) uRatesBitmap |= HW_BIT_RATE_5_5MBPS;
|
|
2296 |
if (uAppRatesBitmap & DRV_RATE_MASK_11_CCK) uRatesBitmap |= HW_BIT_RATE_11MBPS;
|
|
2297 |
if (uAppRatesBitmap & DRV_RATE_MASK_22_PBCC) uRatesBitmap |= HW_BIT_RATE_22MBPS;
|
|
2298 |
if (uAppRatesBitmap & DRV_RATE_MASK_6_OFDM) uRatesBitmap |= HW_BIT_RATE_6MBPS;
|
|
2299 |
if (uAppRatesBitmap & DRV_RATE_MASK_9_OFDM) uRatesBitmap |= HW_BIT_RATE_9MBPS;
|
|
2300 |
if (uAppRatesBitmap & DRV_RATE_MASK_12_OFDM) uRatesBitmap |= HW_BIT_RATE_12MBPS;
|
|
2301 |
if (uAppRatesBitmap & DRV_RATE_MASK_18_OFDM) uRatesBitmap |= HW_BIT_RATE_18MBPS;
|
|
2302 |
if (uAppRatesBitmap & DRV_RATE_MASK_24_OFDM) uRatesBitmap |= HW_BIT_RATE_24MBPS;
|
|
2303 |
if (uAppRatesBitmap & DRV_RATE_MASK_36_OFDM) uRatesBitmap |= HW_BIT_RATE_36MBPS;
|
|
2304 |
if (uAppRatesBitmap & DRV_RATE_MASK_48_OFDM) uRatesBitmap |= HW_BIT_RATE_48MBPS;
|
|
2305 |
if (uAppRatesBitmap & DRV_RATE_MASK_54_OFDM) uRatesBitmap |= HW_BIT_RATE_54MBPS;
|
|
2306 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_0_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_0;
|
|
2307 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_1_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_1;
|
|
2308 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_2_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_2;
|
|
2309 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_3_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_3;
|
|
2310 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_4_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_4;
|
|
2311 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_5_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_5;
|
|
2312 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_6_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_6;
|
|
2313 |
if (uAppRatesBitmap & DRV_RATE_MASK_MCS_7_OFDM) uRatesBitmap |= HW_BIT_RATE_MCS_7;
|
|
2314 |
|
|
2315 |
*pHwRatesBitmap = uRatesBitmap;
|
|
2316 |
|
|
2317 |
return TI_OK;
|
|
2318 |
}
|
|
2319 |
|
|
2320 |
EHwRateBitFiled rateNumberToBitmap(TI_UINT8 uRate)
|
|
2321 |
{
|
|
2322 |
switch(uRate)
|
|
2323 |
{
|
|
2324 |
case 1: return HW_BIT_RATE_1MBPS;
|
|
2325 |
case 2: return HW_BIT_RATE_2MBPS;
|
|
2326 |
case 5: return HW_BIT_RATE_5_5MBPS;
|
|
2327 |
case 6: return HW_BIT_RATE_6MBPS;
|
|
2328 |
case 9: return HW_BIT_RATE_9MBPS;
|
|
2329 |
case 11: return HW_BIT_RATE_11MBPS;
|
|
2330 |
case 12: return HW_BIT_RATE_12MBPS;
|
|
2331 |
case 18: return HW_BIT_RATE_18MBPS;
|
|
2332 |
case 22: return HW_BIT_RATE_22MBPS;
|
|
2333 |
case 24: return HW_BIT_RATE_24MBPS;
|
|
2334 |
case 36: return HW_BIT_RATE_36MBPS;
|
|
2335 |
case 48: return HW_BIT_RATE_48MBPS;
|
|
2336 |
case 54: return HW_BIT_RATE_54MBPS;
|
|
2337 |
default:
|
|
2338 |
return 0;
|
|
2339 |
}
|
|
2340 |
}
|
|
2341 |
|
|
2342 |
TI_STATUS cmdBld_ConvertAppRate (ERate AppRate, TI_UINT8 *pHwRate)
|
|
2343 |
{
|
|
2344 |
TI_UINT8 Rate = 0;
|
|
2345 |
TI_STATUS status = TI_OK;
|
|
2346 |
|
|
2347 |
switch (AppRate)
|
|
2348 |
{
|
|
2349 |
/*
|
|
2350 |
* The handle for 5.5/11/22 PBCC was removed !!!
|
|
2351 |
*/
|
|
2352 |
|
|
2353 |
case DRV_RATE_1M: Rate = txPolicy1; break;
|
|
2354 |
case DRV_RATE_2M: Rate = txPolicy2; break;
|
|
2355 |
case DRV_RATE_5_5M: Rate = txPolicy5_5; break;
|
|
2356 |
case DRV_RATE_11M: Rate = txPolicy11; break;
|
|
2357 |
case DRV_RATE_22M: Rate = txPolicy22; break;
|
|
2358 |
case DRV_RATE_6M: Rate = txPolicy6; break;
|
|
2359 |
case DRV_RATE_9M: Rate = txPolicy9; break;
|
|
2360 |
case DRV_RATE_12M: Rate = txPolicy12; break;
|
|
2361 |
case DRV_RATE_18M: Rate = txPolicy18; break;
|
|
2362 |
case DRV_RATE_24M: Rate = txPolicy24; break;
|
|
2363 |
case DRV_RATE_36M: Rate = txPolicy36; break;
|
|
2364 |
case DRV_RATE_48M: Rate = txPolicy48; break;
|
|
2365 |
case DRV_RATE_54M: Rate = txPolicy54; break;
|
|
2366 |
case DRV_RATE_MCS_0: Rate = txPolicyMcs0; break;
|
|
2367 |
case DRV_RATE_MCS_1: Rate = txPolicyMcs1; break;
|
|
2368 |
case DRV_RATE_MCS_2: Rate = txPolicyMcs2; break;
|
|
2369 |
case DRV_RATE_MCS_3: Rate = txPolicyMcs3; break;
|
|
2370 |
case DRV_RATE_MCS_4: Rate = txPolicyMcs4; break;
|
|
2371 |
case DRV_RATE_MCS_5: Rate = txPolicyMcs5; break;
|
|
2372 |
case DRV_RATE_MCS_6: Rate = txPolicyMcs6; break;
|
|
2373 |
case DRV_RATE_MCS_7: Rate = txPolicyMcs7; break;
|
|
2374 |
|
|
2375 |
default:
|
|
2376 |
WLAN_OS_REPORT(("%s wrong app rate = %d\n",__FUNCTION__,AppRate));
|
|
2377 |
status = TI_NOK;
|
|
2378 |
break;
|
|
2379 |
}
|
|
2380 |
|
|
2381 |
if (status == TI_OK)
|
|
2382 |
*pHwRate = Rate;
|
|
2383 |
else
|
|
2384 |
*pHwRate = txPolicy1;
|
|
2385 |
|
|
2386 |
return status;
|
|
2387 |
}
|
|
2388 |
|
|
2389 |
|
|
2390 |
TI_STATUS cmdBld_SetRxFilter (TI_HANDLE hCmdBld, TI_UINT32 uRxConfigOption, TI_UINT32 uRxFilterOption)
|
|
2391 |
{
|
|
2392 |
DB_WLAN(hCmdBld).RxConfigOption = uRxConfigOption;
|
|
2393 |
DB_WLAN(hCmdBld).RxFilterOption = uRxFilterOption;
|
|
2394 |
DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_ENABLE_PHY_HEADER_PLCP;
|
|
2395 |
|
|
2396 |
if (DB_WLAN(hCmdBld).RxDisableBroadcast)
|
|
2397 |
{
|
|
2398 |
DB_WLAN(hCmdBld).RxConfigOption |= RX_CFG_DISABLE_BCAST;
|
|
2399 |
}
|
|
2400 |
|
|
2401 |
return TI_OK;
|
|
2402 |
}
|
|
2403 |
|
|
2404 |
|
|
2405 |
TI_UINT8 cmdBld_GetBssType (TI_HANDLE hCmdBld)
|
|
2406 |
{
|
|
2407 |
return DB_BSS(hCmdBld).ReqBssType;
|
|
2408 |
}
|
|
2409 |
|
|
2410 |
|
|
2411 |
TI_UINT32 cmdBld_GetAckPolicy (TI_HANDLE hCmdBld, TI_UINT32 uQueueId)
|
|
2412 |
{
|
|
2413 |
return (TI_UINT32)DB_QUEUES(hCmdBld).queues[uQueueId].ackPolicy;
|
|
2414 |
}
|
|
2415 |
|
|
2416 |
|
|
2417 |
TI_STATUS cmdBld_SetSecuritySeqNum (TI_HANDLE hCmdBld, TI_UINT8 securitySeqNumLsByte)
|
|
2418 |
{
|
|
2419 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2420 |
|
|
2421 |
/* If 8 lsb wrap around occurred (new < old). */
|
|
2422 |
if ((TI_UINT16)securitySeqNumLsByte < (pCmdBld->uSecuritySeqNumLow & 0xFF))
|
|
2423 |
{
|
|
2424 |
/* Increment the upper byte of the 16 lsb. */
|
|
2425 |
pCmdBld->uSecuritySeqNumLow += 0x100;
|
|
2426 |
|
|
2427 |
/* If 16 bit wrap around occurred, increment the upper 32 bit. */
|
|
2428 |
if (!(pCmdBld->uSecuritySeqNumLow & 0xFF00))
|
|
2429 |
pCmdBld->uSecuritySeqNumHigh++;
|
|
2430 |
}
|
|
2431 |
|
|
2432 |
/* Save new sequence number 8 lsb (received from the FW). */
|
|
2433 |
pCmdBld->uSecuritySeqNumLow &= 0xFF00;
|
|
2434 |
pCmdBld->uSecuritySeqNumLow |= (TI_UINT16)securitySeqNumLsByte;
|
|
2435 |
|
|
2436 |
return TI_OK;
|
|
2437 |
}
|
|
2438 |
|
|
2439 |
/****************************************************************************
|
|
2440 |
* cmdBld_JoinCmpltForReconfigCb()
|
|
2441 |
****************************************************************************
|
|
2442 |
* DESCRIPTION: The Join-Complete callback used by the reconfig sequenc (see __cmd_start_join()).
|
|
2443 |
* It restores the original Join-Complete CB and continues the sequence.
|
|
2444 |
* It is needed so the reconfig sequence won't progress before the Join
|
|
2445 |
* command is completed (otherwise the FW may drop the other commands).
|
|
2446 |
*
|
|
2447 |
* INPUTS: hCmdBld - The module object
|
|
2448 |
*
|
|
2449 |
* OUTPUT: None
|
|
2450 |
*
|
|
2451 |
* RETURNS: TI_OK
|
|
2452 |
****************************************************************************/
|
|
2453 |
static TI_STATUS cmdBld_JoinCmpltForReconfigCb (TI_HANDLE hCmdBld)
|
|
2454 |
{
|
|
2455 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2456 |
void *fDummyCb;
|
|
2457 |
TI_HANDLE hDummyHndl;
|
|
2458 |
|
|
2459 |
/* Restored the original Join-Complete callback function */
|
|
2460 |
eventMbox_ReplaceEvent (pCmdBld->hEventMbox,
|
|
2461 |
TWD_OWN_EVENT_JOIN_CMPLT,
|
|
2462 |
pCmdBld->fJoinCmpltOriginalCbFunc,
|
|
2463 |
pCmdBld->hJoinCmpltOriginalCbHndl,
|
|
2464 |
&fDummyCb,
|
|
2465 |
&hDummyHndl);
|
|
2466 |
|
|
2467 |
/* Call the reconfig sequence to continue the configuration after Join completion */
|
|
2468 |
cmdBld_ConfigSeq (hCmdBld);
|
|
2469 |
|
|
2470 |
return TI_OK;
|
|
2471 |
}
|
|
2472 |
|
|
2473 |
|
|
2474 |
|
|
2475 |
static TI_STATUS cmdBld_DummyCb (TI_HANDLE hCmdBld)
|
|
2476 |
{
|
|
2477 |
return TI_OK;
|
|
2478 |
}
|
|
2479 |
|
|
2480 |
|
|
2481 |
|
|
2482 |
|
|
2483 |
|
|
2484 |
#ifdef TI_DBG
|
|
2485 |
|
|
2486 |
void cmdBld_DbgForceTemplatesRates (TI_HANDLE hCmdBld, TI_UINT32 uRateMask)
|
|
2487 |
{
|
|
2488 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2489 |
|
|
2490 |
pCmdBld->uDbgTemplatesRateMask = uRateMask;
|
|
2491 |
}
|
|
2492 |
|
|
2493 |
#endif /* TI_DBG */
|
|
2494 |
|