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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 ****************************************************************************/ 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 ****************************************************************************/ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 ****************************************************************************/ 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 */ 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 */ 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 2109 void whalCtrl_EnableInterrupts (TI_HANDLE hWhalCtrl) 2110 { 2111 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl; 2112 2113 FwEvent_EnableInterrupts(pWhalCtrl->hFwEvent); 2114 } 2115 2116 void whalCtrl_DisableInterrupts (TI_HANDLE hWhalCtrl) 2117 { 2118 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)hWhalCtrl; 2119 2120 FwEvent_DisableInterrupts(pWhalCtrl->hFwEvent); 2121 } 2122 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 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 */ 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 */ 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 ****************************************************************************/ 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 ****************************************************************************/ 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 ****************************************************************************/ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 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 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 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 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 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 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 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 ****************************************************************************/ 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 ****************************************************************************/ 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 ****************************************************************************/ 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 ****************************************************************************/ 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 */ 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 */ 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 ****************************************************************************/ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 ************************************************************************/ 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 ************************************************************************/ 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 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 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 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 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 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 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 */ 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 */ 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
