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 59typedef 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 75typedef 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 */ 88UINT8 uDebugCounter ; 89TTNETWIF_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*****************************************************************************/ 101char* 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*****************************************************************************/ 124void 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) 142void TNETWIF_printErrorLog(void) { WLAN_OS_REPORT(("%s define TNETWIF_DEBUG to debug error\n",__FUNCTION__)); } 143 144#endif 145 146extern 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 ****************************************************************************/ 166TI_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 ****************************************************************************/ 204TI_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 ****************************************************************************/ 236static 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 ****************************************************************************/ 343TI_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 ****************************************************************************/ 384TI_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 ****************************************************************************/ 408TI_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 ****************************************************************************/ 433TI_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 ****************************************************************************/ 458TI_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******************************************************************************/ 478TI_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******************************************************************************/ 497void 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******************************************************************************/ 514int 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******************************************************************************/ 532int 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 ****************************************************************************/ 558TI_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 ****************************************************************************/ 586TI_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 ****************************************************************************/ 611TI_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 ****************************************************************************/ 636TI_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 ****************************************************************************/ 665TI_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 ****************************************************************************/ 698TI_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 ****************************************************************************/ 731TI_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 ****************************************************************************/ 756TI_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 ****************************************************************************/ 781TI_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 ****************************************************************************/ 802TI_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 ****************************************************************************/ 827TI_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 ****************************************************************************/ 860UINT8 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 ****************************************************************************/ 883void 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 891void 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 900UINT16 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 911void 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 919void 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 927void 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 935UINT32 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 946void 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 955void 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 964void 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 */ 976void 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 985void 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 994int 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******************************************************************************/ 1016void 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 1027TI_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 1037TI_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 **************************************************************************************** 1051DESCRIPTION: Registers a failure event callback to the elp controler. 1052 1053 1054INPUT: - 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 1058OUTPUT: 1059RETURN: void. 1060****************************************************************************************/ 1061 1062void 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 **************************************************************************************** 1075DESCRIPTION: Registers a failure event to the hal ctrl for case of SDIO bus fail. 1076 1077 1078INPUT: - 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 1082OUTPUT: 1083RETURN: void. 1084****************************************************************************************/ 1085 1086void 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****************************************************************************/ 1106char* 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