|
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 |