1 /* 2 * TWDriver.c 3 * 4 * Copyright(c) 1998 - 2010 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 /** \file TWDriver.c 36 * \brief TI WLAN Hardware Access Driver 37 * 38 * \see TWDriver.h 39 */ 40 41 #define __FILE_ID__ FILE_ID_117 42 #include "report.h" 43 #include "TWDriver.h" 44 #include "MacServices_api.h" 45 #include "txCtrlBlk_api.h" 46 #include "txHwQueue_api.h" 47 #include "txXfer_api.h" 48 #include "txResult_api.h" 49 #include "rxXfer_api.h" 50 #include "TwIf.h" 51 #include "FwEvent_api.h" 52 #include "CmdMBox_api.h" 53 #include "CmdQueue_api.h" 54 #include "eventMbox_api.h" 55 #include "fwDebug_api.h" 56 #include "osApi.h" 57 #include "TWDriverInternal.h" 58 #include "HwInit_api.h" 59 #include "CmdBld.h" 60 #include "RxQueue_api.h" 61 62 63 64 #define TWD_CB_MODULE_OWNER_MASK 0xff00 65 #define TWD_CB_TYPE_MASK 0x00ff 66 67 68 69 70 TI_HANDLE TWD_Create (TI_HANDLE hOs) 71 { 72 TTwd *pTWD; 73 74 /* Allocate the TNETW_Driver module */ 75 pTWD = (TTwd *)os_memoryAlloc (hOs, sizeof(TTwd)); 76 if (pTWD == NULL) 77 { 78 return NULL; 79 } 80 81 os_memoryZero (hOs, pTWD, sizeof(TTwd)); 82 83 pTWD->hOs = hOs; 84 85 /* Create TwIf module */ 86 pTWD->hTwIf = twIf_Create (hOs); 87 if (pTWD->hTwIf == NULL) 88 { 89 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"twIf_Create failed\n"); 90 WLAN_OS_REPORT(("twIf_Create failed\n")); 91 TWD_Destroy ((TI_HANDLE)pTWD); 92 return NULL; 93 } 94 95 /* Create command builder module */ 96 pTWD->hCmdBld = cmdBld_Create (hOs); 97 if (pTWD->hCmdBld == NULL) 98 { 99 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"cmdBld_Create failed\n"); 100 WLAN_OS_REPORT(("cmdBld_Create failed\n")); 101 TWD_Destroy ((TI_HANDLE)pTWD); 102 return NULL; 103 } 104 105 /* Create the MAC Services module */ 106 pTWD->hMacServices = MacServices_create (hOs); 107 if (pTWD->hMacServices == NULL) 108 { 109 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD MacServices_create failed!!!\n"); 110 WLAN_OS_REPORT(("TWD MacServices_create failed!!!\n")); 111 TWD_Destroy ((TI_HANDLE)pTWD); 112 return NULL; 113 } 114 115 /* Create the Ctrl module */ 116 pTWD->hCmdQueue = cmdQueue_Create (hOs); 117 if (pTWD->hCmdQueue == NULL) 118 { 119 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD cmdQueue_Create failed!!!\n"); 120 WLAN_OS_REPORT(("TWD cmdQueue_Create failed!!!\n")); 121 TWD_Destroy ((TI_HANDLE)pTWD); 122 return NULL; 123 } 124 125 /* 126 * Create the FW-Transfer modules: 127 */ 128 129 pTWD->hTxXfer = txXfer_Create (hOs); 130 if (pTWD->hTxXfer == NULL) 131 { 132 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD txXfer_Create failed!!!\n"); 133 WLAN_OS_REPORT(("TWD txXfer_Create failed!!!\n")); 134 TWD_Destroy ((TI_HANDLE)pTWD); 135 return NULL; 136 } 137 138 pTWD->hTxResult = txResult_Create (hOs); 139 if (pTWD->hTxResult == NULL) 140 { 141 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD txResult_Create failed!!!\n"); 142 WLAN_OS_REPORT(("TWD txResult_Create failed!!!\n")); 143 TWD_Destroy ((TI_HANDLE)pTWD); 144 return NULL; 145 } 146 147 pTWD->hRxXfer = rxXfer_Create (hOs); 148 if (pTWD->hRxXfer == NULL) 149 { 150 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD rxXfer_Create failed!!!\n"); 151 WLAN_OS_REPORT(("TWD rxXfer_Create failed!!!\n")); 152 TWD_Destroy ((TI_HANDLE)pTWD); 153 return NULL; 154 } 155 156 pTWD->hFwEvent = fwEvent_Create (hOs); 157 if (pTWD->hFwEvent == NULL) 158 { 159 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD fwEvent_Create failed!!!\n"); 160 WLAN_OS_REPORT(("TWD fwEvent_Create failed!!!\n")); 161 TWD_Destroy ((TI_HANDLE)pTWD); 162 return NULL; 163 } 164 165 pTWD->hEventMbox = eventMbox_Create (hOs); 166 if (pTWD->hEventMbox == NULL) 167 { 168 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD eventMbox_Create failed!!!\n"); 169 WLAN_OS_REPORT(("TWD eventMbox_Create failed!!!\n")); 170 TWD_Destroy ((TI_HANDLE)pTWD); 171 return NULL; 172 } 173 174 #ifdef TI_DBG 175 pTWD->hFwDbg = fwDbg_Create (hOs); 176 if (pTWD->hFwDbg == NULL) 177 { 178 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD fwDbg_Create failed!!!\n"); 179 WLAN_OS_REPORT(("TWD fwDbg_Create failed!!!\n")); 180 TWD_Destroy ((TI_HANDLE)pTWD); 181 return NULL; 182 } 183 #endif /* TI_DBG */ 184 185 pTWD->hCmdMbox = cmdMbox_Create (hOs); 186 if (pTWD->hCmdMbox == NULL) 187 { 188 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD cmdMbox_Create failed!!!\n"); 189 WLAN_OS_REPORT(("TWD cmdMbox_Create failed!!!\n")); 190 TWD_Destroy ((TI_HANDLE)pTWD); 191 return NULL; 192 } 193 194 pTWD->hRxQueue = RxQueue_Create (hOs); 195 if (pTWD->hRxQueue == NULL) 196 { 197 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD RxQueue_Create failed!!!\n"); 198 WLAN_OS_REPORT(("TWD RxQueue_Create failed!!!\n")); 199 TWD_Destroy ((TI_HANDLE)pTWD); 200 return NULL; 201 } 202 203 204 /* 205 * Create the Data-Services modules: 206 */ 207 208 pTWD->hTxCtrlBlk = txCtrlBlk_Create (hOs); 209 if (pTWD->hTxCtrlBlk == NULL) 210 { 211 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD txCtrlBlk_Create failed!!!\n"); 212 WLAN_OS_REPORT(("TWD txCtrlBlk_Create failed!!!\n")); 213 TWD_Destroy ((TI_HANDLE)pTWD); 214 return NULL; 215 } 216 217 pTWD->hTxHwQueue = txHwQueue_Create (hOs); 218 if (pTWD->hTxHwQueue == NULL) 219 { 220 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD txHwQueue_Create failed!!!\n"); 221 WLAN_OS_REPORT(("TWD txHwQueue_Create failed!!!\n")); 222 TWD_Destroy ((TI_HANDLE)pTWD); 223 return NULL; 224 } 225 226 pTWD->hHwInit = hwInit_Create (hOs); 227 if (pTWD->hHwInit == NULL) 228 { 229 TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"wInit_Create failed!\n"); 230 WLAN_OS_REPORT (("wInit_Create failed!\n")); 231 TWD_Destroy ((TI_HANDLE)pTWD); 232 return NULL; 233 } 234 235 WLAN_INIT_REPORT (("TWD_Create: CREATED !!!\n")); 236 237 return (TI_HANDLE)pTWD; 238 } 239 240 TI_STATUS TWD_Destroy (TI_HANDLE hTWD) 241 { 242 TTwd *pTWD = (TTwd *)hTWD; 243 244 WLAN_INIT_REPORT(("TWD_Destroy: called\n")); 245 if (pTWD == NULL) 246 { 247 return TI_NOK; 248 } 249 250 if (pTWD->hTwIf != NULL) 251 { 252 twIf_Destroy (pTWD->hTwIf); 253 pTWD->hTwIf = NULL; 254 } 255 256 /* Free the Command Builder */ 257 if (pTWD->hCmdBld != NULL) 258 { 259 cmdBld_Destroy (pTWD->hCmdBld); 260 pTWD->hCmdBld = NULL; 261 } 262 WLAN_INIT_REPORT(("TWD_Destroy: Command Builder released\n")); 263 264 /* Free the MAC Services */ 265 if (pTWD->hMacServices != NULL) 266 { 267 MacServices_destroy(pTWD->hMacServices); 268 pTWD->hMacServices = NULL; 269 } 270 WLAN_INIT_REPORT(("TWD_Destroy: Mac Services released\n")); 271 272 /* 273 * Free the Ctrl modules 274 */ 275 if (pTWD->hCmdQueue != NULL) 276 { 277 cmdQueue_Destroy(pTWD->hCmdQueue); 278 pTWD->hCmdQueue = NULL; 279 } 280 281 /* 282 * Free the FW-Transfer modules: 283 */ 284 if (pTWD->hTxXfer != NULL) 285 { 286 txXfer_Destroy (pTWD->hTxXfer); 287 pTWD->hTxXfer = NULL; 288 } 289 290 if (pTWD->hTxResult != NULL) 291 { 292 txResult_Destroy (pTWD->hTxResult); 293 pTWD->hTxResult = NULL; 294 } 295 296 if (pTWD->hRxXfer != NULL) 297 { 298 rxXfer_Destroy (pTWD->hRxXfer); 299 pTWD->hRxXfer = NULL; 300 } 301 302 if (pTWD->hEventMbox != NULL) 303 { 304 eventMbox_Destroy (pTWD->hEventMbox); 305 pTWD->hEventMbox = NULL; 306 } 307 308 #ifdef TI_DBG 309 if (pTWD->hFwDbg != NULL) 310 { 311 fwDbg_Destroy (pTWD->hFwDbg); 312 pTWD->hFwDbg = NULL; 313 } 314 #endif /* TI_DBG */ 315 316 if (pTWD->hFwEvent != NULL) 317 { 318 fwEvent_Destroy (pTWD->hFwEvent); 319 pTWD->hFwEvent = NULL; 320 } 321 322 if (pTWD->hCmdMbox != NULL) 323 { 324 cmdMbox_Destroy (pTWD->hCmdMbox); 325 pTWD->hCmdMbox = NULL; 326 } 327 328 if (pTWD->hRxQueue != NULL) 329 { 330 RxQueue_Destroy (pTWD->hRxQueue); 331 pTWD->hRxQueue = NULL; 332 } 333 334 /* 335 * Free the Data-Services modules: 336 */ 337 338 if (pTWD->hTxCtrlBlk != NULL) 339 { 340 txCtrlBlk_Destroy (pTWD->hTxCtrlBlk); 341 pTWD->hTxCtrlBlk = NULL; 342 } 343 344 if (pTWD->hTxHwQueue != NULL) 345 { 346 txHwQueue_Destroy (pTWD->hTxHwQueue); 347 pTWD->hTxHwQueue = NULL; 348 } 349 350 if (pTWD->hHwInit != NULL) 351 { 352 hwInit_Destroy (pTWD->hHwInit); 353 pTWD->hHwInit = NULL; 354 } 355 356 os_memoryFree (pTWD->hOs, (TI_HANDLE)pTWD, sizeof(TTwd)); 357 358 WLAN_INIT_REPORT(("TWD_Destroy pTNETW_Driver released!!!\n")); 359 360 return TI_OK; 361 } 362 363 364 /** 365 * \brief HW Init Callback 366 * 367 * \param hTWD - TWD module object handle 368 * \return void 369 * 370 * \par Description 371 * Static CB function 372 * Called during TWD Module Init by hwInit_Init in order to complete the HW Configuration init 373 * 374 * \sa TWD_InitHw 375 */ 376 static void TWD_InitHwCb (TI_HANDLE hTWD) 377 { 378 TTwd *pTWD = (TTwd *)hTWD; 379 380 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_InitHwCb: call fInitHwCb CB. In std drvMain_InitHwCb()\n"); 381 382 hwInit_InitPolarity(pTWD->hHwInit); 383 384 } 385 386 void TWD_Init (TI_HANDLE hTWD, 387 TI_HANDLE hReport, 388 TI_HANDLE hUser, 389 TI_HANDLE hTimer, 390 TI_HANDLE hContext, 391 TI_HANDLE hTxnQ, 392 TTwdCallback fInitHwCb, 393 TTwdCallback fInitFwCb, 394 TTwdCallback fConfigFwCb, 395 TTwdCallback fStopCb, 396 TTwdCallback fInitFailCb) 397 { 398 TTwd *pTWD = (TTwd *)hTWD; 399 pTWD->bInitSuccess = TI_FALSE; 400 pTWD->bRecoveryEnabled = TI_FALSE; 401 pTWD->hReport = hReport; 402 pTWD->hUser = hUser; 403 pTWD->hTimer = hTimer; 404 pTWD->hContext = hContext; 405 pTWD->hTxnQ = hTxnQ; 406 pTWD->fInitHwCb = fInitHwCb; 407 pTWD->fInitFwCb = fInitFwCb; 408 pTWD->fConfigFwCb = fConfigFwCb; 409 pTWD->fStopCb = fStopCb; 410 pTWD->fInitFailCb = fInitFailCb; 411 412 TRACE1(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_Init: %x\n", hTWD); 413 414 /* FwEvent should be configured first */ 415 fwEvent_Init (pTWD->hFwEvent, hTWD); 416 417 eventMbox_Config (pTWD->hEventMbox, pTWD->hTwIf, pTWD->hReport, pTWD->hFwEvent, pTWD->hCmdBld); 418 419 cmdQueue_Init (pTWD->hCmdQueue, 420 pTWD->hCmdMbox, 421 pTWD->hReport, 422 pTWD->hTwIf, 423 pTWD->hTimer); 424 425 /* Configure Command Builder */ 426 cmdBld_Config (pTWD->hCmdBld, 427 pTWD->hReport, 428 (void *)TWD_FinalizeDownload, 429 hTWD, 430 pTWD->hEventMbox, 431 pTWD->hCmdQueue, 432 pTWD->hTwIf); 433 434 hwInit_Init (pTWD->hHwInit, 435 pTWD->hReport, 436 pTWD->hTimer, 437 hTWD, 438 hTWD, 439 (TFinalizeCb)TWD_FinalizeDownload, 440 TWD_InitHwCb); 441 442 /* 443 * Initialize the FW-Transfer modules 444 */ 445 txXfer_Init (pTWD->hTxXfer, pTWD->hReport, pTWD->hTwIf); 446 447 txResult_Init (pTWD->hTxResult, pTWD->hReport, pTWD->hTwIf); 448 449 rxXfer_Init (pTWD->hRxXfer, pTWD->hFwEvent, pTWD->hReport, pTWD->hTwIf, pTWD->hRxQueue); 450 451 RxQueue_Init (pTWD->hRxQueue, pTWD->hReport, pTWD->hTimer); 452 453 #ifdef TI_DBG 454 fwDbg_Init (pTWD->hFwDbg, pTWD->hReport, pTWD->hTwIf); 455 #endif /* TI_DBG */ 456 457 /* Initialize the MAC Services */ 458 MacServices_init (pTWD->hMacServices, 459 pTWD->hReport, 460 hTWD, 461 pTWD->hCmdBld, 462 pTWD->hEventMbox, 463 pTWD->hTimer); 464 465 /* 466 * Initialize the Data-Services modules 467 */ 468 txCtrlBlk_Init (pTWD->hTxCtrlBlk, pTWD->hReport, pTWD->hContext); 469 txHwQueue_Init (pTWD->hTxHwQueue, pTWD->hReport); 470 471 /* Initialize the TwIf module */ 472 twIf_Init (pTWD->hTwIf, 473 pTWD->hReport, 474 pTWD->hContext, 475 pTWD->hTimer, 476 pTWD->hTxnQ, 477 (TRecoveryCb)TWD_StopComplete, 478 hTWD); 479 } 480 481 TI_STATUS TWD_InitHw (TI_HANDLE hTWD, 482 TI_UINT8 *pbuf, 483 TI_UINT32 length, 484 TI_UINT32 uRxDmaBufLen, 485 TI_UINT32 uTxDmaBufLen) 486 { 487 TTwd *pTWD = (TTwd *)hTWD; 488 TI_STATUS eStatus; 489 490 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_InitHw: called\n"); 491 492 /* Provide bus related parameters to Xfer modules before any usage of the bus! */ 493 rxXfer_SetBusParams (pTWD->hRxXfer, uRxDmaBufLen); 494 txXfer_SetBusParams (pTWD->hTxXfer, uTxDmaBufLen); 495 496 hwInit_SetNvsImage (pTWD->hHwInit, pbuf, length); 497 498 /* 499 * Update the TwIf that the HW is awake 500 * This will protect the initialization process from going to sleep 501 * After the firmware initializations completed (TWD_EnableExternalEvents), the sleep will be enabled 502 */ 503 twIf_Awake (pTWD->hTwIf); 504 twIf_HwAvailable (pTWD->hTwIf); 505 506 /* This initiates the HW init sequence */ 507 eStatus = hwInit_Boot(pTWD->hHwInit); 508 if (eStatus == TXN_STATUS_ERROR) 509 { 510 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR , "TWD_InitHw: hwInit_Boot failed\n"); 511 return TI_NOK; 512 } 513 514 return TI_OK; 515 } 516 517 TI_STATUS TWD_BusOpen (TI_HANDLE hTWD, void* pParams) 518 { 519 TTwd *pTWD = (TTwd *)hTWD; 520 TI_STATUS uStatus; 521 522 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_BusOpen: called\n"); 523 524 /*uStatus = TNETWIF_Open(pTWD->hTNETWIF, pParams);*/ 525 uStatus = TI_OK; 526 527 return uStatus; 528 } 529 530 TI_STATUS TWD_BusClose (TI_HANDLE hTWD) 531 { 532 TTwd *pTWD = (TTwd *)hTWD; 533 TI_STATUS uStatus; 534 535 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_BusClose: called\n"); 536 537 /*uStatus = TNETWIF_Close(pTWD->hTNETWIF);*/ 538 uStatus = TI_OK; 539 540 return uStatus; 541 } 542 543 TI_STATUS TWD_InitFw (TI_HANDLE hTWD, TFileInfo *pFileInfo) 544 { 545 TTwd *pTWD = (TTwd *)hTWD; 546 TI_STATUS status; 547 548 /* check Parameters */ 549 if (( pTWD == NULL ) || ( pFileInfo == NULL )) 550 { 551 return (TI_NOK); 552 } 553 554 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_InitFw: called\n"); 555 556 hwInit_SetFwImage (pTWD->hHwInit, pFileInfo); 557 558 /* This will initiate the download to the FW */ 559 status = hwInit_LoadFw(pTWD->hHwInit); 560 561 if (status == TXN_STATUS_ERROR) 562 { 563 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR , "TWD_InitFw: failed to initialize FW\n"); 564 565 return TI_NOK; 566 } 567 568 return TI_OK; 569 } 570 571 /** 572 * \brief Propagate interrogate results 573 * 574 * \param hTWD - TWD module object handle 575 * \param status - callback status 576 * \return TI_OK on success or TI_NOK on failure 577 * 578 * \par Description 579 * Static CB function 580 * Propagate interrogate results between TX and RX modules 581 * Called by TWD_ConfigFw 582 * 583 * \sa 584 */ 585 static TI_STATUS TWD_ConfigFwCb (TI_HANDLE hTWD, TI_STATUS status) 586 { 587 TTwd *pTWD = (TTwd *)hTWD; 588 TDmaParams *pDmaParams = &DB_DMA(pTWD->hCmdBld); 589 590 /* 591 * Store the addresses of the cyclic buffer (Rx/Tx) 592 * and the path status and control (Tx/Rx) in the corresponding modules 593 */ 594 txResult_setHwInfo (pTWD->hTxResult, pDmaParams); 595 596 rxXfer_Restart (pTWD->hRxXfer); 597 txXfer_Restart (pTWD->hTxXfer); 598 599 rxXfer_SetRxDirectAccessParams (pTWD->hRxXfer, pDmaParams); 600 601 /* Provide number of HW Tx-blocks and descriptors to Tx-HW-Queue module */ 602 txHwQueue_SetHwInfo (pTWD->hTxHwQueue, pDmaParams); 603 604 /* If the configure complete function was registered, we call it here - end of TWD_Configure stage */ 605 if (pTWD->fConfigFwCb) 606 { 607 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ConfigFwCb: call TWD_OWNER_SELF_CONFIG CB. In std drvMain_ConfigFwCb()\n"); 608 609 pTWD->fConfigFwCb (pTWD->hUser, TI_OK); 610 } 611 612 return TI_OK; 613 } 614 615 616 TI_STATUS TWD_SetDefaults (TI_HANDLE hTWD, TTwdInitParams *pInitParams) 617 { 618 TTwd *pTWD = (TTwd *)hTWD; 619 620 TWlanParams *pWlanParams = &DB_WLAN(pTWD->hCmdBld); 621 TKeepAliveList *pKlvParams = &DB_KLV(pTWD->hCmdBld); 622 IniFileRadioParam *pRadioParams = &DB_RADIO(pTWD->hCmdBld); 623 IniFileExtendedRadioParam *pExtRadioParams = &DB_EXT_RADIO(pTWD->hCmdBld); 624 IniFileGeneralParam *pGenParams = &DB_GEN(pTWD->hCmdBld); 625 TRateMngParams *pRateMngParams = &DB_RM(pTWD->hCmdBld); 626 TDmaParams *pDmaParams = &DB_DMA(pTWD->hCmdBld); 627 628 TI_UINT32 k, uIndex; 629 int iParam; 630 631 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_SetDefaults: called\n"); 632 633 pTWD->bRecoveryEnabled = pInitParams->tGeneral.halCtrlRecoveryEnable; 634 635 pWlanParams->PacketDetectionThreshold = pInitParams->tGeneral.packetDetectionThreshold; 636 pWlanParams->qosNullDataTemplateSize = pInitParams->tGeneral.qosNullDataTemplateSize; 637 pWlanParams->PsPollTemplateSize = pInitParams->tGeneral.PsPollTemplateSize; 638 pWlanParams->probeResponseTemplateSize = pInitParams->tGeneral.probeResponseTemplateSize; 639 pWlanParams->probeRequestTemplateSize = pInitParams->tGeneral.probeRequestTemplateSize; 640 pWlanParams->beaconTemplateSize = pInitParams->tGeneral.beaconTemplateSize; 641 pWlanParams->nullTemplateSize = pInitParams->tGeneral.nullTemplateSize; 642 pWlanParams->disconnTemplateSize = pInitParams->tGeneral.disconnTemplateSize; 643 pWlanParams->ArpRspTemplateSize = pInitParams->tGeneral.ArpRspTemplateSize; 644 645 /* Beacon broadcast options */ 646 pWlanParams->BcnBrcOptions.BeaconRxTimeout = pInitParams->tGeneral.BeaconRxTimeout; 647 pWlanParams->BcnBrcOptions.BroadcastRxTimeout = pInitParams->tGeneral.BroadcastRxTimeout; 648 pWlanParams->BcnBrcOptions.RxBroadcastInPs = pInitParams->tGeneral.RxBroadcastInPs; 649 pWlanParams->ConsecutivePsPollDeliveryFailureThreshold = pInitParams->tGeneral.ConsecutivePsPollDeliveryFailureThreshold; 650 651 pWlanParams->RxDisableBroadcast = pInitParams->tGeneral.halCtrlRxDisableBroadcast; 652 pWlanParams->calibrationChannel2_4 = pInitParams->tGeneral.halCtrlCalibrationChannel2_4; 653 pWlanParams->calibrationChannel5_0 = pInitParams->tGeneral.halCtrlCalibrationChannel5_0; 654 655 /* Not used but need by Palau */ 656 pWlanParams->RtsThreshold = pInitParams->tGeneral.halCtrlRtsThreshold; 657 pWlanParams->CtsToSelf = CTS_TO_SELF_DISABLE; 658 659 pWlanParams->WiFiWmmPS = pInitParams->tGeneral.WiFiWmmPS; 660 661 pWlanParams->MaxTxMsduLifetime = pInitParams->tGeneral.halCtrlMaxTxMsduLifetime; 662 pWlanParams->MaxRxMsduLifetime = pInitParams->tGeneral.halCtrlMaxRxMsduLifetime; 663 664 pWlanParams->rxTimeOut.psPoll = pInitParams->tGeneral.rxTimeOut.psPoll; 665 pWlanParams->rxTimeOut.UPSD = pInitParams->tGeneral.rxTimeOut.UPSD; 666 667 /* RSSI/SNR Weights for Average calculations */ 668 pWlanParams->tRssiSnrWeights.rssiBeaconAverageWeight = pInitParams->tGeneral.uRssiBeaconAverageWeight; 669 pWlanParams->tRssiSnrWeights.rssiPacketAverageWeight = pInitParams->tGeneral.uRssiPacketAverageWeight; 670 pWlanParams->tRssiSnrWeights.snrBeaconAverageWeight = pInitParams->tGeneral.uSnrBeaconAverageWeight ; 671 pWlanParams->tRssiSnrWeights.snrPacketAverageWeight = pInitParams->tGeneral.uSnrPacketAverageWeight ; 672 673 /* PM config params */ 674 pWlanParams->uHostClkSettlingTime = pInitParams->tGeneral.uHostClkSettlingTime; 675 pWlanParams->uHostFastWakeupSupport = pInitParams->tGeneral.uHostFastWakeupSupport; 676 677 /* No used */ 678 pWlanParams->FragmentThreshold = pInitParams->tGeneral.halCtrlFragThreshold; 679 pWlanParams->ListenInterval = (TI_UINT8)pInitParams->tGeneral.halCtrlListenInterval; 680 pWlanParams->RateFallback = pInitParams->tGeneral.halCtrlRateFallbackRetry; 681 pWlanParams->MacClock = pInitParams->tGeneral.halCtrlMacClock; 682 pWlanParams->ArmClock = pInitParams->tGeneral.halCtrlArmClock; 683 684 pWlanParams->ch14TelecCca = pInitParams->tGeneral.halCtrlCh14TelecCca; 685 686 /* Data interrupts pacing */ 687 pWlanParams->TxCompletePacingThreshold = pInitParams->tGeneral.TxCompletePacingThreshold; 688 pWlanParams->TxCompletePacingTimeout = pInitParams->tGeneral.TxCompletePacingTimeout; 689 pWlanParams->RxIntrPacingThreshold = pInitParams->tGeneral.RxIntrPacingThreshold; 690 pWlanParams->RxIntrPacingTimeout = pInitParams->tGeneral.RxIntrPacingTimeout; 691 692 /* Number of Rx mem-blocks to allocate in FW */ 693 pDmaParams->NumRxBlocks = pInitParams->tGeneral.uRxMemBlksNum; 694 695 696 /* Configure ARP IP */ 697 pWlanParams->arpFilterType = pInitParams->tArpIpFilter.filterType; 698 IP_COPY (pWlanParams->arp_IP_addr, pInitParams->tArpIpFilter.addr); 699 700 /* Configure address group */ 701 pWlanParams->numGroupAddrs = pInitParams->tMacAddrFilter.numOfMacAddresses; 702 pWlanParams->isMacAddrFilteringnabled = pInitParams->tMacAddrFilter.isFilterEnabled; 703 704 for (k = 0; k < pWlanParams->numGroupAddrs; k++) 705 { 706 MAC_COPY (pWlanParams->aGroupAddr[k], pInitParams->tMacAddrFilter.macAddrTable[k]); 707 } 708 709 710 /* CoexActivity Table */ 711 TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetDefaults: coex numOfElements %d\n", pInitParams->tGeneral.halCoexActivityTable.numOfElements); 712 713 pWlanParams->tWlanParamsCoexActivityTable.numOfElements = 0; 714 for (iParam=0; iParam < (int)pInitParams->tGeneral.halCoexActivityTable.numOfElements; iParam++) 715 { 716 TCoexActivity *pSaveCoex = &pWlanParams->tWlanParamsCoexActivityTable.entry[0]; 717 TCoexActivity *pParmCoex = &pInitParams->tGeneral.halCoexActivityTable.entry[0]; 718 int i, saveIndex; 719 720 /* Check if to overwrite existing entry or put on last index */ 721 for (i=0; i<iParam; i++) 722 { 723 if ((pSaveCoex[i].activityId == pParmCoex[iParam].activityId) && (pSaveCoex[i].coexIp == pParmCoex[iParam].coexIp)) 724 { 725 break; 726 } 727 } 728 729 if (i == iParam) 730 { 731 /* new entry */ 732 saveIndex = pWlanParams->tWlanParamsCoexActivityTable.numOfElements; 733 pWlanParams->tWlanParamsCoexActivityTable.numOfElements++; 734 } 735 else 736 { 737 /* overwrite existing */ 738 saveIndex = i; 739 } 740 741 TRACE4(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetDefaults: save coex Param %d in index %d, %d %d\n", iParam, saveIndex, pParmCoex[iParam].coexIp, pParmCoex[iParam].activityId); 742 743 pSaveCoex[saveIndex].coexIp = pParmCoex[iParam].coexIp; 744 pSaveCoex[saveIndex].activityId = pParmCoex[iParam].activityId; 745 pSaveCoex[saveIndex].defaultPriority = pParmCoex[iParam].defaultPriority; 746 pSaveCoex[saveIndex].raisedPriority = pParmCoex[iParam].raisedPriority; 747 pSaveCoex[saveIndex].minService = pParmCoex[iParam].minService; 748 pSaveCoex[saveIndex].maxService = pParmCoex[iParam].maxService; 749 } 750 751 /* configure keep-alive default mode to enabled */ 752 pKlvParams->enaDisFlag = TI_TRUE; 753 for (uIndex = 0; uIndex < KLV_MAX_TMPL_NUM; uIndex++) 754 { 755 pKlvParams->keepAliveParams[ uIndex ].enaDisFlag = TI_FALSE; 756 } 757 758 /* Configure the TWD modules */ 759 rxXfer_SetDefaults (pTWD->hRxXfer, pInitParams); 760 txXfer_SetDefaults (pTWD->hTxXfer, pInitParams); 761 txHwQueue_Config (pTWD->hTxHwQueue, pInitParams); 762 MacServices_config (pTWD->hMacServices, pInitParams); 763 764 /* 765 * 802.11n 766 */ 767 pWlanParams->tTwdHtCapabilities.b11nEnable = pInitParams->tGeneral.b11nEnable; 768 769 /* Configure HT capabilities setting */ 770 pWlanParams->tTwdHtCapabilities.uChannelWidth = CHANNEL_WIDTH_20MHZ; 771 pWlanParams->tTwdHtCapabilities.uRxSTBC = RXSTBC_NOT_SUPPORTED; 772 pWlanParams->tTwdHtCapabilities.uMaxAMSDU = MAX_MSDU_3839_OCTETS; 773 pWlanParams->tTwdHtCapabilities.uMaxAMPDU = pInitParams->tGeneral.uMaxAMPDU; 774 775 pWlanParams->tTwdHtCapabilities.uAMPDUSpacing = AMPDU_SPC_8_MICROSECONDS; 776 pWlanParams->tTwdHtCapabilities.aRxMCS[0] = (MCS_SUPPORT_MCS_0 | 777 MCS_SUPPORT_MCS_1 | 778 MCS_SUPPORT_MCS_2 | 779 MCS_SUPPORT_MCS_3 | 780 MCS_SUPPORT_MCS_4 | 781 MCS_SUPPORT_MCS_5 | 782 MCS_SUPPORT_MCS_6 | 783 MCS_SUPPORT_MCS_7); 784 os_memoryZero (pTWD->hOs, pWlanParams->tTwdHtCapabilities.aRxMCS + 1, RX_TX_MCS_BITMASK_SIZE - 1); 785 pWlanParams->tTwdHtCapabilities.aTxMCS[0] = (MCS_SUPPORT_MCS_0 | 786 MCS_SUPPORT_MCS_1 | 787 MCS_SUPPORT_MCS_2 | 788 MCS_SUPPORT_MCS_3 | 789 MCS_SUPPORT_MCS_4 | 790 MCS_SUPPORT_MCS_5 | 791 MCS_SUPPORT_MCS_6 | 792 MCS_SUPPORT_MCS_7); 793 os_memoryZero (pTWD->hOs, pWlanParams->tTwdHtCapabilities.aTxMCS + 1, RX_TX_MCS_BITMASK_SIZE - 1); 794 pWlanParams->tTwdHtCapabilities.uRxMaxDataRate = MCS_HIGHEST_SUPPORTED_RECEPTION_DATA_RATE_IN_MBIT_S; 795 pWlanParams->tTwdHtCapabilities.uPCOTransTime = PCO_TRANS_TIME_NO_TRANSITION; 796 pWlanParams->tTwdHtCapabilities.uHTCapabilitiesBitMask = (CAP_BIT_MASK_GREENFIELD_FRAME_FORMAT | 797 CAP_BIT_MASK_SHORT_GI_FOR_20MHZ_PACKETS); 798 pWlanParams->tTwdHtCapabilities.uMCSFeedback = MCS_FEEDBACK_NO; 799 800 os_memoryCopy(pTWD->hOs, (void*)pRadioParams, (void*)&pInitParams->tIniFileRadioParams, sizeof(IniFileRadioParam)); 801 os_memoryCopy(pTWD->hOs, (void*)pExtRadioParams, (void*)&pInitParams->tIniFileExtRadioParams, sizeof(IniFileExtendedRadioParam)); 802 os_memoryCopy(pTWD->hOs, (void*)pGenParams, (void*)&pInitParams->tPlatformGenParams, sizeof(IniFileGeneralParam)); 803 804 os_memoryCopy (pTWD->hOs, 805 (void*)&(pWlanParams->tFmCoexParams), 806 (void*)&(pInitParams->tGeneral.tFmCoexParams), 807 sizeof(TFmCoexParams)); 808 809 /* Rate management params */ 810 pRateMngParams->rateMngParams.InverseCuriosityFactor = pInitParams->tRateMngParams.InverseCuriosityFactor; 811 pRateMngParams->rateMngParams.MaxPer = pInitParams->tRateMngParams.MaxPer; 812 pRateMngParams->rateMngParams.PerAdd = pInitParams->tRateMngParams.PerAdd; 813 pRateMngParams->rateMngParams.PerAddShift = pInitParams->tRateMngParams.PerAddShift; 814 pRateMngParams->rateMngParams.PerAlphaShift = pInitParams->tRateMngParams.PerAlphaShift; 815 pRateMngParams->rateMngParams.PerBeta1Shift = pInitParams->tRateMngParams.PerBeta1Shift; 816 pRateMngParams->rateMngParams.PerBeta2Shift = pInitParams->tRateMngParams.PerBeta2Shift; 817 pRateMngParams->rateMngParams.PerTh1 = pInitParams->tRateMngParams.PerTh1; 818 pRateMngParams->rateMngParams.PerTh2 = pInitParams->tRateMngParams.PerTh2; 819 pRateMngParams->rateMngParams.RateCheckDown = pInitParams->tRateMngParams.RateCheckDown; 820 pRateMngParams->rateMngParams.RateCheckUp = pInitParams->tRateMngParams.RateCheckUp; 821 pRateMngParams->rateMngParams.RateRetryScore = pInitParams->tRateMngParams.RateRetryScore; 822 pRateMngParams->rateMngParams.TxFailHighTh = pInitParams->tRateMngParams.TxFailHighTh; 823 pRateMngParams->rateMngParams.TxFailLowTh = pInitParams->tRateMngParams.TxFailLowTh; 824 825 /* RATE_MNG_MAX_RETRY_POLICY_PARAMS_LEN */ 826 for (uIndex = 0; uIndex < 13; uIndex++) 827 { 828 pRateMngParams->rateMngParams.RateRetryPolicy[uIndex] = pInitParams->tRateMngParams.RateRetryPolicy[uIndex]; 829 } 830 831 /* DCO Itrim params */ 832 pWlanParams->dcoItrimEnabled = pInitParams->tDcoItrimParams.enable; 833 pWlanParams->dcoItrimModerationTimeoutUsec = pInitParams->tDcoItrimParams.moderationTimeoutUsec; 834 835 return TI_OK; 836 } 837 838 TI_STATUS TWD_ConfigFw (TI_HANDLE hTWD) 839 { 840 TTwd *pTWD = (TTwd *)hTWD; 841 842 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_ConfigFw: called\n"); 843 844 /* 845 * Configure the WLAN firmware after config all the hardware objects 846 */ 847 if (cmdBld_ConfigFw (pTWD->hCmdBld, (void *)TWD_ConfigFwCb, hTWD) != TI_OK) 848 { 849 return TI_NOK; 850 } 851 852 return TI_OK; 853 } 854 855 void TWD_FinalizeDownload (TI_HANDLE hTWD) 856 { 857 TTwd *pTWD = (TTwd *)hTWD; 858 859 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_FinalizeDownload: called\n"); 860 861 if ( pTWD == NULL ) 862 { 863 return; 864 } 865 /* Here at the end call the Initialize Complete callback that will release the user Init semaphore */ 866 TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT, "Before sending the Init Complet callback !!!!!\n"); 867 868 /* Sign that init has succeeded */ 869 pTWD->bInitSuccess = TI_TRUE; 870 871 /* Call user application configuration callback */ 872 if (pTWD->fInitFwCb) 873 { 874 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_FinalizeDownload: call fInitFwCb CB. In std drvMain_InitFwCb()\n"); 875 876 (*pTWD->fInitFwCb) (pTWD->hUser, TI_OK); 877 } 878 } 879 880 void TWD_FinalizeOnFailure (TI_HANDLE hTWD) 881 { 882 TTwd *pTWD = (TTwd *)hTWD; 883 884 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_FinalizeOnFailure: called\n"); 885 886 /* Call the upper layer callback for init failure case */ 887 if (pTWD->fInitFailCb) 888 { 889 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_FinalizeOnFailure: call fInitFailCb CB. In std drvMain_InitFailCb()\n"); 890 891 pTWD->fInitFailCb (pTWD->hUser, TI_OK); 892 } 893 } 894 895 TI_STATUS TWD_CheckMailboxCb (TI_HANDLE hTWD, TI_UINT16 uMboxStatus, void *pItrParamBuf) 896 { 897 TTwd *pTWD = (TTwd *)hTWD; 898 899 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CheckMailboxCb: called\n"); 900 901 if (uMboxStatus != TI_OK) 902 { 903 ++pTWD->uNumMboxFailures; 904 TRACE1(pTWD->hReport, REPORT_SEVERITY_WARNING, "TWD_CheckMailboxCb: Periodic intorregate check - Command mailbox failure was occur \n errors failure # %d", pTWD->uNumMboxFailures); 905 906 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CheckMailboxCb: call TWD_INT_EVENT_FAILURE CB. In std healthMonitor_sendFailureEvent()\n"); 907 908 /* Indicating Upper Layer about Mbox Error */ 909 pTWD->fFailureEventCb (pTWD->hFailureEventCb, MBOX_FAILURE); 910 } 911 912 return TI_OK; 913 } 914 #ifdef RS_OVER_TWD 915 extern void (*gBusTxn_ErrorCb)(TI_HANDLE , int); 916 extern void *gBusTxn_ErrorHndle; 917 #endif 918 919 /** 920 * \brief Registers TWD Module Callbacks 921 * 922 * \param hTWD - TWD module object handle 923 * \param uCallBackID - Registered Callback ID 924 * \param fCb - Pointer to Input Registered CB function 925 * \param hCb - Handle to Input Registered CB parameters 926 * \return void 927 * 928 * \par Description 929 * Static CB function 930 * This CB Registers TWD CB functions for future use: 931 * CB which handles failure to the CMD Queue, MAC Service and TwIf 932 * CB which handles Command Complete for the CMD Queue 933 * Called by TWD_RegisterCb 934 * 935 * \sa TWD_RegisterCb 936 */ 937 static void TWD_RegisterOwnCb (TI_HANDLE hTWD, TI_UINT32 uCallBackID, void *fCb, TI_HANDLE hCb) 938 { 939 TTwd *pTWD = (TTwd *)hTWD; 940 941 TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RegisterOwnCB: callback ID=0x%x\n", uCallBackID); 942 943 switch (uCallBackID) 944 { 945 case TWD_INT_EVENT_FAILURE: 946 /* Save Health-Moitor callback */ 947 pTWD->fFailureEventCb = (TFailureEventCb)fCb; 948 pTWD->hFailureEventCb = hCb; 949 950 /* Register For Error Of Mailbox in case of timeout */ 951 cmdQueue_RegisterForErrorCb (pTWD->hCmdQueue, (void *)TWD_CheckMailboxCb, hTWD); 952 953 /* Forward the Health-Moitor callback to the MAC-Services modules */ 954 MacServices_registerFailureEventCB(pTWD->hMacServices, fCb, hCb); 955 956 /* Forward the Health-Moitor callback to the TwIf for bus errors */ 957 twIf_RegisterErrCb (pTWD->hTwIf, fCb, hCb); 958 959 /* Forward the Health-Moitor callback to the RxXfer for Rx packet errors */ 960 rxXfer_RegisterErrCb (pTWD->hRxXfer, fCb, hCb); 961 break; 962 963 case TWD_INT_COMMAND_COMPLETE: 964 cmdQueue_RegisterCmdCompleteGenericCb (pTWD->hCmdQueue, fCb, hCb); 965 break; 966 967 default: 968 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_RegisterOwnCb - Illegal value\n"); 969 } 970 } 971 972 TI_STATUS TWD_RegisterCb (TI_HANDLE hTWD, TI_UINT32 event, TTwdCB *fCb, void *pData) 973 { 974 TTwd *pTWD = (TTwd *)hTWD; 975 TI_UINT32 uModuleId = event & TWD_CB_MODULE_OWNER_MASK; 976 TI_UINT32 uCallbackId = event & TWD_CB_TYPE_MASK; 977 978 if ((fCb == NULL) || (pData == NULL)) 979 { 980 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_Register_CB: Invalid NULL Parameter\n"); 981 982 } 983 984 TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: (Value = 0x%x)\n", event); 985 986 /* First detect which module is the owner */ 987 988 switch (uModuleId) 989 { 990 case TWD_OWNER_TX_HW_QUEUE: 991 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_TX_HW_QUEUE\n"); 992 txHwQueue_RegisterCb (pTWD->hTxHwQueue, uCallbackId, fCb, pData); 993 break; 994 995 case TWD_OWNER_DRIVER_TX_XFER: 996 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_DRIVER_TX_XFER\n"); 997 txXfer_RegisterCb (pTWD->hTxXfer, uCallbackId, fCb, pData); 998 break; 999 1000 case TWD_OWNER_TX_RESULT: 1001 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_TX_RESULT\n"); 1002 txResult_RegisterCb (pTWD->hTxResult, uCallbackId, fCb, pData); 1003 break; 1004 1005 case TWD_OWNER_RX_XFER: 1006 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_RX_XFER\n"); 1007 rxXfer_Register_CB(pTWD->hRxXfer, uCallbackId, fCb, pData); 1008 break; 1009 1010 case TWD_OWNER_RX_QUEUE: 1011 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_RX_QUEUE\n"); 1012 RxQueue_Register_CB(pTWD->hRxQueue, uCallbackId, fCb, pData); 1013 break; 1014 1015 case TWD_OWNER_SELF: 1016 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_SELF\n"); 1017 TWD_RegisterOwnCb (hTWD, uCallbackId, fCb, pData); 1018 break; 1019 1020 case TWD_OWNER_MAC_SERVICES: 1021 switch (uCallbackId) 1022 { 1023 case TWD_OWN_EVENT_SCAN_CMPLT: 1024 MacServices_scanSRV_registerScanCompleteCB (pTWD->hMacServices, (TScanSrvCompleteCb)fCb, pData); 1025 break; 1026 default: 1027 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_Register_CB: TWD_OWNER_MAC_SERVICES - Illegal value\n"); 1028 } 1029 break; 1030 1031 case TWD_OWNER_SELF_CONFIG: 1032 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_SELF_CONFIG\n"); 1033 pTWD->fConfigFwCb = (TTwdCallback)fCb; 1034 break; 1035 1036 default: 1037 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_Register_CB - Illegal value\n"); 1038 } 1039 1040 return TI_OK; 1041 } 1042 1043 TI_STATUS TWD_ExitFromInitMode (TI_HANDLE hTWD) 1044 { 1045 TTwd *pTWD = (TTwd *)hTWD; 1046 1047 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ExitFromInitMode: called\n"); 1048 1049 /* Notify Event MailBox about init complete */ 1050 eventMbox_InitComplete (pTWD->hEventMbox); 1051 1052 /* Enable Mailbox */ 1053 cmdQueue_EnableMbox (pTWD->hCmdQueue); 1054 1055 return TI_OK; 1056 } 1057 1058 1059 #ifdef TI_DBG 1060 TI_STATUS TWD_PrintTxInfo (TI_HANDLE hTWD, ETwdPrintInfoType ePrintInfo) 1061 { 1062 TTwd *pTWD = (TTwd *)hTWD; 1063 1064 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_PrintTxInfo: called\n"); 1065 1066 switch (ePrintInfo) 1067 { 1068 case TWD_PRINT_TX_CTRL_BLK_TBL: 1069 txCtrlBlk_PrintTable (pTWD->hTxCtrlBlk); 1070 break; 1071 1072 case TWD_PRINT_TX_HW_QUEUE_INFO: 1073 txHwQueue_PrintInfo (pTWD->hTxHwQueue); 1074 break; 1075 1076 case TWD_PRINT_TX_XFER_INFO: 1077 txXfer_PrintStats (pTWD->hTxXfer); 1078 break; 1079 1080 case TWD_PRINT_TX_RESULT_INFO: 1081 txResult_PrintInfo (pTWD->hTxResult); 1082 break; 1083 1084 case TWD_CLEAR_TX_RESULT_INFO: 1085 txResult_ClearInfo (pTWD->hTxResult); 1086 break; 1087 1088 case TWD_CLEAR_TX_XFER_INFO: 1089 txXfer_ClearStats (pTWD->hTxXfer); 1090 break; 1091 1092 default: 1093 TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, ": invalid print info request code: %d\n", ePrintInfo); 1094 } 1095 1096 return TI_OK; 1097 } 1098 1099 #endif /* TI_DBG */ 1100 1101 TI_STATUS TWD_InterruptRequest (TI_HANDLE hTWD) 1102 { 1103 TTwd *pTWD = (TTwd *)hTWD; 1104 1105 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_InterruptRequest: called\n"); 1106 1107 fwEvent_InterruptRequest (pTWD->hFwEvent); 1108 1109 return TI_OK; 1110 } 1111 1112 TI_STATUS TWD_RegisterEvent (TI_HANDLE hTWD, TI_UINT32 event, void *fCb, TI_HANDLE hCb) 1113 { 1114 TTwd *pTWD = (TTwd *)hTWD; 1115 1116 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RegisterEvent: called\n"); 1117 1118 return eventMbox_RegisterEvent (pTWD->hEventMbox, event, fCb, hCb); 1119 } 1120 1121 TI_STATUS TWD_DisableEvent (TI_HANDLE hTWD, TI_UINT32 event) 1122 { 1123 TTwd *pTWD = (TTwd *)hTWD; 1124 1125 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_DisableEvent: called\n"); 1126 1127 return eventMbox_MaskEvent (pTWD->hEventMbox, event, NULL, NULL); 1128 } 1129 1130 TI_STATUS TWD_EnableEvent (TI_HANDLE hTWD, TI_UINT32 event) 1131 { 1132 TTwd *pTWD = (TTwd *)hTWD; 1133 1134 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_EnableEvent: called\n"); 1135 1136 return eventMbox_UnMaskEvent (pTWD->hEventMbox, event, NULL, NULL); 1137 } 1138 1139 void TWD_StopComplete (TI_HANDLE hTWD) 1140 { 1141 TTwd *pTWD = (TTwd *)hTWD; 1142 1143 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopComplete: called\n"); 1144 1145 1146 /* reinit last ELP mode flag in recovery */ 1147 cmdBld_Restart(pTWD->hCmdBld); 1148 1149 /* Call upper layer callback */ 1150 if (pTWD->fStopCb) 1151 { 1152 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopComplete: call fStopCb CB. In std drvMain_TwdStopCb()\n"); 1153 1154 (*pTWD->fStopCb) (pTWD->hUser, TI_OK); 1155 } 1156 } 1157 1158 TI_STATUS TWD_Stop (TI_HANDLE hTWD) 1159 { 1160 TTwd *pTWD = (TTwd *)hTWD; 1161 ETxnStatus status; 1162 1163 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_Stop: called\n"); 1164 1165 fwEvent_Stop (pTWD->hFwEvent); 1166 1167 1168 /* close all BA sessions */ 1169 TWD_CloseAllBaSessions(hTWD); 1170 1171 cmdMbox_Restart (pTWD->hCmdMbox); 1172 cmdQueue_Restart (pTWD->hCmdQueue); 1173 cmdQueue_DisableMbox (pTWD->hCmdQueue); 1174 eventMbox_Stop (pTWD->hEventMbox); 1175 MacServices_restart (pTWD->hMacServices); 1176 1177 status = twIf_Restart(pTWD->hTwIf); 1178 1179 /* Call user stop callback */ 1180 if (status != TXN_STATUS_PENDING) 1181 { 1182 TWD_StopComplete (hTWD); 1183 } 1184 1185 return TI_OK; 1186 } 1187 1188 void TWD_EnableExternalEvents (TI_HANDLE hTWD) 1189 { 1190 TTwd *pTWD = (TTwd *)hTWD; 1191 1192 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_EnableExternalEvents: called\n"); 1193 1194 /* 1195 * Enable sleep after all firmware initializations completed 1196 * The awake was in the TWD_initHw phase 1197 */ 1198 twIf_Sleep (pTWD->hTwIf); 1199 1200 fwEvent_EnableExternalEvents (pTWD->hFwEvent); 1201 } 1202 1203 TI_BOOL TWD_RecoveryEnabled (TI_HANDLE hTWD) 1204 { 1205 TTwd *pTWD = (TTwd *)hTWD; 1206 1207 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RecoveryEnabled: called\n"); 1208 1209 return pTWD->bRecoveryEnabled; 1210 } 1211 1212 TI_UINT32 TWD_GetMaxNumberOfCommandsInQueue (TI_HANDLE hTWD) 1213 { 1214 TTwd *pTWD = (TTwd *)hTWD; 1215 1216 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetMaxNumberOfCommandsInQueue: called\n"); 1217 1218 return cmdQueue_GetMaxNumberOfCommands (pTWD->hCmdQueue); 1219 } 1220 1221 TI_STATUS TWD_SetPsMode (TI_HANDLE hTWD, 1222 E80211PsMode ePsMode, 1223 TI_BOOL bSendNullDataOnExit, 1224 TI_HANDLE hPowerSaveCompleteCb, 1225 TPowerSaveCompleteCb fPowerSaveCompleteCb, 1226 TPowerSaveResponseCb fPowerSaveResponseCb) 1227 { 1228 TTwd *pTWD = (TTwd *)hTWD; 1229 1230 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetPsMode: called\n"); 1231 1232 return MacServices_powerSrv_SetPsMode (pTWD->hMacServices, 1233 ePsMode, 1234 bSendNullDataOnExit, 1235 hPowerSaveCompleteCb, 1236 fPowerSaveCompleteCb, 1237 fPowerSaveResponseCb); 1238 } 1239 1240 TI_BOOL TWD_GetPsStatus (TI_HANDLE hTWD) 1241 { 1242 TTwd *pTWD = (TTwd *)hTWD; 1243 1244 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetPsStatus: called\n"); 1245 1246 return MacServices_powerSrv_getPsStatus (pTWD->hMacServices); 1247 } 1248 1249 TI_STATUS TWD_SetNullRateModulation (TI_HANDLE hTWD, TI_UINT16 rate) 1250 { 1251 TTwd *pTWD = (TTwd *)hTWD; 1252 1253 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetRateModulation: called\n"); 1254 1255 MacServices_powerSrv_SetRateModulation (pTWD->hMacServices, rate); 1256 1257 return TI_OK; 1258 } 1259 1260 void TWD_UpdateDtimTbtt (TI_HANDLE hTWD, TI_UINT8 uDtimPeriod, TI_UINT16 uBeaconInterval) 1261 { 1262 TTwd *pTWD = (TTwd *)hTWD; 1263 1264 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_UpdateDtimTbtt: called\n"); 1265 1266 MacServices_scanSrv_UpdateDtimTbtt (pTWD->hMacServices, uDtimPeriod, uBeaconInterval); 1267 } 1268 1269 TI_STATUS TWD_StartMeasurement (TI_HANDLE hTWD, 1270 TMeasurementRequest *pMsrRequest, 1271 TI_UINT32 uTimeToRequestExpiryMs, 1272 TCmdResponseCb fResponseCb, 1273 TI_HANDLE hResponseCb, 1274 TMeasurementSrvCompleteCb fCompleteCb, 1275 TI_HANDLE hCompleteCb) 1276 { 1277 TTwd *pTWD = (TTwd *)hTWD; 1278 1279 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StartMeasurement: called\n"); 1280 1281 return MacServices_measurementSRV_startMeasurement (pTWD->hMacServices, 1282 pMsrRequest, 1283 uTimeToRequestExpiryMs, 1284 fResponseCb, 1285 hResponseCb, 1286 fCompleteCb, 1287 hCompleteCb); 1288 } 1289 1290 TI_STATUS TWD_StopMeasurement (TI_HANDLE hTWD, 1291 TI_BOOL bSendNullData, 1292 TCmdResponseCb fResponseCb, 1293 TI_HANDLE hResponseCb) 1294 { 1295 TTwd *pTWD = (TTwd *)hTWD; 1296 1297 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopMeasurement: called\n"); 1298 1299 return MacServices_measurementSRV_stopMeasurement (pTWD->hMacServices, 1300 bSendNullData, 1301 fResponseCb, 1302 hResponseCb); 1303 } 1304 1305 TI_STATUS TWD_RegisterScanCompleteCb (TI_HANDLE hTWD, 1306 TScanSrvCompleteCb fScanCompleteCb, 1307 TI_HANDLE hScanCompleteCb) 1308 { 1309 TTwd *pTWD = (TTwd *)hTWD; 1310 1311 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RegisterScanCompleteCb: called\n"); 1312 1313 MacServices_scanSRV_registerScanCompleteCB (pTWD->hMacServices, 1314 fScanCompleteCb, 1315 hScanCompleteCb); 1316 1317 return TI_OK; 1318 } 1319 1320 #ifdef TI_DBG 1321 TI_STATUS TWD_PrintMacServDebugStatus (TI_HANDLE hTWD) 1322 { 1323 TTwd *pTWD = (TTwd *)hTWD; 1324 1325 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_PrintMacServDebugStatus: called\n"); 1326 1327 MacServices_scanSrv_printDebugStatus (pTWD->hMacServices); 1328 1329 return TI_OK; 1330 } 1331 #endif 1332 1333 TI_STATUS TWD_Scan (TI_HANDLE hTWD, 1334 TScanParams *pScanParams, 1335 EScanResultTag eScanTag, 1336 TI_BOOL bHighPriority, 1337 TI_BOOL bDriverMode, 1338 TI_BOOL bScanOnDriverModeError, 1339 E80211PsMode ePsRequest, 1340 TI_BOOL bSendNullData, 1341 TCmdResponseCb fResponseCb, 1342 TI_HANDLE hResponseCb) 1343 { 1344 TTwd *pTWD = (TTwd *)hTWD; 1345 1346 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_Scan: called\n"); 1347 1348 return MacServices_scanSRV_scan (pTWD->hMacServices, 1349 pScanParams, 1350 eScanTag, 1351 bHighPriority, 1352 bDriverMode, 1353 bScanOnDriverModeError, 1354 ePsRequest, 1355 bSendNullData, 1356 fResponseCb, 1357 hResponseCb); 1358 } 1359 1360 TI_STATUS TWD_StopScan (TI_HANDLE hTWD, 1361 EScanResultTag eScanTag, 1362 TI_BOOL bSendNullData, 1363 TCmdResponseCb fScanCommandResponseCb, 1364 TI_HANDLE hCb) 1365 { 1366 TTwd *pTWD = (TTwd *)hTWD; 1367 1368 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopScan: called\n"); 1369 1370 return MacServices_scanSRV_stopScan (pTWD->hMacServices, 1371 eScanTag, 1372 bSendNullData, 1373 fScanCommandResponseCb, 1374 hCb); 1375 } 1376 1377 TI_STATUS TWD_StopScanOnFWReset (TI_HANDLE hTWD) 1378 { 1379 TTwd *pTWD = (TTwd *)hTWD; 1380 1381 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopScanOnFWReset: called\n"); 1382 1383 return MacServices_scanSRV_stopOnFWReset (pTWD->hMacServices); 1384 } 1385 1386 TI_STATUS TWD_StartConnectionScan (TI_HANDLE hTWD, 1387 TPeriodicScanParams *pPeriodicScanParams, 1388 EScanResultTag eScanTag, 1389 TI_UINT32 uPassiveScanDfsDwellTimeMs, 1390 TCmdResponseCb fResponseCb, 1391 TI_HANDLE hResponseCb) 1392 { 1393 TTwd *pTWD = (TTwd *)hTWD; 1394 1395 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StartConnectionScan: called\n"); 1396 1397 return cmdBld_StartPeriodicScan (pTWD->hCmdBld, pPeriodicScanParams, eScanTag, uPassiveScanDfsDwellTimeMs, 1398 (void*)fResponseCb, hResponseCb); 1399 } 1400 1401 TI_STATUS TWD_StopPeriodicScan (TI_HANDLE hTWD, 1402 EScanResultTag eScanTag, 1403 TCmdResponseCb fResponseCb, 1404 TI_HANDLE hResponseCb) 1405 { 1406 TTwd *pTWD = (TTwd *)hTWD; 1407 1408 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopPeriodicScan: called\n"); 1409 1410 return cmdBld_StopPeriodicScan (pTWD->hCmdBld, eScanTag, (void*)fResponseCb, hResponseCb); 1411 } 1412 1413 TI_STATUS TWD_readMem (TI_HANDLE hTWD, TFwDebugParams* pMemDebug, void* fCb, TI_HANDLE hCb) 1414 { 1415 if (hTWD == NULL || pMemDebug == NULL) 1416 { 1417 return (TI_NOK); 1418 } 1419 1420 TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_readMem: called\n"); 1421 1422 if (fwDbg_ReadAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length,pMemDebug->UBuf.buf8,(TFwDubCallback)fCb,hCb) == TI_NOK) 1423 { 1424 TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_CONSOLE ,"TWD_readMem Error: fwDbg_handleCommand failed\n"); 1425 WLAN_OS_REPORT(("TWD_readMem Error: fwDbg_handleCommand failed\n")); 1426 return TI_NOK; 1427 } 1428 1429 return (TI_OK); 1430 } 1431 1432 TI_STATUS TWD_writeMem (TI_HANDLE hTWD, TFwDebugParams* pMemDebug, void* fCb, TI_HANDLE hCb) 1433 { 1434 if (hTWD == NULL || pMemDebug == NULL) 1435 { 1436 return (TI_NOK); 1437 } 1438 1439 TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_writeMem: called\n"); 1440 1441 if (fwDbg_WriteAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length,pMemDebug->UBuf.buf8,(TFwDubCallback)fCb,hCb) == TI_NOK) 1442 { 1443 TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_CONSOLE ,"TWD_writeMem Error: fwDbg_handleCommand failed\n"); 1444 WLAN_OS_REPORT(("TWD_writeMem Error: fwDbg_handleCommand failed\n")); 1445 return TI_NOK; 1446 } 1447 1448 return(TI_OK); 1449 } 1450 1451 TI_BOOL TWD_isValidMemoryAddr (TI_HANDLE hTWD, TFwDebugParams* pMemDebug) 1452 { 1453 if (hTWD == NULL || pMemDebug == NULL) 1454 { 1455 return TI_FALSE; 1456 } 1457 1458 TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_isValidMemoryAddr: called\n"); 1459 1460 return fwDbg_isValidMemoryAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length); 1461 } 1462 1463 TI_BOOL TWD_isValidRegAddr (TI_HANDLE hTWD, TFwDebugParams* pMemDebug) 1464 { 1465 if (hTWD == NULL || pMemDebug == NULL ) 1466 { 1467 return TI_FALSE; 1468 } 1469 1470 TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_isValidRegAddr: called\n"); 1471 1472 return fwDbg_isValidRegAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length); 1473 } 1474 1475 /** 1476 * \brief Set Template Frame 1477 * 1478 * \param hTWD - TWD module object handle 1479 * \param pMib - Pointer to Input MIB Structure 1480 * \return TI_OK on success or TI_NOK on failure 1481 * 1482 * \par Description 1483 * Static function 1484 * Configure/Interrogate/Modulate the Frame Rate if needed (according to Templete Type) 1485 * and then write the MIB TemplateFrame to the FW 1486 * 1487 * \sa 1488 */ 1489 static TI_STATUS TWD_WriteMibTemplateFrame (TI_HANDLE hTWD, TMib* pMib) 1490 { 1491 TTwd *pTWD = (TTwd *)hTWD; 1492 TSetTemplate tSetTemplate; 1493 TI_UINT32 uRateMask = RATE_TO_MASK(pMib->aData.TemplateFrame.Rate); 1494 1495 /* 1496 * Construct the template MIB element 1497 */ 1498 switch(pMib->aData.TemplateFrame.FrameType) 1499 { 1500 case TEMPLATE_TYPE_BEACON: 1501 tSetTemplate.type = BEACON_TEMPLATE; 1502 break; 1503 1504 case TEMPLATE_TYPE_PROBE_REQUEST: 1505 tSetTemplate.type = PROBE_REQUEST_TEMPLATE; 1506 tSetTemplate.eBand = RADIO_BAND_2_4_GHZ; /* needed for GWSI, if so band must also be passed to choose correct template (G or A) */ 1507 break; 1508 1509 case TEMPLATE_TYPE_NULL_FRAME: 1510 tSetTemplate.type = NULL_DATA_TEMPLATE; 1511 MacServices_powerSrv_SetRateModulation (pTWD->hMacServices, (TI_UINT16)uRateMask); 1512 break; 1513 1514 case TEMPLATE_TYPE_PROBE_RESPONSE: 1515 tSetTemplate.type = PROBE_RESPONSE_TEMPLATE; 1516 break; 1517 1518 case TEMPLATE_TYPE_QOS_NULL_FRAME: 1519 tSetTemplate.type = QOS_NULL_DATA_TEMPLATE; 1520 break; 1521 1522 case TEMPLATE_TYPE_PS_POLL: 1523 tSetTemplate.type = PS_POLL_TEMPLATE; 1524 break; 1525 1526 default: 1527 TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMibTemplateFrame - ERROR - template is not supported, %d\n", pMib->aData.TemplateFrame.FrameType); 1528 return PARAM_NOT_SUPPORTED; 1529 } 1530 1531 tSetTemplate.len = pMib->aData.TemplateFrame.Length; 1532 tSetTemplate.ptr = (TI_UINT8 *) &(pMib->aData.TemplateFrame.Data); 1533 tSetTemplate.uRateMask = uRateMask; 1534 1535 return TWD_CmdTemplate (hTWD, &tSetTemplate, NULL, NULL); 1536 } 1537 1538 /** 1539 * \brief Set Beacon Filter IE Table 1540 * 1541 * \param hTWD - TWD module object handle 1542 * \param pMib - Pointer to Input MIB Structure 1543 * \return TI_OK on success or TI_NOK on failure 1544 * 1545 * \par Description 1546 * Static function 1547 * Configure the MIB Beacon Filter IE table 1548 * 1549 * \sa 1550 */ 1551 static TI_STATUS TWD_WriteMibBeaconFilterIETable (TI_HANDLE hTWD, TMib *pMib) 1552 { 1553 TTwd *pTWD = (TTwd *)hTWD; 1554 TI_UINT8 numOf221IE = 0; 1555 TI_UINT8 i = 0; 1556 TI_UINT8 IETableLen = 0; 1557 TI_UINT8 numOfIEs = 0; 1558 TI_UINT8 *IETable = NULL; 1559 1560 numOfIEs = pMib->aData.BeaconFilter.iNumberOfIEs; 1561 IETable = pMib->aData.BeaconFilter.iIETable; 1562 /* Find the actual IETableLen */ 1563 for (i = 0; i < numOfIEs; i++) 1564 { 1565 if (IETable[IETableLen] == 0xdd) 1566 { 1567 IETableLen += 8; 1568 numOf221IE++; 1569 } 1570 else 1571 { 1572 IETableLen += 2; 1573 } 1574 } 1575 1576 TRACE4(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_WriteMibBeaconFilterIETable: IETable=0x%x Num Of IE=%d ( including %d 221 ) - Table Len=%d\n", IETable, numOfIEs, numOf221IE, IETableLen); 1577 1578 return TWD_CfgBeaconFilterTable (hTWD, numOfIEs, IETable, IETableLen); 1579 } 1580 1581 /** 1582 * \brief Set Tx Rate Policy 1583 * 1584 * \param hTWD - TWD module object handle 1585 * \param pMib - Pointer to Input MIB Structure 1586 * \return TI_OK on success or TI_NOK on failure 1587 * 1588 * \par Description 1589 * Static function 1590 * Coordinates between legacy TxRatePolicy implementation and the MIB format: 1591 * Converts the pGwsi_txRatePolicy back to command builder commands. 1592 * Activates the TWD_set function. 1593 * 1594 * \sa 1595 */ 1596 static TI_STATUS TWD_WriteMibTxRatePolicy (TI_HANDLE hTWD, TMib* pMib) 1597 { 1598 TTwd *pTWD = (TTwd *)hTWD; 1599 1600 #ifdef TI_DBG 1601 if (NULL == pMib) 1602 { 1603 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "ERROR: TWD_WriteMibTxRatePolicy pMib=NULL !!!"); 1604 return TI_NOK; 1605 } 1606 #endif /* TI_DBG */ 1607 1608 return cmdBld_CfgTxRatePolicy (pTWD->hCmdBld, &pMib->aData.txRatePolicy, NULL, NULL); 1609 } 1610 1611 TI_STATUS TWD_WriteMib (TI_HANDLE hTWD, TMib *pMib) 1612 { 1613 TTwd *pTWD = (TTwd *)hTWD; 1614 1615 #ifdef TI_DBG 1616 TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_WriteMib :pMib %p:\n",pMib); 1617 1618 TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_WriteMib :aMib %x:\n",pMib->aMib); 1619 1620 TRACE_INFO_HEX(pTWD->hReport, (TI_UINT8*)pMib, TI_MIN (sizeof(TMib), pMib->Length)); 1621 #endif /* TI_DBG */ 1622 1623 if (NULL == pMib) 1624 { 1625 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMib :pMib = NULL !!\n"); 1626 return PARAM_VALUE_NOT_VALID; 1627 } 1628 1629 switch (pMib->aMib) 1630 { 1631 case MIB_dot11MaxReceiveLifetime: 1632 return cmdBld_CfgRxMsduLifeTime (pTWD->hCmdBld, pMib->aData.MaxReceiveLifeTime * 1024, (void *)NULL, (void *)NULL); 1633 1634 case MIB_ctsToSelf: 1635 return cmdBld_CfgCtsProtection (pTWD->hCmdBld, (TI_UINT8)pMib->aData.CTSToSelfEnable, (void *)NULL, (TI_HANDLE)NULL); 1636 1637 case MIB_dot11GroupAddressesTable: 1638 { 1639 if (NULL == pMib->aData.GroupAddressTable.aGroupTable) 1640 { 1641 TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMib(MIB_dot11GroupAddressesTable) :GroupTable = NULL !!\n"); 1642 return PARAM_VALUE_NOT_VALID; 1643 } 1644 1645 return TWD_CfgGroupAddressTable (hTWD, 1646 pMib->aData.GroupAddressTable.nNumberOfAddresses, 1647 pMib->aData.GroupAddressTable.aGroupTable, 1648 pMib->aData.GroupAddressTable.bFilteringEnable); 1649 } 1650 1651 case MIB_arpIpAddressesTable: 1652 { 1653 TIpAddr IpAddress; 1654 1655 IP_COPY (IpAddress, pMib->aData.ArpIpAddressesTable.addr); 1656 1657 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_WriteMib(MIB_arpIpAddressesTable) IpAddress:\n"); 1658 TRACE_INFO_HEX(pTWD->hReport, (TI_UINT8*)&IpAddress, 4); 1659 1660 return cmdBld_CfgArpIpAddrTable (pTWD->hCmdBld, 1661 IpAddress, 1662 (TI_BOOL)pMib->aData.ArpIpAddressesTable.FilteringEnable, 1663 IP_VER_4, 1664 NULL, 1665 NULL); 1666 } 1667 1668 case MIB_templateFrame: 1669 return TWD_WriteMibTemplateFrame (hTWD, pMib); 1670 1671 case MIB_beaconFilterIETable: 1672 return TWD_WriteMibBeaconFilterIETable (hTWD, pMib); 1673 1674 case MIB_rxFilter: 1675 { 1676 TI_UINT32 uRxFilter = 0; 1677 TI_UINT8 uMibRxFilter = pMib->aData.RxFilter; 1678 1679 if (uMibRxFilter & MIB_RX_FILTER_PROMISCOUS_SET) 1680 { 1681 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n TWD_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ANY_DEST_MAC\n"); 1682 uRxFilter = RX_CFG_ENABLE_ANY_DEST_MAC; 1683 } 1684 else 1685 { 1686 uRxFilter = RX_CFG_ENABLE_ONLY_MY_DEST_MAC; 1687 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n halCtrl_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ONLY_MY_DEST_MAC\n"); 1688 } 1689 1690 if ((uMibRxFilter & MIB_RX_FILTER_BSSID_SET) != 0) 1691 { 1692 uRxFilter = uRxFilter | RX_CFG_ENABLE_ONLY_MY_BSSID; 1693 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n halCtrl_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ONLY_MY_BSSID\n"); 1694 } 1695 else 1696 { 1697 uRxFilter = uRxFilter | RX_CFG_ENABLE_ANY_BSSID; 1698 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n halCtrl_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ANY_BSSID\n"); 1699 } 1700 1701 /* 1702 * Activates the TWD_setRxFilters function 1703 */ 1704 return TWD_CfgRx (hTWD, uRxFilter, RX_FILTER_OPTION_DEF); 1705 } 1706 1707 case MIB_txRatePolicy: 1708 return TWD_WriteMibTxRatePolicy (hTWD, pMib); 1709 1710 default: 1711 TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMib - ERROR - MIB element not supported, %d\n", pMib->aMib); 1712 1713 return TI_NOK; 1714 1715 } /* switch */ 1716 } 1717 1718 TI_STATUS TWD_ReadMib (TI_HANDLE hTWD, TI_HANDLE hCb, void* fCb, void* pCb) 1719 { 1720 TTwd *pTWD = (TTwd *)hTWD; 1721 1722 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ReadMib: called\n"); 1723 1724 return cmdBld_ReadMib (pTWD->hCmdBld, hCb, fCb, pCb); 1725 } 1726 1727 void TWD_DisableInterrupts(TI_HANDLE hTWD) 1728 { 1729 TTwd *pTWD = (TTwd *)hTWD; 1730 1731 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_DisableInterrupts: called\n"); 1732 1733 fwEvent_DisableInterrupts(pTWD->hFwEvent); 1734 } 1735 1736 void TWD_EnableInterrupts(TI_HANDLE hTWD) 1737 { 1738 TTwd *pTWD = (TTwd *)hTWD; 1739 1740 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_EnableInterrupts: called\n"); 1741 1742 fwEvent_EnableInterrupts(pTWD->hFwEvent); 1743 } 1744 1745 TI_UINT32 TWD_TranslateToFwTime (TI_HANDLE hTWD, TI_UINT32 uHostTime) 1746 { 1747 TTwd *pTWD = (TTwd *)hTWD; 1748 1749 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_TranslateToFwTime: called\n"); 1750 1751 return fwEvent_TranslateToFwTime (pTWD->hFwEvent, uHostTime); 1752 } 1753 1754 void TWD_GetTwdHtCapabilities (TI_HANDLE hTWD, TTwdHtCapabilities **pTwdHtCapabilities) 1755 { 1756 TTwd *pTWD = (TTwd *)hTWD; 1757 TWlanParams *pWlanParams = &DB_WLAN(pTWD->hCmdBld); 1758 1759 TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetTwdHtCapabilities: called\n"); 1760 1761 *pTwdHtCapabilities = &(pWlanParams->tTwdHtCapabilities); 1762 } 1763 1764 /** 1765 * \brief TWD get FEM type 1766 * * 1767 * \param Handle - handle to object 1768 * \return uint8 1769 * 1770 * \par Description 1771 * The function return the Front end module that was read frm FW register * 1772 * \sa 1773 */ 1774 TI_UINT8 TWD_GetFEMType (TI_HANDLE hTWD) 1775 { 1776 TTwd *pTWD = (TTwd *)hTWD; 1777 IniFileGeneralParam *pGenParams = &DB_GEN(pTWD->hCmdBld); 1778 1779 return pGenParams->TXBiPFEMManufacturer; 1780 1781 } 1782 1783 /** 1784 * \brief TWD end function of read radio state machine 1785 * * * 1786 * \param Handle - handle to object 1787 * \return void 1788 * 1789 * \par Description 1790 * The function calling to HwInit call back function, after finish reading FEM registers * 1791 * \sa 1792 */ 1793 void TWD_FinalizeFEMRead(TI_HANDLE hTWD) 1794 { 1795 TTwd *pTWD = (TTwd *)hTWD; 1796 1797 (*pTWD->fInitHwCb) (pTWD->hUser, TI_OK); 1798 } 1799 1800 1801 1802 1803 void TWD_FinalizePolarityRead(TI_HANDLE hTWD) 1804 { 1805 TTwd *pTWD = (TTwd *)hTWD; 1806 /* allways read FEM type from Radio Registers */ 1807 hwInit_ReadRadioParams(pTWD->hHwInit); 1808 } 1809
