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 *****************************************************************************/
TNETWIF_FuncEnumToString(ETNETIF_Functions eFunc)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 *****************************************************************************/
TNETWIF_printErrorLog(void)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)
TNETWIF_printErrorLog(void)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 ****************************************************************************/
TNETWIF_Create(TI_HANDLE hOs)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 ****************************************************************************/
TNETWIF_Destroy(TI_HANDLE hTNETWIF)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 ****************************************************************************/
TNETWIF_ConfigCb(TI_HANDLE hTNETWIF,UINT8 module_id,TI_STATUS status)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 ****************************************************************************/
TNETWIF_Config(TI_HANDLE hTNETWIF,TI_HANDLE hReport,UINT32 uRegBaseAddr,UINT32 uMemBaseAddr,TNETWIF_callback_t fCb,TI_HANDLE hCb)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 ****************************************************************************/
TNETWIF_ReConfig(TI_HANDLE hTNETWIF)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 ****************************************************************************/
TNETWIF_Start(TI_HANDLE hTNETWIF,UINT8 module_id,TI_HANDLE hCb,TNETWIF_callback_t fCb)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 ****************************************************************************/
TNETWIF_Restart(TI_HANDLE hTNETWIF,UINT8 module_id,TI_HANDLE hCb,TNETWIF_callback_t fCb)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 ****************************************************************************/
TNETWIF_Finish(TI_HANDLE hTNETWIF,UINT8 module_id,TI_HANDLE hCb,TNETWIF_callback_t fCb)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 ******************************************************************************/
TNETWIF_UnMux(TI_HANDLE hTNETWIF)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 ******************************************************************************/
TNETWIF_BusTxn_Complete(TI_HANDLE hTNETWIF)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 ******************************************************************************/
TNETWIF_ElpCtrl_Mode(TI_HANDLE hTNETWIF,elpCtrl_Mode_e mode)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 ******************************************************************************/
TNETWIF_ElpCtrl_HostIF_required(TI_HANDLE hTNETWIF,int flag)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 ****************************************************************************/
TNETWIF_WriteMemSync(TI_HANDLE hTNETWIF,UINT32 addr,UINT8 * data,UINT32 len)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 ****************************************************************************/
TNETWIF_ReadMemSync(TI_HANDLE hTNETWIF,UINT32 addr,UINT8 * data,UINT32 len)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 ****************************************************************************/
TNETWIF_ReadRegSync(TI_HANDLE hTNETWIF,UINT32 addr,UINT32 * data)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 ****************************************************************************/
TNETWIF_WriteRegSync(TI_HANDLE hTNETWIF,UINT32 addr,UINT32 data)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 ****************************************************************************/
TNETWIF_ReadMemOpt(TI_HANDLE hTNETWIF,UINT32 addr,UINT8 * data,UINT32 len,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb)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 ****************************************************************************/
TNETWIF_WriteMemOpt(TI_HANDLE hTNETWIF,UINT32 addr,UINT8 * data,UINT32 len,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb)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 ****************************************************************************/
TNETWIF_ReadRegOpt(TI_HANDLE hTNETWIF,UINT32 addr,UINT32 * data,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb)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 ****************************************************************************/
TNETWIF_WriteRegOpt(TI_HANDLE hTNETWIF,UINT32 addr,UINT32 data,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb)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 ****************************************************************************/
TNETWIF_WriteELPSync(TI_HANDLE hTNETWIF,UINT32 data)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 ****************************************************************************/
TNETWIF_WriteELPOpt(TI_HANDLE hTNETWIF,UINT32 data,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb,BOOL bMore)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 ****************************************************************************/
TNETWIF_ReadELPOpt(TI_HANDLE hTNETWIF,UINT8 * data,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb,BOOL bMore)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 ****************************************************************************/
TNETWIF_GetU08(TI_HANDLE hTNETWIF,UINT32 Addr)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 ****************************************************************************/
TNETWIF_SetU08(TI_HANDLE hTNETWIF,UINT32 Addr,UINT8 Val)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
TNETWIF_ResetU08_Bits(TI_HANDLE hTNETWIF,UINT32 Addr,UINT8 BitsVal)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
TNETWIF_GetU16(TI_HANDLE hTNETWIF,UINT32 Addr)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
TNETWIF_SetU16(TI_HANDLE hTNETWIF,UINT32 Addr,UINT16 Val)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
TNETWIF_SetU16_Bits(TI_HANDLE hTNETWIF,UINT32 Addr,UINT16 BitsVal)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
TNETWIF_ResetU16_Bits(TI_HANDLE hTNETWIF,UINT32 Addr,UINT16 BitsVal)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
TNETWIF_GetU32(TI_HANDLE hTNETWIF,UINT32 Addr)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
TNETWIF_SetU32(TI_HANDLE hTNETWIF,UINT32 Addr,UINT32 Val)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
TNETWIF_SetU32_Bits(TI_HANDLE hTNETWIF,UINT32 Addr,UINT32 BitsVal)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
TNETWIF_ResetU32_Bits(TI_HANDLE hTNETWIF,UINT32 Addr,UINT32 BitsVal)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 */
TNETWIF_RegSetBitVal(TI_HANDLE hTNETWIF,UINT32 RegAddr,UINT32 BitVal)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
TNETWIF_RegResetBitVal(TI_HANDLE hTNETWIF,UINT32 RegAddr,UINT32 BitVal)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
TNETWIF_RegIsBitSet(TI_HANDLE hTNETWIF,UINT32 RegAddr,UINT32 BitVal)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 ******************************************************************************/
TNETWIF_rx_start_instance(TI_HANDLE CB_Handle,TI_HANDLE module_id,TI_STATUS status)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
TNETWIF_SetPartitions(TI_HANDLE hTNETWIF,TNETIF_HwAccess_SetPartition_mode_e partitionMode,UINT32 partition_start)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
TNETWIF_SetPartitionsOpt(TI_HANDLE hTNETWIF,TNETIF_HwAccess_SetPartition_mode_e partitionMode,UINT32 partition_start,UINT8 module_id,TNETWIF_callback_t fCb,TI_HANDLE hCb)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
TNETWIF_RegisterFailureEventCB(TI_HANDLE hTNETWIF,void * failureEventCB,TI_HANDLE hFailureEventObj)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
TNETWIF_RegisterBusFailureEventCB(TI_HANDLE hTNETWIF,void * failureEventCB,TI_HANDLE hFailureEventObj)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 ****************************************************************************/
TNETWIF_ModuleIdToString(UINT32 module_id)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