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 /**************************************************************************** 37 * 38 * MODULE: GWSI_Synchronizer.c 39 * PURPOSE: GWSI Synchronizer used to synchronize between the CMD,INT,TX 40 * 41 ****************************************************************************/ 42 43 #include "commonTypes.h" 44 #include "report.h" 45 #include "osApi.h" 46 /* Need tthe TNETWARB API Function to create and confit it */ 47 #include "TNETWArb.h" 48 #include "TNETWIF.h" 49 /* Need the HwAcess API Function to create and confit it */ 50 #include "whalHwAccess.h" 51 /* Need the ELP Control API Function to create and confit it */ 52 #include "ElpCtrl.h" 53 54 /* 55 * Special debug mode to trace all calls to TNETWIF_XXX 56 */ 57 #ifdef TNETWIF_DEBUG 58 59 typedef enum 60 { 61 No_FUNC, 62 Start_FUNC, 63 Restart_FUNC, 64 Finish_FUNC, 65 WriteMem_FUNC, 66 ReadMem_FUNC, 67 WriteReg_FUNC, 68 ReadReg_FUNC, 69 WriteElp_FUNC, 70 ReadElp_FUNC, 71 BusComplete_FUNC, 72 UnMux_FUNC 73 } ETNETIF_Functions; 74 75 typedef struct 76 { 77 UINT32 uData; 78 UINT32 uModule; 79 UINT32 uTS; 80 ETNETIF_Functions eFunc; 81 82 } TTNETWIF_DEBUG; 83 84 /* Should be the max value of uDebugCounter */ 85 #define TNETWIF_SIZE_OF_DEBUG_ARRAY 256 86 87 /* Global variables for debug */ 88 UINT8 uDebugCounter ; 89 TTNETWIF_DEBUG tDebug[TNETWIF_SIZE_OF_DEBUG_ARRAY]; 90 91 #define TNETWIF_TRACE(hOs,func,module,data) \ 92 tDebug[uDebugCounter].uData = (UINT32)(data); \ 93 tDebug[uDebugCounter].uModule = module; \ 94 tDebug[uDebugCounter].uTS = os_timeStampUs(hOs); \ 95 tDebug[uDebugCounter].eFunc = func; \ 96 uDebugCounter++; 97 98 /**************************************************************************** 99 * TNETWIF_FuncEnumdToString() 100 *****************************************************************************/ 101 char* TNETWIF_FuncEnumToString(ETNETIF_Functions eFunc) 102 { 103 switch (eFunc) 104 { 105 case No_FUNC: return "(No_FUNC) "; 106 case Start_FUNC: return "(Start_FUNC) "; 107 case Restart_FUNC: return "(Restart_FUNC) "; 108 case Finish_FUNC: return "(Finish_FUNC) "; 109 case WriteMem_FUNC: return "(WriteMem_FUNC) "; 110 case ReadMem_FUNC: return "(ReadMem_FUNC) "; 111 case WriteReg_FUNC: return "(WriteReg_FUNC) "; 112 case ReadReg_FUNC: return "(ReadReg_FUNC) "; 113 case WriteElp_FUNC: return "(WriteElp_FUNC) "; 114 case ReadElp_FUNC: return "(ReadElp_FUNC) "; 115 case BusComplete_FUNC: return "(BusComplete_FUNC) "; 116 case UnMux_FUNC: return "(UnMux_FUNC) "; 117 default : 118 return " No_FUNC???)"; 119 } 120 } 121 /**************************************************************************** 122 * TNETWIF_printErrorLog() 123 *****************************************************************************/ 124 void TNETWIF_printErrorLog(void) 125 { 126 int i; 127 WLAN_OS_REPORT(("\n%s\n",__FUNCTION__)); 128 WLAN_OS_REPORT(("Counter at %d (i.e. last operation is %d)\n",uDebugCounter,uDebugCounter-1)); 129 for ( i = 0 ; i < TNETWIF_SIZE_OF_DEBUG_ARRAY ; i++) 130 { 131 WLAN_OS_REPORT(("%03d %s: %s TS(Diff) = %07d data = 0x%x\n",i, 132 TNETWIF_FuncEnumToString(tDebug[i].eFunc), 133 TNETWIF_ModuleIdToString(tDebug[i].uModule), 134 tDebug[i].uTS - tDebug[(UINT8)(i-1)].uTS, 135 tDebug[i].uData)); 136 } 137 } 138 139 #else /* TNETWIF_DEBUG */ 140 141 #define TNETWIF_TRACE(hOs,func,module_id,data) 142 void TNETWIF_printErrorLog(void) { WLAN_OS_REPORT(("%s define TNETWIF_DEBUG to debug error\n",__FUNCTION__)); } 143 144 #endif 145 146 extern void os_TNETWIF_BusTxn_Complete(TI_HANDLE OsContext,int status); 147 148 149 /*********************************************************************************** 150 Internal TNETWIF function use 151 152 153 154 **************************************************************************************/ 155 /****************************************************************************/ 156 /* TNETWIF_Create() 157 **************************************************************************** 158 * DESCRIPTION: Request The Bus 159 * 160 * INPUTS: 161 * 162 * OUTPUT: String the name of the Queue 163 * 164 * RETURNS: 165 ****************************************************************************/ 166 TI_HANDLE TNETWIF_Create (TI_HANDLE hOs) 167 { 168 TNETWIF_t *pTNETWIF; 169 170 /* Allocate the TNETWIF module */ 171 pTNETWIF = os_memoryAlloc (hOs, sizeof(TNETWIF_t)); 172 173 if (pTNETWIF == NULL) 174 return NULL; 175 176 os_memoryZero (hOs, pTNETWIF, sizeof(TNETWIF_t)); 177 178 pTNETWIF->hOs = hOs; 179 180 /* Create the TNETW Arbiter module */ 181 pTNETWIF->hTNETWArb = TNETWArb_Init (hOs); 182 183 /* Create the Hw Access module */ 184 pTNETWIF->hHwAccess = whal_hwAccess_Create (hOs); 185 186 /* Create the ELP Controller module */ 187 pTNETWIF->hELPCtrl = elpCtrl_Create (hOs); 188 189 return (TI_HANDLE)pTNETWIF; 190 } 191 192 193 /****************************************************************************/ 194 /* TNETWIF_Destroy() 195 **************************************************************************** 196 * DESCRIPTION: Destroy The TNETWIF Module 197 * 198 * INPUTS: 199 * 200 * OUTPUT: String the name of the Queue 201 * 202 * RETURNS: 203 ****************************************************************************/ 204 TI_STATUS TNETWIF_Destroy (TI_HANDLE hTNETWIF) 205 { 206 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 207 208 /* Destroy the ELP Controller module */ 209 elpCtrl_Destroy (pTNETWIF->hELPCtrl); 210 211 /* Destroy the HwAccess Module */ 212 whal_hwAccess_Destroy (pTNETWIF->hHwAccess); 213 214 /* Destroy the TNETW Arbiter */ 215 TNETWArb_Destroy (pTNETWIF->hTNETWArb); 216 217 /* Free the TNETWIF Memory */ 218 os_memoryFree (pTNETWIF->hOs, pTNETWIF, sizeof(TNETWIF_t)); 219 220 221 return OK; 222 } 223 224 225 /****************************************************************************/ 226 /* TNETWIF_ConfigCb() 227 **************************************************************************** 228 * DESCRIPTION: TNETWIF module configuration state machine 229 * 230 * INPUTS: 231 * 232 * OUTPUT: 233 * 234 * RETURNS: 235 ****************************************************************************/ 236 static void TNETWIF_ConfigCb (TI_HANDLE hTNETWIF, UINT8 module_id, TI_STATUS status) 237 { 238 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 239 240 switch (pTNETWIF->uInitStage) 241 { 242 case 0: 243 pTNETWIF->uInitStage ++; 244 245 #ifdef GWSI_SPI_TEST 246 /* 247 * This is a special build meant only for testing the SPI bus. We don't need anything 248 * but initiating the TNETWIF. That's why we skip partition and ELP phase 249 */ 250 pTNETWIF->uInitStage = 3; 251 #endif /* GWSI_SPI_TEST */ 252 253 /* Register the arbiter callback */ 254 TNETWArb_register_handler (pTNETWIF->hTNETWArb, 255 HAL_INIT_MODULE_ID, 256 TNETWIF_ConfigCb, 257 hTNETWIF); 258 259 /* Configure the HwAccess with the DMA Done callback */ 260 status = (TI_STATUS)whal_hwAccess_Config (pTNETWIF->hHwAccess, 261 pTNETWIF->hReport, 262 pTNETWIF->uRegBaseAddr, 263 pTNETWIF->uMemBaseAddr, 264 os_TNETWIF_BusTxn_Complete, 265 pTNETWIF->hOs); 266 267 if (status == TNETWIF_PENDING) 268 { 269 pTNETWIF->status = TNETWIF_PENDING; 270 return; 271 } 272 else if (status == TNETWIF_ERROR) 273 { /* This case is mainly used for the SPI test */ 274 pTNETWIF->status = TNETWIF_ERROR; 275 } 276 else 277 { 278 pTNETWIF->status = TNETWIF_COMPLETE; 279 } 280 281 case 1: 282 pTNETWIF->uInitStage ++; 283 284 #if defined(HW_ACCESS_SDIO) || defined(HW_ACCESS_WSPI) 285 status = TNETWIF_SetPartitionsOpt (hTNETWIF, 286 HW_ACCESS_DOWNLOAD, 287 HW_ACCESS_DOWN_PART0_ADDR, 288 module_id, 289 (TNETWIF_callback_t)TNETWIF_ConfigCb, 290 hTNETWIF); 291 if (status == TNETWIF_PENDING) 292 { 293 pTNETWIF->status = TNETWIF_PENDING; 294 return; 295 } 296 else 297 { 298 pTNETWIF->status = TNETWIF_COMPLETE; 299 } 300 #endif 301 302 case 2: 303 pTNETWIF->uInitStage ++; 304 305 /* Awake firmware */ 306 if (TNETWIF_WriteELPOpt (hTNETWIF, 307 ELPCTRL_WAKE_UP, 308 HAL_INIT_MODULE_ID, 309 TNETWIF_ConfigCb, 310 hTNETWIF, 311 TRUE) == TNETWIF_PENDING) 312 { 313 pTNETWIF->status = TNETWIF_PENDING; 314 return; 315 } 316 else 317 { 318 pTNETWIF->status = TNETWIF_COMPLETE; 319 } 320 321 case 3: 322 /* Call upper module callback */ 323 pTNETWIF->fCb (pTNETWIF->hCb, module_id, pTNETWIF->status); 324 pTNETWIF->uInitStage = 0; 325 326 WLAN_REPORT_INIT (pTNETWIF->hReport, TNETW_IF_MODULE_LOG, 327 ("%s(%d) - TNETWIF Initialized\n", __FILE__, __LINE__)); 328 } 329 } 330 331 332 /****************************************************************************/ 333 /* TNETWIF_Config() 334 **************************************************************************** 335 * DESCRIPTION: Configure the TNETWIF module 336 * 337 * INPUTS: 338 * 339 * OUTPUT: 340 * 341 * RETURNS: 342 ****************************************************************************/ 343 TI_STATUS TNETWIF_Config (TI_HANDLE hTNETWIF, TI_HANDLE hReport, UINT32 uRegBaseAddr, UINT32 uMemBaseAddr, TNETWIF_callback_t fCb, TI_HANDLE hCb) 344 { 345 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 346 347 pTNETWIF->hReport = hReport; 348 pTNETWIF->uInitStage = 0; 349 pTNETWIF->uRegBaseAddr = uRegBaseAddr; 350 pTNETWIF->uMemBaseAddr = uMemBaseAddr; 351 pTNETWIF->fCb = fCb; 352 pTNETWIF->hCb = hCb; 353 pTNETWIF->status = TNETWIF_PENDING; 354 #ifdef TNETWIF_DEBUG 355 uDebugCounter = 0; 356 os_memoryZero(pTNETWIF->hOs, (void*)tDebug, sizeof(tDebug)); 357 WLAN_OS_REPORT(("Using Debug Arbiter\n")); 358 #endif 359 360 /* Send the ELP Controller handle to the TNETW Arbiter */ 361 TNETWArb_Config (pTNETWIF->hTNETWArb, hReport, pTNETWIF->hELPCtrl); 362 363 /* Configure ELP control before the 1st TNETWIF_Start call */ 364 elpCtrl_Configure (pTNETWIF->hELPCtrl, hTNETWIF, TNETWArb_TxnCb); 365 366 /* Start TNETWIF config state machine */ 367 TNETWIF_Start (hTNETWIF, HAL_INIT_MODULE_ID, hTNETWIF, TNETWIF_ConfigCb); 368 369 return pTNETWIF->status; 370 } 371 372 373 /****************************************************************************/ 374 /* TNETWIF_ReConfig() 375 **************************************************************************** 376 * DESCRIPTION: stop the SDIO in Recovery process 377 * 378 * INPUTS: 379 * 380 * OUTPUT: status 381 * 382 * RETURNS: 383 ****************************************************************************/ 384 TI_STATUS TNETWIF_ReConfig (TI_HANDLE hTNETWIF) 385 { 386 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 387 TI_STATUS status = OK; 388 #if (defined(_WINDOWS) && defined(HW_ACCESS_SDIO)) 389 #else 390 whal_hwAccess_Stop (pTNETWIF->hHwAccess); 391 #endif 392 393 return (status); 394 } 395 396 397 /****************************************************************************/ 398 /* TNETWIF_Start() 399 **************************************************************************** 400 * DESCRIPTION: Request The Bus 401 * 402 * INPUTS: 403 * 404 * OUTPUT: String the name of the Queue 405 * 406 * RETURNS: 407 ****************************************************************************/ 408 TI_STATUS TNETWIF_Start (TI_HANDLE hTNETWIF, UINT8 module_id, TI_HANDLE hCb, TNETWIF_callback_t fCb) 409 { 410 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 411 TI_STATUS status; 412 413 TNETWIF_TRACE(pTNETWIF->hOs,Start_FUNC,module_id,fCb) 414 415 /* Call the TNETW Arbiter for the start operation - the client requests access the bus */ 416 status = TNETWArb_Start (pTNETWIF->hTNETWArb, module_id, hCb, fCb); 417 418 return status; 419 } 420 421 422 /****************************************************************************/ 423 /* TNETWIF_Restart() 424 **************************************************************************** 425 * DESCRIPTION: Re-Request The Bus 426 * 427 * INPUTS: 428 * 429 * OUTPUT: 430 * 431 * RETURNS: 432 ****************************************************************************/ 433 TI_STATUS TNETWIF_Restart (TI_HANDLE hTNETWIF, UINT8 module_id, TI_HANDLE hCb, TNETWIF_callback_t fCb) 434 { 435 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 436 TI_STATUS status; 437 438 TNETWIF_TRACE(pTNETWIF->hOs,Restart_FUNC,module_id,fCb) 439 440 /* Call the TNETW Arbiter for the restart operation - the client requests access to the bus */ 441 status = TNETWArb_Restart (pTNETWIF->hTNETWArb, module_id, hCb, fCb); 442 443 return status; 444 } 445 446 447 /****************************************************************************/ 448 /* TNETWIF_Finish() 449 **************************************************************************** 450 * DESCRIPTION: Release The Bus 451 * 452 * INPUTS: 453 * 454 * OUTPUT: 455 * 456 * RETURNS: 457 ****************************************************************************/ 458 TI_STATUS TNETWIF_Finish (TI_HANDLE hTNETWIF, UINT8 module_id, TI_HANDLE hCb, TNETWIF_callback_t fCb) 459 { 460 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 461 TI_STATUS status; 462 463 TNETWIF_TRACE(pTNETWIF->hOs,Finish_FUNC,module_id,fCb) 464 465 /* Call the TNETW Arbiter for the finish operation - the client frees the bus */ 466 status = TNETWArb_Finish (pTNETWIF->hTNETWArb, module_id, hCb, fCb); 467 468 return status; 469 } 470 471 /****************************************************************************** 472 ** ** 473 ** Function Name: TNETWIF_UnMux ** 474 ** ** 475 ** Description: This should be called FwEvent to switch MUX from WLAN_READY to FwEvent. ** 476 ** ** 477 ******************************************************************************/ 478 TI_STATUS TNETWIF_UnMux (TI_HANDLE hTNETWIF) 479 { 480 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 481 482 TNETWIF_TRACE(pTNETWIF->hOs,UnMux_FUNC,0xFF,0) 483 484 return (TI_STATUS)elpCtrl_UnMux(pTNETWIF->hELPCtrl); 485 486 } 487 488 489 /****************************************************************************** 490 ** ** 491 ** Function Name: TNETWIF_BusTxn_Complete ** 492 ** ** 493 ** Description: This should be called now from the tasklet 494 Distribute SPI interrupt to all running modules . ** 495 ** ** 496 ******************************************************************************/ 497 void TNETWIF_BusTxn_Complete (TI_HANDLE hTNETWIF) 498 { 499 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 500 501 TNETWIF_TRACE(pTNETWIF->hOs,BusComplete_FUNC,0xFF,0) 502 503 TNETWArb_CallTxnCb (pTNETWIF->hTNETWArb); 504 } 505 506 507 /****************************************************************************** 508 ** ** 509 ** Function Name: TNETWIF_ElpCtrl_Mode ** 510 ** ** 511 ** Description: this function changes the mode of the ElpCtrl ** 512 ** ** 513 ******************************************************************************/ 514 int TNETWIF_ElpCtrl_Mode (TI_HANDLE hTNETWIF, elpCtrl_Mode_e mode) 515 { 516 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 517 518 elpCtrl_Mode (pTNETWIF->hELPCtrl, mode); 519 520 return OK; 521 522 } 523 524 525 /****************************************************************************** 526 ** ** 527 ** Function Name: TNETWIF_ElpCtrl_HostIF_required ** 528 ** ** 529 ** Description: 530 ** ** 531 ******************************************************************************/ 532 int TNETWIF_ElpCtrl_HostIF_required (TI_HANDLE hTNETWIF, int flag) 533 { 534 /* TODO: what is the purpose of this API? */ 535 return OK; 536 } 537 538 539 /****************************************************************************** 540 IO Operations : There are 3 modes of operation: 541 1) Synchronous mode : The caller context is blocked till the Transcation has finished 542 2) Asynchronous mode : The caller context is unblocked and the Transcation will end later by DMA 543 ******************************************************************************/ 544 #ifdef USE_SYNC_API 545 546 /******* Synchronous IO mode **************************************************/ 547 /**************************************************************************** 548 * TNETWIF_WriteMemSync() 549 **************************************************************************** 550 * DESCRIPTION: Request an Synchronous IO with the Bus 551 * 552 * INPUTS: 553 * 554 * OUTPUT: 555 * 556 * RETURNS: 557 ****************************************************************************/ 558 TI_STATUS TNETWIF_WriteMemSync (TI_HANDLE hTNETWIF, UINT32 addr, UINT8* data, UINT32 len) 559 { 560 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 561 int status; 562 563 /* Then Call the HwAccess to operate the I/O */ 564 status = whal_hwAccess_WriteMem (pTNETWIF->hHwAccess, addr, data, len); 565 566 /* The return status could be TNETWIF_COMPLETE in case of Success 567 TNETWIF_ERROR in case of ERROR */ 568 if (status == OK) 569 return TNETWIF_COMPLETE; 570 else 571 return TNETWIF_ERROR; 572 } 573 574 575 /**************************************************************************** 576 * TNETWIF_ReadMemSync() 577 **************************************************************************** 578 * DESCRIPTION: Request an Synchronous IO with the Bus 579 * 580 * INPUTS: 581 * 582 * OUTPUT: 583 * 584 * RETURNS: 585 ****************************************************************************/ 586 TI_STATUS TNETWIF_ReadMemSync (TI_HANDLE hTNETWIF, UINT32 addr, UINT8* data, UINT32 len) 587 { 588 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 589 TI_STATUS status; 590 591 /* Then Call the HwAccess to operate the I/O */ 592 status = (TI_STATUS)whal_hwAccess_ReadMem (pTNETWIF->hHwAccess, addr, data, len); 593 594 /* The return status could be TNETWIF_COMPLETE in case of Success 595 TNETWIF_ERROR in case of ERROR */ 596 return status; 597 } 598 599 600 /**************************************************************************** 601 * TNETWIF_ReadRegSync() 602 **************************************************************************** 603 * DESCRIPTION: Request an Synchronous IO with the Bus 604 * 605 * INPUTS: 606 * 607 * OUTPUT: 608 * 609 * RETURNS: 610 ****************************************************************************/ 611 TI_STATUS TNETWIF_ReadRegSync (TI_HANDLE hTNETWIF, UINT32 addr, UINT32* data) 612 { 613 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 614 TI_STATUS status; 615 616 /* Then Call the HwAccess to operate the I/O */ 617 status = (TI_STATUS)whal_hwAccess_ReadReg (pTNETWIF->hHwAccess, addr, data); 618 619 /* The return status could be TNETWIF_COMPLETE in case of Success 620 TNETWIF_ERROR in case of ERROR */ 621 return status; 622 } 623 624 625 /**************************************************************************** 626 * TNETWIF_WriteRegSync() 627 **************************************************************************** 628 * DESCRIPTION: Request an Synchronous IO with the Bus 629 * 630 * INPUTS: 631 * 632 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR 633 * 634 * RETURNS: 635 ****************************************************************************/ 636 TI_STATUS TNETWIF_WriteRegSync (TI_HANDLE hTNETWIF, UINT32 addr, UINT32 data) 637 { 638 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 639 TI_STATUS status; 640 641 /* Then Call the HwAccess to operate the I/O */ 642 status = (TI_STATUS)whal_hwAccess_WriteReg (pTNETWIF->hHwAccess, addr, data); 643 644 /* The return status could be TNETWIF_COMPLETE in case of Success 645 TNETWIF_ERROR in case of ERROR */ 646 return status; 647 } 648 #endif /* USE_SYNC_API */ 649 650 651 /******* Optimized IO mode : In this mode the SDIO/SPI Driver will decide with its inner thresholds if to make a DMA or not **************************************************/ 652 653 /**************************************************************************** 654 * TNETWIF_ReadMemOpt() 655 **************************************************************************** 656 * DESCRIPTION: Request an Unspecified Read Memory IO with the Bus 657 * Note: Currently, only Sync read is implemented! 658 * 659 * INPUTS: 660 * 661 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR 662 * 663 * RETURNS: 664 ****************************************************************************/ 665 TI_STATUS TNETWIF_ReadMemOpt 666 ( 667 TI_HANDLE hTNETWIF, 668 UINT32 addr, 669 UINT8 *data, 670 UINT32 len, 671 UINT8 module_id, 672 TNETWIF_callback_t fCb, 673 TI_HANDLE hCb) 674 { 675 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 676 677 TNETWIF_TRACE(pTNETWIF->hOs,ReadMem_FUNC,module_id,data) 678 679 /* First Register the Callback to the TNET Arbiter where the DMA DONE Callback will be received */ 680 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 681 682 /* Call the HwAccess to operate the I/O */ 683 return (TI_STATUS)whal_hwAccess_ReadMemAsync (pTNETWIF->hHwAccess, addr, data, len); 684 } 685 686 687 /**************************************************************************** 688 * TNETWIF_WriteMemOpt() 689 **************************************************************************** 690 * DESCRIPTION: Request an Unspecified Write Memory IO with the Bus 691 * 692 * INPUTS: 693 * 694 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR 695 * 696 * RETURNS: 697 ****************************************************************************/ 698 TI_STATUS TNETWIF_WriteMemOpt 699 ( 700 TI_HANDLE hTNETWIF, 701 UINT32 addr, 702 UINT8 *data, 703 UINT32 len, 704 UINT8 module_id, 705 TNETWIF_callback_t fCb, 706 TI_HANDLE hCb) 707 { 708 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 709 710 TNETWIF_TRACE(pTNETWIF->hOs,WriteMem_FUNC,module_id,*(UINT32*)(data + TNETWIF_WRITE_OFFSET_BYTES)) 711 712 /* First Register the Callback to the TNET Arbiter where the DMA DONE Callback will be received */ 713 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 714 715 /* Then Call the HwAccess to operate the I/O */ 716 return whal_hwAccess_WriteMemAsync (pTNETWIF->hHwAccess, addr, data, len); 717 } 718 719 720 /**************************************************************************** 721 * TNETWIF_ReadRegOpt() 722 **************************************************************************** 723 * DESCRIPTION: Request an Unspecified Read Register IO with the Bus 724 * 725 * INPUTS: 726 * 727 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR or TNETWIF_PENDING 728 * 729 * RETURNS: 730 ****************************************************************************/ 731 TI_STATUS TNETWIF_ReadRegOpt (TI_HANDLE hTNETWIF, UINT32 addr, UINT32* data, UINT8 module_id, TNETWIF_callback_t fCb, TI_HANDLE hCb) 732 { 733 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 734 735 TNETWIF_TRACE(pTNETWIF->hOs,ReadReg_FUNC,module_id,data) 736 737 /* First Register the Callback to the TNET Arbiter where the DMA DONE Callback will be received */ 738 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 739 740 /* Call the HwAccess to operate the I/O */ 741 return (TI_STATUS)whal_hwAccess_ReadRegAsync (pTNETWIF->hHwAccess, addr, data); 742 } 743 744 745 /**************************************************************************** 746 * TNETWIF_WriteRegOpt() 747 **************************************************************************** 748 * DESCRIPTION: Request an Unspecified Read Register IO with the Bus 749 * 750 * INPUTS: 751 * 752 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR or TNETWIF_PENDING 753 * 754 * RETURNS: 755 ****************************************************************************/ 756 TI_STATUS TNETWIF_WriteRegOpt (TI_HANDLE hTNETWIF, UINT32 addr, UINT32 data, UINT8 module_id, TNETWIF_callback_t fCb, TI_HANDLE hCb) 757 { 758 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 759 760 TNETWIF_TRACE(pTNETWIF->hOs,WriteReg_FUNC,module_id,data) 761 762 /* First Register the Callback to the TNET Arbiter where the DMA DONE Callback will be received */ 763 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 764 765 /* Then Call the HwAccess to operate the I/O */ 766 return (TI_STATUS)whal_hwAccess_WriteRegAsync (pTNETWIF->hHwAccess, addr, data); 767 } 768 769 #ifdef USE_SYNC_API 770 /**************************************************************************** 771 * TNETWIF_WriteELPSync() 772 **************************************************************************** 773 * DESCRIPTION: Request an Unspecified Read Register IO with the Bus 774 * 775 * INPUTS: 776 * 777 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR or TNETWIF_PENDING 778 * 779 * RETURNS: 780 ****************************************************************************/ 781 TI_STATUS TNETWIF_WriteELPSync (TI_HANDLE hTNETWIF, UINT32 data) 782 { 783 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 784 785 /* Call the HwAccess to operate the I/O */ 786 return (TI_STATUS)whal_hwAccess_WriteELP (pTNETWIF->hHwAccess, data); 787 } 788 #endif /* USE_SYNC_API */ 789 790 791 /**************************************************************************** 792 * TNETWIF_WriteELPOpt() 793 **************************************************************************** 794 * DESCRIPTION: Request an Unspecified Read Register IO with the Bus 795 * 796 * INPUTS: bMore - indicate whether more txn on the bus are about to happen 797 * 798 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR or TNETWIF_PENDING 799 * 800 * RETURNS: 801 ****************************************************************************/ 802 TI_STATUS TNETWIF_WriteELPOpt (TI_HANDLE hTNETWIF, UINT32 data, UINT8 module_id, TNETWIF_callback_t fCb, TI_HANDLE hCb, BOOL bMore) 803 { 804 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 805 806 TNETWIF_TRACE(pTNETWIF->hOs,WriteElp_FUNC,module_id,data) 807 808 /* Register a callback */ 809 if(fCb) 810 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 811 812 /* Call the HwAccess to operate the I/O */ 813 return (TI_STATUS)whal_hwAccess_WriteELPAsync (pTNETWIF->hHwAccess, data, fCb != NULL, bMore); 814 } 815 816 /**************************************************************************** 817 * TNETWIF_ReadELPOpt() 818 **************************************************************************** 819 * DESCRIPTION: Request an Unspecified Read Register IO with the Bus 820 * 821 * INPUTS: bMore - indicate whether more txn on the bus are about to happen 822 * 823 * OUTPUT: TI_STATUS TNETWIF_COMPLETE or TNETWIF_ERROR or TNETWIF_PENDING 824 * 825 * RETURNS: 826 ****************************************************************************/ 827 TI_STATUS TNETWIF_ReadELPOpt (TI_HANDLE hTNETWIF, UINT8 *data, UINT8 module_id, TNETWIF_callback_t fCb, TI_HANDLE hCb, BOOL bMore) 828 { 829 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 830 831 TNETWIF_TRACE(pTNETWIF->hOs,ReadElp_FUNC,module_id,data) 832 833 /* Register a callback */ 834 if(fCb) 835 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 836 837 /* Call the HwAccess to operate the I/O */ 838 return (TI_STATUS)whal_hwAccess_ReadELPAsync (pTNETWIF->hHwAccess, data, fCb != NULL, bMore); 839 } 840 841 842 /***************************************************************************************************** 843 * Registers API : All the following API are synchronous only and the return value can be: 844 ** TNEDTWIF_ERROR - In case the action did not succeed 845 ** TNETWIF_COMPLETE - In case the action succeeded 846 847 *******************************************************************************************************/ 848 #ifdef USE_SYNC_API 849 /**************************************************************************** 850 * TNETWIF_GetU08() 851 **************************************************************************** 852 * DESCRIPTION: Request an U8 Value from the Hw Access 853 * 854 * INPUTS: 855 * 856 * OUTPUT: String the name of the Queue 857 * 858 * RETURNS: 859 ****************************************************************************/ 860 UINT8 TNETWIF_GetU08 (TI_HANDLE hTNETWIF, UINT32 Addr) 861 { 862 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 863 UINT8 Value; 864 865 Value = whal_hwAccess_GetU08 (pTNETWIF->hHwAccess, Addr); 866 867 return Value; 868 869 } 870 871 872 /**************************************************************************** 873 * TNETWIF_SetU08() 874 **************************************************************************** 875 * DESCRIPTION: Set an U8 Value from the Hw Access 876 * 877 * INPUTS: 878 * 879 * OUTPUT: String the name of the Queue 880 * 881 * RETURNS: 882 ****************************************************************************/ 883 void TNETWIF_SetU08 (TI_HANDLE hTNETWIF, UINT32 Addr, UINT8 Val) 884 { 885 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 886 887 whal_hwAccess_SetU08 (pTNETWIF->hHwAccess, Addr, Val); 888 } 889 890 891 void TNETWIF_ResetU08_Bits (TI_HANDLE hTNETWIF, UINT32 Addr, UINT8 BitsVal) 892 { 893 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 894 895 whal_hwAccess_ResetU08_Bits (pTNETWIF->hHwAccess, Addr, BitsVal); 896 897 } 898 899 900 UINT16 TNETWIF_GetU16 (TI_HANDLE hTNETWIF, UINT32 Addr) 901 { 902 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 903 UINT16 U16Value; 904 905 U16Value = whal_hwAccess_GetU16 (pTNETWIF->hHwAccess,Addr); 906 907 return U16Value; 908 } 909 910 911 void TNETWIF_SetU16 (TI_HANDLE hTNETWIF, UINT32 Addr, UINT16 Val) 912 { 913 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 914 915 whal_hwAccess_SetU16 (pTNETWIF->hHwAccess, Addr, Val); 916 } 917 918 919 void TNETWIF_SetU16_Bits (TI_HANDLE hTNETWIF, UINT32 Addr, UINT16 BitsVal) 920 { 921 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 922 923 whal_hwAccess_SetU16_Bits (pTNETWIF->hHwAccess,Addr,BitsVal); 924 } 925 926 927 void TNETWIF_ResetU16_Bits (TI_HANDLE hTNETWIF, UINT32 Addr, UINT16 BitsVal) 928 { 929 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 930 931 whal_hwAccess_ResetU16_Bits (pTNETWIF->hHwAccess, Addr, BitsVal); 932 } 933 934 935 UINT32 TNETWIF_GetU32 (TI_HANDLE hTNETWIF, UINT32 Addr) 936 { 937 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 938 UINT32 U32Value; 939 940 U32Value = whal_hwAccess_GetU32 (pTNETWIF->hHwAccess, Addr); 941 942 return U32Value; 943 } 944 945 946 void TNETWIF_SetU32 (TI_HANDLE hTNETWIF, UINT32 Addr, UINT32 Val) 947 { 948 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 949 950 whal_hwAccess_SetU32 (pTNETWIF->hHwAccess ,Addr, Val); 951 952 } 953 954 955 void TNETWIF_SetU32_Bits (TI_HANDLE hTNETWIF, UINT32 Addr, UINT32 BitsVal) 956 { 957 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 958 959 whal_hwAccess_SetU32_Bits (pTNETWIF->hHwAccess, Addr, BitsVal); 960 961 } 962 963 964 void TNETWIF_ResetU32_Bits (TI_HANDLE hTNETWIF, UINT32 Addr, UINT32 BitsVal) 965 { 966 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 967 968 whal_hwAccess_ResetU32_Bits (pTNETWIF->hHwAccess, Addr, BitsVal); 969 970 } 971 972 973 /* 974 * Hardware Registers Api 975 */ 976 void TNETWIF_RegSetBitVal (TI_HANDLE hTNETWIF, UINT32 RegAddr, UINT32 BitVal) 977 { 978 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 979 980 whal_hwAccess_RegSetBitVal (pTNETWIF->hHwAccess, RegAddr, BitVal); 981 982 } 983 984 985 void TNETWIF_RegResetBitVal (TI_HANDLE hTNETWIF, UINT32 RegAddr, UINT32 BitVal) 986 { 987 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 988 989 whal_hwAccess_RegResetBitVal (pTNETWIF->hHwAccess, RegAddr, BitVal); 990 991 } 992 993 994 int TNETWIF_RegIsBitSet (TI_HANDLE hTNETWIF, UINT32 RegAddr, UINT32 BitVal) 995 { 996 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 997 int status; 998 999 status = whal_hwAccess_RegIsBitSet (pTNETWIF->hHwAccess, RegAddr, BitVal); 1000 return status; 1001 } 1002 1003 #endif /* USE_SYNC_API */ 1004 1005 1006 /*********************************************************************************** 1007 ** Client implementation 1008 ***********************************************************************************/ 1009 /****************************************************************************** 1010 ** ** 1011 ** Function Name: gwsi_rx_start_instance ** 1012 ** ** 1013 ** Description: GWSI Rx Data Path Start Instance. ** 1014 ** ** 1015 ******************************************************************************/ 1016 void TNETWIF_rx_start_instance (TI_HANDLE CB_Handle, TI_HANDLE module_id, TI_STATUS status) 1017 { 1018 /* WLAN_REPORT_ERROR (GWSI_handle->hReport, TNETW_IF_MODULE_LOG, 1019 ("\n gwsi_rx_start_instance() : Not implemented Yet !!! \n\n"));*/ 1020 1021 return; 1022 } 1023 1024 1025 #ifdef USE_SYNC_API 1026 1027 TI_STATUS TNETWIF_SetPartitions (TI_HANDLE hTNETWIF, TNETIF_HwAccess_SetPartition_mode_e partitionMode, UINT32 partition_start) 1028 { 1029 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 1030 1031 return (TI_STATUS)whal_hwAccess_SetPartitions (pTNETWIF->hHwAccess, partitionMode, partition_start); 1032 } 1033 1034 #endif /* USE_SYNC_API */ 1035 1036 1037 TI_STATUS TNETWIF_SetPartitionsOpt (TI_HANDLE hTNETWIF, TNETIF_HwAccess_SetPartition_mode_e partitionMode, UINT32 partition_start, UINT8 module_id, TNETWIF_callback_t fCb, TI_HANDLE hCb) 1038 { 1039 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 1040 1041 /* Register a callback */ 1042 TNETWArb_register_handler (pTNETWIF->hTNETWArb, module_id, fCb, hCb); 1043 1044 return (TI_STATUS)whal_hwAccess_SetPartitionsAsync (pTNETWIF->hHwAccess, partitionMode, partition_start); 1045 } 1046 1047 1048 /**************************************************************************************** 1049 * TNETWIF_RegisterFailureEventCB * 1050 **************************************************************************************** 1051 DESCRIPTION: Registers a failure event callback to the elp controler. 1052 1053 1054 INPUT: - hTNETWIF - handle to the TNETWIF object. 1055 - failureEventCB - the failure event callback function.\n 1056 - hFailureEventObj - handle to the object passed to the failure event callback function. 1057 1058 OUTPUT: 1059 RETURN: void. 1060 ****************************************************************************************/ 1061 1062 void TNETWIF_RegisterFailureEventCB (TI_HANDLE hTNETWIF, 1063 void *failureEventCB, 1064 TI_HANDLE hFailureEventObj ) 1065 { 1066 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 1067 1068 elpCtrl_RegisterFailureEventCB (pTNETWIF->hELPCtrl, failureEventCB, hFailureEventObj); 1069 } 1070 1071 1072 /**************************************************************************************** 1073 * TNETWIF_RegisterBusFailureEventCB * 1074 **************************************************************************************** 1075 DESCRIPTION: Registers a failure event to the hal ctrl for case of SDIO bus fail. 1076 1077 1078 INPUT: - hTNETWIF - handle to the TNETWIF object. 1079 - failureEventCB - the failure event callback function.\n 1080 - hFailureEventObj - handle to the object passed to the failure event callback function. 1081 1082 OUTPUT: 1083 RETURN: void. 1084 ****************************************************************************************/ 1085 1086 void TNETWIF_RegisterBusFailureEventCB (TI_HANDLE hTNETWIF, 1087 void *failureEventCB, 1088 TI_HANDLE hFailureEventObj) 1089 { 1090 TNETWIF_t *pTNETWIF = (TNETWIF_t *)hTNETWIF; 1091 whal_hwAccess_RegisterForErrorCB (pTNETWIF->hHwAccess, failureEventCB, hFailureEventObj); 1092 1093 } 1094 1095 /**************************************************************************** 1096 * TNETWIF_ModuleIdToString() 1097 **************************************************************************** 1098 * DESCRIPTION: Convert the module ID to the Name of the module in string 1099 * 1100 * INPUTS: UINT32 module_id 1101 * 1102 * OUTPUT: String the name of the module 1103 * 1104 * RETURNS: 1105 ****************************************************************************/ 1106 char* TNETWIF_ModuleIdToString(UINT32 module_id) 1107 { 1108 switch (module_id) 1109 { 1110 case DEFAULT_MODULE_ID: return "(DEFAULT_MODULE_ID) "; 1111 case TX_XFER_MODULE_ID: return "(TX_XFER_MODULE_ID) "; 1112 case HAL_RX_MODULE_ID: return "(HAL_RX_MODULE_ID ) "; 1113 case HAL_INT_MODULE_ID: return "(HAL_INT_MODULE_ID) "; 1114 case HAL_CMD_MODULE_ID: return "(HAL_CMD_MODULE_ID ) "; 1115 case FW_EVENT_MODULE_ID: return "(FW_EVENT_MODULE_ID) "; 1116 case HAL_INIT_MODULE_ID: return "(HAL_INIT_MODULE_ID )"; 1117 1118 default : 1119 return "(NOT_SUPPORTED) "; 1120 } 1121 1122 } 1123 1124
