1 /****************************************************************************
2 **+-----------------------------------------------------------------------+**
3 **| |**
4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
5 **| All rights reserved. |**
6 **| |**
7 **| Redistribution and use in source and binary forms, with or without |**
8 **| modification, are permitted provided that the following conditions |**
9 **| are met: |**
10 **| |**
11 **| * Redistributions of source code must retain the above copyright |**
12 **| notice, this list of conditions and the following disclaimer. |**
13 **| * Redistributions in binary form must reproduce the above copyright |**
14 **| notice, this list of conditions and the following disclaimer in |**
15 **| the documentation and/or other materials provided with the |**
16 **| distribution. |**
17 **| * Neither the name Texas Instruments nor the names of its |**
18 **| contributors may be used to endorse or promote products derived |**
19 **| from this software without specific prior written permission. |**
20 **| |**
21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
32 **| |**
33 **+-----------------------------------------------------------------------+**
34 ****************************************************************************/
35
36 #include "whalCommon.h"
37 #include "whalCtrl_api.h"
38 #include "whalCtrl.h"
39 #include "txHwQueue_api.h"
40 #include "txXfer_api.h"
41 #include "txResult_api.h"
42 #include "whalSecurity.h"
43 #include "eventMbox_api.h"
44 #include "whalBus_Api.h"
45 #include "TNETW_Driver_api.h"
46 #include "commonTypes.h"
47 #include "TNETW_Driver.h"
48 #include "DebugTraceXfer_api.h"
49 #include "FwEvent_api.h"
50
51 /*
52 Rx filter field is mostly hard-coded.
53 This filter value basically pass only valid beacons / probe responses. For exact bit description,
54 consult either the DPG or the FPG (or both, and Yoel...)
55 */
56 #define CFG_RX_PRSP_EN_ 4
57 #define CFG_RX_MGMT_EN_ 0x10
58 #define CFG_RX_BCN_EN_ 0x200
59 #define RX_FILTER_CFG_ (CFG_RX_PRSP_EN_ | CFG_RX_MGMT_EN_ | CFG_RX_BCN_EN_)
60
61 #define SIZE_OF_HEADER 4
62
63 void whalCtrl_PrintAll (TI_HANDLE hWhalCtrl);
64
65
66 #ifdef ROAMING_TRIGGER_DBG
67 static void whalCtrl_dbg_RSSI_LEVEL(TI_HANDLE hWhalCtrl,char* str , UINT32 strLen);
68 TI_STATUS whalCtrl_dbg_SYNCHRONIZATION(TI_HANDLE hWhalCtrl);
69 TI_STATUS whalCtrl_dbg_BSS_LOSE(TI_HANDLE hWhalCtrl);
70 TI_STATUS whalCtrl_dbg_MAX_TX_RETRY(TI_HANDLE hWhalCtrl);
71 TI_STATUS whalCtrl_dbgRegisterRoamingEventCB(TI_HANDLE hWhalCtrl);
72 int whalCtrl_dbgRoamingCommands (TI_HANDLE hWhalCtrl);
73 #endif
74
75 static int whalCtrl_ReadTemplateFrameMib(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf);
76 static int whalCtrl_WriteTemplateFrameMib(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib);
77 static int whalCtrl_PltMibSetBeaconFilterIETable(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib);
78 static int whalCtrl_PltMibGetBeaconFilterIETable(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf);
79 static int whalCtrl_PLT_ReadMIB_TxRatePolicy(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf);
80 static int whalCtrl_PLT_WriteMIB_TxRatePolicy(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib);
81
82 /*
83 * ----------------------------------------------------------------------------
84 * Function : whalCtrl_Create
85 *
86 * Input :
87 * Output :
88 * Process :
89 * Note(s) : Done
90 * -----------------------------------------------------------------------------
91 */
whalCtrl_Create(TI_HANDLE hOs)92 TI_HANDLE whalCtrl_Create (TI_HANDLE hOs)
93 {
94 WHAL_CTRL *pWhalCtrl;
95 WlanParams_T *pWlanParams;
96 DmaParams_T *pDmaParams;
97
98 /*
99 allocate the HAL Ctrl
100 */
101 pWhalCtrl = (WHAL_CTRL *)os_memoryAlloc (hOs, sizeof(WHAL_CTRL));
102 if (pWhalCtrl == NULL)
103 {
104 WLAN_OS_REPORT(("whalCtrl_Create: Error memory Allocation\n"));
105 return NULL;
106 }
107 os_memoryZero (hOs, (void *)pWhalCtrl, sizeof(WHAL_CTRL));
108
109 pWhalCtrl->hOs = hOs;
110 pWhalCtrl->EncDecEnableFlag = FALSE;
111
112
113 /*
114 Create the Params object
115 */
116 pWhalCtrl->pWhalParams = whal_params_Create (hOs,TRUE);
117 if (pWhalCtrl->pWhalParams == NULL)
118 {
119 WLAN_OS_REPORT(("whalCtrl_Create: Error whal_params_Create\n"));
120 whalCtrl_Destroy(pWhalCtrl);
121 return NULL;
122 }
123
124 /* Initialize the Params object database fields*/
125 pWlanParams = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
126 pWlanParams->hwAccessMethod = HW_ACCESS_BUS_SLAVE_INDIRECT;
127 pWlanParams->maxSitesFragCollect = HAL_CTRL_SITE_FRAG_COLLECT_DEF;
128 pWlanParams->RtsThreshold = HAL_CTRL_RTS_THRESHOLD_DEF;
129 pWlanParams->bJoin = FALSE;
130
131 /*soft gemini defaults*/
132 pWlanParams->SoftGeminiEnable = SG_DISABLE;
133
134
135 /*becon filter defaults*/
136 pWlanParams->beaconFilterParams.desiredState = FALSE;
137 pWlanParams->beaconFilterParams.numOfElements = DEF_NUM_STORED_FILTERS;
138 pWlanParams->beaconFilterIETable.numberOfIEs = DEF_BEACON_FILTER_IE_TABLE_NUM;
139 pWlanParams->beaconFilterIETable.IETableSize = BEACON_FILTER_IE_TABLE_DEF_SIZE;
140
141
142 /* set the dma params */
143 pDmaParams = whal_ParamsGetDmaParams(pWhalCtrl->pWhalParams);
144 whal_ParamsSetDmaParams(pWhalCtrl->pWhalParams);
145
146
147
148 /*
149 Configure the hardware control object
150 */
151 pWhalCtrl->pHwCtrl = whal_hwCtrl_Create(hOs, pWhalCtrl->pWhalParams);
152 if (pWhalCtrl->pHwCtrl == NULL)
153 {
154 WLAN_OS_REPORT(("whalCtrl_Create: Error whal_hwCtrl_Create\n"));
155 whalCtrl_Destroy(pWhalCtrl);
156 return NULL;
157 }
158
159 /* set the Roaming params */
160 /* Configure the Low RSSI, the Low SNR and the Missed beacon Defaults */
161 whal_ParamsSetRoamingParams(pWhalCtrl->pWhalParams);
162
163
164 /*
165 Create the Security Object
166 */
167 pWhalCtrl->pWhalSecurity = whalSecur_Create (hOs, pWhalCtrl, pDmaParams->NumStations);
168
169 if (pWhalCtrl->pWhalSecurity == NULL)
170 {
171 WLAN_OS_REPORT(("whalCtrl_Create: Error whalSecur_Create\n"));
172 whalCtrl_Destroy(pWhalCtrl);
173 return NULL;
174 }
175
176
177 WLAN_INIT_REPORT(("whalCtrl_Create end %x\n",(TI_HANDLE)pWhalCtrl));
178
179 return (pWhalCtrl);
180 }
181
182 /*
183 * ----------------------------------------------------------------------------
184 * Function : whalCtrl_GetSetHwAddr
185 *
186 * Input :
187 * Output :
188 * Process : Configure the hardware control object
189 * Note(s) : Done
190 * -----------------------------------------------------------------------------
191 */
whalCtrl_GetSetHwAddr(WHAL_CTRL * pWhalCtrl,TI_HANDLE hMemMgr,UINT32 * pFWImage)192 int whalCtrl_GetSetHwAddr (WHAL_CTRL* pWhalCtrl, TI_HANDLE hMemMgr,UINT32 *pFWImage)
193 {
194 int Status;
195 UINT32 AcxRegAddr;
196 UINT32 AcxMemAddr;
197
198 /*
199 * Initiate and get the wlan hardware register and memory addresses
200 */
201 AcxRegAddr = (UINT32)os_hwGetRegistersAddr(pWhalCtrl->hOs);
202 AcxMemAddr = (UINT32)os_hwGetMemoryAddr(pWhalCtrl->hOs);
203
204 /* Get the handle of the Interrupt handler object */
205 pWhalCtrl->hWhalBus = whal_hwCtrl_GetBusHandle(pWhalCtrl->pHwCtrl);
206
207 /*
208 * Configure wlan hardware control object
209 */
210 Status = whal_hwCtrl_Config( pWhalCtrl->pHwCtrl,(TI_HANDLE)pWhalCtrl,
211 whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams)->hwAccessMethod,
212 AcxRegAddr,
213 AcxMemAddr,
214 pWhalCtrl->hReport,
215 hMemMgr,
216 pFWImage,
217
218 pWhalCtrl->hEventMbox);
219 if (Status == TNETWIF_ERROR)
220 {
221 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl_GetSetHwAddr: whal_hwCtrl_Config failure \n"));
222 }
223
224 return Status;
225 }
226
227
228 typedef int (*fcallback_t) (TI_HANDLE);
229
230
231 /*
232 * ----------------------------------------------------------------------------
233 * Function : whalCtrl_ConfigHwCb2
234 *
235 * Input :
236 * Output :
237 * Process : last configuration call to the low level hal
238 * Note(s) : Done
239 * -----------------------------------------------------------------------------
240 */
whalCtrl_ConfigHwCb2(TI_HANDLE hWhalCtrl,TI_STATUS status)241 static int whalCtrl_ConfigHwCb2 (TI_HANDLE hWhalCtrl, TI_STATUS status)
242 {
243 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
244
245 if (status != OK)
246 {
247 return NOK;
248 }
249
250 /* Call the upper layer callback */
251 return (*((fcallback_t)pWhalCtrl->fCb)) (pWhalCtrl->hCb);
252 }
253
254
255 /*
256 * ----------------------------------------------------------------------------
257 * Function : whalCtrl_ConfigHwCb1
258 *
259 * Input :
260 * Output :
261 * Process : last configuration call to the low level hal
262 * Note(s) : Done
263 * -----------------------------------------------------------------------------
264 */
whalCtrl_ConfigHwCb1(TI_HANDLE hWhalCtrl,TI_STATUS status)265 static int whalCtrl_ConfigHwCb1 (TI_HANDLE hWhalCtrl, TI_STATUS status)
266 {
267 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
268 DmaParams_T *pDmaParams = whal_ParamsGetDmaParams (pWhalCtrl->pWhalParams);
269
270 /*
271 * Store the addresses of the double buffer (Rx/Tx)
272 * and the path status and control (Tx/Rx) in the corresponding modules
273 */
274 FwEvent_SetHwInfo (pWhalCtrl->hFwEvent, &(pWhalCtrl->pHwCtrl->DataPathParams));
275
276 txXfer_setHwInfo (pWhalCtrl->hTxXfer, &(pWhalCtrl->pHwCtrl->DataPathParams));
277
278 txResult_setHwInfo (pWhalCtrl->hTxResult, &(pWhalCtrl->pHwCtrl->DataPathParams));
279
280 rxXfer_SetDoubleBufferAddr (pWhalCtrl->hRxXfer, &(pWhalCtrl->pHwCtrl->DataPathParams));
281
282 /* Provide number of HW Tx-blocks and descriptors to Tx-HW-Queue module */
283 txHwQueue_setHwInfo (pWhalCtrl->hTxHwQueue, pDmaParams);
284
285 #ifdef TI_DBG
286 /* Set the debug trace addresses */
287 debugTrace_ConfigHw (pWhalCtrl->hDebugTrace,
288 (UINT32)pWhalCtrl->pHwCtrl->MemMap.debugBuffer1Start,
289 (UINT32)pWhalCtrl->pHwCtrl->MemMap.debugBuffer2Start);
290 #endif /* TI_DBG */
291
292 /*
293 * Register all health/sanityCheck/Recovery callbacks
294 * --------------------------------------------------
295 * DeviceError - CORE callback for full recovery
296 * HealthReport - Event Mbox callback for extracting device error
297 * MacStatus - Event Mbox callback for checkHwStatus FCS_ERR, RX_FREE_MEM regs
298 * AciIndication - Event Mbox callback for accumulate SCR_PAD8 image
299 * Mailbox error - Mailbox queue callback for case of timeout/error
300 * Power control error - PowerMngr callback in case of power ctrl timeout
301 * Failure event - CORE Callback in case of MailboxError or PowerCtrl error
302 */
303 #ifdef USE_RECOVERY
304 whalCtrl_RegisterErrorsCallbacks (hWhalCtrl);
305 #endif
306
307 #ifdef ROAMING_TRIGGER_DBG
308 whalCtrl_dbgRegisterRoamingEventCB (hWhalCtrl);
309 whalCtrl_dbgRoamingCommands (hWhalCtrl);
310 #endif
311
312 return whal_hwInfoElemMiscTableGet (pWhalCtrl->pHwCtrl->pHwMboxConfig,
313 &pWhalCtrl->misc,
314 (void *)whalCtrl_ConfigHwCb2,
315 hWhalCtrl);
316 }
317
318
319 /*
320 * ----------------------------------------------------------------------------
321 * Function : whalCtrl_ConfigHw
322 *
323 * Input :
324 * Output :
325 * Process : last configuration call to the low level hal
326 * Note(s) : Done
327 * -----------------------------------------------------------------------------
328 */
whalCtrl_ConfigHw(TI_HANDLE hWhalCtrl,TnetwDrv_InitParams_t * pInitParams,void * fCb,TI_HANDLE hCb)329 int whalCtrl_ConfigHw
330 (
331 TI_HANDLE hWhalCtrl,
332 TnetwDrv_InitParams_t *pInitParams,
333 void *fCb,
334 TI_HANDLE hCb
335 )
336 {
337 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
338 TxParam_t *pTxParams = whal_ParamsGetTxParams (pWhalCtrl->pWhalParams);
339 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams (pWhalCtrl->pWhalParams);
340 UINT8 acID;
341 int k = 0;
342
343 pWhalCtrl->fCb = fCb;
344 pWhalCtrl->hCb = hCb;
345
346 if (NULL != pInitParams)
347 {
348 /* whalCtrl_init_t */
349 pWlanParams->PacketDetectionThreshold = pInitParams->whalCtrl_init.packetDetectionThreshold;
350 pWlanParams->qosNullDataTemplateSize = pInitParams->whalCtrl_init.qosNullDataTemplateSize;
351 pWlanParams->PsPollTemplateSize = pInitParams->whalCtrl_init.PsPollTemplateSize;
352 pWlanParams->probeResponseTemplateSize = pInitParams->whalCtrl_init.probeResponseTemplateSize;
353 pWlanParams->probeRequestTemplateSize = pInitParams->whalCtrl_init.probeRequestTemplateSize;
354 pWlanParams->beaconTemplateSize = pInitParams->whalCtrl_init.beaconTemplateSize;
355 pWlanParams->nullTemplateSize = pInitParams->whalCtrl_init.nullTemplateSize;
356 /* Beacon broadcast options */
357 pWlanParams->BcnBrcOptions.BeaconRxTimeout = pInitParams->whalCtrl_init.BeaconRxTimeout;
358 pWlanParams->BcnBrcOptions.BroadcastRxTimeout = pInitParams->whalCtrl_init.BroadcastRxTimeout;
359 pWlanParams->BcnBrcOptions.RxBroadcastInPs = pInitParams->whalCtrl_init.RxBroadcastInPs;
360
361 pWlanParams->ConsecutivePsPollDeliveryFailureThreshold =
362 pInitParams->whalCtrl_init.ConsecutivePsPollDeliveryFailureThreshold;
363
364 pTxParams->txCompleteTimeout = pInitParams->whalCtrl_init.txCompleteTimeout;
365 pTxParams->txCompleteThreshold = pInitParams->whalCtrl_init.txCompleteThreshold;
366
367 /* halCtrlConfigParams_t */
368 pWlanParams->RxEnergyDetection = pInitParams->halCtrlConfigParams.halCtrlRxEnergyDetection;
369 pWlanParams->TxEnergyDetection = pInitParams->halCtrlConfigParams.halCtrlTxEnergyDetection;
370 pWlanParams->ACIMode = pInitParams->halCtrlConfigParams.halCtrlACIMode;
371 pWlanParams->inputCCA = pInitParams->halCtrlConfigParams.halCtrlInputCCA;
372 pWlanParams->qualifiedCCA = pInitParams->halCtrlConfigParams.halCtrlQualifiedCCA;
373 pWlanParams->stompForRx = pInitParams->halCtrlConfigParams.halCtrlStompForRx;
374 pWlanParams->stompForTx = pInitParams->halCtrlConfigParams.halCtrlStompForTx;
375 pWlanParams->txCCA = pInitParams->halCtrlConfigParams.halCtrlTxCCA;
376 pWlanParams->RxDisableBroadcast = pInitParams->halCtrlConfigParams.halCtrlRxDisableBroadcast;
377 pWlanParams->calibrationChannel2_4 = pInitParams->halCtrlConfigParams.halCtrlCalibrationChannel2_4;
378 pWlanParams->calibrationChannel5_0 = pInitParams->halCtrlConfigParams.halCtrlCalibrationChannel5_0;
379
380 /* Not used but need by Palau */
381 pWlanParams->RtsThreshold = pInitParams->halCtrlConfigParams.halCtrlRtsThreshold;
382 pWlanParams->CtsToSelf = CTS_TO_SELF_DISABLE;
383
384 pWlanParams->WiFiWmmPS = pInitParams->halCtrlConfigParams.WiFiWmmPS;
385
386 pWlanParams->MaxTxMsduLifetime = pInitParams->halCtrlConfigParams.halCtrlMaxTxMsduLifetime;
387 pWlanParams->MaxRxMsduLifetime = pInitParams->halCtrlConfigParams.halCtrlMaxRxMsduLifetime;
388
389 pWlanParams->rxTimeOut.psPoll = pInitParams->halCtrlConfigParams.rxTimeOut.psPoll;
390 pWlanParams->rxTimeOut.UPSD = pInitParams->halCtrlConfigParams.rxTimeOut.UPSD;
391
392 /* No used */
393 pWlanParams->FragmentThreshold = pInitParams->halCtrlConfigParams.halCtrlFragThreshold;
394 pWlanParams->ListenInterval = (UINT8)pInitParams->halCtrlConfigParams.halCtrlListenInterval;
395 pWlanParams->RateFallback = pInitParams->halCtrlConfigParams.halCtrlRateFallbackRetry;
396 pWlanParams->MacClock = pInitParams->halCtrlConfigParams.halCtrlMacClock;
397 pWlanParams->ArmClock = pInitParams->halCtrlConfigParams.halCtrlArmClock;
398 pWlanParams->Enable4x = pInitParams->halCtrlConfigParams.halCtrlEnable4x;
399 pWlanParams->TxCompleteThreshold = pInitParams->halCtrlConfigParams.halCtrlTxCompleteThreshold;
400
401 /* Configure ARP IP */
402
403 pWlanParams->isArpIpFilteringEnabled = pInitParams->arpIpFilterParams.isFilterEnabled ;
404 os_memoryCopy(pWhalCtrl->hOs,(void *)pWlanParams->arp_IP_addr.addr,(void *)pInitParams->arpIpFilterParams.arpIpInitParams.addr , IP_V4_ADDR_LEN) ;
405
406 /* Configure address group */
407 pWlanParams->numGroupAddrs = pInitParams->macAddrFilterParams.numOfMacAddresses;
408 pWlanParams->isMacAddrFilteringnabled = pInitParams->macAddrFilterParams.isFilterEnabled;
409
410 for (k = 0; k < pWlanParams->numGroupAddrs; k++)
411 {
412 os_memoryCopy (pWhalCtrl->hOs,(void*)pWlanParams->Group_addr[k].addr, (void*)pInitParams->macAddrFilterParams.macAddrTable[k].addr, MAC_ADDR_LEN);
413 }
414
415 /* Configure beacon timing (early wakeup parmeter) */
416 pWlanParams->earlyWakeUp = pInitParams->macPreambleParams.earlyWakeUp;
417
418 /* QoS configure queue */
419 for (acID = 0; acID < MAX_NUM_OF_AC; acID++)
420 {
421 /*
422 * Setting ac queues params for AccessCategoryCfg (TNET configuration)
423 */
424 pWlanParams->acQueuesParams[acID].acId = acID;
425 pWlanParams->acQueuesParams[acID].qId = acID;
426 pWlanParams->acQueuesParams[acID].percentOfBlockHighThreshold = pInitParams->whalCtrl_init.TxBlocksHighPercentPerAc[acID];
427 pWlanParams->acQueuesParams[acID].percentOfBlockLowThreshold = pInitParams->whalCtrl_init.TxBlocksLowPercentPerAc[acID];
428 }
429 }
430
431 /*
432 * Configure the WLAN hardware after config all the hardware objects
433 */
434 if (whal_hwCtrl_ConfigHw (pWhalCtrl->pHwCtrl, (void *)whalCtrl_ConfigHwCb1, hWhalCtrl, FALSE) != OK)
435 return NOK;
436
437 return OK;
438 }
439
440
441 /*
442 * ----------------------------------------------------------------------------
443 * Function : whalCtrl_Config
444 *
445 * Input :
446 * Output :
447 * Process :
448 * Note(s) : Done
449 * -----------------------------------------------------------------------------
450 */
whalCtrl_Config(TI_HANDLE hWhalCtrl,TI_HANDLE hTNETW_Driver,whalCtrl_config_t * pWhalCtrlCfg,UINT32 * pFWImage)451 TI_STATUS whalCtrl_Config (TI_HANDLE hWhalCtrl,TI_HANDLE hTNETW_Driver, whalCtrl_config_t* pWhalCtrlCfg,UINT32 *pFWImage)
452 {
453 int Stt = OK;
454
455 whalSecur_config_t securCfg;
456 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
457 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
458
459 /* Save config parameters */
460 pWhalCtrl->hReport = pWhalCtrlCfg->hReport;
461 pWhalCtrl->hFwEvent = pWhalCtrlCfg->hFwEvent;
462 pWhalCtrl->hRxXfer = pWhalCtrlCfg->hRxXfer;
463 pWhalCtrl->hTxXfer = pWhalCtrlCfg->hTxXfer;
464 pWhalCtrl->hTxHwQueue = pWhalCtrlCfg->hTxHwQueue;
465 pWhalCtrl->hTxResult = pWhalCtrlCfg->hTxResult;
466 pWhalCtrl->hTNETW_Driver = hTNETW_Driver;
467 pWhalCtrl->hEventMbox = pWhalCtrlCfg->hEventMbox;
468 pWhalCtrl->hCmdQueue = pWhalCtrlCfg->hCmdQueue;
469 #ifdef TI_DBG
470 pWhalCtrl->hDebugTrace = pWhalCtrlCfg->hDebugTrace;
471 #endif /* TI_DBG */
472 /*
473 Config the Params object
474 */
475 whal_params_Config (pWhalCtrl->pWhalParams, pWhalCtrl->hReport);
476
477 /*
478 Configure the security object
479 */
480 securCfg.hMemMgr = pWhalCtrlCfg->hMemMgr;
481 securCfg.hReport = pWhalCtrl->hReport;
482 if (whalSecur_Config (pWhalCtrl->pWhalSecurity, &securCfg) != OK)
483 {
484 WLAN_REPORT_ERROR (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("Error on whalSecur_Config\n"));
485 }
486
487 /*
488 Initialize the Params object database fields
489 */
490
491 pWlanParams->FragmentationOnHal = 0;
492
493 #if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
494 /* NO pInitTableCopy in GWSI yet */
495 pWlanParams->RecoveryEnable =
496 ((TnetwDrv_InitParams_t*)(((TnetwDrv_t *)hTNETW_Driver)->pInitTableCopy))->halCtrlConfigParams.halCtrlRecoveryEnable;
497 #endif /* GWSI_DRIVER */
498
499 /*
500 Call local function to configure the hardware control object
501 */
502 /* This will at the end call the download function */
503 Stt = whalCtrl_GetSetHwAddr(pWhalCtrl, pWhalCtrlCfg->hMemMgr,pFWImage);
504 /* This could return TNETWIF__ERROR,TNETWIF_COMPLETE or TNETWIF_PENDING */
505 return (TI_STATUS)Stt;
506 }
507
508
509 /*
510 * ----------------------------------------------------------------------------
511 * Function : whalCtrl_GetTnetwifHandle
512 *
513 * Input :
514 * Output :
515 * Process :
516 * Note(s) :
517 * -----------------------------------------------------------------------------
518 */
whalCtrl_GetTnetwifHandle(TI_HANDLE hWhalCtrl)519 TI_HANDLE whalCtrl_GetTnetwifHandle (TI_HANDLE hWhalCtrl)
520 {
521 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
522
523 return whal_hwCtrl_GetTnentwifHandle (pWhalCtrl->pHwCtrl);
524 }
525
526
527 /*
528 * ----------------------------------------------------------------------------
529 * Function : whalCtrl_GetTnetwifHandle
530 *
531 * Input :
532 * Output :
533 * Process :
534 * Note(s) :
535 * -----------------------------------------------------------------------------
536 */
whalCtrl_GetWhalParams(TI_HANDLE hWhalCtrl)537 TI_HANDLE whalCtrl_GetWhalParams (TI_HANDLE hWhalCtrl)
538 {
539 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
540
541 return (TI_HANDLE)pWhalCtrl->pWhalParams;
542 }
543
544
545 /****************************************************************************
546 * whalCtrl_FinalizeDownload()
547 ****************************************************************************
548 * DESCRIPTION: Finalize all the remaining initialization after the download has finished
549 *
550 * INPUTS:
551 *
552 * OUTPUT: None
553 *
554 * RETURNS: OK or NOK
555 ****************************************************************************/
whalCtrl_FinalizeDownload(TI_HANDLE hWhalCtrl)556 TI_STATUS whalCtrl_FinalizeDownload (TI_HANDLE hWhalCtrl)
557 {
558 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
559
560 /* Call the upper layer to finalize all download action and then send the InitComplete Callback */
561 #if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
562 return TnetwDrv_InitHw_FinalizeDownload(pWhalCtrl->hTNETW_Driver);
563 #else
564 /* GWSI SA deosn't suport recovery, so the normal finalize function is called directly */
565 return TnetwDrv_FinalizeDownload (pWhalCtrl->hTNETW_Driver);
566 #endif
567 }
568
569
570 /****************************************************************************
571 * whalCtrl_FinalizeOnFailure()
572 ****************************************************************************
573 * DESCRIPTION: Finalize all the remaining initialization after the download has failed
574 *
575 * INPUTS:
576 *
577 * OUTPUT: None
578 *
579 * RETURNS: OK or NOK
580 ****************************************************************************/
whalCtrl_FinalizeOnFailure(TI_HANDLE hWhalCtrl)581 TI_STATUS whalCtrl_FinalizeOnFailure (TI_HANDLE hWhalCtrl)
582 {
583 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
584
585 /* Call the upper layer to finalize all download */
586 return TnetwDrv_FinalizeOnFailure (pWhalCtrl->hTNETW_Driver);
587 }
588
589
590 /*
591 * ----------------------------------------------------------------------------
592 * Function : whalCtrl_Register_CB
593 *
594 * Input :
595 * Output :
596 * Process :
597 * Note(s) :
598 * -----------------------------------------------------------------------------
599 */
whalCtrl_Register_CB(TI_HANDLE hWhalCtrl,tiUINT32 CallBackID,void * CBFunc,TI_HANDLE CBObj)600 void whalCtrl_Register_CB(TI_HANDLE hWhalCtrl,tiUINT32 CallBackID,void *CBFunc,TI_HANDLE CBObj)
601 {
602 WHAL_CTRL* pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
603
604 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("whalCtrl_Register_CB (Value = 0x%x)\n", CallBackID));
605
606 switch(CallBackID)
607 {
608 case HAL_INTERNAL_EVENT_FAILURE:
609 pWhalCtrl->FailureEvent_CB = (failureEventCB_t)CBFunc;
610 pWhalCtrl->FailureEvent_CB_handle = CBObj;
611 /* Register all health/sanityCheck/Recovery callbacks
612 DeviceError - CORE callback for full recovery
613 HealthReport - Event Mbox callback for extracting device error
614 MacStatus - Event Mbox callback for checkHwStatus FCS_ERR, RX_FREE_MEM regs
615 Mailbox error - Mailbox queue callback for case of timeout/error */
616 #ifdef USE_RECOVERY
617 whalCtrl_RegisterErrorsCallbacks(hWhalCtrl);
618 #else
619 CmdQueue_RegisterForErrorCB(pWhalCtrl->hCmdQueue, CBFunc, CBObj);
620 #endif
621 break;
622 case HAL_INT_COMMAND_COMPLETE:
623 whalCtrl_RegisterCmdCompleteGenericCB(hWhalCtrl,CBFunc,CBObj);
624 break;
625 default:
626 /* register to the Event MBOX the corresponding Callback */
627 whalCtrl_EventMbox_RegisterForEvent(hWhalCtrl, (int)(CallBackID), CBFunc, CBObj);
628 whalCtrl_EventMbox_Enable(hWhalCtrl, (int)(CallBackID));
629 }
630
631 return;
632 }
633
634
635 /*
636 * ----------------------------------------------------------------------------
637 * Function : whalCtrl_PreRecoveryProcess
638 *
639 * Input : TI_HANDLE hWhalCtrl
640 * Output :
641 * Process : prepare for recovery - save all mbox callbacks
642 * Note(s) :
643 * -----------------------------------------------------------------------------
644 */
645
whalCtrl_PreRecoveryProcess(TI_HANDLE hWhalCtrl)646 void whalCtrl_PreRecoveryProcess(TI_HANDLE hWhalCtrl)
647 {
648 WHAL_CTRL* pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
649
650 CmdQueue_StartReconfig( pWhalCtrl->hCmdQueue );
651 }
652
653
654 /*
655 * ----------------------------------------------------------------------------
656 * Function : whalCtrl_SetMacAddress
657 *
658 * Input :
659 * Output :
660 * Process :
661 * Note(s) : Done
662 * -----------------------------------------------------------------------------
663 */
whalCtrl_SetMacAddress(TI_HANDLE hWhalCtrl,macAddress_t * macAddr)664 int whalCtrl_SetMacAddress(TI_HANDLE hWhalCtrl, macAddress_t *macAddr)
665 {
666 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
667
668 return whal_hwCtrl_SetMacAddress(pWhalCtrl->pHwCtrl, macAddr);
669 }
670
671 /*
672 * ----------------------------------------------------------------------------
673 * Function : whalCtrl_SetParam
674 *
675 * Input :
676 * Output :
677 * Process :
678 * Note(s) : Done
679 * -----------------------------------------------------------------------------
680 */
whalCtrl_SetParam(TI_HANDLE hWhalCtrl,whalParamInfo_t * pParamInfo)681 TI_STATUS whalCtrl_SetParam (TI_HANDLE hWhalCtrl, whalParamInfo_t* pParamInfo)
682 {
683 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
684 HwMboxConfig_T *pInfoElemConfig = whal_hwCtrl_GetMboxConfig(pWhalCtrl->pHwCtrl);
685 WlanParams_T *pWlanParams = &pWhalCtrl->pWhalParams->WlanParams;
686 TxParam_t *pTxParams = whal_ParamsGetTxParams(pWhalCtrl->pWhalParams);
687
688
689 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
690 ("whalCtrl_SetParam : paramType=0x%X\n", pParamInfo->paramType));
691
692 switch ((externalParam_e)pParamInfo->paramType)
693 {
694 case HAL_CTRL_RTS_THRESHOLD_PARAM:
695
696 if (pParamInfo->content.halCtrlRtsThreshold > HAL_CTRL_RTS_THRESHOLD_MAX)
697 {
698 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl########HAL_CTRL_RTS_THRESHOLD_PARAM: Value out of permitted range 0x%x\n",
699 pParamInfo->content.halCtrlRtsThreshold));
700 return (PARAM_VALUE_NOT_VALID);
701 }
702
703 if (whal_hwInfoElemRtsThresholdSet (pInfoElemConfig,pParamInfo->content.halCtrlRtsThreshold) == OK)
704 {
705 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl########HAL_CTRL_RTS_THRESHOLD_PARAM 0x%x\n",
706 pParamInfo->content.halCtrlRtsThreshold));
707 pWlanParams->RtsThreshold = pParamInfo->content.halCtrlRtsThreshold;
708 }
709
710
711 break;
712
713 case HAL_CTRL_CTS_TO_SELF_PARAM:
714
715 if (whal_hwInfoElemCtsToSelfSet (pInfoElemConfig, pParamInfo->content.halCtrlCtsToSelf) == OK)
716 pWlanParams->CtsToSelf = pParamInfo->content.halCtrlCtsToSelf;
717 else
718 return NOK;
719
720 break;
721
722 case HAL_CTRL_RX_TIME_OUT_PARAM:
723
724 if (whal_hwInfoElemRxTimeOutSet (pInfoElemConfig, &pParamInfo->content.halCtrlRxTimeOut) == OK)
725 {
726 pWlanParams->rxTimeOut.psPoll = pParamInfo->content.halCtrlRxTimeOut.psPoll;
727 pWlanParams->rxTimeOut.UPSD = pParamInfo->content.halCtrlRxTimeOut.UPSD;
728 }
729 break;
730
731
732 case HAL_CTRL_FRAG_THRESHOLD_PARAM:
733 if ((pParamInfo->content.halCtrlFragThreshold < HAL_CTRL_FRAG_THRESHOLD_MIN) ||
734 (pParamInfo->content.halCtrlFragThreshold > HAL_CTRL_FRAG_THRESHOLD_MAX))
735 return (PARAM_VALUE_NOT_VALID);
736
737 pWlanParams->FragmentThreshold = pParamInfo->content.halCtrlFragThreshold;
738 pWlanParams->FragmentationOnHal = 0;
739 break;
740
741 case HAL_CTRL_DOT11_MAX_RX_MSDU_LIFE_TIME:
742 if (whal_hwInfoElemRxMsduLifeTimeSet (pInfoElemConfig, pParamInfo->content.halCtrlMaxRxMsduLifetime) == OK)
743 pWlanParams->MaxRxMsduLifetime = (UINT32)pParamInfo->content.halCtrlMaxRxMsduLifetime;
744 break;
745
746 case HAL_CTRL_ACX_STATISTICS_PARAM:
747 if (whal_hwInfoElemAcxStatisiticsSet (pInfoElemConfig) != OK)
748 return (NOK);
749 break;
750
751 case HAL_CTRL_LISTEN_INTERVAL_PARAM:
752 if ((pParamInfo->content.halCtrlListenInterval < HAL_CTRL_LISTEN_INTERVAL_MIN) ||
753 (pParamInfo->content.halCtrlListenInterval > HAL_CTRL_LISTEN_INTERVAL_MAX))
754 return (PARAM_VALUE_NOT_VALID);
755
756 pWlanParams->ListenInterval = (UINT8)pParamInfo->content.halCtrlListenInterval;
757 break;
758
759 case HAL_CTRL_AID_PARAM:
760 pWlanParams->Aid = pParamInfo->content.halCtrlAid;
761
762 /* Configure the ACXAID info element*/
763 if (whal_hwCtrl_AidSet (pWhalCtrl->pHwCtrl, pParamInfo->content.halCtrlAid) != OK)
764 return (NOK);
765 break;
766
767 case HAL_CTRL_RSN_HW_ENC_DEC_ENABLE_PARAM:
768
769 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
770 (" whalCtrl########HW_ENC_DEC_ENABLE %d\n", pParamInfo->content.rsnHwEncDecrEnable));
771
772 /* Set the Encryption/Decryption on the HW*/
773 if (whalSecur_HwEncDecrEnable (pWhalCtrl->pWhalSecurity, pParamInfo->content.rsnHwEncDecrEnable) != OK)
774 return (NOK);
775 break;
776
777 case HAL_CTRL_RSN_KEY_ADD_PARAM:
778
779 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl########KEY_ADD\n"));
780
781 if (whalSecur_KeyAdd (pWhalCtrl->pWhalSecurity,
782 (securityKeys_t *) pParamInfo->content.configureCmdCBParams.CB_buf,
783 FALSE,
784 pParamInfo->content.configureCmdCBParams.CB_Func,
785 pParamInfo->content.configureCmdCBParams.CB_handle) != OK)
786 return (NOK);
787 break;
788
789 case HAL_CTRL_RSN_KEY_REMOVE_PARAM:
790
791 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl########KEY_REMOVE\n"));
792
793 if (whalSecur_KeyRemove (pWhalCtrl->pWhalSecurity,
794 (securityKeys_t *) pParamInfo->content.configureCmdCBParams.CB_buf,
795 FALSE,
796 pParamInfo->content.configureCmdCBParams.CB_Func,
797 pParamInfo->content.configureCmdCBParams.CB_handle) != OK)
798 return (NOK);
799 break;
800
801 case HAL_CTRL_RSN_DEFAULT_KEY_ID_PARAM:
802 if ((int) *pParamInfo->content.configureCmdCBParams.CB_buf > MAX_DEFAULT_KEY_ID)
803 return (PARAM_VALUE_NOT_VALID);
804
805 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl########DEFAULT_KEY_ID %d\n",
806 (UINT8)pParamInfo->content.rsnDefaultKeyID));
807
808 if (whalSecur_DefaultKeyIdSet(pWhalCtrl->pWhalSecurity,
809 *pParamInfo->content.interogateCmdCBParams.CB_buf,
810 pParamInfo->content.interogateCmdCBParams.CB_Func,
811 pParamInfo->content.interogateCmdCBParams.CB_handle) != OK)
812 return (NOK);
813
814 break;
815
816 case HAL_CTRL_RSN_SECURITY_MODE_PARAM:
817 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
818 (" whalCtrl########SECURITY_MODE_SET %d\n", pParamInfo->content.rsnEncryptionStatus));
819 if (whalSecur_SecurModeSet (pWhalCtrl->pWhalSecurity, (cipherSuite_e)pParamInfo->content.rsnEncryptionStatus) != OK)
820 return (NOK);
821 break;
822
823 #ifdef EXC_MODULE_INCLUDED
824 case HAL_CTRL_RSN_EXC_SW_ENC_ENABLE_PARAM:
825 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
826 (" whalCtrl########EXC_SW_ENC_ENABLE %d\n", pParamInfo->content.rsnExcSwEncFlag));
827 #ifdef CKIP_ENABLED
828 if (whalSecur_SwEncEnable (pWhalCtrl->pWhalSecurity, pParamInfo->content.rsnExcSwEncFlag) != OK)
829 return (NOK);
830 #endif
831 /* when SW encryption is ON, HW encryption should be turned OFF and vice versa */
832
833 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
834 (" whalCtrl: Set HwEncDecrEnable to %d\n", !pParamInfo->content.rsnExcSwEncFlag));
835
836 /* Set the Encryption/Decryption on the HW*/
837 if (whalSecur_HwEncDecrEnable (pWhalCtrl->pWhalSecurity, (BOOL)(!(pParamInfo->content.rsnExcSwEncFlag))) != OK)
838 return (NOK);
839 break;
840
841 case HAL_CTRL_RSN_EXC_MIC_FIELD_ENABLE_PARAM:
842 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
843 (" whalCtrl########EXC_MIC_FIELD_ENABLE %d\n", pParamInfo->content.rsnExcMicFieldFlag));
844 #ifdef CKIP_ENABLED
845 if (whalSecur_MicFieldEnable (pWhalCtrl->pWhalSecurity, pParamInfo->content.rsnExcMicFieldFlag) != OK)
846 return (NOK);
847 #endif
848 break;
849 #endif /* EXC_MODULE_INCLUDED*/
850
851 case HAL_CTRL_TX_POWER_PARAM:
852
853 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
854 (" whalCtrl########TX_POWER_LEVEL old = %d new = %d\n",
855 pTxParams->TxPowerDbm, pParamInfo->content.halCtrlTxPowerDbm));
856
857 if ( pTxParams->TxPowerDbm == pParamInfo->content.halCtrlTxPowerDbm)
858 { /* Save up time if we set the same value */
859 return TX_POWER_SET_SAME_VALUE;
860 }
861
862 pTxParams->TxPowerDbm = pParamInfo->content.halCtrlTxPowerDbm;
863
864 /* configure the wlan hardware */
865 if (whal_hwInfoElemTxPowerSet (pInfoElemConfig,
866 &pTxParams->TxPowerDbm) != OK)
867 return (NOK);
868 break;
869
870
871 case HAL_CTRL_SG_ENABLE_PARAM:
872 return (TI_STATUS)whal_hwCtrl_SoftGeminiEnable(pWhalCtrl->pHwCtrl,(SoftGeminiEnableModes_e)pParamInfo->content.SoftGeminiEnable);
873
874 case HAL_CTRL_SG_CONFIG_PARAM:
875 return (TI_STATUS)whal_hwCtrl_SetSoftGeminiParams(pWhalCtrl->pHwCtrl,&(pParamInfo->content.SoftGeminiParam));
876
877 case HAL_CTRL_ANTENNA_DIVERSITY_PARAMS:
878 /* save parameters */
879 whal_hwCtrl_SaveAntennaDiversityOptions (pWhalCtrl->pHwCtrl, &(pParamInfo->content.antennaDiversityOptions));
880 /* Configure FW with new parameters */
881 whal_hwCtrl_CurrentAntennaDiversitySendCmd (pWhalCtrl->pHwCtrl);
882 break;
883
884 case HAL_CTRL_TX_ANTENNA_PARAM:
885 /* save antenna number */
886 whal_hwCtrl_SetTxAntenna( pWhalCtrl->pHwCtrl, pParamInfo->content.antennaNum );
887 /* Write parameters to FW */
888 whal_hwCtrl_CurrentAntennaDiversitySendCmd( pWhalCtrl->pHwCtrl );
889 break;
890
891 case HAL_CTRL_RX_ANTENNA_PARAM:
892 /* save antenna number */
893 whal_hwCtrl_SetRxAntenna( pWhalCtrl->pHwCtrl, pParamInfo->content.antennaNum );
894 /* Write parameters to FW */
895 whal_hwCtrl_CurrentAntennaDiversitySendCmd( pWhalCtrl->pHwCtrl );
896 break;
897
898 /*
899 * TX Parameters
900 */
901
902 case HAL_CTRL_TX_RATE_CLASS_PARAMS:
903 return (TI_STATUS)whal_hwCtrl_TxRatePolicy(pWhalCtrl->pHwCtrl,pParamInfo->content.pTxRatePlicy);
904 /* break; */
905
906 case HAL_CTRL_QUEUES_PARAMS:
907 os_memoryCopy (pWhalCtrl->hOs, &pWhalCtrl->pWhalParams->WlanParams.QtrafficParams,
908 pParamInfo->content.pQueueTrafficParams, sizeof(queueTrafficParams_t));
909
910 return (TI_STATUS)whal_hwCtrl_TrafficConf(pWhalCtrl->pHwCtrl,pParamInfo->content.pQueueTrafficParams);
911 /* break; */
912
913 case HAL_CTRL_AC_PARAMS:
914 os_memoryCopy (pWhalCtrl->hOs, &pWhalCtrl->pWhalParams->WlanParams.acQosParams,
915 pParamInfo->content.configureCmdCBParams.CB_buf, sizeof(acQosParams_t));
916 return (TI_STATUS)whal_hwCtrl_AcParamsConf(pWhalCtrl->pHwCtrl,&pParamInfo->content.configureCmdCBParams);
917 /* break; */
918
919
920
921 #if 0
922
923 /*Tx Ack/No Ack*/
924 case HAL_CTRL_TX_ACK_POLICY:
925 return (whal_ParamsSetAccessCategoryAckPolicy(pWhalCtrl->pWhalParams,
926 pParamInfo->content.AcAckPolicy.AckPolicy,
927 pParamInfo->content.AcAckPolicy.AcId));
928 break;
929
930 #endif
931
932 case HAL_CTRL_MIN_POWER_LEVEL:
933 whalCtrl_SetMinPowerLevel(pWhalCtrl,
934 pParamInfo->content.minPowerPolicy);
935 break;
936
937
938 case HAL_CTRL_CLK_RUN_ENABLE:
939 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
940 (" whalCtrl_SetParam: CLK_RUN_ENABLE %d\n", pParamInfo->content.halCtrlClkRunEnable));
941
942 /* Set the Encryption/Decryption on the HW*/
943 if (whal_hwCtrl_ClkRunEnableSet (pWhalCtrl->pHwCtrl, pParamInfo->content.halCtrlClkRunEnable) != OK)
944 return (NOK);
945 break;
946
947 case HAL_CTRL_EARLY_WAKEUP:
948 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
949 (" whalCtrl_SetParam: SET EARLY WAKEUP to %d\n", pParamInfo->content.earlyWakeup));
950 pWlanParams->earlyWakeUp = pParamInfo->content.earlyWakeup;
951 break;
952
953 /* PLT params */
954 case HAL_CTRL_PLT_WRITE_MIB:
955 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_WRITE_MIB(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
956 return (TI_STATUS)whalCtrl_WriteMib(hWhalCtrl, &pParamInfo->content.PltMib);
957
958 /* break; */
959
960 case HAL_CTRL_PLT_RX_PER_START:
961 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_RX_PER_START(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
962 return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_START,
963 pParamInfo->content.interogateCmdCBParams.CB_handle,
964 pParamInfo->content.interogateCmdCBParams.CB_Func);
965 /* break; */
966
967 case HAL_CTRL_PLT_RX_PER_STOP:
968 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_RX_PER_STOP(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
969 return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_STOP,
970 pParamInfo->content.interogateCmdCBParams.CB_handle,
971 pParamInfo->content.interogateCmdCBParams.CB_Func);
972 /* break; */
973
974 case HAL_CTRL_PLT_RX_PER_CLEAR:
975 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_RX_PER_CLEAR(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
976 return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_CLEAR,
977 pParamInfo->content.interogateCmdCBParams.CB_handle,
978 pParamInfo->content.interogateCmdCBParams.CB_Func);
979 /* break; */
980 case HAL_CTRL_PLT_TX_CW:
981 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_TX_CW(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
982 return (TI_STATUS)whalCtrl_TxCW(pWhalCtrl, &pParamInfo->content.PltCW,
983 NULL, NULL, NULL);
984 /*break;*/
985
986 case HAL_CTRL_PLT_TX_CONTINUES:
987 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_TX_CONTINUES(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
988 return (TI_STATUS)whalCtrl_TxContinues(pWhalCtrl, &pParamInfo->content.PltTxContinues,
989 NULL, NULL, NULL);
990 /*break;*/
991
992 case HAL_CTRL_PLT_TX_STOP:
993 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_TX_STOP(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
994 return (TI_STATUS)whal_hwCmdBit_perTxStop(pWhalCtrl->pHwCtrl->pHwMboxCmdBit,
995 NULL, NULL, NULL);
996 /*break;*/
997
998 case HAL_CTRL_PLT_WRITE_REGISTER:
999 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_WRITE_REGISTER(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
1000 return (TI_STATUS)whalCtrl_WriteRegister(pWhalCtrl, pParamInfo->content.interogateCmdCBParams.CB_handle, pParamInfo->content.interogateCmdCBParams.CB_Func, pParamInfo->content.interogateCmdCBParams.CB_buf);
1001 /* break; */
1002
1003 default:
1004 WLAN_REPORT_ERROR(pWhalCtrl->hReport,
1005 HAL_CTRL_MODULE_LOG,
1006 ("%s(%d) - whalCtrl_SetParam - ERROR - Param is not supported, %d\n\n",
1007 __FILE__,__LINE__,pParamInfo->paramType));
1008 return (PARAM_NOT_SUPPORTED);
1009 }
1010
1011 return (OK);
1012 }
1013
1014
1015 /*
1016 * ----------------------------------------------------------------------------
1017 * Function : whalCtrl_GetParam
1018 *
1019 * Input :
1020 * Output :
1021 * Process :
1022 * Note(s) : Done
1023 * -----------------------------------------------------------------------------
1024 */
whalCtrl_GetParam(TI_HANDLE hWhalCtrl,whalParamInfo_t * pParamInfo)1025 TI_STATUS whalCtrl_GetParam (TI_HANDLE hWhalCtrl, whalParamInfo_t* pParamInfo)
1026 {
1027 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1028 WlanParams_T *pWlanParams = &pWhalCtrl->pWhalParams->WlanParams;
1029 HwMboxConfig_T *pInfoElemConfig = whal_hwCtrl_GetMboxConfig(pWhalCtrl->pHwCtrl);
1030 TxParam_t *pTxParams = whal_ParamsGetTxParams(pWhalCtrl->pWhalParams);
1031
1032 switch ((externalParam_e)pParamInfo->paramType)
1033 {
1034 case HAL_CTRL_RTS_THRESHOLD_PARAM:
1035 pParamInfo->content.halCtrlRtsThreshold = pWlanParams->RtsThreshold;
1036 break;
1037
1038 case HAL_CTRL_FRAG_THRESHOLD_PARAM:
1039 pParamInfo->content.halCtrlFragThreshold = pWlanParams->FragmentThreshold;
1040 break;
1041
1042 case HAL_CTRL_COUNTERS_PARAM:
1043 /* Constant zero because the ACX last buffer next pointer is always pointed
1044 to itself, so it's like an endless buffer*/
1045 pParamInfo->content.halCtrlCounters.RecvNoBuffer = 0;
1046 pParamInfo->content.halCtrlCounters.FragmentsRecv = 0; /* not supported;*/
1047 pParamInfo->content.halCtrlCounters.FrameDuplicates = 0;/* not supported*/
1048 pParamInfo->content.halCtrlCounters.FcsErrors = pWhalCtrl->pWhalParams->GenCounters.FcsErrCnt;
1049 pParamInfo->content.halCtrlCounters.RecvError = pWhalCtrl->pWhalParams->GenCounters.FcsErrCnt;
1050 break;
1051
1052 case HAL_CTRL_LISTEN_INTERVAL_PARAM:
1053 pParamInfo->content.halCtrlListenInterval = pWlanParams->ListenInterval;
1054 break;
1055
1056 case HAL_CTRL_RSN_DEFAULT_KEY_ID_PARAM:
1057 /* Not implemented */
1058 return NOK;
1059 /* break; */
1060
1061 case HAL_CTRL_TX_POWER_PARAM:
1062 pParamInfo->content.halCtrlTxPowerDbm = pTxParams->TxPowerDbm;
1063 break;
1064
1065 case HAL_CTRL_ACX_STATISTICS_PARAM:
1066 /* Not implemented */
1067 #if 0
1068 {
1069 acxStatisitcs_t acxStatisitics;
1070 pParamInfo->content.acxStatisitics.FWpacketReceived = acxStatisitics.FWpacketReceived;
1071 /* Not supported */
1072 pParamInfo->content.acxStatisitics.HALpacketReceived = 0;
1073 }
1074 #endif
1075 return NOK;
1076
1077 case HAL_CTRL_MEDIUM_OCCUPANCY_PARAM:
1078 if (whal_hwInfoElemMediumOccupancyGet (pInfoElemConfig,
1079 pParamInfo->content.interogateCmdCBParams) != OK)
1080 return (NOK);
1081
1082 break;
1083
1084 case HAL_CTRL_TSF_DTIM_MIB:
1085 if (whal_hwInfoElemTfsDtimGet(pInfoElemConfig,
1086 pParamInfo->content.interogateCmdCBParams) != OK)
1087 return (NOK);
1088
1089 break;
1090
1091
1092 case HAL_CTRL_AID_PARAM:
1093 if (whal_hwCtrl_CurrentAssociationIdGet(pWhalCtrl->pHwCtrl,
1094 &(pParamInfo->content.halCtrlAid)) != OK)
1095 return (NOK);
1096
1097 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1098 (" AID 2 %d\n", pParamInfo->content.halCtrlAid));
1099
1100
1101 break;
1102
1103 case HAL_CTRL_NOISE_HISTOGRAM_PARAM:
1104 if (whal_hwInfoElemNoiseHistogramResultsGet (pInfoElemConfig,
1105 pParamInfo->content.interogateCmdCBParams) != OK)
1106 {
1107 return (NOK);
1108 }
1109
1110 break;
1111
1112 case HAL_CTRL_TX_ANTENNA_PARAM:
1113 /* get antenna number */
1114 whal_hwCtrl_GetTxAntenna( pWhalCtrl->pHwCtrl, &(pParamInfo->content.antennaNum) );
1115 break;
1116
1117 case HAL_CTRL_RX_ANTENNA_PARAM:
1118 /* get antenna number */
1119 whal_hwCtrl_GetRxAntenna( pWhalCtrl->pHwCtrl, &(pParamInfo->content.antennaNum) );
1120 break;
1121
1122 case HAL_CTRL_CURRENT_CHANNEL:
1123 /* get current channel number */
1124 pParamInfo->content.halCtrlCurrentChannel = whal_ParamsGetRadioChannel( pWhalCtrl->pWhalParams );
1125
1126 case HAL_CTRL_MIN_POWER_LEVEL:
1127 whalCtrl_GetMinPowerLevel(pWhalCtrl, &pParamInfo->content.minPowerPolicy);
1128 break;
1129
1130 /*SNR and RSSI belongs to the same MIB, and the relevant CB is passed here*/
1131 case HAL_CTRL_RSSI_LEVEL_PARAM:
1132 case HAL_CTRL_SNR_RATIO_PARAM:
1133 /* 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 */
1134 whalCtrl_GetAsynRSSI (pWhalCtrl,pParamInfo->content.interogateCmdCBParams.CB_Func, pParamInfo->content.interogateCmdCBParams.CB_handle , pParamInfo->content.interogateCmdCBParams.CB_buf);
1135 break;
1136
1137 case HAL_CTRL_BCN_BRC_OPTIONS:
1138 pParamInfo->content.BcnBrcOptions.BeaconRxTimeout = pWlanParams->BcnBrcOptions.BeaconRxTimeout;
1139 pParamInfo->content.BcnBrcOptions.BroadcastRxTimeout = pWlanParams->BcnBrcOptions.BroadcastRxTimeout;
1140 pParamInfo->content.BcnBrcOptions.RxBroadcastInPs = pWlanParams->BcnBrcOptions.RxBroadcastInPs;
1141 break;
1142
1143 case HAL_CTRL_DOT11_MAX_RX_MSDU_LIFE_TIME:
1144 pParamInfo->content.halCtrlMaxRxMsduLifetime = pWlanParams->MaxRxMsduLifetime;
1145 break;
1146
1147
1148 /* PLT params */
1149 case HAL_CTRL_PLT_RX_PER_GET_RESULTS:
1150 return (TI_STATUS)whalCtrl_RxPER(pWhalCtrl, PLT_RX_PER_GETRESULTS,
1151 pParamInfo->content.interogateCmdCBParams.CB_handle,
1152 pParamInfo->content.interogateCmdCBParams.CB_Func);
1153 /* break; */
1154
1155 case HAL_CTRL_PLT_READ_MIB:
1156 return (TI_STATUS)whalCtrl_ReadMib(pWhalCtrl,
1157 pParamInfo->content.interogateCmdCBParams.CB_handle,
1158 pParamInfo->content.interogateCmdCBParams.CB_Func,
1159 pParamInfo->content.interogateCmdCBParams.CB_buf);
1160
1161 /* break; */
1162
1163 case HAL_CTRL_PLT_READ_REGISTER:
1164 whalCtrl_ReadRegister(pWhalCtrl, pParamInfo->content.interogateCmdCBParams.CB_handle,
1165 pParamInfo->content.interogateCmdCBParams.CB_Func,
1166 pParamInfo->content.interogateCmdCBParams.CB_buf);
1167 break;
1168
1169 case HAL_CTRL_PLT_RX_TX_CAL:
1170 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("%s - HAL_CTRL_PLT_RX_TX_CAL(0x%x) \n", __FUNCTION__, pParamInfo->paramType));
1171 return (TI_STATUS)whal_hwCmdBit_TestCmd(pWhalCtrl->pHwCtrl->pHwMboxCmdBit,
1172 pParamInfo->content.interogateCmdCBParams.CB_Func,
1173 pParamInfo->content.interogateCmdCBParams.CB_handle,
1174 (TestCmd_t*)pParamInfo->content.interogateCmdCBParams.CB_buf);
1175 /*break*/
1176
1177 case HAL_CTRL_PLT_RX_CAL_STATUS:
1178 whal_hwCmdBit_GetPltRxCalibrationStatus( pWhalCtrl->pHwCtrl->pHwMboxCmdBit,
1179 &(pParamInfo->content.PltRxCalibrationStatus) );
1180 return OK;
1181 /* break */
1182
1183 case HAL_CTRL_CTS_TO_SELF_PARAM:
1184 pParamInfo->content.halCtrlCtsToSelf = pWlanParams->CtsToSelf;
1185 break;
1186
1187 case HAL_CTRL_TX_RATE_CLASS_PARAMS:
1188 pParamInfo->content.pTxRatePlicy = whal_hwCtrl_GetTxRatePolicy(pWhalCtrl->pHwCtrl);
1189 break;
1190
1191 case HAL_CTRL_SG_CONFIG_PARAM:
1192 return (TI_STATUS)whal_hwCtrl_GetSoftGeminiParams(pWhalCtrl->pHwCtrl,
1193 pParamInfo->content.interogateCmdCBParams.CB_Func,
1194 pParamInfo->content.interogateCmdCBParams.CB_handle,
1195 (void*)pParamInfo->content.interogateCmdCBParams.CB_buf);
1196
1197 case HAL_CTRL_REVISION:
1198 return (TI_STATUS)whal_hwInfoElemAcxRevisionGet (pInfoElemConfig,
1199 pParamInfo->content.interogateCmdCBParams.CB_Func,
1200 pParamInfo->content.interogateCmdCBParams.CB_handle,
1201 (void*)pParamInfo->content.interogateCmdCBParams.CB_buf);
1202
1203 case HAL_CTRL_RSN_SECURITY_MODE_PARAM:
1204 pParamInfo->content.rsnEncryptionStatus = (halCtrl_CipherSuite_e)whalSecur_SecurModeGet (pWhalCtrl->pWhalSecurity);
1205
1206 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1207 (" whalCtrl########SECURITY_MODE_GET %d\n", pParamInfo->content.rsnEncryptionStatus));
1208 break;
1209
1210 case HAL_CTRL_EARLY_WAKEUP:
1211 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1212 (" whalCtrl_SetParam: GET EARLY WAKEUP is %d\n", pWlanParams->earlyWakeUp));
1213 pParamInfo->content.earlyWakeup = pWlanParams->earlyWakeUp;
1214
1215 break;
1216
1217 case HAL_CTRL_POWER_LEVEL_TABLE_PARAM:
1218 if (whal_hwInfoElemPowerLevelTableGet (pInfoElemConfig,
1219 pParamInfo->content.interogateCmdCBParams) != OK)
1220 {
1221 return (NOK);
1222 }
1223
1224 break;
1225 case HAL_CTRL_POWER_CONSUMPTION:
1226 whalCtrl_getConsumptionStatistics(pWhalCtrl->pHwCtrl->pHwMboxConfig,
1227 pParamInfo->content.interogateCmdCBParams.CB_Func,
1228 pParamInfo->content.interogateCmdCBParams.CB_handle,
1229 (void*)pParamInfo->content.interogateCmdCBParams.CB_buf);
1230 break;
1231
1232 default:
1233 WLAN_REPORT_ERROR(pWhalCtrl->hReport,
1234 HAL_CTRL_MODULE_LOG,
1235 ("%s(%d) - whalCtrl_GetParam - ERROR - Param is not supported, %d\n\n",
1236 __FILE__,__LINE__,pParamInfo->paramType));
1237 return (PARAM_NOT_SUPPORTED);
1238 /* break; */
1239 }
1240
1241 return (OK);
1242 }
1243
1244
1245 /*
1246 * ----------------------------------------------------------------------------
1247 * Function : whalCtrl_setRxFilters
1248 *
1249 * Input :
1250 * Output :
1251 * Process : Configures the Rx filters
1252 * Note(s) : Done
1253 * -----------------------------------------------------------------------------
1254 */
whalCtrl_setRxFilters(TI_HANDLE hWhalCtrl,UINT32 RxConfigOption,UINT32 RxFilterOption)1255 int whalCtrl_setRxFilters(TI_HANDLE hWhalCtrl, UINT32 RxConfigOption, UINT32 RxFilterOption)
1256 {
1257 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1258
1259 return whal_hwCtrl_setRxFilters(pWhalCtrl->pHwCtrl, RxConfigOption, RxFilterOption);
1260 }
1261
1262 /*
1263 * ----------------------------------------------------------------------------
1264 * Function : whalCtrl_GetRxFilters
1265 *
1266 * Input :
1267 * Output :
1268 * Process : Configures the Rx filters
1269 * Note(s) : Done
1270 * -----------------------------------------------------------------------------
1271 */
whalCtrl_GetRxFilters(TI_HANDLE hWhalCtrl,UINT32 * pRxConfigOption,UINT32 * pRxFilterOption)1272 int whalCtrl_GetRxFilters (TI_HANDLE hWhalCtrl, UINT32* pRxConfigOption, UINT32* pRxFilterOption)
1273 {
1274 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1275
1276 return whal_hwCtrl_GetRxFilters(pWhalCtrl->pHwCtrl, pRxConfigOption, pRxFilterOption);
1277 }
1278
1279 /*
1280 * ----------------------------------------------------------------------------
1281 * Function : whalCtrl_getRxDataFiltersStatistics
1282 *
1283 * Input : Retrieve Statistics
1284 * Output :
1285 * Process :
1286 * Note(s) : Done
1287 * -----------------------------------------------------------------------------
1288 */
whalCtrl_getRxDataFiltersStatistics(TI_HANDLE hWhalCtrl,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)1289 int whalCtrl_getRxDataFiltersStatistics(TI_HANDLE hWhalCtrl, void * CB_Func, TI_HANDLE CB_handle, void * CB_Buf)
1290 {
1291 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
1292
1293 whal_hwInfoElemGetRxDataFiltersStatistics(pWhalCtrl->pHwCtrl->pHwMboxConfig, CB_Func, CB_handle, CB_Buf);
1294
1295 return OK;
1296 }
1297
1298
1299 /*
1300 * ----------------------------------------------------------------------------
1301 * Function : whalCtrl_setRxDataFiltersParams
1302 *
1303 * Input : enabled - 0 to disable data filtering, any other value to enable.
1304 * defaultAction - The default action to take on non-matching packets.
1305 * Output :
1306 * Process : Enable or disable the Rx Data Filtering feature.
1307 * Note(s) : Done
1308 * -----------------------------------------------------------------------------
1309 */
whalCtrl_setRxDataFiltersParams(TI_HANDLE hWhalCtrl,BOOL enabled,filter_e defaultAction)1310 int whalCtrl_setRxDataFiltersParams(TI_HANDLE hWhalCtrl, BOOL enabled, filter_e defaultAction)
1311 {
1312 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
1313
1314 pWhalCtrl->pWhalParams->WlanParams.rxFilterDefaultEnable = enabled;
1315 pWhalCtrl->pWhalParams->WlanParams.rxFilterDefaultAction = defaultAction;
1316
1317 return whal_hwCtrl_setRxDataFiltersParams(pWhalCtrl->pHwCtrl, enabled, defaultAction);
1318 }
1319
1320
1321 /*
1322 * ----------------------------------------------------------------------------
1323 * Function : whalCtrl_setRxDataFilter
1324 *
1325 * Input : index - Index of the Rx Data filter
1326 * command - Disable or enable the filter
1327 * action - Action to take on packets matching the pattern
1328 * numFieldPatterns - Number of field patterns in the filter
1329 * lenFieldPatterns - Length of the field pattern series
1330 * fieldPatterns - Series of field patterns
1331 * Output :
1332 * Process : Adds or removes the Rx Data Filter at the specified entry.
1333 * Note(s) : Done
1334 * -----------------------------------------------------------------------------
1335 */
whalCtrl_setRxDataFilter(TI_HANDLE hWhalCtrl,UINT8 index,UINT8 command,filter_e action,UINT8 numFieldPatterns,UINT8 lenFieldPatterns,UINT8 * fieldPatterns)1336 int whalCtrl_setRxDataFilter(TI_HANDLE hWhalCtrl, UINT8 index, UINT8 command, filter_e action, UINT8 numFieldPatterns, UINT8 lenFieldPatterns, UINT8 * fieldPatterns)
1337 {
1338 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
1339
1340 pWhalCtrl->pWhalParams->WlanParams.rxFilterCgf[index].rxFilterCommand = command;
1341 pWhalCtrl->pWhalParams->WlanParams.rxFilterCgf[index].rxFilterAction = action;
1342 pWhalCtrl->pWhalParams->WlanParams.rxFilterCgf[index].rxFilterNumFieldPatterns = numFieldPatterns;
1343 pWhalCtrl->pWhalParams->WlanParams.rxFilterCgf[index].rxFilterLenFieldPatterns = lenFieldPatterns;
1344
1345 os_memoryCopy(pWhalCtrl->hOs, (pWhalCtrl->pWhalParams->WlanParams.rxFilterCgf[index].rxFilterFieldPatterns),
1346 fieldPatterns, lenFieldPatterns);
1347
1348 return whal_hwCtrl_setRxDataFilter(pWhalCtrl->pHwCtrl, index, command, action, numFieldPatterns, lenFieldPatterns, fieldPatterns);
1349 }
1350
1351
1352
1353
1354 /*
1355 * ----------------------------------------------------------------------------
1356 * Function : whalCtrl_SetarpIpAddressesTable
1357 *
1358 * Input :
1359 * Output :
1360 * Process : Configures the ARP table
1361 * Note(s) : Done
1362 * -----------------------------------------------------------------------------
1363 */
whalCtrl_SetarpIpAddressesTable(TI_HANDLE hWhalCtrl,IpAddress_t * IP_addr,UINT8 isEnabled,IPver_e IP_ver)1364 int whalCtrl_SetarpIpAddressesTable(TI_HANDLE hWhalCtrl, IpAddress_t * IP_addr, UINT8 isEnabled , IPver_e IP_ver)
1365 {
1366 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
1367
1368 return whal_hwCtrl_SetarpIpAddressesTable(pWhalCtrl->pHwCtrl, IP_addr, isEnabled , IP_ver);
1369 }
1370
1371
1372 /*
1373 * ----------------------------------------------------------------------------
1374 * Function : whalCtrl_GetGroupIpAddressesTable
1375 *
1376 * Input :
1377 * Output :
1378 * Process : Retrieve the ARP IP address table
1379 * -----------------------------------------------------------------------------
1380 */
whalCtrl_GetGroupIpAddressesTable(TI_HANDLE hWhalCtrl,UINT8 * pisEnabled,UINT8 * pnumGroupAddrs,macAddress_t * Group_addr)1381 int whalCtrl_GetGroupIpAddressesTable(TI_HANDLE hWhalCtrl, UINT8* pisEnabled, UINT8* pnumGroupAddrs, macAddress_t *Group_addr)
1382 {
1383 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1384 return whal_hwCtrl_GetGroupAddressesTable(pWhalCtrl->pHwCtrl,
1385 pisEnabled, pnumGroupAddrs, Group_addr);
1386 }
1387
1388
1389 /*
1390 * ----------------------------------------------------------------------------
1391 * Function : whalCtrl_SetarpIpFilterEnabled
1392 *
1393 * Input :
1394 * Output :
1395 * Process : Configures the ARP table
1396 * Note(s) : Done
1397 * -----------------------------------------------------------------------------
1398 */
whalCtrl_SetarpIpFilterEnabled(TI_HANDLE hWhalCtrl,UINT8 isEnabled)1399 int whalCtrl_SetarpIpFilterEnabled(TI_HANDLE hWhalCtrl,UINT8 isEnabled )
1400 {
1401 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
1402 return whal_hwCtrl_SetarpIpFilterEnabled(pWhalCtrl->pHwCtrl, isEnabled ) ;
1403
1404 }
1405
1406
1407 /*
1408 * ----------------------------------------------------------------------------
1409 * Function : whalCtrl_StartScan
1410 *
1411 * Input :
1412 * Output :
1413 * Process :
1414 * Note(s) : Done
1415 * -----------------------------------------------------------------------------
1416 */
whalCtrl_StartScan(TI_HANDLE hWhalCtrl,whalCtrl_scan_t * pScanVals,BOOLEAN bHighPriority,void * ScanCommandResponseCB,TI_HANDLE CB_handle)1417 int whalCtrl_StartScan (TI_HANDLE hWhalCtrl, whalCtrl_scan_t* pScanVals, BOOLEAN bHighPriority ,void* ScanCommandResponseCB, TI_HANDLE CB_handle)
1418 {
1419
1420 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1421 BasicScanChannelParameters_t* chanPtr;
1422 ScanParameters_t tnetScanParams;
1423
1424 UINT8* pBSSID;
1425 int i;
1426
1427 /* Convert general scan data to tnet structure */
1428 tnetScanParams.basicScanParameters.tidTrigger = pScanVals->Tid;
1429 tnetScanParams.basicScanParameters.numOfProbRqst = pScanVals->probeReqNumber;
1430 tnetScanParams.basicScanParameters.ssidLength = pScanVals->desiredSsid.len;
1431 os_memoryCopy( pWhalCtrl->hOs, (void *)tnetScanParams.basicScanParameters.ssidStr,
1432 (void *)pScanVals->desiredSsid.ssidString, tnetScanParams.basicScanParameters.ssidLength );
1433
1434 /*
1435 scan options field is composed of scan type and band selection.
1436 First, use the lookup table to convert the scan type
1437 */
1438
1439 tnetScanParams.basicScanParameters.scanOptions = 0;
1440
1441 switch ( pScanVals->scanType )
1442 {
1443 case SCAN_TYPE_NORMAL_ACTIVE :
1444 tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE;
1445 break;
1446
1447 case SCAN_TYPE_NORMAL_PASSIVE :
1448 tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE;
1449 break;
1450
1451 case SCAN_TYPE_TRIGGERED_ACTIVE :
1452 tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE | TRIGGERED_SCAN;
1453 break;
1454
1455 case SCAN_TYPE_TRIGGERED_PASSIVE :
1456 tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE | TRIGGERED_SCAN;
1457 break;
1458
1459 default:
1460 WLAN_REPORT_ERROR( pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1461 ("Invalid scan type:%d\n", pScanVals->scanType) );
1462 return NOK;
1463 }
1464
1465 /* Add the band selection */
1466 if ( RADIO_BAND_5_0_GHZ == pScanVals->band )
1467 {
1468 tnetScanParams.basicScanParameters.scanOptions |= SCAN_5GHZ_BAND;
1469 }
1470
1471 /* Add high priority bit */
1472 if ( bHighPriority )
1473 {
1474 tnetScanParams.basicScanParameters.scanOptions |= SCAN_PRIORITY_HIGH;
1475 }
1476
1477 tnetScanParams.basicScanParameters.scanOptions = ENDIAN_HANDLE_WORD( tnetScanParams.basicScanParameters.scanOptions );
1478
1479 /* important note: BSSID filter (0x0010) is DISABLED, because the FW sets it according
1480 to BSSID value (broadcast does not filter, any other value will */
1481 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = 0x12802 ;
1482 tnetScanParams.basicScanParameters.rxCfg.FilterOptions = ENDIAN_HANDLE_LONG( RX_FILTER_CFG_ );
1483
1484 /* If the SSID is not broadcast SSID, also filter according to SSID */
1485 if ( FALSE == utils_isAnySSID( &(pScanVals->desiredSsid) ) )
1486 {
1487 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions |= 0x0400;
1488 }
1489 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = ENDIAN_HANDLE_LONG( tnetScanParams.basicScanParameters.rxCfg.ConfigOptions );
1490
1491 /* Rate conversion is done in the HAL */
1492 whalUtils_ConvertAppRatesBitmap(pScanVals->probeRequestRate, 0, &(tnetScanParams.basicScanParameters.txdRateSet));
1493 tnetScanParams.basicScanParameters.txdRateSet = ENDIAN_HANDLE_WORD( tnetScanParams.basicScanParameters.txdRateSet );
1494
1495 tnetScanParams.basicScanParameters.numChannels = ENDIAN_HANDLE_WORD( pScanVals->numOfChannels );
1496
1497 /* copy channel specific scan data to HAL structure */
1498 for ( i = 0; i < pScanVals->numOfChannels; i++ )
1499 {
1500 int j;
1501 UINT8* macAddr;
1502
1503 macAddr = (UINT8*)&tnetScanParams.basicScanChannelParameters[ i ].bssIdL;
1504
1505 /* copy the MAC address, upside down (CHIP structure) */
1506 for ( j = 0; j < MAC_ADDR_LEN; j++ )
1507 {
1508 macAddr[ j ] = pScanVals->channelEntry[ i ].normalChannelEntry.bssId.addr[ MAC_ADDR_LEN - 1 - j ];
1509 }
1510 tnetScanParams.basicScanChannelParameters[ i ].scanMinDuration =
1511 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].normalChannelEntry.minChannelDwellTime );
1512 tnetScanParams.basicScanChannelParameters[ i ].scanMaxDuration =
1513 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].normalChannelEntry.maxChannelDwellTime );
1514 tnetScanParams.basicScanChannelParameters[ i ].ETCondCount =
1515 pScanVals->channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes |
1516 pScanVals->channelEntry[ i ].normalChannelEntry.earlyTerminationEvent;
1517 tnetScanParams.basicScanChannelParameters[ i ].txPowerAttenuation =
1518 pScanVals->channelEntry[ i ].normalChannelEntry.txPowerDbm;
1519 tnetScanParams.basicScanChannelParameters[ i ].channel =
1520 pScanVals->channelEntry[ i ].normalChannelEntry.channel;
1521 }
1522
1523 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1524 ("RxCfg = 0x%x\n \
1525 RxFilterCfg = 0x%x\n \
1526 scanOptions = 0x%x\n \
1527 numChannels = %d\n \
1528 probeNumber = %d\n \
1529 probeRateModulation = 0x%x\n \
1530 tidTrigger = %d\n" ,
1531 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions,
1532 tnetScanParams.basicScanParameters.rxCfg.FilterOptions,
1533 tnetScanParams.basicScanParameters.scanOptions,
1534 tnetScanParams.basicScanParameters.numChannels,
1535 tnetScanParams.basicScanParameters.numOfProbRqst,
1536 tnetScanParams.basicScanParameters.txdRateSet,
1537 tnetScanParams.basicScanParameters.tidTrigger));
1538
1539 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1540 ("Channel BSSID MinTime MaxTime ET TxPower probChan\n"));
1541
1542 for( i=0; i < pScanVals->numOfChannels; i++)
1543 {
1544 chanPtr = &tnetScanParams.basicScanChannelParameters[i];
1545 pBSSID = (UINT8*)&chanPtr->bssIdL;
1546
1547 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1548 ("%6d %02x:%02x:%02x:%02x:%02x:%02x %5d %5d %2d %5d %5d\n",i,
1549 pBSSID[5],pBSSID[4],pBSSID[3],pBSSID[2],pBSSID[1],pBSSID[0],
1550 chanPtr->scanMinDuration, chanPtr->scanMaxDuration, chanPtr->ETCondCount,
1551 chanPtr->txPowerAttenuation, chanPtr->channel));
1552 }
1553 /* Send the scan command*/
1554 return (whal_hwCtrl_StartScan (pWhalCtrl->pHwCtrl, &tnetScanParams , ScanCommandResponseCB , CB_handle));
1555 }
1556
1557 /*
1558 * ----------------------------------------------------------------------------
1559 * Function : whalCtrl_StartSPSScan
1560 *
1561 * Input :
1562 * Output :
1563 * Process :
1564 * Note(s) : Done
1565 * -----------------------------------------------------------------------------
1566 */
whalCtrl_StartSPSScan(TI_HANDLE hWhalCtrl,whalCtrl_scan_t * pScanVals,void * ScanCommandResponseCB,TI_HANDLE CB_handle)1567 int whalCtrl_StartSPSScan( TI_HANDLE hWhalCtrl, whalCtrl_scan_t* pScanVals, void* ScanCommandResponseCB, TI_HANDLE CB_handle)
1568 {
1569
1570 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1571 ScheduledScanParameters_t tnetSPSScanParams;
1572 int i;
1573
1574 /* Convert general scan data to TNET structure */
1575 tnetSPSScanParams.scheduledGeneralParameters.scanOptions = SCAN_PASSIVE;
1576 /* Add the band selection */
1577 if ( RADIO_BAND_5_0_GHZ == pScanVals->band )
1578 {
1579 tnetSPSScanParams.scheduledGeneralParameters.scanOptions |= SCAN_5GHZ_BAND;
1580 }
1581 tnetSPSScanParams.scheduledGeneralParameters.scanOptions = ENDIAN_HANDLE_WORD( tnetSPSScanParams.scheduledGeneralParameters.scanOptions );
1582
1583 /* important note: BSSID filter (0x0010) is DISABLED, because the FW sets it according
1584 to BSSID value (broadcast does not filter, any other value will */
1585 /* If the SSID is not broadcast SSID, also filter according to SSID */
1586 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = 0x12802;
1587 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.FilterOptions = ENDIAN_HANDLE_LONG( RX_FILTER_CFG_ );
1588 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = ENDIAN_HANDLE_LONG( tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions );
1589
1590 /* latest TSF value - used to discover TSF error (AP recovery) */
1591 tnetSPSScanParams.scheduledGeneralParameters.scanCmdTime_h = ENDIAN_HANDLE_LONG( INT64_HIGHER(pScanVals->latestTSFValue) );
1592 tnetSPSScanParams.scheduledGeneralParameters.scanCmdTime_l = ENDIAN_HANDLE_LONG( INT64_LOWER(pScanVals->latestTSFValue) );
1593
1594 tnetSPSScanParams.scheduledGeneralParameters.numChannels = pScanVals->numOfChannels;
1595
1596 /* copy channel specific scan data to HAL structure */
1597 for ( i = 0; i < pScanVals->numOfChannels; i++ )
1598 {
1599 int j;
1600 UINT8* macAddr;
1601
1602 macAddr = (UINT8*)&tnetSPSScanParams.scheduledChannelParameters[ i ].bssIdL;
1603
1604 /* copy the MAC address, upside down (CHIP structure) */
1605 for ( j = 0; j < MAC_ADDR_LEN; j++ )
1606 {
1607 macAddr[ j ] = pScanVals->channelEntry[ i ].normalChannelEntry.bssId.addr[ MAC_ADDR_LEN - 1 - j ];
1608 }
1609 tnetSPSScanParams.scheduledChannelParameters[ i ].scanMaxDuration =
1610 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].SPSChannelEntry.scanDuration );
1611 tnetSPSScanParams.scheduledChannelParameters[ i ].scanStartTime =
1612 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].SPSChannelEntry.scanStartTime );
1613 tnetSPSScanParams.scheduledChannelParameters[ i ].ETCondCount =
1614 pScanVals->channelEntry[ i ].SPSChannelEntry.ETMaxNumOfAPframes |
1615 pScanVals->channelEntry[ i ].SPSChannelEntry.earlyTerminationEvent;
1616 tnetSPSScanParams.scheduledChannelParameters[ i ].channel =
1617 pScanVals->channelEntry[ i ].SPSChannelEntry.channel;
1618 }
1619 #ifdef TI_DBG
1620 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1621 ("RxCfg = 0x%x\n \
1622 RxFilterCfg = 0x%x\n \
1623 scanOptions = 0x%x\n \
1624 numChannels = %d\n",
1625 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions,
1626 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.FilterOptions,
1627 tnetSPSScanParams.scheduledGeneralParameters.scanOptions,
1628 tnetSPSScanParams.scheduledGeneralParameters.numChannels));
1629
1630 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1631 ("Channel BSSID StartTime Duration ET probChan\n"));
1632
1633 for( i=0; i < tnetSPSScanParams.scheduledGeneralParameters.numChannels; i++)
1634 {
1635 ScheduledChannelParameters_t* chanPtr = &tnetSPSScanParams.scheduledChannelParameters[ i ];
1636 UINT8* pBSSID = (UINT8*)&chanPtr->bssIdL;
1637
1638 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1639 ("%6d %02x:%02x:%02x:%02x:%02x:%02x %5d %5d %2d %5d\n",i,
1640 pBSSID[5],pBSSID[4],pBSSID[3],pBSSID[2],pBSSID[1],pBSSID[0],
1641 chanPtr->scanStartTime, chanPtr->scanMaxDuration, chanPtr->ETCondCount,
1642 chanPtr->channel));
1643 }
1644 #endif /* TI_DBG */
1645
1646 /* Send the scan command*/
1647 return (whal_hwCtrl_StartSPSScan (pWhalCtrl->pHwCtrl, &tnetSPSScanParams, ScanCommandResponseCB,CB_handle));
1648 }
1649
1650 /*
1651 * ----------------------------------------------------------------------------
1652 * Function : whalCtrl_StopScan
1653 *
1654 * Input :
1655 * Output :
1656 * Process :
1657 * Note(s) : Done
1658 * -----------------------------------------------------------------------------
1659 */
whalCtrl_StopScan(TI_HANDLE hWhalCtrl,void * ScanCommandResponseCB,TI_HANDLE CB_handle)1660 int whalCtrl_StopScan (TI_HANDLE hWhalCtrl , void* ScanCommandResponseCB, TI_HANDLE CB_handle)
1661 {
1662 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1663
1664 return (whal_hwCtrl_StopScan (pWhalCtrl->pHwCtrl, ScanCommandResponseCB, CB_handle));
1665 }
1666
1667 /*
1668 * ----------------------------------------------------------------------------
1669 * Function : whalCtrl_StopSPSScan
1670 *
1671 * Input :
1672 * Output :
1673 * Process :
1674 * Note(s) : Done
1675 * -----------------------------------------------------------------------------
1676 */
whalCtrl_StopSPSScan(TI_HANDLE hWhalCtrl,void * ScanCommandResponseCB,TI_HANDLE CB_handle)1677 int whalCtrl_StopSPSScan (TI_HANDLE hWhalCtrl, void* ScanCommandResponseCB, TI_HANDLE CB_handle)
1678 {
1679 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1680
1681 return (whal_hwCtrl_StopSPSScan (pWhalCtrl->pHwCtrl, ScanCommandResponseCB, CB_handle));
1682 }
1683
1684 /*
1685 * ----------------------------------------------------------------------------
1686 * Function : whalCtrl_SetSplitScanTimeOut
1687 *
1688 * Input :
1689 * Output :
1690 * Process :
1691 * Note(s) : Done
1692 * -----------------------------------------------------------------------------
1693 */
1694
whalCtrl_SetSplitScanTimeOut(TI_HANDLE hWhalCtrl,UINT32 uTimeOut)1695 TI_STATUS whalCtrl_SetSplitScanTimeOut (TI_HANDLE hWhalCtrl, UINT32 uTimeOut)
1696 {
1697 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1698
1699 /* Go all the way to the CmdQueue - According to new architecture ??? */
1700 return (TI_STATUS)(CmdQueue_Command (pWhalCtrl->hCmdQueue, CMD_TRIGGER_SCAN_TO, (char*)&uTimeOut, sizeof(uTimeOut)));
1701
1702 }
1703 /*
1704 * ----------------------------------------------------------------------------
1705 * Function : whalCtrl_JoinBss
1706 *
1707 * Input :
1708 * Output :
1709 * Process :
1710 * Note(s) : Done
1711 * -----------------------------------------------------------------------------
1712 */
whalCtrl_JoinBss(TI_HANDLE hWhalCtrl,whalCtrl_joinBss_t * pJoinBssParams)1713 int whalCtrl_JoinBss (TI_HANDLE hWhalCtrl, whalCtrl_joinBss_t* pJoinBssParams)
1714 {
1715 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1716 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
1717 #ifdef TI_DBG
1718 UINT8 dbgSsidStr[33];
1719 BssInfoParams_T *pBssInfoParams = whal_ParamsGetBssInfoParams(pWhalCtrl->pWhalParams);
1720 #endif /* TI_DBG */
1721
1722
1723 /* for debug purpose, can be removed later*/
1724 if (pJoinBssParams->ssidLength > 32)
1725 pJoinBssParams->ssidLength = 32;
1726
1727 #ifdef TI_DBG
1728 os_memoryCopy(pWhalCtrl->hOs, (void *)dbgSsidStr, (void *)pJoinBssParams->pSSID, pJoinBssParams->ssidLength);
1729 dbgSsidStr[pJoinBssParams->ssidLength] = '\0';
1730
1731 /* HW generate packets - CTS - should be at CCK rates only */
1732 if ((pJoinBssParams->radioBand == RADIO_BAND_2_4_GHZ) &&
1733 (pJoinBssParams->hwGenCtrlTxRate > DRV_RATE_11M))
1734 {
1735 pJoinBssParams->hwGenCtrlTxRate = DRV_RATE_2M; /* default value, if no CCK rate is in the basic rates */
1736 if(pJoinBssParams->basicRateSet & DRV_RATE_MASK_1_BARKER) pJoinBssParams->hwGenCtrlTxRate = DRV_RATE_1M;
1737 if(pJoinBssParams->basicRateSet & DRV_RATE_MASK_2_BARKER) pJoinBssParams->hwGenCtrlTxRate = DRV_RATE_2M;
1738 if(pJoinBssParams->basicRateSet & DRV_RATE_MASK_5_5_CCK) pJoinBssParams->hwGenCtrlTxRate = DRV_RATE_5_5M;
1739 if(pJoinBssParams->basicRateSet & DRV_RATE_MASK_11_CCK) pJoinBssParams->hwGenCtrlTxRate = DRV_RATE_11M;
1740
1741 WLAN_REPORT_WARNING(pWhalCtrl->hReport,HAL_CTRL_MODULE_LOG,
1742 ("%s hwGenCtrlTxRate > 11 !!! changed to %d (rate_e)\n",__FUNCTION__,pJoinBssParams->hwGenCtrlTxRate));
1743
1744 }
1745
1746 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1747 ("\n whalCtrl_JoinBss :\n \
1748 bssType = %d\n \
1749 beaconInterval = %d\n \
1750 dtimInterval = %d\n \
1751 channel = %d \n \
1752 BSSID = %x-%x-%x-%x-%x-%x \n \
1753 SSID = %s \n \
1754 ssidLength = %d \n \
1755 basicRateSet = 0x%x \n \
1756 supportedRateSet = 0x%x \n ",
1757 pJoinBssParams->bssType,
1758 pJoinBssParams->beaconInterval,
1759 pJoinBssParams->dtimInterval,
1760 pJoinBssParams->channel,
1761 pJoinBssParams->pBSSID[0],
1762 pJoinBssParams->pBSSID[1],
1763 pJoinBssParams->pBSSID[2],
1764 pJoinBssParams->pBSSID[3],
1765 pJoinBssParams->pBSSID[4],
1766 pJoinBssParams->pBSSID[5],
1767 dbgSsidStr,
1768 pJoinBssParams->ssidLength,
1769 pJoinBssParams->basicRateSet,
1770 pJoinBssParams->supportedRateSet));
1771
1772 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1773 ("RadioBand = %d \n \
1774 Ctrl = 0x%x \n \
1775 hwGenCtrlTxRate = 0x%x \n \
1776 hwGenMgmtTxRate = 0x%x \n \
1777 preamble = 0x%x \n",
1778 pJoinBssParams->radioBand,
1779 pBssInfoParams->Ctrl,
1780 pJoinBssParams->hwGenCtrlTxRate,
1781 pJoinBssParams->hwGenMgmtTxRate,
1782 pJoinBssParams->preamble));
1783 #endif /* TI_DBG */
1784 /*
1785 * save Bss info parameters
1786 */
1787 whal_ParamsSetReqBssType(pWhalCtrl->pWhalParams, pJoinBssParams->bssType);
1788 whal_ParamsSetBssId(pWhalCtrl->pWhalParams, (char *)pJoinBssParams->pBSSID);
1789 whal_ParamsSetSsid(pWhalCtrl->pWhalParams, (char *)pJoinBssParams->pSSID, pJoinBssParams->ssidLength);
1790 whal_ParamsSetBeaconInterval(pWhalCtrl->pWhalParams, (UINT16)pJoinBssParams->beaconInterval);
1791 whal_ParamsSetDtimCount(pWhalCtrl->pWhalParams, (UINT8)pJoinBssParams->dtimInterval);
1792 whal_ParamsSetRadioChannel(pWhalCtrl->pWhalParams, pJoinBssParams->channel);
1793 whal_ParamsSetRadioBand(pWhalCtrl->pWhalParams, pJoinBssParams->radioBand);
1794 whal_ParamsSetBasicRatesSet(pWhalCtrl->pWhalParams, pJoinBssParams->basicRateSet);
1795 whal_ParamsSetSupportedRatesSet(pWhalCtrl->pWhalParams, pJoinBssParams->supportedRateSet);
1796
1797 /*
1798 * Save the frame rates in whalParams and configure it to the Fw later. That command was previously included
1799 * in the join command and it is now separated.
1800 */
1801 /* Set the Ctrl frames rate and modulation */
1802 whal_ParamsSetHwGenTxParams(pWhalCtrl->pWhalParams, pJoinBssParams->hwGenCtrlTxRate, TRUE);
1803 /* Set the Management frame rate and modulation */
1804 whal_ParamsSetHwGenTxParams(pWhalCtrl->pWhalParams, pJoinBssParams->hwGenMgmtTxRate, FALSE);
1805
1806
1807 /* In case we're joining a new BSS, reset the TKIP/AES sequence counter. */
1808 /* The firmware resets its own counter - so we won't have mismatch in the following TX complete events */
1809 pWhalCtrl->pHwCtrl->SecuritySeqNumLow = 0;
1810 pWhalCtrl->pHwCtrl->SecuritySeqNumHigh = 0;
1811
1812 pWlanParams->bJoin = TRUE;
1813 /*
1814 * call the hardware to start/join the bss
1815 */
1816 return whal_hwCtrl_StartJoin(pWhalCtrl->pHwCtrl, pJoinBssParams->bssType, NULL, NULL);
1817
1818 }
1819
1820
1821 /*
1822 * ----------------------------------------------------------------------------
1823 * Function : whalCtrl_ReJoinBss
1824 *
1825 * Input :
1826 * Output :
1827 * Process :
1828 * Note(s) : Done
1829 * -----------------------------------------------------------------------------
1830 */
whalCtrl_ReJoinBss(TI_HANDLE hWhalCtrl)1831 int whalCtrl_ReJoinBss (TI_HANDLE hWhalCtrl)
1832 {
1833 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1834
1835 return whal_hwCtrl_ReJoinBss ((TI_HANDLE)pWhalCtrl->pHwCtrl);
1836 }
1837
1838
1839 /*
1840 * ----------------------------------------------------------------------------
1841 * Function : whalCtrl_Stop
1842 *
1843 * Input : None
1844 * Output :
1845 * Process : Send command to the ACX to instruct it to enter a low-power sleep
1846 * state
1847 * Note(s) : Done
1848 * -----------------------------------------------------------------------------
1849 */
whalCtrl_Stop(TI_HANDLE hWhalCtrl)1850 int whalCtrl_Stop (TI_HANDLE hWhalCtrl)
1851 {
1852 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1853
1854 whal_hwCtrl_Stop (pWhalCtrl->pHwCtrl);
1855
1856 return (OK);
1857 }
1858
1859
1860 /*
1861 * ----------------------------------------------------------------------------
1862 * Function : whalCtrl_SetTemplate
1863 *
1864 * Input :
1865 * Output :
1866 * Process :
1867 * Note(s) : Done
1868 * -----------------------------------------------------------------------------
1869 */
whalCtrl_SetTemplate(TI_HANDLE hWhalCtrl,whalCtrl_setTemplate_t * pTemplateParams)1870 int whalCtrl_SetTemplate (TI_HANDLE hWhalCtrl, whalCtrl_setTemplate_t* pTemplateParams)
1871 {
1872 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1873 HwMboxCmd_T *pHwCmd = whal_hwCtrl_GetMboxCmd(pWhalCtrl->pHwCtrl);
1874 TemplateListParams_T *pWhalTemplates = &pWhalCtrl->pWhalParams->TemplateList;
1875 int Stt;
1876
1877 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1878 ("Template Type=%x :: size=%d\n", pTemplateParams->templateType , pTemplateParams->templateLen));
1879
1880 switch(pTemplateParams->templateType)
1881 {
1882 case BEACON_TEMPLATE:
1883 pWhalTemplates->Beacon.Size = pTemplateParams->templateLen;
1884 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->Beacon.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1885 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,
1886 CMD_BEACON,NULL,NULL);
1887 break;
1888 case PROBE_RESPONSE_TEMPLATE:
1889 pWhalTemplates->ProbeResp.Size = pTemplateParams->templateLen;
1890 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->ProbeResp.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1891 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,
1892 CMD_PROBE_RESP,NULL,NULL);
1893 break;
1894 case PROBE_REQUEST_TEMPLATE:
1895 pWhalTemplates->ProbeReq.Size = pTemplateParams->templateLen;
1896 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->ProbeReq.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1897 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,
1898 CMD_PROBE_REQ,NULL,NULL);
1899 break;
1900 case NULL_DATA_TEMPLATE:
1901 pWhalTemplates->NullData.Size = pTemplateParams->templateLen;
1902 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->NullData.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1903 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,
1904 CMD_NULL_DATA,NULL,NULL);
1905 break;
1906 case PS_POLL_TEMPLATE:
1907 pWhalTemplates->PsPoll.Size = pTemplateParams->templateLen;
1908 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->PsPoll.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1909 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,
1910 CMD_PS_POLL,NULL,NULL);
1911 break;
1912 case QOS_NULL_DATA_TEMPLATE:
1913 pWhalTemplates->QosNullData.Size = pTemplateParams->templateLen;
1914 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->QosNullData.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1915 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,
1916 CMD_QOS_NULL_DATA,NULL,NULL);
1917 break;
1918 default:
1919 Stt = NOK;
1920 break;
1921 }
1922
1923 return (Stt);
1924 }
1925
1926 /*
1927 * ----------------------------------------------------------------------------
1928 * Function : whalCtrl_SetTemplateWithCB
1929 *
1930 * Input : Same as whalCtrl_SetTemplate but with CB
1931 * Output :
1932 * Process :
1933 * Note(s) : Done
1934 * -----------------------------------------------------------------------------
1935 */
whalCtrl_SetTemplateWithCB(TI_HANDLE hWhalCtrl,whalCtrl_setTemplate_t * pTemplateParams,void * CBFunc,TI_HANDLE CBObj)1936 int whalCtrl_SetTemplateWithCB (TI_HANDLE hWhalCtrl, whalCtrl_setTemplate_t* pTemplateParams,void *CBFunc,TI_HANDLE CBObj)
1937 {
1938 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1939 HwMboxCmd_T *pHwCmd = whal_hwCtrl_GetMboxCmd(pWhalCtrl->pHwCtrl);
1940 TemplateListParams_T *pWhalTemplates = &pWhalCtrl->pWhalParams->TemplateList;
1941 int Stt;
1942
1943 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1944 ("%s Template Type=%x :: size=%d\n",__FUNCTION__,pTemplateParams->templateType , pTemplateParams->templateLen));
1945
1946 switch(pTemplateParams->templateType)
1947 {
1948
1949 case PROBE_REQUEST_TEMPLATE:
1950 pWhalTemplates->ProbeReq.Size = pTemplateParams->templateLen;
1951 os_memoryCopy(pWhalCtrl->hOs, (void *)&pWhalTemplates->ProbeReq.Buffer, (void *)pTemplateParams->pTemplate, pTemplateParams->templateLen);
1952 Stt = whal_hwMboxCmd_ConfigureTemplateFrame(pHwCmd, pTemplateParams->pTemplate, (UINT16)pTemplateParams->templateLen,CMD_PROBE_REQ,CBFunc,CBObj);
1953 break;
1954 default:
1955 WLAN_REPORT_ERROR (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
1956 ("%s not implemented yet !!!\n",__FUNCTION__,pTemplateParams->templateType , pTemplateParams->templateLen));
1957 Stt = NOK;
1958 break;
1959 }
1960
1961 return (Stt);
1962 }
1963 /*
1964 * ----------------------------------------------------------------------------
1965 Function : whalCtrl_GetTemplate
1966 *
1967 * Input : pWhalCtrl - handle to whal ctrl object
1968 * templateType - type of template to retrieve
1969 * Output : The template buffer that is saved in the Hal
1970 * Process : If the template type is legal the template buffer and length are
1971 * returned. Otherwise NULL is returned
1972 * Note(s) : Done
1973 * -----------------------------------------------------------------------------
1974 */
whalCtrl_GetTemplate(TI_HANDLE hWhalCtrl,whalCtrl_templateType_e templateType)1975 TemplateParams_T * whalCtrl_GetTemplate(TI_HANDLE hWhalCtrl, whalCtrl_templateType_e templateType)
1976 {
1977 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
1978 TemplateParams_T * returnTemplate;
1979
1980 switch(templateType)
1981 {
1982 case BEACON_TEMPLATE:
1983 returnTemplate = &pWhalCtrl->pWhalParams->TemplateList.Beacon;
1984 break;
1985 case PROBE_RESPONSE_TEMPLATE:
1986 returnTemplate = &pWhalCtrl->pWhalParams->TemplateList.ProbeResp;
1987 break;
1988 case PROBE_REQUEST_TEMPLATE:
1989 returnTemplate = &pWhalCtrl->pWhalParams->TemplateList.ProbeReq;
1990 break;
1991 case NULL_DATA_TEMPLATE:
1992 returnTemplate = &pWhalCtrl->pWhalParams->TemplateList.NullData;
1993 break;
1994 default:
1995 returnTemplate = NULL;
1996 break;
1997 }
1998
1999 return (returnTemplate);
2000 }
2001
2002 /*
2003 * ----------------------------------------------------------------------------
2004 * Function : whalCtrl_Destroy
2005 *
2006 * Input :
2007 * Output :
2008 * Process :
2009 * Note(s) : Done
2010 * -----------------------------------------------------------------------------
2011 */
whalCtrl_Destroy(TI_HANDLE hWhalCtrl)2012 int whalCtrl_Destroy (TI_HANDLE hWhalCtrl)
2013 {
2014 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2015 DmaParams_T *pDmaParams=NULL;
2016
2017 if (pWhalCtrl == NULL)
2018 return OK;
2019
2020 if (pWhalCtrl->pWhalParams != NULL)
2021 {
2022 pDmaParams = whal_ParamsGetDmaParams(pWhalCtrl->pWhalParams);
2023 }
2024
2025 if( (pDmaParams != NULL) && (pWhalCtrl->pWhalSecurity != NULL) )
2026 {
2027 if (whalSecur_Destroy (pWhalCtrl->pWhalSecurity, pDmaParams->NumStations) != OK)
2028 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl_Destroy: whalSecur_Destroy failure \n"));
2029 }
2030
2031 if (pWhalCtrl->pHwCtrl != NULL)
2032 {
2033 if (whal_hwCtrl_Destroy (pWhalCtrl->pHwCtrl) != OK)
2034 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, (" whalCtrl_Destroy: whal_hwCtrl_Destroy failure \n"));
2035 }
2036
2037 if (pWhalCtrl->pWhalParams != NULL)
2038 {
2039 whal_params_Destroy(pWhalCtrl->pWhalParams);
2040 }
2041
2042 /* free the whalCtrl data structure*/
2043 os_memoryFree (pWhalCtrl->hOs, pWhalCtrl, sizeof(WHAL_CTRL));
2044
2045 return (OK);
2046 }
2047
2048 /****************************************************************************
2049 * whal_hwCtrl_GetWhalParamsHandle()
2050 ****************************************************************************
2051 * DESCRIPTION: Return the handle of the whal params object.
2052 *
2053 * INPUTS:
2054 *
2055 * OUTPUT: None
2056 *
2057 * RETURNS: handle of the WhalParams object
2058 ****************************************************************************/
whalCtrl_GetWhalParamsHandle(WHAL_CTRL * pWhalCtrl)2059 WhalParams_T *whalCtrl_GetWhalParamsHandle(WHAL_CTRL *pWhalCtrl)
2060 {
2061 return pWhalCtrl->pWhalParams;
2062 }
2063
2064
2065
2066 /*
2067 * ----------------------------------------------------------------------------
2068 * Function : Handle DMA Done interrupt
2069 *
2070 * Input :
2071 * Output :
2072 * Process :
2073 * Note(s) : Done
2074 * -----------------------------------------------------------------------------
2075 */
whalCtrl_HandleBusTxn_Complete(TI_HANDLE hWhalCtrl)2076 void whalCtrl_HandleBusTxn_Complete(TI_HANDLE hWhalCtrl)
2077 {
2078 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2079
2080 /*
2081 At this point the interrupts are masked!
2082 it register at this position and remove its request after the interrupts are enabled again.
2083 */
2084 whalBus_TNETWIF_HandleBusTxn_Complete(pWhalCtrl->hWhalBus);
2085 }
2086
2087
2088 /*
2089 * ----------------------------------------------------------------------------
2090 * Function : Enable/Disable/Check/Handle interrupts - call HwCtrl object
2091 *
2092 * Input :
2093 * Output :
2094 * Process :
2095 * Note(s) : Done
2096 * -----------------------------------------------------------------------------
2097 */
whalCtrl_HandleInterrupts(TI_HANDLE hWhalCtrl)2098 int whalCtrl_HandleInterrupts (TI_HANDLE hWhalCtrl)
2099 {
2100 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2101
2102 /*
2103 At this point the interrupts are masked!
2104 it register at this position and remove its request after the interrupts are enabled again.
2105 */
2106 return FwEvent(pWhalCtrl->hFwEvent);
2107 }
2108
whalCtrl_EnableInterrupts(TI_HANDLE hWhalCtrl)2109 void whalCtrl_EnableInterrupts (TI_HANDLE hWhalCtrl)
2110 {
2111 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2112
2113 FwEvent_EnableInterrupts(pWhalCtrl->hFwEvent);
2114 }
2115
whalCtrl_DisableInterrupts(TI_HANDLE hWhalCtrl)2116 void whalCtrl_DisableInterrupts (TI_HANDLE hWhalCtrl)
2117 {
2118 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2119
2120 FwEvent_DisableInterrupts(pWhalCtrl->hFwEvent);
2121 }
2122
whalCtrl_CheckInterrupts(TI_HANDLE hWhalCtrl)2123 UINT32 whalCtrl_CheckInterrupts (TI_HANDLE hWhalCtrl)
2124 {
2125 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2126
2127 return FwEvent_CheckInterrupts(pWhalCtrl->hFwEvent);
2128 }
2129
2130
whalCtr_SlaveAckMaskNotification(TI_HANDLE hWhalCtrl)2131 void whalCtr_SlaveAckMaskNotification (TI_HANDLE hWhalCtrl)
2132 {
2133 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2134
2135 FwEvent_StateChanged(pWhalCtrl->hFwEvent);
2136 }
2137
2138 /*
2139 * ----------------------------------------------------------------------------
2140 * Function : whalCtrl_isCardIn
2141 *
2142 * Input :
2143 * Output :
2144 * Process :
2145 * Note(s) : Done
2146 * -----------------------------------------------------------------------------
2147 */
whalCtrl_isCardIn(TI_HANDLE hWhalCtrl)2148 BOOL whalCtrl_isCardIn (TI_HANDLE hWhalCtrl)
2149 {
2150 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2151
2152 return whalBus_FwCtrl_isCardIn(pWhalCtrl->pHwCtrl->hWhalBus);
2153 }
2154
2155 /*
2156 * ----------------------------------------------------------------------------
2157 * Function : whalCtrl_setSend4xWackInfo
2158 *
2159 * Input :
2160 * Output :
2161 * Process :
2162 * Note(s) :
2163 * -----------------------------------------------------------------------------
2164 */
whalCtrl_setSend4xWackInfo(TI_HANDLE hWhalCtrl,UINT8 Send4xWackInfo)2165 int whalCtrl_setSend4xWackInfo(TI_HANDLE hWhalCtrl, UINT8 Send4xWackInfo)
2166 {
2167 /* not implemented */
2168 return NOK;
2169 }
2170 /*
2171 * ----------------------------------------------------------------------------
2172 * Function : whalCtrl_getSend4xWackInfo
2173 *
2174 * Input :
2175 * Output :
2176 * Process :
2177 * Note(s) :
2178 * -----------------------------------------------------------------------------
2179 */
whalCtrl_getSend4xWackInfo(TI_HANDLE hWhalCtrl,UINT8 * Send4xWackInfo)2180 int whalCtrl_getSend4xWackInfo(TI_HANDLE hWhalCtrl, UINT8 *Send4xWackInfo)
2181 {
2182 /* not implemented */
2183 return NOK;
2184 }
2185
2186
2187 /*
2188 * ----------------------------------------------------------------------------
2189 * Function : whalCtrl_SetSlotTime
2190 *
2191 * Input :
2192 * Output :
2193 * Process :
2194 * Note(s) : Done
2195 * -----------------------------------------------------------------------------
2196 */
whalCtrl_SetSlotTime(TI_HANDLE hWhalCtrl,slotTime_e SlotTimeVal)2197 int whalCtrl_SetSlotTime (TI_HANDLE hWhalCtrl, slotTime_e SlotTimeVal)
2198 {
2199 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2200
2201 pWhalCtrl->pWhalParams->WlanParams.SlotTime = SlotTimeVal;
2202 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("whalCtrl_SetSlotTime : Slot time = %d\n",
2203 SlotTimeVal));
2204
2205 /* Configure the new Slot-Time value to the FW. */
2206 return whal_hwCtrl_SetSlotTime(pWhalCtrl->pHwCtrl, SlotTimeVal);
2207 }
2208
2209 /*
2210 * ----------------------------------------------------------------------------
2211 * Function : whalCtrl_SetPreamble
2212 *
2213 * Input :
2214 * Output :
2215 * Process :
2216 * Note(s) : Done
2217 * -----------------------------------------------------------------------------
2218 */
whalCtrl_SetPreamble(TI_HANDLE hWhalCtrl,preamble_e preambleVal)2219 int whalCtrl_SetPreamble (TI_HANDLE hWhalCtrl, preamble_e preambleVal)
2220 {
2221 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2222
2223 pWhalCtrl->pWhalParams->WlanParams.preamble= preambleVal;
2224 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG, ("whalCtrl_SetPreamble : preamble = %d\n",
2225 preambleVal));
2226
2227 return whal_hwCtrl_SetPreamble(pWhalCtrl->pHwCtrl, preambleVal);
2228 }
2229
2230 /*
2231 * ----------------------------------------------------------------------------
2232 * Function : whalCtrl_SetFrameRate
2233 *
2234 * Input : bCtrlFrame - Whether to set new Ctrl rate+modulation or new Mgmt rate+modulation
2235 * Output :
2236 * Process :
2237 * Note(s) : Modulation is determined using the rate and the previously configured preamble
2238 * -----------------------------------------------------------------------------
2239 */
whalCtrl_SetFrameRate(TI_HANDLE hWhalCtrl,rate_e txFrmRate,BOOL bCtrlFrame)2240 int whalCtrl_SetFrameRate (TI_HANDLE hWhalCtrl,
2241 rate_e txFrmRate,
2242 BOOL bCtrlFrame)
2243 {
2244 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2245
2246 whal_ParamsSetHwGenTxParams (pWhalCtrl->pWhalParams, txFrmRate, bCtrlFrame);
2247
2248 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
2249 ("whalCtrl_SetFrameRate : txCtrlFrmRate = %d , txCtrlFrmModulation = %d , txMgmtFrmRate = %d , txMgmtFrmModulation = %d\n",
2250 pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmRate,pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmModulation,
2251 pWhalCtrl->pWhalParams->BssInfoParams.txMgmtFrmRate,pWhalCtrl->pWhalParams->BssInfoParams.txMgmtFrmModulation));
2252
2253 return whal_hwCtrl_SetFrameRate(pWhalCtrl->pHwCtrl,
2254 pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmRate,
2255 pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmModulation,
2256 pWhalCtrl->pWhalParams->BssInfoParams.txMgmtFrmRate,
2257 pWhalCtrl->pWhalParams->BssInfoParams.txMgmtFrmModulation);
2258 }
2259
2260 /*
2261 * ----------------------------------------------------------------------------
2262 * Function : whalCtrl_SetCwMin
2263 *
2264 * Input :
2265 * Output :
2266 * Process :
2267 * Note(s) : Done
2268 * -----------------------------------------------------------------------------
2269 */
whalCtrl_SetCwMin(TI_HANDLE hWhalCtrl,UINT8 CwMin)2270 int whalCtrl_SetCwMin (TI_HANDLE hWhalCtrl, UINT8 CwMin)
2271 {
2272 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2273 pWhalCtrl->pWhalParams->WlanParams.CwMin = CwMin;
2274 return OK;
2275 }
2276
2277 /*
2278 * ----------------------------------------------------------------------------
2279 * Function : whalCtrl_SetPacketDetectionThreshold
2280 *
2281 * Input :
2282 * Output :
2283 * Process :
2284 * Note(s) : Done
2285 * -----------------------------------------------------------------------------
2286 */
whalCtrl_SetPacketDetectionThreshold(TI_HANDLE hWhalCtrl,UINT8 PDThreshold)2287 int whalCtrl_SetPacketDetectionThreshold (TI_HANDLE hWhalCtrl, UINT8 PDThreshold)
2288 {
2289 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2290
2291 pWhalCtrl->pWhalParams->WlanParams.PacketDetectionThreshold = PDThreshold;
2292 return whal_hwCtrl_PacketDetectionThreshold(pWhalCtrl->pHwCtrl, &PDThreshold);
2293 }
2294
2295 /*
2296 * ----------------------------------------------------------------------------
2297 * Function : whalCtrl_SetEnergyDetection
2298 *
2299 * Input :
2300 * Output :
2301 * Process :
2302 * Note(s) : Done
2303 * -----------------------------------------------------------------------------
2304 */
whalCtrl_SetEnergyDetection(TI_HANDLE hWhalCtrl,BOOL energyDetection)2305 int whalCtrl_SetEnergyDetection (TI_HANDLE hWhalCtrl, BOOL energyDetection)
2306 {
2307 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2308
2309 return whal_hwCtrl_SetEnergyDetection(pWhalCtrl->pHwCtrl, energyDetection);
2310 }
2311
2312 /*
2313 * ----------------------------------------------------------------------------
2314 * Function : whalCtrl_SwitchChannel
2315 *
2316 * Input : channel - newChannelNumber
2317 * Output :
2318 * Process :
2319 * Note(s) : Done
2320 * -----------------------------------------------------------------------------
2321 */
whalCtrl_SwitchChannel(TI_HANDLE hWhalCtrl,UINT8 channel)2322 int whalCtrl_SwitchChannel(TI_HANDLE hWhalCtrl , UINT8 channel)
2323 {
2324 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2325
2326 return whal_hwCtrl_switchChannel(pWhalCtrl->pHwCtrl, channel);
2327
2328 }
2329
2330 /*
2331 * ----------------------------------------------------------------------------
2332 * Function : whalCtrl_DisableTx
2333 *
2334 * Input : None
2335 * Output :
2336 * Process :
2337 * Note(s) : Done
2338 * -----------------------------------------------------------------------------
2339 */
whalCtrl_DisableTx(TI_HANDLE hWhalCtrl)2340 int whalCtrl_DisableTx(TI_HANDLE hWhalCtrl)
2341 {
2342 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2343
2344 return whal_hwCtrl_DisableTx(pWhalCtrl->pHwCtrl);
2345
2346 }
2347
2348 /*
2349 * ----------------------------------------------------------------------------
2350 * Function : whalCtrl_EnableTx
2351 *
2352 * Input : None
2353 * Output :
2354 * Process :
2355 * Note(s) : Done
2356 * -----------------------------------------------------------------------------
2357 */
whalCtrl_EnableTx(TI_HANDLE hWhalCtrl)2358 int whalCtrl_EnableTx(TI_HANDLE hWhalCtrl)
2359 {
2360 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2361
2362 return whal_hwCtrl_EnableTx(pWhalCtrl->pHwCtrl, whal_ParamsGetRadioChannel(pWhalCtrl->pWhalParams));
2363 }
2364
2365 /*
2366 * ----------------------------------------------------------------------------
2367 * Function : whalCtrl_GetTime
2368 *
2369 * Input : None
2370 * Output :
2371 * Process :
2372 * Note(s) : Get Mac time from the Event Mbox (For Tx expiry Time)
2373 * -----------------------------------------------------------------------------
2374 */
whalCtrl_GetTime(TI_HANDLE hWhalCtrl)2375 UINT32 whalCtrl_GetTime(TI_HANDLE hWhalCtrl)
2376 {
2377 return 0;
2378 }
2379
2380 /*
2381 * ----------------------------------------------------------------------------
2382 * Function : whalCtrl_setDtimPeriod
2383 *
2384 * Input : dtimPeriod - new Dtim Period
2385 * Output :
2386 * Process :
2387 * Note(s) : Done
2388 * -----------------------------------------------------------------------------
2389 */
whalCtrl_setDtimPeriod(TI_HANDLE hWhalCtrl,UINT8 dtimPeriod,UINT16 TBTT)2390 int whalCtrl_setDtimPeriod(TI_HANDLE hWhalCtrl, UINT8 dtimPeriod, UINT16 TBTT)
2391 {
2392 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2393 UINT8 localDtimPeriod = (UINT8)dtimPeriod;
2394 UINT16 localTBTT = (UINT16)TBTT;
2395
2396 whal_ParamsSetDtimCount(pWhalCtrl->pWhalParams, (UINT8)dtimPeriod);
2397
2398 whal_hwInfoElemDtimPeriodSet (pWhalCtrl->pHwCtrl->pHwMboxConfig, &localDtimPeriod, &localTBTT);
2399
2400 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
2401 ("whalCtrl_setDtimPeriod: DITIM=%d TBTT=%d\n",localDtimPeriod,localTBTT));
2402
2403 return OK;
2404 }
2405
2406 /*
2407 * ----------------------------------------------------------------------------
2408 * Function : whalCtrl_GetDtimCount
2409 *
2410 * Input :
2411 * Output : UINT8
2412 * Process :
2413 * Note(s) : Done
2414 * -----------------------------------------------------------------------------
2415 */
whalCtrl_GetDtimCount(TI_HANDLE hWhalCtrl)2416 UINT8 whalCtrl_GetDtimCount(TI_HANDLE hWhalCtrl)
2417 {
2418 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2419 return whal_ParamsGetDtimCount(pWhalCtrl->pWhalParams);
2420 }
2421
2422 /*
2423 * ----------------------------------------------------------------------------
2424 * Function : whalCtrl_InterrogateMbox
2425 *
2426 * Input :
2427 * Output : UINT8
2428 * Process :
2429 * Note(s) : Done
2430 * -----------------------------------------------------------------------------
2431 */
whalCtrl_InterrogateMbox(TI_HANDLE hWhalCtrl,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)2432 int whalCtrl_InterrogateMbox(TI_HANDLE hWhalCtrl , void *CB_Func, TI_HANDLE CB_handle, void *CB_Buf)
2433 {
2434 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2435
2436 whal_hwInfoElemStationIdForRecoveryGet (pWhalCtrl->pHwCtrl->pHwMboxConfig, CB_Func, CB_handle, CB_Buf);
2437
2438 return OK;
2439 }
2440
2441 /*
2442 * ----------------------------------------------------------------------------
2443 * Function : whalCtrl_InterrogateGwsiStatisitics
2444 *
2445 * Input : Retrieve Statistics
2446 * Output :
2447 * Process :
2448 * Note(s) : Done
2449 * -----------------------------------------------------------------------------
2450 */
whalCtrl_InterrogateGwsiStatisitics(TI_HANDLE hWhalCtrl,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)2451 int whalCtrl_InterrogateGwsiStatisitics(TI_HANDLE hWhalCtrl, void * CB_Func, TI_HANDLE CB_handle, void * CB_Buf)
2452 {
2453 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
2454
2455 whal_hwInfoElemAcxReadGwsiStatisiticsGet (pWhalCtrl->pHwCtrl->pHwMboxConfig, CB_Func, CB_handle, CB_Buf);
2456
2457 return OK;
2458 }
2459
2460
2461 /*
2462 * ----------------------------------------------------------------------------
2463 * Function : whalCtrl_InterrogateGwsiCounters
2464 *
2465 * Input : Retrieve Counters
2466 * Output :
2467 * Process :
2468 * Note(s) : Done
2469 * -----------------------------------------------------------------------------
2470 */
whalCtrl_InterrogateGwsiCounters(TI_HANDLE hWhalCtrl,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)2471 int whalCtrl_InterrogateGwsiCounters(TI_HANDLE hWhalCtrl, void * CB_Func, TI_HANDLE CB_handle, void * CB_Buf)
2472 {
2473 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
2474
2475 whal_hwInfoElemAcxReadGwsiCountersGet (pWhalCtrl->pHwCtrl->pHwMboxConfig, CB_Func, CB_handle, CB_Buf);
2476
2477 return OK;
2478 }
2479
2480
2481 /* ----------------------------------------------------------------------------
2482 * Function : whalCtrl_getTsf
2483 *
2484 * Input : hwHalCtrl handle, pTsf container for the FW mac timer
2485 * Output :
2486 * Process :
2487 * Note(s) : The time will be in usec
2488 * -----------------------------------------------------------------------------
2489 */
whalCtrl_getTsf(TI_HANDLE hwHalCtrl,UINT32 * pTsf)2490 int whalCtrl_getTsf(TI_HANDLE hwHalCtrl, UINT32 *pTsf)
2491 {
2492 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hwHalCtrl;
2493
2494 if (pTsf == NULL){
2495 WLAN_REPORT_FATAL_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
2496 ("whalCtrl_getTsf: got pTsf paramerter as NULL\n"));
2497
2498 return NOK;
2499 }
2500
2501 return(whal_hwCtrl_getTsf(pWhalCtrl->pHwCtrl, pTsf));
2502 }
2503
2504
whalCtrl_SendGenCmd(TI_HANDLE hWhalCtrl,char * pBuf,UINT32 Length)2505 int whalCtrl_SendGenCmd (TI_HANDLE hWhalCtrl, char* pBuf, UINT32 Length)
2506 {
2507 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2508 short CmdId;
2509
2510 if ((Length < CMD_DISABLE_RX) || (pBuf == NULL)){
2511 WLAN_REPORT_REPLY(pWhalCtrl->hReport, HAL_HW_DATA_MODULE_LOG,
2512 ("whalCtrl_SendGenCmd: Parameter error\n"));
2513
2514 return NOK;
2515 }
2516
2517 os_memoryCopy(pWhalCtrl, (void *)&CmdId, (void *)pBuf, sizeof(CmdId));
2518 return (whal_hwCtrl_GenCmd(pWhalCtrl->pHwCtrl, CmdId, pBuf+SIZE_OF_HEADER, (Length - SIZE_OF_HEADER)));
2519 }
2520
2521
whalCtrl_IsCardInstalled(TI_HANDLE hWhalCtrl)2522 int whalCtrl_IsCardInstalled(TI_HANDLE hWhalCtrl)
2523 {
2524 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2525 return whalBus_FwCtrl_isCardIn(pWhalCtrl->pHwCtrl->hWhalBus);
2526 }
2527
2528
2529 /*
2530 * ----------------------------------------------------------------------------
2531 * Function : whalCtrl_SetBeaconInterval
2532 *
2533 * Input :
2534 * Output :
2535 * Process :
2536 * Note(s) : Done
2537 * -----------------------------------------------------------------------------
2538 */
whalCtrl_SetBeaconInterval(TI_HANDLE hWhalCtrl,UINT16 Val)2539 void whalCtrl_SetBeaconInterval(TI_HANDLE hWhalCtrl , UINT16 Val)
2540 {
2541 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2542 whal_ParamsSetBeaconInterval(pWhalCtrl->pWhalParams ,Val);
2543 }
2544
2545 /*
2546 * ----------------------------------------------------------------------------
2547 * Function : whalCtrl_GetBeaconInterval
2548 *
2549 * Input :
2550 * Output : UINT16
2551 * Process :
2552 * Note(s) : Done
2553 * -----------------------------------------------------------------------------
2554 */
whalCtrl_GetBeaconInterval(TI_HANDLE hWhalCtrl)2555 UINT16 whalCtrl_GetBeaconInterval(TI_HANDLE hWhalCtrl)
2556 {
2557 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2558 return whal_ParamsGetBeaconInterval(pWhalCtrl->pWhalParams);
2559 }
2560
2561
2562 /****************************************************************************
2563 * whalCtrl_exitFromInitMode()
2564 ****************************************************************************
2565 * DESCRIPTION: change the interrupt module to work in operational mode
2566 * and the Queue to work in Async Mode
2567 * INPUTS:
2568 *
2569 * OUTPUT: None
2570 *
2571 * RETURNS: OK.
2572 ****************************************************************************/
whalCtrl_exitFromInitMode(TI_HANDLE hWhalCtrl)2573 void whalCtrl_exitFromInitMode(TI_HANDLE hWhalCtrl)
2574 {
2575 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2576
2577 /* Notify Event MailBox about init complete */
2578 eventMbox_InitComplete (pWhalCtrl->hEventMbox);
2579
2580 /*
2581 this call must be the last cmd send to the FW because upon its completion the os_complete will be called
2582 */
2583
2584 whal_hwInfoElemStationIdGet (pWhalCtrl->pHwCtrl->pHwMboxConfig,
2585 (void*)((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->fConfigureEndCB,
2586 ((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->fConfigureEndObj,
2587 &pWhalCtrl->pHwCtrl->mbox);
2588
2589 /*
2590 * In case of full asynchronous mode the code below is executed earlier -
2591 * upon starting configuring the firmware via command mailbox
2592 */
2593
2594 #if defined(USE_SYNC_API)
2595
2596 whalBus_ExitFromInitMode (pWhalCtrl->hWhalBus);
2597
2598 os_enableIrq (pWhalCtrl->hOs);
2599
2600 #endif
2601 }
2602
2603 /****************************************************************************
2604 * whalCtrl_exitFromInitModePart1()
2605 ****************************************************************************
2606 * DESCRIPTION: Notify Event MailBox about init complete
2607 *
2608 * INPUTS:
2609 *
2610 * OUTPUT: None
2611 *
2612 * RETURNS: OK.
2613 ****************************************************************************/
whalCtrl_exitFromInitModePart1(TI_HANDLE hWhalCtrl)2614 void whalCtrl_exitFromInitModePart1(TI_HANDLE hWhalCtrl)
2615 {
2616 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2617
2618 /* Notify Event MailBox about init complete */
2619 eventMbox_InitComplete (pWhalCtrl->hEventMbox);
2620
2621 }
2622
2623 /****************************************************************************
2624 * whalCtrl_exitFromInitModePart2()
2625 ****************************************************************************
2626 * DESCRIPTION: change the interrupt module to work in operational mode
2627 * and the Queue to work in Async Mode
2628 * INPUTS:
2629 *
2630 * OUTPUT: None
2631 *
2632 * RETURNS: OK.
2633 ****************************************************************************/
whalCtrl_exitFromInitModePart2(TI_HANDLE hWhalCtrl)2634 void whalCtrl_exitFromInitModePart2(TI_HANDLE hWhalCtrl)
2635 {
2636 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2637
2638
2639 /*
2640 this call must be the last cmd send to the FW because upon its completion the os_complete will be called
2641 */
2642
2643 whal_hwInfoElemStationIdGet (pWhalCtrl->pHwCtrl->pHwMboxConfig,
2644 (void*)((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->fConfigureEndCB,
2645 ((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->fConfigureEndObj,
2646 &pWhalCtrl->pHwCtrl->mbox);
2647
2648 /*
2649 * In case of full asynchronous mode the code below is executed earlier -
2650 * upon starting configuring the firmware via command mailbox
2651 */
2652
2653 #if defined(USE_SYNC_API)
2654
2655 whalBus_ExitFromInitMode (pWhalCtrl->hWhalBus);
2656
2657 os_enableIrq (pWhalCtrl->hOs);
2658
2659 #endif
2660 }
2661
2662
2663 /*
2664 * ----------------------------------------------------------------------------
2665 * Function : whalCtrl_NoiseHistogramCmd
2666 *
2667 * Input :
2668 * Output :
2669 * Process :
2670 * Note(s) : Done
2671 * -----------------------------------------------------------------------------
2672 */
whalCtrl_NoiseHistogramCmd(TI_HANDLE hWhalCtrl,whalCtrl_noiseHistogram_t * pNoiseHistParams)2673 int whalCtrl_NoiseHistogramCmd(TI_HANDLE hWhalCtrl, whalCtrl_noiseHistogram_t* pNoiseHistParams)
2674 {
2675 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2676
2677 /* Send the Noise Histogram command*/
2678 return (whal_hwCtrl_NoiseHistogramCmd(pWhalCtrl->pHwCtrl, pNoiseHistParams));
2679 }
2680
2681 /*
2682 * ----------------------------------------------------------------------------
2683 * Function : whalCtrl_powerMgmtOptionsConfig
2684 *
2685 * Input : 1) TI_HANDLE - handle to the WhalCtrl object.
2686 *
2687 * Output : TI_STATUS - OK on success else NOK.
2688 *
2689 * Process : configuration of the power managment options mailbox command.
2690 *
2691 * Note(s) :
2692 * -----------------------------------------------------------------------------
2693 */
whalCtrl_powerMgmtConfig(TI_HANDLE theWhalCtrlHandle,whalCtrl_powerSaveParams_t * powerSaveParams)2694 TI_STATUS whalCtrl_powerMgmtConfig(TI_HANDLE theWhalCtrlHandle,
2695 whalCtrl_powerSaveParams_t* powerSaveParams)
2696 /*whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)*/
2697 {
2698 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)theWhalCtrlHandle;
2699
2700
2701
2702 int powerMgmtConfStatus;
2703
2704 /*
2705 breaking the debug information into 2 section due to the fact that this message is
2706 too long and exceed message buffer limitation.
2707 */
2708 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,
2709 HAL_CTRL_MODULE_LOG,
2710 ("whalCtrlPowerSaveParams -:\n\
2711 ps802_11Enable = 0x%X\n\
2712 hangOverPeriod = 0x%X\n\
2713 needToSendNullData = 0x%X\n\
2714 numNullPktRetries = 0x%X\n\
2715 NullPktRateModulation = 0x%X\n",
2716 powerSaveParams->ps802_11Enable,
2717 powerSaveParams->hangOverPeriod,
2718 powerSaveParams->needToSendNullData,
2719 powerSaveParams->numNullPktRetries,
2720 powerSaveParams->NullPktRateModulation));
2721
2722
2723 /*
2724 PowerMgmtOptions IE
2725 */
2726
2727 powerMgmtConfStatus = whal_hwCtrl_PowerMgmtConfigurationSet (pWhalCtrl->pHwCtrl,
2728 powerSaveParams);
2729
2730 return (TI_STATUS)powerMgmtConfStatus;
2731 }
2732
2733
2734 /*
2735 * ----------------------------------------------------------------------------
2736 * Function : whalCtrl_SetBeaconFiltering
2737 *
2738 * Input : UINT8, UINT8
2739 * Output :
2740 * Process :
2741 * Note(s) : Done
2742 * -----------------------------------------------------------------------------
2743 */
whalCtrl_SetBeaconFiltering(TI_HANDLE hWhalCtrl,UINT8 beaconFilteringStatus,UINT8 numOfBeaconsToBuffer)2744 int whalCtrl_SetBeaconFiltering(TI_HANDLE hWhalCtrl, UINT8 beaconFilteringStatus, UINT8 numOfBeaconsToBuffer)
2745 {
2746 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2747
2748
2749 pWhalCtrl->pWhalParams->WlanParams.beaconFilterParams.desiredState = beaconFilteringStatus;
2750 pWhalCtrl->pWhalParams->WlanParams.beaconFilterParams.numOfElements = numOfBeaconsToBuffer;
2751
2752
2753 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,
2754 HAL_CTRL_MODULE_LOG,
2755 ("whalCtrl_SetBeaconFiltering :\n\
2756 beaconFilteringStatus = %s \n\
2757 numberOfBeaconsToBuffer = %d\n",
2758 (beaconFilteringStatus == FALSE) ? "BUFFERING" : "FILTERING",
2759 numOfBeaconsToBuffer));
2760
2761 return whal_hwCtrl_SetBeaconFiltering(pWhalCtrl->pHwCtrl, beaconFilteringStatus, numOfBeaconsToBuffer);
2762 }
2763
2764
2765 /*
2766 * ----------------------------------------------------------------------------
2767 * Function : whalCtrl_GetBeaconFiltering
2768 *
2769 * Input : UINT8, UINT8
2770 * Output :
2771 * Process :
2772 * Note(s) : Done
2773 * -----------------------------------------------------------------------------
2774 */
whalCtrl_GetBeaconFiltering(TI_HANDLE hWhalCtrl)2775 int whalCtrl_GetBeaconFiltering(TI_HANDLE hWhalCtrl)
2776 {
2777 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2778
2779 if ( NULL == pWhalCtrl )
2780 {
2781 WLAN_OS_REPORT(("whalCtrl_GetBeaconFiltering-hWhalCtrl = NULL !"));
2782 return NOK ;
2783 }
2784 else
2785 {
2786 if ( NULL == pWhalCtrl->pWhalParams )
2787 {
2788 WLAN_REPORT_ERROR(pWhalCtrl->hReport , HAL_CTRL_MODULE_LOG , ("whalCtrl_GetBeaconFiltering : pWhalParams = NULL !!!")) ;
2789 return NOK ;
2790 }
2791 return (OK);
2792 }
2793
2794 }
2795
2796
2797 /*
2798 * ----------------------------------------------------------------------------
2799 * Function : whalCtrl_SetBeaconFilterIETable
2800 *
2801 * Input : Number of IE in table, Table, Table szie
2802 * Output :
2803 * Process : transfer paramaters to the HAL, check for size limit
2804 * Note(s) : Done
2805 * -----------------------------------------------------------------------------
2806 */
whalCtrl_SetBeaconFilterIETable(TI_HANDLE hWhalCtrl,UINT8 * numberOfIEs,UINT8 * IETable,UINT8 * IETableSize)2807 int whalCtrl_SetBeaconFilterIETable(TI_HANDLE hWhalCtrl, UINT8 *numberOfIEs, UINT8 * IETable, UINT8 *IETableSize)
2808 {
2809 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2810
2811
2812 if (*IETableSize > BEACON_FILTER_TABLE_MAX_SIZE)
2813 {
2814 WLAN_REPORT_ERROR(pWhalCtrl->hReport,
2815 HAL_CTRL_MODULE_LOG,
2816 ("whalCtrl_SetBeaconFilterIETable : Table size is too big %d (>%d)\n",
2817 *IETableSize, BEACON_FILTER_TABLE_MAX_SIZE));
2818 return PARAM_VALUE_NOT_VALID;
2819 }
2820
2821 os_memoryZero (pWhalCtrl->hOs, (void *)pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.IETable, BEACON_FILTER_TABLE_MAX_SIZE);
2822 os_memoryCopy(pWhalCtrl->hOs, (void *)pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.IETable, (void *)IETable, *IETableSize);
2823 pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.numberOfIEs = *numberOfIEs;
2824 pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.IETableSize = *IETableSize;
2825
2826
2827 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,
2828 HAL_CTRL_MODULE_LOG,
2829 ("whalCtrl_SetBeaconFilterIETable : \n\
2830 Number of IE = %d \n\
2831 IETable = 0x%p \n\
2832 IETableSize = %d\n",
2833 *numberOfIEs, IETable, *IETableSize));
2834
2835 return whal_hwCtrl_SetBeaconFilterIETable(pWhalCtrl->pHwCtrl, numberOfIEs, IETable, IETableSize ) ;
2836 }
2837
2838
2839
2840 /*
2841 * ----------------------------------------------------------------------------
2842 * Function : whalCtrl_wakeUpCondition
2843 *
2844 * Input : 1) TI_HANDLE - handle to the WhalCtrl object.
2845 *
2846 * Output : TI_STATUS - OK on success else NOK.
2847 *
2848 * Process : configuration of the power managment options mailbox command.
2849 *
2850 * Note(s) :
2851 * -----------------------------------------------------------------------------
2852 */
whalCtrl_wakeUpCondition(TI_HANDLE theWhalCtrlHandle,whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)2853 TI_STATUS whalCtrl_wakeUpCondition(TI_HANDLE theWhalCtrlHandle,
2854 whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)
2855 {
2856 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)theWhalCtrlHandle;
2857 whalCtrl_powerMgmtConfig_t *pPowerMgmtOptionsConfig = &thePowerMgmtConfig;
2858 int status;
2859
2860 /*
2861 breaking the debug information into 2 section due to the fact that this message is
2862 too long and exceed message buffer limitation.
2863 */
2864 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,
2865 HAL_CTRL_MODULE_LOG,
2866 ("whalCtrl_wakeUpCondition :\n\
2867 listenInterval = 0x%X\n",
2868 pPowerMgmtOptionsConfig->listenInterval));
2869
2870 status = whal_hwCtrl_wakeUpCondition (pWhalCtrl->pHwCtrl,
2871 pPowerMgmtOptionsConfig);
2872
2873 return (TI_STATUS)status;
2874 }
2875
2876 /*
2877 * ----------------------------------------------------------------------------
2878 * Function : whalCtrl_PMConfig
2879 *
2880 * Input : 1) TI_HANDLE - handle to the WhalCtrl object.
2881 *
2882 * Output : TI_STATUS - OK on success else NOK.
2883 *
2884 * Process : configuration of the power managment options mailbox command.
2885 *
2886 * Note(s) :
2887 * -----------------------------------------------------------------------------
2888 */
whalCtrl_PMConfig(TI_HANDLE theWhalCtrlHandle,whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)2889 TI_STATUS whalCtrl_PMConfig(TI_HANDLE theWhalCtrlHandle,
2890 whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)
2891 {
2892 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)theWhalCtrlHandle;
2893 whalCtrl_powerMgmtConfig_t *pPowerMgmtOptionsConfig = &thePowerMgmtConfig;
2894 TI_STATUS status;
2895
2896 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,
2897 HAL_CTRL_MODULE_LOG,
2898 ("whalCtrl_PMConfig :\n\
2899 ELPEnable = 0x%X\n\
2900 BBWakeUpTime = 0x%X\n\
2901 PLLlockTime = 0x%X\n",
2902 pPowerMgmtOptionsConfig->ELPEnable,
2903 pPowerMgmtOptionsConfig->BBWakeUpTime,
2904 pPowerMgmtOptionsConfig->PLLlockTime));
2905
2906 status = (TI_STATUS)whal_hwCtrl_PMConfig (pWhalCtrl->pHwCtrl, pPowerMgmtOptionsConfig);
2907 return status;
2908 }
2909
2910 /*
2911 * ----------------------------------------------------------------------------
2912 * Function : whalCtrl_BcnBrcOptions
2913 *
2914 * Input : 1) TI_HANDLE - handle to the WhalCtrl object.
2915 *
2916 * Output : TI_STATUS - OK on success else NOK.
2917 *
2918 * Process : configuration of the power managment options mailbox command.
2919 *
2920 * Note(s) :
2921 * -----------------------------------------------------------------------------
2922 */
whalCtrl_BcnBrcOptions(TI_HANDLE theWhalCtrlHandle,whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)2923 TI_STATUS whalCtrl_BcnBrcOptions(TI_HANDLE theWhalCtrlHandle,
2924 whalCtrl_powerMgmtConfig_t thePowerMgmtConfig)
2925 {
2926 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)theWhalCtrlHandle;
2927 whalCtrl_powerMgmtConfig_t *pPowerMgmtBcnBrcOptions = &thePowerMgmtConfig;
2928 TI_STATUS status;
2929
2930 /* Just take the last configured parameter of ConsecutivePsPollDeliveryFailureThreshold */
2931 pPowerMgmtBcnBrcOptions->ConsecutivePsPollDeliveryFailureThreshold =
2932 (whal_ParamsGetWlanParams (pWhalCtrl->pWhalParams))->ConsecutivePsPollDeliveryFailureThreshold;
2933
2934 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,
2935 HAL_CTRL_MODULE_LOG,
2936 ("whalCtrl_BcnBrcOptions :\n\
2937 BeaconRxTimeout = 0x%X\n\
2938 BroadcastRxTimeout = 0x%X\n\
2939 RxBroadcastInPs = 0x%X\n",
2940 pPowerMgmtBcnBrcOptions->BcnBrcOptions.BeaconRxTimeout,
2941 pPowerMgmtBcnBrcOptions->BcnBrcOptions.BroadcastRxTimeout,
2942 pPowerMgmtBcnBrcOptions->BcnBrcOptions.RxBroadcastInPs));
2943
2944 status = (TI_STATUS)whal_hwCtrl_BcnBrcOptions (pWhalCtrl->pHwCtrl, pPowerMgmtBcnBrcOptions);
2945 return status;
2946 }
2947
2948 /*
2949 * ----------------------------------------------------------------------------
2950 * Function : whalCtrl_RegisterCmdCompleteGenericCB
2951 *
2952 * Input : 1) hWhalCtrl - this
2953 * 2) CbFunc - The Callback
2954 *
2955 *
2956 * Note(s) : None
2957 * -----------------------------------------------------------------------------
2958 */
whalCtrl_RegisterCmdCompleteGenericCB(TI_HANDLE hWhalCtrl,void * CbFunc,void * CbObj)2959 int whalCtrl_RegisterCmdCompleteGenericCB(TI_HANDLE hWhalCtrl, void *CbFunc, void *CbObj)
2960 {
2961 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2962
2963 return CmdQueue_RegisterCmdCompleteGenericCB(((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->hCmdQueue,CbFunc,CbObj);
2964 }
2965
2966
2967 /*
2968 * ----------------------------------------------------------------------------
2969 * Function : whalCtrl_EventMbox_RegisterForEvent
2970 *
2971 * Input : 1) hWhalCtrl - this
2972 * 2) EventBit - The Event id
2973 * 3) CbFunc - The Callback
2974 * 4) CbObj - The Callback Handle
2975 *
2976 * Note(s) : None
2977 * -----------------------------------------------------------------------------
2978 */
whalCtrl_EventMbox_RegisterForEvent(TI_HANDLE hWhalCtrl,int EventBit,void * CbFunc,void * CbObj)2979 int whalCtrl_EventMbox_RegisterForEvent(TI_HANDLE hWhalCtrl, int EventBit, void *CbFunc, void *CbObj)
2980 {
2981 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2982
2983 return eventMbox_RegisterEventCB(pWhalCtrl->hEventMbox,
2984 EventBit, CbFunc, CbObj);
2985 }
2986 /*
2987 * ----------------------------------------------------------------------------
2988 * Function : whalCtrl_EventMbox_Disable
2989 *
2990 * Input : 1) hWhalCtrl - this
2991 * 2) EventBit - The Event id
2992 *
2993 * Note(s) : None
2994 * -----------------------------------------------------------------------------
2995 */
whalCtrl_EventMbox_Disable(TI_HANDLE hWhalCtrl,int EventBit)2996 int whalCtrl_EventMbox_Disable(TI_HANDLE hWhalCtrl, int EventBit)
2997 {
2998 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
2999
3000 return eventMbox_EvMask(pWhalCtrl->hEventMbox, EventBit);
3001 }
3002 /*
3003 * ----------------------------------------------------------------------------
3004 * Function : whalCtrl_EventMbox_Enable
3005 *
3006 * Input : 1) hWhalCtrl - this
3007 * 2) EventBit - The Event id
3008 *
3009 * Note(s) : None
3010 * -----------------------------------------------------------------------------
3011 */
whalCtrl_EventMbox_Enable(TI_HANDLE hWhalCtrl,int EventBit)3012 int whalCtrl_EventMbox_Enable(TI_HANDLE hWhalCtrl, int EventBit)
3013 {
3014 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3015
3016 return eventMbox_EvUnMask(pWhalCtrl->hEventMbox, EventBit);
3017 }
3018
3019 /*
3020 * ----------------------------------------------------------------------------
3021 * Function : whalCtrl_GetRadioStandByState
3022 *
3023 * Input :
3024 *
3025 * Note(s) : None
3026 * -----------------------------------------------------------------------------
3027 */
whalCtrl_GetRadioStandByState(TI_HANDLE hWhalCtrl)3028 int whalCtrl_GetRadioStandByState(TI_HANDLE hWhalCtrl)
3029 {
3030 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3031
3032 return whalBus_FwCtrl_GetRadioStandByState(pWhalCtrl->pHwCtrl->hWhalBus);
3033 }
3034
3035
3036 /*
3037 * ----------------------------------------------------------------------------
3038 * Function : whalCtrl_GetFWInfo
3039 *
3040 * Input :
3041 * Output : FWInfo
3042 * Process : Retrieves the FWInfo
3043 * Note(s) : Done
3044 * -----------------------------------------------------------------------------
3045 */
whalCtrl_GetFWInfo(TI_HANDLE hWhalCtrl,whalCtrl_chip_t * pChip_Version)3046 TI_STATUS whalCtrl_GetFWInfo (TI_HANDLE hWhalCtrl, whalCtrl_chip_t *pChip_Version)
3047 {
3048 int i;
3049 char *StaId;
3050
3051 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3052 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
3053
3054 /*
3055 * return parameters from the wlan hardware
3056 */
3057 StaId = (char *)(whal_ParamsGetSrcMac(pWhalCtrl->pWhalParams));
3058 for (i=0; i<6; i++)
3059 {
3060 pChip_Version->macAddress.addr[i] = StaId[i];
3061 }
3062 pChip_Version->preamble = (preamble_e)pWlanParams->preamble;
3063
3064
3065 /* update the EEPROM version*/
3066 pChip_Version->e2Ver.major = pWlanParams->majorE2Ver;
3067 pChip_Version->e2Ver.minor = pWlanParams->minorE2Ver;
3068
3069 /*
3070 * get radio number and type
3071 */
3072 {
3073 UINT32 RadioType;
3074 UINT32 RadioNumber;
3075
3076 whalCtrl_getRadioNumber(hWhalCtrl, &RadioType, &RadioNumber);
3077
3078 pChip_Version->radioType = (radioType_e)RadioType;
3079 pChip_Version->e2Ver.last = RadioNumber;
3080 }
3081
3082 /* update the firmware version*/
3083 os_memoryCopy(pWhalCtrl->hOs, (void *)pChip_Version->fwVer,
3084 (void *)(whal_ParamsGetFwVersion(pWhalCtrl->pWhalParams)), FW_VERSION_LEN);
3085 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3086 ("FW version is %s\n", pChip_Version->fwVer));
3087
3088 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3089 ("E2 Major version is %d\n", pChip_Version->e2Ver.major));
3090 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3091 ("E2 Minor version is %d\n", pChip_Version->e2Ver.minor));
3092 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3093 ("E2 Last version is %d\n", pChip_Version->e2Ver.last));
3094
3095 return OK;
3096 }
3097
3098 /*
3099 * ----------------------------------------------------------------------------
3100 * Function : whalCtrl_SwitchChannelCmd
3101 *
3102 * Input :
3103 * Output :
3104 * Process :
3105 * Note(s) : Done
3106 * -----------------------------------------------------------------------------
3107 */
whalCtrl_SwitchChannelCmd(TI_HANDLE hWhalCtrl,whalCtrl_switchChannelCmd_t * pSwitchChannelCmd)3108 int whalCtrl_SwitchChannelCmd (TI_HANDLE hWhalCtrl, whalCtrl_switchChannelCmd_t* pSwitchChannelCmd)
3109 {
3110 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3111
3112
3113 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3114 ("\n SwitchChannelCmd :\n \
3115 channelNumber = %d\n \
3116 switchTime = %d\n \
3117 txFlag = %d\n \
3118 flush = %d \n ",
3119 pSwitchChannelCmd->channelNumber,
3120 pSwitchChannelCmd->switchTime,
3121 pSwitchChannelCmd->txFlag,
3122 pSwitchChannelCmd->flush));
3123
3124 /*
3125 * save Bss info parameters
3126 */
3127 pWhalCtrl->pWhalParams->BssInfoParams.RadioChannel = pSwitchChannelCmd->channelNumber;
3128
3129 /*
3130 * call the hardware to start/join the bss
3131 */
3132 return whal_hwCtrl_SwitchChannelCmd(pWhalCtrl->pHwCtrl, pSwitchChannelCmd);
3133
3134 }
3135
3136 /*
3137 * ----------------------------------------------------------------------------
3138 * Function : whalCtrl_SwitchChannelCancelCmd
3139 *
3140 * Input :
3141 * Output :
3142 * Process :
3143 * Note(s) : Done
3144 * -----------------------------------------------------------------------------
3145 */
whalCtrl_SwitchChannelCancelCmd(TI_HANDLE hWhalCtrl,UINT8 channel)3146 int whalCtrl_SwitchChannelCancelCmd (TI_HANDLE hWhalCtrl, UINT8 channel)
3147 {
3148 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3149
3150 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3151 ("\n whalCtrl_SwitchChannelCancelCmd :\n "));
3152
3153 /*
3154 * save Bss info parameters
3155 */
3156 pWhalCtrl->pWhalParams->BssInfoParams.RadioChannel = channel;
3157
3158 /*
3159 * call the hardware to start/join the bss
3160 */
3161 return whal_hwCtrl_SwitchChannelCancelCmd(pWhalCtrl->pHwCtrl);
3162
3163 }
3164
3165
3166 /*
3167 * ----------------------------------------------------------------------------
3168 * Function : whalCtrl_SetRSSIParamsCmd
3169 *
3170 * Input : pointer to stuct "whalCtrl_roamingTriggerCmd_t", but only the
3171 * following parameters are relevant;
3172 * RSSIthreshold
3173 * RSSIFilterWeight
3174 * RSSIFilterDepth
3175 *
3176 * Output :
3177 * Process :
3178 * -----------------------------------------------------------------------------
3179 */
whalCtrl_SetRSSIParamsCmd(TI_HANDLE hWhalCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)3180 int whalCtrl_SetRSSIParamsCmd (TI_HANDLE hWhalCtrl, whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
3181 {
3182 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3183
3184 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3185 ("\n SetRSSIParamsCmd :\n \
3186 RSSIthreshold = %d\n \
3187 RSSIFilterWeight = %d\n \
3188 RSSIFilterDepth = %d \n ",
3189 pRoamingTriggerCmd->rssiThreshold,
3190 pRoamingTriggerCmd->rssiFilterWeight,
3191 pRoamingTriggerCmd->rssiFilterDepth));
3192
3193 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.rssiThreshold = pRoamingTriggerCmd->rssiThreshold;
3194 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.rssiFilterWeight = pRoamingTriggerCmd->rssiFilterWeight;
3195 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.rssiFilterDepth = pRoamingTriggerCmd->rssiFilterDepth;
3196 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.lowRSSIEventType = pRoamingTriggerCmd->lowRSSIEventType;
3197
3198 return whal_hwCtrl_SetRSSIParams( pWhalCtrl->pHwCtrl, pRoamingTriggerCmd);
3199 }
3200
3201 /*
3202 * ----------------------------------------------------------------------------
3203 * Function : whalCtrl_SetSNRParamsCmd
3204 *
3205 * Input :
3206 *
3207 * Output :
3208 * Process :
3209 * -----------------------------------------------------------------------------
3210 */
whalCtrl_SetSNRParamsCmd(TI_HANDLE hWhalCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)3211 int whalCtrl_SetSNRParamsCmd (TI_HANDLE hWhalCtrl, whalCtrl_roamingTriggerCmd_t *pRoamingTriggerCmd)
3212 {
3213 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3214
3215
3216 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3217 ("\n whalCtrl_SetSNRParamsCmd :\n \
3218 SNRThreshold = %d\n \
3219 SNRFilterWeight = %d\n \
3220 SNRFilterDepth = %d \n \
3221 EdgeLevel = %d \n ",
3222 pRoamingTriggerCmd->snrThreshold,
3223 pRoamingTriggerCmd->snrFilterWeight,
3224 pRoamingTriggerCmd->snrFilterDepth,
3225 pRoamingTriggerCmd->lowSNREventType));
3226
3227
3228 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.snrThreshold = pRoamingTriggerCmd->snrThreshold;
3229 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.snrFilterWeight = pRoamingTriggerCmd->snrFilterWeight;
3230 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.snrFilterDepth = pRoamingTriggerCmd->snrFilterDepth;
3231 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.lowSNREventType = pRoamingTriggerCmd->lowSNREventType;
3232
3233 return whal_hwCtrl_SetSNRParams(pWhalCtrl->pHwCtrl, &pWhalCtrl->pWhalParams->WlanParams.roamTriggers);
3234 }
3235
3236 /*
3237 * ----------------------------------------------------------------------------
3238 * Function : whalCtrl_SetMaxTxRetryParamsCmd
3239 *
3240 * Input : pointer to stuct "whalCtrl_roamingTriggerCmd_t", but only the
3241 * following parameters are relevant;
3242 * maxTxRetry
3243 *
3244 * Output :
3245 * Process :
3246 * -----------------------------------------------------------------------------
3247 */
whalCtrl_SetMaxTxRetryParamsCmd(TI_HANDLE hWhalCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)3248 int whalCtrl_SetMaxTxRetryParamsCmd (TI_HANDLE hWhalCtrl, whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
3249 {
3250 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3251
3252 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3253 ("\n SetMaxTxRetryParamsCmdCmd :\n \
3254 maxTxRetry = %d \n ",
3255 pRoamingTriggerCmd->maxTxRetry));
3256 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.maxTxRetry = pRoamingTriggerCmd->maxTxRetry;
3257
3258 return whal_hwCtrl_SetMaxTxRetryParams(pWhalCtrl->pHwCtrl, pRoamingTriggerCmd);
3259 }
3260
3261
3262 /*
3263 * ----------------------------------------------------------------------------
3264 * Function : whalCtrl_SetBssLossTsfThresholdParamsCmd
3265 *
3266 * Input : pointer to stuct "whalCtrl_roamingTriggerCmd_t", but only the
3267 * following parameters are relevant;
3268 * BssLossTimeout
3269 * TsfMissThreshold
3270 *
3271 * Output :
3272 * Process :
3273 * -----------------------------------------------------------------------------
3274 */
whalCtrl_SetBssLossTsfThresholdParamsCmd(TI_HANDLE hWhalCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)3275 int whalCtrl_SetBssLossTsfThresholdParamsCmd (TI_HANDLE hWhalCtrl, whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
3276 {
3277 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3278
3279 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3280 ("\n whalCtrl_SetBssLossTsfThresholdParamsCmd :\n \
3281 BssLossTimeout = %d\n \
3282 TsfMissThreshold = %d \n ",
3283 pRoamingTriggerCmd->BssLossTimeout,
3284 pRoamingTriggerCmd->TsfMissThreshold));
3285
3286 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.BssLossTimeout = pRoamingTriggerCmd->BssLossTimeout;
3287 pWhalCtrl->pWhalParams->WlanParams.roamTriggers.TsfMissThreshold = pRoamingTriggerCmd->TsfMissThreshold;
3288
3289 return whal_hwCtrl_SetBssLossTsfThresholdParams( pWhalCtrl->pHwCtrl, pRoamingTriggerCmd);
3290 }
3291
3292 /*
3293 * ----------------------------------------------------------------------------
3294 * Function : whalCtrl_GetAverageRSSI
3295 *
3296 * Input : averageRSSI - pointer for return verage RSSI result
3297 *
3298 * Output : averageRSSI
3299 * Process :
3300 * -----------------------------------------------------------------------------
3301 */
whalCtrl_GetAverageRSSI(TI_HANDLE hWhalCtrl,INT8 * averageRSSI)3302 int whalCtrl_GetAverageRSSI (TI_HANDLE hWhalCtrl, INT8* averageRSSI)
3303 {
3304 #ifdef TI_DBG /* remove the #ifdef TI_DBG when implementing this function */
3305 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3306
3307 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3308 ("\n GetAverageRSSI :\n \
3309 averageRSSI = NOT IMPLEMENTED\n"));
3310 #endif /* TI_DBG */
3311 return NOK;
3312 }
3313
3314
3315 /*
3316 * ----------------------------------------------------------------------------
3317 * Function : whalCtrl_GetAverageRSSI
3318 *
3319 * Input : averageRSSI - pointer for return verage RSSI result
3320 *
3321 * Output : averageRSSI
3322 * Process :
3323 * -----------------------------------------------------------------------------
3324 */
whalCtrl_GetAsynRSSI(TI_HANDLE hWhalCtrl,void * CB_Func,TI_HANDLE CB_handle,PUINT8 CB_Buf)3325 int whalCtrl_GetAsynRSSI (TI_HANDLE hWhalCtrl,void *CB_Func, TI_HANDLE CB_handle, PUINT8 CB_Buf)
3326 {
3327 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3328 int status ;
3329
3330 status = whal_hwCtrl_GetAsynRSSI(pWhalCtrl->pHwCtrl,CB_Func,CB_handle,CB_Buf);
3331
3332 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3333 ("\n whalCtrl_GetAsynRSSI AYNC!!!! :\n "));
3334
3335 return status;
3336 }
3337
3338
3339 /*
3340 * ----------------------------------------------------------------------------
3341 * Function : whalCtrl_FwDisconnect
3342 * Input : None
3343 * Output :
3344 * Process :
3345 * Note(s) : Done
3346 * -----------------------------------------------------------------------------
3347 */
3348
whalCtrl_FwDisconnect(TI_HANDLE hWhalCtrl,UINT32 ConfigOptions,UINT32 FilterOptions)3349 int whalCtrl_FwDisconnect(TI_HANDLE hWhalCtrl, UINT32 ConfigOptions, UINT32 FilterOptions)
3350 {
3351 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3352 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pWhalCtrl->pWhalParams);
3353
3354 pWlanParams->bJoin = FALSE;
3355
3356 WLAN_REPORT_INFORMATION (pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3357 ("Sending FW disconnect, ConfigOptions=%x, FilterOPtions=%x\n",
3358 ConfigOptions, FilterOptions));
3359
3360 return whal_hwCtrl_FwDisconnect(pWhalCtrl->pHwCtrl, ConfigOptions, FilterOptions);
3361
3362 } /* whalCtrl_FwDisconnect()*/
3363
3364 /*
3365 * ----------------------------------------------------------------------------
3366 * Function : whalCtrl_resetTxCounters
3367 * Input : None
3368 * Output :
3369 * Process : Reset the HAL Tx statistics counters.
3370 * Note(s) : Done
3371 * -----------------------------------------------------------------------------
3372 */
3373
whalCtrl_resetTxCounters(TI_HANDLE hWhalCtrl)3374 void whalCtrl_resetTxCounters(TI_HANDLE hWhalCtrl)
3375 {
3376 /*
3377 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3378
3379 whalBus_resetTxCounters(pWhalCtrl->hWhalBus);
3380 */
3381 }
3382
3383
3384 /*---------------------------------------------------------
3385 debug commands for testing the Roaming trigger functions
3386 -----------------------------------------------------------*/
3387 #ifdef ROAMING_TRIGGER_DBG
whalCtrl_dbgRoamingCommands(TI_HANDLE hWhalCtrl)3388 int whalCtrl_dbgRoamingCommands (TI_HANDLE hWhalCtrl)
3389 {
3390 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3391 whalCtrl_roamingTriggerCmd_t roamingTriggerCmd;
3392 whalCtrl_roamingTriggerCmd_t *pCmd ;
3393 int stt1, stt4;
3394 INT8 rssiVal ;
3395
3396 pCmd = &roamingTriggerCmd ;
3397
3398 pCmd->rssiFilterDepth = 15;
3399 pCmd->rssiFilterWeight = 20;
3400 pCmd->rssiThreshold = -70;
3401 pCmd->lowRSSIEventType = 0;
3402 stt1 = whalCtrl_SetRSSIParamsCmd (pWhalCtrl, pCmd);
3403
3404 pCmd->maxTxRetry = 10;
3405 stt1 = whalCtrl_SetMaxTxRetryParamsCmd (pWhalCtrl, pCmd);
3406
3407 pCmd->BssLossTimeout = 1;
3408 pCmd->TsfMissThreshold = 6;
3409 stt1 = whalCtrl_SetBssLossTsfThresholdParamsCmd (pWhalCtrl, pCmd);
3410
3411 stt4 = whalCtrl_GetAverageRSSI(pWhalCtrl,&rssiVal);
3412
3413 return (OK);
3414 }
3415
3416
whalCtrl_dbgRegisterRoamingEventCB(TI_HANDLE hWhalCtrl)3417 TI_STATUS whalCtrl_dbgRegisterRoamingEventCB(TI_HANDLE hWhalCtrl)
3418 {
3419 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3420
3421 whalCtrl_EventMbox_RegisterForEvent(pWhalCtrl,
3422 HAL_EVENT_RSSI_LEVEL,
3423 (void *)whalCtrl_dbg_RSSI_LEVEL,
3424 pWhalCtrl);
3425 whalCtrl_EventMbox_Enable(pWhalCtrl, HAL_EVENT_RSSI_LEVEL);
3426
3427 whalCtrl_EventMbox_RegisterForEvent(pWhalCtrl,
3428 HAL_EVENT_SYNCHRONIZATION_TIMEOUT,
3429 (void *)whalCtrl_dbg_SYNCHRONIZATION,
3430 pWhalCtrl);
3431 whalCtrl_EventMbox_Enable(pWhalCtrl, HAL_EVENT_SYNCHRONIZATION_TIMEOUT);
3432
3433 whalCtrl_EventMbox_RegisterForEvent(pWhalCtrl,
3434 HAL_EVENT_BSS_LOSE,
3435 (void *)whalCtrl_dbg_BSS_LOSE,
3436 pWhalCtrl);
3437 whalCtrl_EventMbox_Enable(pWhalCtrl, HAL_EVENT_BSS_LOSE);
3438
3439 whalCtrl_EventMbox_RegisterForEvent(pWhalCtrl,
3440 HAL_EVENT_MAX_TX_RETRY,
3441 (void *)whalCtrl_dbg_MAX_TX_RETRY,
3442 pWhalCtrl);
3443 whalCtrl_EventMbox_Enable(pWhalCtrl, HAL_EVENT_MAX_TX_RETRY);
3444
3445 return (OK);
3446 }
3447
3448
3449
3450
3451
whalCtrl_dbg_RSSI_LEVEL(TI_HANDLE hWhalCtrl,char * str,UINT32 strLen)3452 static void whalCtrl_dbg_RSSI_LEVEL(TI_HANDLE hWhalCtrl,char* str , UINT32 strLen)
3453 {
3454 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3455 INT8 averageRssi ;
3456
3457 os_memoryCopy(pWhalCtrl->hOs, (void *)&averageRssi, (void *)str, strLen);
3458
3459
3460 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, SITE_MGR_MODULE_LOG,
3461 ("got event: whalCtrl_dbg_RSSI_LEVEL, averageRssi=0x%x\n",averageRssi));
3462
3463 }
3464
whalCtrl_dbg_SYNCHRONIZATION(TI_HANDLE hWhalCtrl)3465 TI_STATUS whalCtrl_dbg_SYNCHRONIZATION(TI_HANDLE hWhalCtrl)
3466 {
3467 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3468
3469 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, SITE_MGR_MODULE_LOG,
3470 ("got event: whalCtrl_dbg_SYNCHRONIZATION\n"));
3471
3472 return OK;
3473 }
3474
whalCtrl_dbg_BSS_LOSE(TI_HANDLE hWhalCtrl)3475 TI_STATUS whalCtrl_dbg_BSS_LOSE(TI_HANDLE hWhalCtrl)
3476 {
3477 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3478
3479 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, SITE_MGR_MODULE_LOG,
3480 ("got event: whalCtrl_dbg_BSS_LOSE\n"));
3481
3482 return OK;
3483 }
3484
whalCtrl_dbg_MAX_TX_RETRY(TI_HANDLE hWhalCtrl)3485 TI_STATUS whalCtrl_dbg_MAX_TX_RETRY(TI_HANDLE hWhalCtrl)
3486 {
3487 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3488
3489 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, SITE_MGR_MODULE_LOG,
3490 ("got event: whalCtrl_dbg_MAX_TX_RETRY\n"));
3491
3492 return OK;
3493 }
3494 #endif
3495 /*---------------------------------------------------------
3496 debug commands for testing the Roaming trigger functions
3497 -----------------------------------------------------------*/
3498
3499
3500 /****************************************************************************
3501 * whalCtrl_measurementParams()
3502 ****************************************************************************
3503 * DESCRIPTION: send Command for measurement configuration
3504 * to the mailbox
3505 *
3506 * INPUTS: None
3507 *
3508 * OUTPUT: None
3509 *
3510 * RETURNS: OK or NOK
3511 ****************************************************************************/
whalCtrl_measurementCmd(TI_HANDLE hWhalCtrl,whalCtrl_MeasurementParameters_t * pMeasurementParams,void * CommandResponseCB,TI_HANDLE CB_handle)3512 int whalCtrl_measurementCmd (TI_HANDLE hWhalCtrl, whalCtrl_MeasurementParameters_t *pMeasurementParams,
3513 void* CommandResponseCB, TI_HANDLE CB_handle)
3514 {
3515 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3516
3517 return (whal_hwCtrl_measurement (pWhalCtrl->pHwCtrl, pMeasurementParams, CommandResponseCB, CB_handle));
3518 }
3519
3520 /****************************************************************************
3521 * whalCtrl_measurementStop()
3522 ****************************************************************************
3523 * DESCRIPTION: send Command for stoping measurement
3524 *
3525 * INPUTS: None
3526 *
3527 * OUTPUT: None
3528 *
3529 * RETURNS: OK or NOK
3530 ****************************************************************************/
whalCtrl_measurementStop(TI_HANDLE hWhalCtrl,void * CommandResponseCB,TI_HANDLE CB_handle)3531 int whalCtrl_measurementStop (TI_HANDLE hWhalCtrl,void* CommandResponseCB, TI_HANDLE CB_handle)
3532 {
3533 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3534
3535 return (whal_hwCtrl_measurementStop (pWhalCtrl->pHwCtrl, CommandResponseCB, CB_handle));
3536 }
3537
3538 /****************************************************************************
3539 * whalCtrl_ApDiscoveryCmd()
3540 ****************************************************************************
3541 * DESCRIPTION: send Command for AP Discovery
3542 * to the mailbox
3543 *
3544 * INPUTS: None
3545 *
3546 * OUTPUT: None
3547 *
3548 * RETURNS: OK or NOK
3549 ****************************************************************************/
whalCtrl_ApDiscoveryCmd(TI_HANDLE hWhalCtrl,whalCtrl_ApDiscoveryParameters_t * pApDiscoveryParams)3550 int whalCtrl_ApDiscoveryCmd (TI_HANDLE hWhalCtrl, whalCtrl_ApDiscoveryParameters_t* pApDiscoveryParams)
3551 {
3552 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3553
3554 return (whal_hwCtrl_ApDiscovery (pWhalCtrl->pHwCtrl, pApDiscoveryParams));
3555 }
3556
3557 /****************************************************************************
3558 * whalCtrl_ApDiscoveryStop()
3559 ****************************************************************************
3560 * DESCRIPTION: send Command for stoping AP Discovery
3561 *
3562 * INPUTS: None
3563 *
3564 * OUTPUT: None
3565 *
3566 * RETURNS: OK or NOK
3567 ****************************************************************************/
whalCtrl_ApDiscoveryStop(TI_HANDLE hWhalCtrl)3568 int whalCtrl_ApDiscoveryStop (TI_HANDLE hWhalCtrl)
3569 {
3570 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3571
3572 return (whal_hwCtrl_ApDiscoveryStop (pWhalCtrl->pHwCtrl));
3573 }
3574
3575 /*
3576 * ----------------------------------------------------------------------------
3577 * Function : whalCtrl_SetGroupIpAddressesTable
3578 *
3579 * Input :
3580 * Output :
3581 * Process : Configures the Group table
3582 * Note(s) : Done
3583 * -----------------------------------------------------------------------------
3584 */
whalCtrl_SetGroupAddressesTable(TI_HANDLE hWhalCtrl,UINT8 numGroupAddrs,macAddress_t * Group_addr,UINT8 isEnabled)3585 int whalCtrl_SetGroupAddressesTable(TI_HANDLE hWhalCtrl,
3586 UINT8 numGroupAddrs,
3587 macAddress_t *Group_addr,
3588 UINT8 isEnabled)
3589 {
3590 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3591 if ( numGroupAddrs > MAX_MULTICAST_GROUP_ADDRS)
3592 {
3593 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
3594 ("whalCtrl_SetGroupAddressesTable: numGroupAddrs=%d !!!\n", numGroupAddrs));
3595 return PARAM_VALUE_NOT_VALID;
3596 }
3597 return whal_hwCtrl_SetGroupAddressesTable(pWhalCtrl->pHwCtrl,
3598 numGroupAddrs, Group_addr,isEnabled);
3599 }
3600
3601 /*
3602 * ----------------------------------------------------------------------------
3603 * Function : whalCtrl_GetGroupIpAddressesTable
3604 *
3605 * Input :
3606 * Output :
3607 * Process : Retrieve the Group table
3608 * -----------------------------------------------------------------------------
3609 */
whalCtrl_GetGroupAddressesTable(TI_HANDLE hWhalCtrl,UINT8 * pisEnabled,UINT8 * pnumGroupAddrs,macAddress_t * Group_addr)3610 int whalCtrl_GetGroupAddressesTable(TI_HANDLE hWhalCtrl,UINT8* pisEnabled, UINT8* pnumGroupAddrs, macAddress_t *Group_addr)
3611 {
3612 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3613 return whal_hwCtrl_GetGroupAddressesTable(pWhalCtrl->pHwCtrl,
3614 pisEnabled, pnumGroupAddrs, Group_addr);
3615 }
3616
3617
3618 /****************************************************************************
3619 * whalCtrl_ElpCtrl_SetMode()
3620 ****************************************************************************
3621 * DESCRIPTION: wrapper function for the lower TNETWIF_ElpCtrl_Mode
3622 *
3623 * INPUTS:
3624 * hWhalCtrl The current context handle
3625 * mode The ElpCtrl mode
3626 *
3627 * OUTPUT: None
3628 *
3629 * RETURNS: OK or NOK
3630 ****************************************************************************/
whalCtrl_ElpCtrl_SetMode(TI_HANDLE hWhalCtrl,elpCtrl_Mode_e mode)3631 int whalCtrl_ElpCtrl_SetMode(TI_HANDLE hWhalCtrl, elpCtrl_Mode_e mode)
3632 {
3633 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3634
3635 return whalBus_TNETWIF_ElpCtrl_SetMode(pWhalCtrl->hWhalBus, mode);
3636 }
3637
3638 /*
3639 * ----------------------------------------------------------------------------
3640 * Function : whalCtrl_SetMinPowerLevel
3641 *
3642 * Input : 1) theWhalCtrlHandle - handle to the WhalCtrl object.
3643 * 2) minPowerPolicy - the min power policy to set
3644 *
3645 * Output : TI_STATUS - OK on success else NOK.
3646 *
3647 * Process : configuration of the min power policy to the FW.
3648 *
3649 * Note(s) :
3650 * -----------------------------------------------------------------------------
3651 */
whalCtrl_SetMinPowerLevel(TI_HANDLE theWhalCtrlHandle,powerAutho_PowerPolicy_e minPowerPolicy)3652 TI_STATUS whalCtrl_SetMinPowerLevel(TI_HANDLE theWhalCtrlHandle,
3653 powerAutho_PowerPolicy_e minPowerPolicy)
3654 {
3655 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)theWhalCtrlHandle;
3656 WlanParams_T *pWlanParams = &pWhalCtrl->pWhalParams->WlanParams;
3657
3658 /* save th eparameter inside the WlanParams */
3659 pWlanParams->minPowerLevel = minPowerPolicy;
3660
3661 return (TI_STATUS)whal_hwCtrl_MinPowerLevelSet(pWhalCtrl->pHwCtrl,minPowerPolicy);
3662 }
3663
3664 /*
3665 * ----------------------------------------------------------------------------
3666 * Function : whalCtrl_GetMinPowerLevel
3667 *
3668 * Input : 1) theWhalCtrlHandle - handle to the WhalCtrl object.
3669 * 2) minPowerPolicy - a pointer to the min power policy to get
3670 *
3671 * Output : TI_STATUS - OK on success else NOK.
3672 *
3673 * Process : gets the min power policy that was configured to the FW.
3674 *
3675 * Note(s) :
3676 * -----------------------------------------------------------------------------
3677 */
whalCtrl_GetMinPowerLevel(TI_HANDLE theWhalCtrlHandle,powerAutho_PowerPolicy_e * minPowerPolicy)3678 TI_STATUS whalCtrl_GetMinPowerLevel(TI_HANDLE theWhalCtrlHandle,
3679 powerAutho_PowerPolicy_e* minPowerPolicy)
3680 {
3681 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)theWhalCtrlHandle;
3682 WlanParams_T *pWlanParams = &pWhalCtrl->pWhalParams->WlanParams;
3683
3684 /* save th eparameter inside the WlanParams */
3685 *minPowerPolicy = pWlanParams->minPowerLevel;
3686
3687 return OK;
3688 }
3689
3690
3691
3692 /*
3693 * ----------------------------------------------------------------------------
3694 * Function : whalCtrl_SetInfoElemEventMask
3695 *
3696 * Input : eventMask - Vector to be Masked
3697 *
3698 * Process : set FW with the Masked Vector
3699 *
3700 * Note(s) : called from eventMbox.c
3701 * -----------------------------------------------------------------------------
3702 */
whalCtrl_SetInfoElemEventMask(TI_HANDLE hWhalCtrl,UINT32 eventMask)3703 void whalCtrl_SetInfoElemEventMask(TI_HANDLE hWhalCtrl,UINT32 eventMask)
3704 {
3705 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)hWhalCtrl;
3706
3707 whal_hwInfoElemEventMaskSet (pWhalCtrl->pHwCtrl->pHwMboxConfig, eventMask);
3708 }
3709
3710
3711
3712 /*
3713 * ----------------------------------------------------------------------------
3714 * Function : whalCtrl_RxPER
3715 *
3716 * Input :
3717 *
3718 * Output :
3719 * Process :
3720 * -----------------------------------------------------------------------------
3721 */
whalCtrl_RxPER(TI_HANDLE hWhalCtrl,PLT_RxPerCmd_e eRxPerCmd,TI_HANDLE CB_Handle,void * CB_Func)3722 int whalCtrl_RxPER(TI_HANDLE hWhalCtrl, PLT_RxPerCmd_e eRxPerCmd, TI_HANDLE CB_Handle, void *CB_Func)
3723 {
3724 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3725 int status ;
3726 status = whal_hwCmdBit_RxPER(pWhalCtrl->pHwCtrl->pHwMboxCmdBit, eRxPerCmd, CB_Handle, CB_Func);
3727 return status;
3728 }
3729
3730 /*
3731 * ----------------------------------------------------------------------------
3732 * Function : whalCtrl_TxCW
3733 *
3734 * Input :
3735 *
3736 * Output :
3737 * Process :
3738 * -----------------------------------------------------------------------------
3739 */
whalCtrl_TxCW(TI_HANDLE hWhalCtrl,TestCmdChannelBand_t * PltTxCarrier,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)3740 int whalCtrl_TxCW(TI_HANDLE hWhalCtrl, TestCmdChannelBand_t* PltTxCarrier, void * CB_Func, TI_HANDLE CB_handle, void * CB_Buf)
3741 {
3742 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3743 int status ;
3744
3745 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
3746 ("whalCtrl_TxCW: chID = %d bandID = %d\n ",
3747 PltTxCarrier->channel,
3748 PltTxCarrier->band));
3749
3750 status = whal_hwCmdBit_Telec(pWhalCtrl->pHwCtrl->pHwMboxCmdBit,PltTxCarrier->channel, PltTxCarrier->band, CB_Func, CB_handle, CB_Buf);
3751 return status;
3752 }
3753
3754 /*
3755 * ----------------------------------------------------------------------------
3756 * Function : whalCtrl_TxContinues
3757 *
3758 * Input :
3759 *
3760 * Output :
3761 * Process :
3762 * -----------------------------------------------------------------------------
3763 */
whalCtrl_TxContinues(TI_HANDLE hWhalCtrl,PltTxContinues_t * pPLT_TX_Continues,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)3764 int whalCtrl_TxContinues(TI_HANDLE hWhalCtrl, PltTxContinues_t* pPLT_TX_Continues, void * CB_Func, TI_HANDLE CB_handle, void * CB_Buf)
3765 {
3766 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3767 int status ;
3768
3769 status = whal_hwCmdBit_Fcc(pWhalCtrl->pHwCtrl->pHwMboxCmdBit,
3770 pPLT_TX_Continues->chID, pPLT_TX_Continues->rate,
3771 pPLT_TX_Continues->preamble, pPLT_TX_Continues->band,
3772 pPLT_TX_Continues->InterPacketDelay, pPLT_TX_Continues->mode, pPLT_TX_Continues->NumOfFrames,
3773 pPLT_TX_Continues->aSeqNumMode, pPLT_TX_Continues->aPacketLength, (uint8*)&(pPLT_TX_Continues->aPeerMacAddr),
3774 CB_Func, CB_handle, CB_Buf);
3775 return status;
3776 }
3777
3778 /*
3779 * ----------------------------------------------------------------------------
3780 * Function : whalCtrl_WriteRegister
3781 *
3782 * Input :
3783 *
3784 * Output :
3785 * Process :
3786 * -----------------------------------------------------------------------------
3787 */
whalCtrl_WriteRegister(TI_HANDLE hWhalCtrl,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)3788 int whalCtrl_WriteRegister(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf)
3789 {
3790 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3791 int status ;
3792
3793 status = whal_hwCmdBit_WriteRegister(pWhalCtrl->pHwCtrl->pHwMboxCmdBit, CB_Handle, CB_Func, CB_Buf);
3794 return status;
3795 }
3796
3797
3798 /*
3799 * ----------------------------------------------------------------------------
3800 * Function : whalCtrl_ReadRegister
3801 *
3802 * Input :
3803 *
3804 * Output :
3805 * Process :
3806 * -----------------------------------------------------------------------------
3807 */
whalCtrl_ReadRegister(TI_HANDLE hWhalCtrl,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)3808 int whalCtrl_ReadRegister(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf)
3809 {
3810 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3811 int status ;
3812
3813 status = whal_hwCmdBit_ReadRegister(pWhalCtrl->pHwCtrl->pHwMboxCmdBit, CB_Handle, CB_Func, CB_Buf);
3814 return status;
3815 }
3816
3817 /****************************************************************************************
3818 * whalCtrl_ReadMib()
3819 ****************************************************************************************
3820 DESCRIPTION: Read configuration information and statistics
3821
3822 INPUT:
3823
3824 OUTPUT:
3825
3826 RETURN:
3827
3828 ************************************************************************/
whalCtrl_ReadMib(TI_HANDLE hWhalCtrl,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)3829 int whalCtrl_ReadMib(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf)
3830 {
3831 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3832 PLT_MIB_t* pMibBuf = (PLT_MIB_t*)CB_Buf;
3833 CmdQueue_InterrogateCB_t RetFunc = (CmdQueue_InterrogateCB_t)CB_Func;
3834 TI_STATUS Status;
3835
3836
3837
3838 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3839 ("whalCtrl_ReadMib :pMibBuf %p:\n",pMibBuf));
3840
3841 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3842 ("whalCtrl_ReadMib :aMib %x:\n",pMibBuf->aMib));
3843
3844 switch (pMibBuf->aMib)
3845 {
3846 case PLT_MIB_dot11StationId:
3847 /*
3848 * Use the Station ID CallBack as the Read MIB Cb to get back context
3849 */
3850 return(whalCtrl_InterrogateMbox(hWhalCtrl , CB_Func, CB_Handle, CB_Buf));
3851 /* break; */
3852
3853 case PLT_MIB_dot11MaxReceiveLifetime:
3854 {
3855 whalParamInfo_t ParamInfo;
3856 ParamInfo.paramType = (UINT32)HAL_CTRL_DOT11_MAX_RX_MSDU_LIFE_TIME;
3857 ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlMaxRxMsduLifetime);
3858 Status = whalCtrl_GetParam(hWhalCtrl, &ParamInfo);
3859 pMibBuf->aData.MaxReceiveLifeTime = ParamInfo.content.halCtrlMaxRxMsduLifetime / 1024; /* converting from usecs to TUs*/
3860 pMibBuf->Length = sizeof(pMibBuf->aData.MaxReceiveLifeTime);
3861 RetFunc(CB_Handle, Status, (void*)pMibBuf);
3862 }
3863 break;
3864
3865
3866 case PLT_MIB_dot11GroupAddressesTable:
3867 {
3868 Status = (TI_STATUS)whalCtrl_GetGroupAddressesTable(
3869 hWhalCtrl,
3870 &pMibBuf->aData.GroupAddressTable.bFilteringEnable,
3871 &pMibBuf->aData.GroupAddressTable.nNumberOfAddresses,
3872 pMibBuf->aData.GroupAddressTable.GroupTable);
3873
3874 pMibBuf->Length = sizeof(pMibBuf->aData.GroupAddressTable.bFilteringEnable) +
3875 sizeof(pMibBuf->aData.GroupAddressTable.nNumberOfAddresses) +
3876 pMibBuf->aData.GroupAddressTable.nNumberOfAddresses * sizeof(macAddress_t);
3877
3878 RetFunc(CB_Handle, Status, CB_Buf);
3879 }
3880
3881 break;
3882
3883 case PLT_MIB_ctsToSelf:
3884 {
3885 whalParamInfo_t ParamInfo;
3886 ParamInfo.paramType = (UINT32)HAL_CTRL_CTS_TO_SELF_PARAM;
3887 ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlCtsToSelf);
3888 Status = whalCtrl_GetParam(hWhalCtrl, &ParamInfo);
3889 pMibBuf->aData.CTSToSelfEnable = ParamInfo.content.halCtrlCtsToSelf;
3890 pMibBuf->Length = sizeof(pMibBuf->aData.CTSToSelfEnable);
3891 RetFunc(CB_Handle, Status, CB_Buf);
3892 }
3893 break;
3894
3895 case PLT_MIB_arpIpAddressesTable:
3896 {
3897 IpAddress_t IpAddress;
3898 IPver_e IPver;
3899 UINT8 Enable;
3900 TI_STATUS status;
3901
3902 pMibBuf->Length = sizeof(PLT_MIB_ArpIpAddressesTable_t);
3903 status = (TI_STATUS)whalCtrl_GetArpIpAddressesTable(pWhalCtrl->pHwCtrl,
3904 &IpAddress,
3905 &Enable,
3906 &IPver);
3907 if (status == OK)
3908 {
3909 pMibBuf->aData.ArpIpAddressesTable.FilteringEnable = Enable;
3910
3911 if (IP_VER_4 == IPver) /* IP_VER_4 only */
3912 {
3913 os_memoryCopy(pWhalCtrl->hOs,
3914 (PVOID)pMibBuf->aData.ArpIpAddressesTable.addr,
3915 (PVOID)IpAddress.addr,
3916 IP_V4_ADDR_LEN);
3917 }
3918 else
3919 {
3920 status = NOK;
3921 }
3922 }
3923 RetFunc(CB_Handle, status, CB_Buf);
3924 return status;
3925 }
3926
3927
3928 /*break; Unreachble code*/
3929
3930 case PLT_MIB_templateFrame:
3931 whalCtrl_ReadTemplateFrameMib(hWhalCtrl, CB_Handle, CB_Func, CB_Buf);
3932 break;
3933
3934 case PLT_MIB_rxFilter:
3935 {
3936 UINT32 RxConfigOption;
3937 UINT32 RxFilterOption;
3938
3939 pMibBuf->Length = 1;
3940 pMibBuf->aData.RxFilter = 0;
3941
3942 /*Get RX filter data*/
3943 Status = (TI_STATUS)whalCtrl_GetRxFilters(pWhalCtrl, &RxConfigOption, &RxFilterOption);
3944 if (OK == Status)
3945 {
3946 /*Translate to MIB bitmap*/
3947 if ((RxConfigOption & RX_CFG_MAC) == RX_CFG_ENABLE_ANY_DEST_MAC)
3948 pMibBuf->aData.RxFilter |= PLT_MIB_RX_FILTER_PROMISCOUS_SET;
3949
3950 if ((RxConfigOption & RX_CFG_BSSID) == RX_CFG_ENABLE_ONLY_MY_BSSID)
3951 pMibBuf->aData.RxFilter |= PLT_MIB_RX_FILTER_BSSID_SET;
3952 }
3953 RetFunc(CB_Handle, Status, CB_Buf);
3954 }
3955 break;
3956
3957 case PLT_MIB_beaconFilterIETable:
3958 return (whalCtrl_PltMibGetBeaconFilterIETable(hWhalCtrl, CB_Handle, CB_Func, CB_Buf));
3959 /* break; */
3960
3961 case PLT_MIB_txRatePolicy:
3962 return (whalCtrl_PLT_ReadMIB_TxRatePolicy(hWhalCtrl, CB_Handle, CB_Func, CB_Buf));
3963 /* break; */
3964
3965
3966 case PLT_MIB_countersTable:
3967 return(whalCtrl_InterrogateGwsiCounters (hWhalCtrl , CB_Func, CB_Handle, CB_Buf));
3968 /* break; */
3969
3970
3971 case PLT_MIB_statisticsTable:
3972 return (whalCtrl_InterrogateGwsiStatisitics(hWhalCtrl , CB_Func, CB_Handle, CB_Buf));
3973 /* break; */
3974
3975 default:
3976 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
3977 ("whalCtrl_ReadMib:MIB aMib 0x%x Not supported\n",pMibBuf->aMib));
3978 return NOK;
3979 }
3980 return OK;
3981
3982 }
3983
3984 /****************************************************************************************
3985 * whalCtrl_WriteMib()
3986 ****************************************************************************************
3987 DESCRIPTION: Set configuration information
3988
3989 INPUT:
3990
3991 OUTPUT:
3992
3993 RETURN:
3994
3995 ************************************************************************/
whalCtrl_WriteMib(TI_HANDLE hWhalCtrl,PLT_MIB_t * pMib)3996 int whalCtrl_WriteMib(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib)
3997 {
3998 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
3999
4000 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4001 ("whalCtrl_WriteMib :pMib %p:\n",pMib));
4002
4003 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4004 ("whalCtrl_WriteMib :aMib %x:\n",pMib->aMib));
4005
4006 WLAN_REPORT_HEX_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4007 (PUINT8)pMib, min(sizeof(PLT_MIB_t), pMib->Length));
4008
4009 if (NULL == pMib)
4010 {
4011 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4012 ("whalCtrl_WriteMib :pMib = NULL !!\n"));
4013 return PARAM_VALUE_NOT_VALID;
4014 }
4015
4016
4017 switch (pMib->aMib)
4018 {
4019 case PLT_MIB_dot11MaxReceiveLifetime:
4020 {
4021 whalParamInfo_t ParamInfo;
4022 ParamInfo.paramType = (UINT32)HAL_CTRL_DOT11_MAX_RX_MSDU_LIFE_TIME;
4023 ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlMaxRxMsduLifetime);
4024 ParamInfo.content.halCtrlMaxRxMsduLifetime = pMib->aData.MaxReceiveLifeTime;
4025 ParamInfo.content.halCtrlMaxRxMsduLifetime *= 1024; /* converting from TUs to usecs */
4026 return whalCtrl_SetParam(hWhalCtrl, &ParamInfo);
4027 }
4028 /* break; */
4029
4030 case PLT_MIB_ctsToSelf:
4031 {
4032 whalParamInfo_t ParamInfo;
4033 ParamInfo.paramType = (UINT32)HAL_CTRL_CTS_TO_SELF_PARAM;
4034 ParamInfo.paramLength = sizeof(ParamInfo.content.halCtrlCtsToSelf);
4035 ParamInfo.content.halCtrlCtsToSelf = pMib->aData.CTSToSelfEnable;
4036 return whalCtrl_SetParam(hWhalCtrl, &ParamInfo);
4037 }
4038 /* break; */
4039
4040 case PLT_MIB_dot11GroupAddressesTable:
4041 {
4042
4043 if ( NULL == pMib->aData.GroupAddressTable.GroupTable)
4044 {
4045 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4046 ("whalCtrl_WriteMib(PLT_MIB_dot11GroupAddressesTable) :GroupTable = NULL !!\n"));
4047 return PARAM_VALUE_NOT_VALID;
4048 }
4049
4050 return whalCtrl_SetGroupAddressesTable(hWhalCtrl,
4051 pMib->aData.GroupAddressTable.nNumberOfAddresses,
4052 pMib->aData.GroupAddressTable.GroupTable,
4053 pMib->aData.GroupAddressTable.bFilteringEnable);
4054 }
4055 /* break; */
4056
4057 case PLT_MIB_arpIpAddressesTable:
4058 {
4059 IpAddress_t IpAddress;
4060 IpAddress.addr[0] = pMib->aData.ArpIpAddressesTable.addr[0];
4061 IpAddress.addr[1] = pMib->aData.ArpIpAddressesTable.addr[1];
4062 IpAddress.addr[2] = pMib->aData.ArpIpAddressesTable.addr[2];
4063 IpAddress.addr[3] = pMib->aData.ArpIpAddressesTable.addr[3];
4064
4065 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4066 ("whalCtrl_WriteMib(PLT_MIB_arpIpAddressesTable) IpAddress:\n"));
4067 WLAN_REPORT_HEX_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4068 (PUINT8)&IpAddress, 4);
4069
4070 return whalCtrl_SetarpIpAddressesTable(hWhalCtrl,
4071 &IpAddress,
4072 pMib->aData.ArpIpAddressesTable.FilteringEnable,
4073 IP_VER_4);
4074 }
4075 /* break; */
4076
4077 case PLT_MIB_templateFrame:
4078 return whalCtrl_WriteTemplateFrameMib(hWhalCtrl, pMib);
4079 /* break; */
4080
4081 case PLT_MIB_beaconFilterIETable:
4082 return whalCtrl_PltMibSetBeaconFilterIETable(hWhalCtrl, pMib);
4083 /* break; */
4084
4085 case PLT_MIB_rxFilter:
4086 {
4087 UINT32 whal_rx_filter = 0;
4088 tiUINT8 Mib_Rx_Filter = pMib->aData.RxFilter;
4089
4090 /*
4091 * Construct the WHAL rx filter element
4092 */
4093 if (Mib_Rx_Filter & PLT_MIB_RX_FILTER_PROMISCOUS_SET )
4094 {
4095 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,HAL_CTRL_MODULE_LOG,("\n whalCtrl_WriteMib PLT_MIB_rxFilter - RX_CFG_ENABLE_ANY_DEST_MAC\n")) ;
4096 whal_rx_filter = RX_CFG_ENABLE_ANY_DEST_MAC;
4097 }
4098 else
4099 {
4100 whal_rx_filter = RX_CFG_ENABLE_ONLY_MY_DEST_MAC;
4101 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,HAL_CTRL_MODULE_LOG,("\n halCtrl_WriteMib PLT_MIB_rxFilter - RX_CFG_ENABLE_ONLY_MY_DEST_MAC\n")) ;
4102 }
4103
4104 if ( Mib_Rx_Filter & PLT_MIB_RX_FILTER_BSSID_SET )
4105 {
4106 whal_rx_filter = whal_rx_filter | RX_CFG_ENABLE_ONLY_MY_BSSID;
4107 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,HAL_CTRL_MODULE_LOG,("\n halCtrl_WriteMib PLT_MIB_rxFilter - RX_CFG_ENABLE_ONLY_MY_BSSID\n")) ;
4108 }
4109 else
4110 {
4111 whal_rx_filter = whal_rx_filter | RX_CFG_ENABLE_ANY_BSSID;
4112 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport,HAL_CTRL_MODULE_LOG,("\n halCtrl_WriteMib PLT_MIB_rxFilter - RX_CFG_ENABLE_ANY_BSSID\n") );
4113 }
4114
4115 /*
4116 * Activates the whalCtrl_setRxFilters function
4117 */
4118 return whalCtrl_setRxFilters(hWhalCtrl, whal_rx_filter, RX_FILTER_OPTION_DEF);
4119
4120 }
4121 /* break; */
4122
4123 case PLT_MIB_txRatePolicy:
4124 return whalCtrl_PLT_WriteMIB_TxRatePolicy(hWhalCtrl, pMib);
4125 /* break; */
4126
4127 default:
4128 WLAN_REPORT_ERROR(pWhalCtrl->hReport,
4129 HAL_CTRL_MODULE_LOG,
4130 ("%s(%d) - whalCtrl_WriteMib - ERROR - MIB element not supported, %d\n\n",
4131 __FILE__,__LINE__,pMib->aMib));
4132
4133 return NOK;
4134
4135 } /* switch */
4136
4137 /* return OK;*/
4138 }
4139
4140
whalCtrl_ReadTemplateFrameMib(TI_HANDLE hWhalCtrl,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)4141 int whalCtrl_ReadTemplateFrameMib(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf)
4142 {
4143 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
4144 PLT_MIB_t* pMibBuf = (PLT_MIB_t*)CB_Buf;
4145 CmdQueue_InterrogateCB_t RetFunc = (CmdQueue_InterrogateCB_t)CB_Func;
4146 TemplateParams_T* pTemplateParams;
4147 whalCtrl_templateType_e templateType;
4148
4149 switch(pMibBuf->aData.TemplateFrame.FrameType)
4150 {
4151 case PLT_TEMPLATE_TYPE_BEACON:
4152 templateType = BEACON_TEMPLATE;
4153 pMibBuf->aData.TemplateFrame.Rate = pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmRateDriverFormat;
4154 break;
4155
4156 case PLT_TEMPLATE_TYPE_PROBE_REQUEST:
4157 templateType = PROBE_REQUEST_TEMPLATE;
4158 pMibBuf->aData.TemplateFrame.Rate = DRV_RATE_INVALID;
4159 break;
4160
4161 case PLT_TEMPLATE_TYPE_NULL_FRAME:
4162 {
4163 TI_HANDLE hHalCtrl;
4164 TI_HANDLE hMacServices;
4165 TnetwDrv_TEMP_GetHandles(pWhalCtrl->hTNETW_Driver, &hHalCtrl, &hMacServices);
4166 pMibBuf->aData.TemplateFrame.Rate = MacServices_powerSrv_GetRateModulation(hMacServices);
4167 templateType = NULL_DATA_TEMPLATE;
4168 }
4169 break;
4170
4171 case PLT_TEMPLATE_TYPE_PROBE_RESPONSE:
4172 templateType = PROBE_RESPONSE_TEMPLATE;
4173 pMibBuf->aData.TemplateFrame.Rate = pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmRateDriverFormat;
4174 break;
4175
4176 case PLT_TEMPLATE_TYPE_QOS_NULL_FRAME:
4177 templateType = QOS_NULL_DATA_TEMPLATE;
4178 pMibBuf->aData.TemplateFrame.Rate = pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmRateDriverFormat;
4179 break;
4180
4181 case PLT_TEMPLATE_TYPE_PS_POLL:
4182 templateType = PS_POLL_TEMPLATE;
4183 pMibBuf->aData.TemplateFrame.Rate = pWhalCtrl->pWhalParams->BssInfoParams.txCtrlFrmRateDriverFormat;
4184 break;
4185 default:
4186 WLAN_REPORT_ERROR(pWhalCtrl->hReport,
4187 HAL_CTRL_MODULE_LOG,
4188 ("%s(%d) - whalCtrl_ReadTemplateFrameMib - ERROR - template is not supported, %d\n\n",
4189 __FILE__,__LINE__,pMibBuf->aData.TemplateFrame.FrameType));
4190 return PARAM_NOT_SUPPORTED;
4191 }
4192
4193 pTemplateParams = whalCtrl_GetTemplate(hWhalCtrl, templateType);
4194
4195 if (pTemplateParams)
4196 {
4197 pMibBuf->Length = pTemplateParams->Size + 10;
4198
4199 pMibBuf->aData.TemplateFrame.Length = pTemplateParams->Size;
4200
4201 os_memoryCopy(pWhalCtrl->hOs,
4202 pMibBuf->aData.TemplateFrame.Data,
4203 pTemplateParams->Buffer,
4204 pTemplateParams->Size);
4205
4206
4207 pMibBuf->aData.TemplateFrame.Rate = whalUtils_DRV_RATE2GwsiRate(pMibBuf->aData.TemplateFrame.Rate);
4208 RetFunc(CB_Handle, OK, CB_Buf);
4209 return OK;
4210 }
4211
4212 RetFunc(CB_Handle, NOK, CB_Buf);
4213 return NOK;
4214 }
4215
whalCtrl_WriteTemplateFrameMib(TI_HANDLE hWhalCtrl,PLT_MIB_t * pMib)4216 int whalCtrl_WriteTemplateFrameMib(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib)
4217 {
4218 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
4219 rate_e rate;
4220 whalCtrl_setTemplate_t whal_set_template_s;
4221
4222
4223 /*convert the rate to driver rate*/
4224 rate = (rate_e)whalUtils_GwsiRate2DRV_RATE(pMib->aData.TemplateFrame.Rate);
4225
4226 /*
4227 * Construct the template MIB element
4228 */
4229 switch(pMib->aData.TemplateFrame.FrameType)
4230 {
4231 case PLT_TEMPLATE_TYPE_BEACON:
4232 whal_set_template_s.templateType = BEACON_TEMPLATE;
4233
4234 /* Set new Mgmt rate (write it to Fw along with the modulation) */
4235 whalCtrl_SetFrameRate(hWhalCtrl, rate, FALSE);
4236
4237 break;
4238
4239 case PLT_TEMPLATE_TYPE_PROBE_REQUEST:
4240 whal_set_template_s.templateType = PROBE_REQUEST_TEMPLATE;
4241 break;
4242
4243 case PLT_TEMPLATE_TYPE_NULL_FRAME:
4244 {
4245 TI_HANDLE hHalCtrl;
4246 TI_HANDLE hMacServices;
4247 TnetwDrv_TEMP_GetHandles(pWhalCtrl->hTNETW_Driver, &hHalCtrl, &hMacServices);
4248
4249 whal_set_template_s.templateType = NULL_DATA_TEMPLATE;
4250 MacServices_powerSrv_SetRateModulation(hMacServices,
4251 (UINT16)whalUtils_GwsiRate2DRV_RATE_MASK(pMib->aData.TemplateFrame.Rate));
4252 }
4253 break;
4254
4255 case PLT_TEMPLATE_TYPE_PROBE_RESPONSE:
4256 whal_set_template_s.templateType = PROBE_RESPONSE_TEMPLATE;
4257
4258 /* Set new Mgmt rate (write it to Fw along with the modulation) */
4259 whalCtrl_SetFrameRate(hWhalCtrl, rate, FALSE);
4260
4261 break;
4262
4263 case PLT_TEMPLATE_TYPE_QOS_NULL_FRAME:
4264 whal_set_template_s.templateType = QOS_NULL_DATA_TEMPLATE;
4265
4266 /* Set new Ctrl rate (write it to Fw along with the modulation) */
4267 whalCtrl_SetFrameRate(hWhalCtrl, rate, TRUE);
4268
4269 break;
4270
4271 case PLT_TEMPLATE_TYPE_PS_POLL:
4272 whal_set_template_s.templateType = PS_POLL_TEMPLATE;
4273
4274 /* Set new Ctrl rate (write it to Fw along with the modulation) */
4275 whalCtrl_SetFrameRate(hWhalCtrl, rate, TRUE);
4276
4277 break;
4278
4279 default:
4280 WLAN_REPORT_ERROR(pWhalCtrl->hReport,
4281 HAL_CTRL_MODULE_LOG,
4282 ("%s(%d) - whalCtrl_WriteTemplateFrameMib - ERROR - template is not supported, %d\n\n",
4283 __FILE__,__LINE__,pMib->aData.TemplateFrame.FrameType));
4284 return PARAM_NOT_SUPPORTED;
4285 }
4286
4287 whal_set_template_s.templateLen = pMib->aData.TemplateFrame.Length;
4288 whal_set_template_s.pTemplate = (UINT8 *) &(pMib->aData.TemplateFrame.Data);
4289
4290
4291 return whalCtrl_SetTemplate(hWhalCtrl, &whal_set_template_s);
4292 }
4293
whalCtrl_PltMibSetBeaconFilterIETable(TI_HANDLE hWhalCtrl,PLT_MIB_t * pMib)4294 int whalCtrl_PltMibSetBeaconFilterIETable(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib)
4295 {
4296 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
4297 UINT8 numOf221IE = 0 ;
4298 UINT8 i = 0 ;
4299 UINT8 IETableLen = 0 ;
4300 UINT8 numOfIEs = 0 ;
4301 UINT8 *IETable = NULL ;
4302
4303 numOfIEs = pMib->aData.BeaconFilter.iNumberOfIEs;
4304 IETable = pMib->aData.BeaconFilter.iIETable;
4305 /*find the actual IETableLen */
4306 for ( i = 0 ; i < numOfIEs ; i++ )
4307 {
4308 if ( IETable[IETableLen] == 0xdd )
4309 {
4310 IETableLen += 8;
4311 numOf221IE++;
4312 }
4313 else
4314 IETableLen += 2;
4315 }
4316
4317 WLAN_REPORT_INFORMATION(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4318 ("\nwhalCtrl_PltMibSetBeaconFilterIETable,IETable=0x%x Num Of IE=%d ( including %d 221 ) - Table Len=%d\n",
4319 IETable , numOfIEs , numOf221IE , IETableLen ));
4320
4321 return whalCtrl_SetBeaconFilterIETable(hWhalCtrl, &numOfIEs, IETable, &IETableLen);
4322 }
4323
whalCtrl_PltMibGetBeaconFilterIETable(TI_HANDLE hWhalCtrl,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)4324 int whalCtrl_PltMibGetBeaconFilterIETable(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf)
4325 {
4326 PLT_MIB_t* pMib = (PLT_MIB_t*)CB_Buf;
4327 CmdQueue_InterrogateCB_t RetFunc = (CmdQueue_InterrogateCB_t)CB_Func;
4328 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
4329 UINT8 IETableSize = 0;
4330
4331
4332 /*Get params*/
4333 pMib->aData.BeaconFilter.iNumberOfIEs = pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.numberOfIEs;
4334 IETableSize = pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.IETableSize;
4335
4336 os_memoryZero (pWhalCtrl->hOs,
4337 pMib->aData.BeaconFilter.iIETable,
4338 sizeof(pMib->aData.BeaconFilter.iIETable));
4339
4340 os_memoryCopy(pWhalCtrl->hOs,
4341 pMib->aData.BeaconFilter.iIETable,
4342 pWhalCtrl->pWhalParams->WlanParams.beaconFilterIETable.IETable,
4343 IETableSize);
4344 pMib->Length = IETableSize + 1;
4345
4346 RetFunc(CB_Handle, OK, CB_Buf);
4347 return OK;
4348
4349 }
4350
4351 /**
4352 * \author \n
4353 * \date \n
4354 * \brief Coordinates between legacy TxRatePolicy implementation and the MIB format: \n
4355 * Converts the pGwsi_txRatePolicy back to whal commands
4356 * Activates the whal whalCtrl_set function
4357 * Function Scope \e Public.\n
4358 * \param - \n
4359 * \return \n
4360 */
4361
whalCtrl_PLT_WriteMIB_TxRatePolicy(TI_HANDLE hWhalCtrl,PLT_MIB_t * pMib)4362 int whalCtrl_PLT_WriteMIB_TxRatePolicy(TI_HANDLE hWhalCtrl, PLT_MIB_t* pMib) /* Pointer to the MIB data*/
4363 {
4364 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl;
4365 whalParamInfo_t param;
4366
4367 if (NULL == pMib)
4368 {
4369 WLAN_REPORT_ERROR(pWhalCtrl->hReport, HAL_CTRL_MODULE_LOG,
4370 ("ERROR : whalCtrl_PLT_WriteMIB_TxRatePolicy pMib=NULL !!!"));
4371 }
4372
4373
4374 param.paramType = (UINT32)HAL_CTRL_TX_RATE_CLASS_PARAMS;
4375 param.content.pTxRatePlicy = &pMib->aData.txRatePolicy;
4376
4377 /*
4378 * Call WhalCtrl Set I/F
4379 */
4380 return(whalCtrl_SetParam(hWhalCtrl, ¶m));
4381 }
4382
4383 /**
4384 * \author \n
4385 * \date \n
4386 * \brief Coordinates between legacy TxRatePolicy implementation and the MIB format: \n
4387 * Converts the pGwsi_txRatePolicy back to whal commands
4388 * Activates the whal whalCtrl_set function
4389 * Function Scope \e Public.\n
4390 * \param - \n
4391 * \return \n
4392 */
4393
whalCtrl_PLT_ReadMIB_TxRatePolicy(TI_HANDLE hWhalCtrl,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)4394 int whalCtrl_PLT_ReadMIB_TxRatePolicy(TI_HANDLE hWhalCtrl, TI_HANDLE CB_Handle, void* CB_Func, void* CB_Buf)
4395 {
4396 PLT_MIB_t* pMib = (PLT_MIB_t*)CB_Buf;
4397 CmdQueue_InterrogateCB_t RetFunc = (CmdQueue_InterrogateCB_t)CB_Func;
4398 whalParamInfo_t param;
4399 tiUINT32 Status = OK;
4400
4401
4402 param.paramType = (UINT32)HAL_CTRL_TX_RATE_CLASS_PARAMS;
4403 whalCtrl_GetParam(hWhalCtrl, ¶m);
4404 if (param.content.pTxRatePlicy == NULL)
4405 Status = NOK;
4406
4407 /*Copy the data form the param to the MIB*/
4408 pMib->aData.txRatePolicy = *param.content.pTxRatePlicy;
4409 pMib->Length = pMib->aData.txRatePolicy.numOfRateClasses * sizeof(pMib->aData.txRatePolicy.rateClass[0]) +
4410 sizeof(pMib->aData.txRatePolicy.numOfRateClasses);
4411 RetFunc(CB_Handle, Status, CB_Buf);
4412 return Status;
4413 }
4414
4415 /*
4416 * ----------------------------------------------------------------------------
4417 * Function : whalCtrl_updateSecuritySeqNum
4418 *
4419 * Process : Update the current TKIP/AES security-sequence-number according to the last
4420 * Tx data packet seq-number, for reloading it to the FW in case of recovery.
4421 * The complete 32 bit number is deduced from the 8 LS bits provided by the FW
4422 * in the Tx-Result, assuming the total number is never incremented in more
4423 * than 255 per one packet (limited by max fragments per packet).
4424 *
4425 * Input : 1) theWhalCtrlHandle - handle to the WhalCtrl object.
4426 * 2) securitySeqNumLsByte - the LS byte of the last Tx frame security-sequence-number.
4427 *
4428 * -----------------------------------------------------------------------------
4429 */
whalCtrl_updateSecuritySeqNum(TI_HANDLE hWhalCtrl,UINT8 securitySeqNumLsByte)4430 void whalCtrl_updateSecuritySeqNum(TI_HANDLE hWhalCtrl, UINT8 securitySeqNumLsByte)
4431 {
4432 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL*)hWhalCtrl;
4433 HwCtrl_T *pHwCtrl = (HwCtrl_T *)pWhalCtrl->pHwCtrl;
4434
4435 /* If 8 lsb wrap around occurred (new < old). */
4436 if ( (UINT16)securitySeqNumLsByte < (pHwCtrl->SecuritySeqNumLow & 0xFF))
4437 {
4438 /* Increment the upper byte of the 16 lsb. */
4439 pHwCtrl->SecuritySeqNumLow += 0x100;
4440
4441 /* If 16 bit wrap around occurred, increment the upper 32 bit. */
4442 if( !(pHwCtrl->SecuritySeqNumLow & 0xFF00) )
4443 pHwCtrl->SecuritySeqNumHigh++;
4444 }
4445
4446 /* Save new sequence number 8 lsb (received from the FW). */
4447 pHwCtrl->SecuritySeqNumLow &= 0xFF00;
4448 pHwCtrl->SecuritySeqNumLow |= (UINT16)securitySeqNumLsByte;
4449 }
4450
4451
4452 /*
4453 * ----------------------------------------------------------------------------
4454 * Function : whalCtrl_setBetParams
4455 *
4456 * Input : enabled - 0 to disable BET, 0 to disable BET
4457 * MaximumConsecutiveET - Max number of consecutive beacons
4458 * that may be early terminated.
4459 * Output :
4460 * Process : Configures Beacon Early Termination information element.
4461 * Note(s) : None
4462 * -----------------------------------------------------------------------------
4463 */
whalCtrl_setBetParams(TI_HANDLE hWhalCtrl,UINT8 Enable,UINT8 MaximumConsecutiveET)4464 int whalCtrl_setBetParams(TI_HANDLE hWhalCtrl, UINT8 Enable, UINT8 MaximumConsecutiveET)
4465 {
4466 WHAL_CTRL * pWhalCtrl = (WHAL_CTRL *) hWhalCtrl;
4467
4468 pWhalCtrl->pWhalParams->WlanParams.BetEnable = Enable;
4469 pWhalCtrl->pWhalParams->WlanParams.MaximumConsecutiveET = MaximumConsecutiveET;
4470
4471 return whal_hwCtrl_setBetParams(pWhalCtrl->pHwCtrl, Enable, MaximumConsecutiveET);
4472 }
4473
4474