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#ifdef TI_DBG
37
38#include "FwEvent_api.h"
39#include "whalParams.h"
40#include "DebugTraceXfer_api.h"
41#include "report.h"
42#include "whalBus_Defs.h"
43#include "TNETWIF.h"
44#include "utils.h"
45#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
46#include "memMngrEx.h"
47#endif
48#include "whalCommon.h"
49
50
51
52/*****************************************************************************
53 **         UDP Packet Build                                                **
54 *****************************************************************************/
55#define Ether_Type  0x0800  /* For IP Protocol */
56
57 /* This is an Ethernet Version 2 frame: 14 Byte */
58typedef struct {
59  UINT8    ether_dst[6];
60  UINT8    ether_src[6];
61  UINT16   ether_Type;
62} etherHeader;
63
64
65#define IP_Version    0x45   /* IP Ver - 4 Length Of IP Header 5 UINT32 (20 Byte) */
66#define IP_TimeToLive 128    /* limit the number of Router Hops  */
67#define IP_Protocol   0x11   /* UDP protocol */
68
69 /* This is an IP frame: 20 Byte */
70typedef struct
71{
72    UINT8   IpVer;
73    UINT8   TypeOfService;
74    UINT16  Totallen;
75    UINT16  Indentification;
76    UINT16  FragOffset;
77    UINT8   TimeToLive;
78    UINT8   protocol;
79    UINT16  csum;
80    UINT8   src[4];
81    UINT8   dst[4];
82} ipstruct;
83
84#define Source_Port 0
85#define Destination_Port 5555
86
87 /* This is a UDP frame: 8 Byte */
88typedef struct {
89  UINT16    src_port;
90  UINT16    dst_port;
91  UINT16    UDP_len;
92  UINT16    UDP_Csum;
93} UDPStruct;
94
95 /* This is a Trace Frame:*/
96#pragma pack(1)
97typedef struct {
98  etherHeader  Ether_Header;
99  ipstruct     IP_Header;
100  UDPStruct    UDP_Header;
101} TraceFrame;
102#pragma pack()
103
104/*****************************************************************************
105 **         Structures                                                      **
106 *****************************************************************************/
107typedef enum
108{
109    DEBUG_TRACE_STATE_IDLE,
110    DEBUG_TRACE_STATE_READ_BUF,
111    DEBUG_TRACE_STATE_ACK_EVENT
112} debugTraceState_e;
113/*
114 *  DebugTraceXfer: The Debug Trace Object
115 */
116typedef struct
117{
118    TraceFrame      FrameHeader; /* Do Not Change Place */
119
120    /* use a struct to read buffers from the bus - used for extra bytes reserving */
121    PADDING (UINT32  debugWords[TRACE_BUFFER_MAX_SIZE * 2])   /* *2 for the 2 buffers */
122
123    BOOL            bDoPrint;
124    BOOL            bUdpSend;
125    BOOL            bSync;  /* indicate if we are in Synch bus or not */
126
127    UINT32          TraceBufferSize;
128
129    UINT32          BufferOffset[2];    /* holds the offset of Buffer A and Buffer B */
130    UINT8           currBuffer;         /* switch between 0 and 1 according to the buffer used */
131
132    debugTraceState_e state;
133    TI_STATUS       returnValue;
134
135    TI_HANDLE       hOs;
136    TI_HANDLE       hReport;
137    TI_HANDLE       hFwEvent;
138    TI_HANDLE       hMemMgr;
139    TI_HANDLE       hTNETWIF;
140} DebugTrace_t;
141
142/****************************************************************************
143 *                      static function declaration
144 ****************************************************************************/
145#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
146static void debugTrace_BuildFrame(DebugTrace_t *pDebugTrace, UINT8* MacAddress);
147#endif
148static void debugTrace_StateMachine(TI_HANDLE hDebugTrace,UINT8 module_id ,TI_STATUS status);
149
150/****************************************************************************
151 *                      debugTrace_Create()
152 *****************************************************************************
153 * DESCRIPTION: Create
154 *
155 * INPUTS:
156 *
157 * RETURNS:
158 *
159 *****************************************************************************/
160TI_HANDLE debugTrace_Create(TI_HANDLE hOs)
161{
162    DebugTrace_t *pDebugTrace;
163
164    pDebugTrace = os_memoryAlloc(hOs, sizeof(DebugTrace_t));
165    if (pDebugTrace == NULL)
166    {
167        WLAN_OS_REPORT(("debugTrace_Create: Error Creating Trace Buffer \n"));
168        return NULL;
169    }
170
171    os_memoryZero(hOs, pDebugTrace, sizeof(DebugTrace_t));
172
173    pDebugTrace->hOs = hOs;
174
175    return((TI_HANDLE)pDebugTrace);
176}
177
178/****************************************************************************
179 *                      debugTrace_Destroy()
180 *****************************************************************************
181 * DESCRIPTION: Destroy
182 *
183 * INPUTS:
184 *
185 * RETURNS:
186 *
187 *****************************************************************************/
188void debugTrace_Destroy(TI_HANDLE hDebugTrace)
189{
190    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
191
192    if (pDebugTrace)
193    {
194        os_memoryFree(pDebugTrace->hOs, pDebugTrace, sizeof(DebugTrace_t));
195    }
196}
197
198/****************************************************************************
199 *                      debugTrace_Config()
200 *****************************************************************************
201 * DESCRIPTION: Config
202 *
203 * INPUTS:
204 *
205 * RETURNS:
206 *
207 *****************************************************************************/
208void debugTrace_Config(TI_HANDLE hDebugTrace, TI_HANDLE hWhalParams, TI_HANDLE hReport,
209                        TI_HANDLE hMemMgr, TI_HANDLE hTNETWIF, TI_HANDLE hFwEvent)
210{
211    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
212
213    pDebugTrace->hReport  = hReport;
214    pDebugTrace->hMemMgr  = hMemMgr;
215    pDebugTrace->hTNETWIF = hTNETWIF;
216    pDebugTrace->hFwEvent = hFwEvent;
217
218    /* next 2 parameters are TRUE & FALSE by default but can be changed in run time */
219    pDebugTrace->bUdpSend  = FALSE;
220    pDebugTrace->bDoPrint  = TRUE;
221    pDebugTrace->TraceBufferSize = whal_ParamsGetTraceBufferSize(hWhalParams);
222    pDebugTrace->currBuffer = 0;
223
224#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
225    /* Build Frame to be send to the OS */
226    debugTrace_BuildFrame(pDebugTrace, whal_ParamsGetSrcMac(hWhalParams));
227#endif
228
229    /* Enable Trace Interrupts  - actual interrupts will be raised only after init phase */
230    FwEvent_Enable(pDebugTrace->hFwEvent, ACX_INTR_TRACE_A);
231    FwEvent_Enable(pDebugTrace->hFwEvent, ACX_INTR_TRACE_B);
232}
233
234 /****************************************************************************
235 *                      debugTrace_ConfigHw()
236 *****************************************************************************
237 * DESCRIPTION: Initialize the address to read the buffer from the FW
238 *
239 * INPUTS:  hDebugTrace - Debug Trace object
240 *
241 * RETURNS:
242 *
243 *****************************************************************************/
244void debugTrace_ConfigHw(TI_HANDLE hDebugTrace,UINT32 TraceAddA, UINT32 TraceAddB)
245{
246    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
247
248    pDebugTrace->BufferOffset[0] = TraceAddA;
249    pDebugTrace->BufferOffset[1] = TraceAddB;
250
251    WLAN_REPORT_INIT(pDebugTrace->hReport, HAL_HW_CTRL_MODULE_LOG,
252        ("debugTrace_ConfigHw: Buffer A offSet =0x%x, Buffer B offSet =0x%x, TraceBufferSize = %d \n"
253        ,pDebugTrace->BufferOffset[0], pDebugTrace->BufferOffset[1],pDebugTrace->TraceBufferSize));
254
255}
256
257/****************************************************************************
258 *                      debugTrace_Event()
259 *****************************************************************************
260 * DESCRIPTION: Called upon an interrupt of debug trace kind.
261 *
262 * INPUTS:  hDebugTrace - Debug Trace object
263 *
264 * RETURNS:
265 *
266 *****************************************************************************/
267TI_STATUS debugTrace_Event(TI_HANDLE hDebugTrace)
268{
269    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
270
271    WLAN_REPORT_INFORMATION(pDebugTrace->hReport, HAL_HW_CTRL_MODULE_LOG,
272        (" debugTrace_Event: Reading from Buffer %d \n",pDebugTrace->currBuffer));
273
274    /* assume that we are in synch bus until otherwise is proven */
275    pDebugTrace->bSync = TRUE;
276
277    debugTrace_StateMachine(pDebugTrace,0,(TI_STATUS)0);
278
279    return pDebugTrace->returnValue;
280}
281
282
283/****************************************************************************
284 *                      debugTrace_StateMachine()
285 ****************************************************************************
286 * DESCRIPTION: Manage the Debug trace state machine
287 *
288 *              The SM is running one event at a time (buffer A or B) .
289 *              The order of the states is always the same: IDLE --> READ_BUF --> ACK_EVENT
290 *              The difference is whether we are using Synch or Asynch API.
291 *              In the Synch case (SDIO) we are looping in the while-loop till we return to IDLE, and we return
292 *              to FwEvent module a TNETWIF_OK status.
293 *              In the Asynch case we use the SM CB to return to the SM after each Asynch call
294 *              (In that case the return status is TNETWIF_PENDING, and we are waiting for the CB).
295 *              In the Asynch case the FwEvent module gets TNETWIF_PENDING in return, and waits for
296 *              the FwEvent_EventComplete() call in order to move the FwEvent SM.
297 *
298 * INPUTS:  hFwEvent - The object
299 *          module_id - not used (for CB API only)
300 *          status    - not used (for CB API only)
301 *
302 * OUTPUT:  None
303 *
304 * RETURNS: TNETWIF_PENDING in case of Async and TNETWIF_OK on Sync
305 ****************************************************************************/
306static void debugTrace_StateMachine(TI_HANDLE hDebugTrace,UINT8 module_id ,TI_STATUS status)
307{
308    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
309
310    pDebugTrace->returnValue = OK;
311
312    while(pDebugTrace->returnValue != TNETWIF_PENDING)
313    {
314        switch(pDebugTrace->state)
315        {
316            case DEBUG_TRACE_STATE_IDLE:
317
318                pDebugTrace->returnValue = TNETWIF_ReadMemOpt (pDebugTrace->hTNETWIF,
319                                                               pDebugTrace->BufferOffset[pDebugTrace->currBuffer],
320                                                               PADREAD (pDebugTrace->debugWords),
321                                                               pDebugTrace->TraceBufferSize,
322                                                               FW_EVENT_MODULE_ID,
323                                                               debugTrace_StateMachine,
324                                                               pDebugTrace);
325
326                pDebugTrace->state = DEBUG_TRACE_STATE_READ_BUF;
327
328                break;
329
330            case DEBUG_TRACE_STATE_READ_BUF:
331                /* Now, handle the buffer */
332                /* Print on every Trace */
333                if(pDebugTrace->bDoPrint)
334                {
335                    debugTrace_Print(pDebugTrace);
336                }
337
338#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
339                /* Handle The Trace */
340                if(pDebugTrace->bUdpSend)
341                {
342                    debugTrace_handleBuffer(hDebugTrace);
343                }
344#endif
345
346                /*Trigger the FW when finishing handle the event */
347                pDebugTrace->returnValue = TNETWIF_WriteRegOpt(pDebugTrace->hTNETWIF, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_DEBUG_ACK,
348                                                FW_EVENT_MODULE_ID,debugTrace_StateMachine,pDebugTrace);
349
350                pDebugTrace->state = DEBUG_TRACE_STATE_ACK_EVENT;
351
352                break;
353
354            case DEBUG_TRACE_STATE_ACK_EVENT:
355
356                /* Handling of the event is done. Now switch to the next buffer for the next time */
357                pDebugTrace->currBuffer = (++pDebugTrace->currBuffer) & 0x1; /* &0x1 is %2 */
358
359                if (FALSE  == pDebugTrace->bSync )
360                {
361                    /* Async bus - call FwEvent for notifying the completion */
362                    FwEvent_EventComplete(pDebugTrace->hFwEvent, TNETWIF_OK);
363                }
364                else    /* This is the Sync case and we return TNETWIF_OK */
365                {
366                    pDebugTrace->returnValue = TNETWIF_OK;
367                }
368                /* Exit SM */
369                pDebugTrace->state = DEBUG_TRACE_STATE_IDLE;
370                return;
371
372/*                break; */
373
374            default:
375                WLAN_REPORT_ERROR(pDebugTrace->hReport, HAL_HW_CTRL_MODULE_LOG,
376                    ("debugTrace_StateMachine: unKnown state !!!\n"));
377
378                break;
379        }
380    }
381    /* if we are here - we got TNETWIF_PENDING, so we are in Async mode */
382    pDebugTrace->bSync = FALSE;
383
384    if (pDebugTrace->returnValue == TNETWIF_ERROR)
385    {
386        WLAN_REPORT_ERROR(pDebugTrace->hReport, HAL_HW_CTRL_MODULE_LOG,
387                ("debugTrace_StateMachine: rc = TNETWIF_ERROR in state %d  \n",pDebugTrace->state));
388    }
389}
390
391 /****************************************************************************
392 *                      debugTrace_Disable()
393 *****************************************************************************
394 * DESCRIPTION: disable receiving interrupts of this kind (debug trace)
395 *
396 * INPUTS:  hDebugTrace - Debug Trace object
397 *
398 * RETURNS:
399 *
400 *****************************************************************************/
401void debugTrace_Disable(TI_HANDLE hDebugTrace)
402{
403    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
404
405    FwEvent_Disable(pDebugTrace->hFwEvent, ACX_INTR_TRACE_A);
406    FwEvent_Disable(pDebugTrace->hFwEvent, ACX_INTR_TRACE_B);
407
408    WLAN_REPORT_INFORMATION(pDebugTrace->hReport, HAL_HW_CTRL_MODULE_LOG,
409                            ("whal_DebugTrace_t_Disable: Trace Disable \n"));
410
411}
412
413 /****************************************************************************
414 *                      debugTrace_Enable()
415 *****************************************************************************
416 * DESCRIPTION: Enables receiving interrupts of this kind (debug trace)
417 *
418 * INPUTS:  hDebugTrace - Debug Trace object
419 *
420 * RETURNS:
421 *
422 *****************************************************************************/
423void debugTrace_Enable(TI_HANDLE hDebugTrace)
424{
425    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
426
427    FwEvent_Enable(pDebugTrace->hFwEvent, ACX_INTR_TRACE_A);
428    FwEvent_Enable(pDebugTrace->hFwEvent, ACX_INTR_TRACE_B);
429
430    WLAN_REPORT_INFORMATION(pDebugTrace->hReport, HAL_CTRL_MODULE_LOG,
431                            ("whal_DebugTrace_tEnable: Trace Enable \n"));
432}
433
434 /****************************************************************************
435 *                      debugTrace_Print()
436 *****************************************************************************
437 * DESCRIPTION: Print the current buffer
438 *
439 * INPUTS:  hDebugTrace - Debug Trace object
440 *
441 * RETURNS:
442 *
443 *****************************************************************************/
444void debugTrace_Print(TI_HANDLE hDebugTrace)
445{
446    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
447
448    UINT32 index;
449
450    WLAN_OS_REPORT(("Trace buffer size = %d\n",pDebugTrace->TraceBufferSize));
451
452    for(index = 0; index < pDebugTrace->TraceBufferSize / 4 ; index+=2)
453    {
454        WLAN_OS_REPORT(("0x%08X 0x%08X\n",
455                        pDebugTrace->debugWords[index],
456                        pDebugTrace->debugWords[index+1]));
457    }
458}
459
460 /****************************************************************************
461 *                      debugTrace_EnablePrint()
462 *****************************************************************************
463 * DESCRIPTION: enable printing on each interrupt
464 *
465 * INPUTS:  hDebugTrace - Debug Trace object
466 *
467 * RETURNS:
468 *
469 *****************************************************************************/
470void debugTrace_EnablePrint(TI_HANDLE hDebugTrace)
471{
472    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
473
474    pDebugTrace->bDoPrint = TRUE;
475
476    WLAN_OS_REPORT(("whal_DebugTrace_t_EnablePrint: Print Enabled \n"));
477
478}
479
480 /****************************************************************************
481 *                      debugTrace_DisablePrint()
482 *****************************************************************************
483 * DESCRIPTION: disable printing on each interrupt
484 *
485 * INPUTS:  hDebugTrace - Debug Trace object
486 *
487 * RETURNS:
488 *
489 *****************************************************************************/
490void debugTrace_DisablePrint(TI_HANDLE hDebugTrace)
491{
492    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
493
494    pDebugTrace->bDoPrint = FALSE;
495
496    WLAN_OS_REPORT(("whal_DebugTrace_t_DisablePrint: Print Disabled \n"));
497
498}
499
500 /****************************************************************************
501 *                      debugTrace_UdpEnable()
502 *****************************************************************************
503 * DESCRIPTION: enable sending udp on each interrupt
504 *
505 * INPUTS:  hDebugTrace - Debug Trace object
506 *
507 * RETURNS:
508 *
509 *****************************************************************************/
510void debugTrace_UdpEnable(TI_HANDLE hDebugTrace)
511{
512    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
513
514    pDebugTrace->bUdpSend = TRUE;
515
516    WLAN_OS_REPORT(("whal_DebugTrace_t_UdpEnable: Enable UDP trace send\n"));
517}
518
519 /****************************************************************************
520 *                      debugTrace_UdpDisable()
521 *****************************************************************************
522 * DESCRIPTION: disable sending udp on each interrupt
523 *
524 * INPUTS:  hDebugTrace - Debug Trace object
525 *
526 * RETURNS:
527 *
528 *****************************************************************************/
529void debugTrace_UdpDisable(TI_HANDLE hDebugTrace)
530{
531    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
532
533    pDebugTrace->bUdpSend = FALSE;
534
535    WLAN_OS_REPORT(("whal_DebugTrace_t_UdpEnable: Disable UDP trace send\n"));
536
537}
538
539#if !defined(GWSI_DRIVER) && !defined(GWSI_LIB)
540 /****************************************************************************
541 *                      debugTrace_handleBuffer()
542 *****************************************************************************
543 * DESCRIPTION:
544 *
545 * INPUTS:  hDebugTrace - Debug Trace object
546 *
547 * RETURNS:
548 *
549 *****************************************************************************/
550void debugTrace_handleBuffer(TI_HANDLE hDebugTrace)
551{
552    DebugTrace_t *pDebugTrace = (DebugTrace_t *)hDebugTrace;
553    mem_MSDU_T *pMsdu;
554    mem_BD_T *pBd;
555    UINT8    *srcDataPtr;
556    int Stt;
557    int AcxMpduLen;
558
559    /* The Msdu Len should be The IP total Length + the Ethernet header length */
560    AcxMpduLen = wlan_ntohs(pDebugTrace->FrameHeader.IP_Header.Totallen)
561                    + sizeof(pDebugTrace->FrameHeader.Ether_Header);
562
563    /*
564     * allocate host msdu
565     */
566    Stt = wlan_memMngrAllocMSDU(pDebugTrace->hMemMgr, &pMsdu, AcxMpduLen, TRACE_BUFFER_MODULE);
567    if (Stt != OK)
568    {
569        WLAN_REPORT_ERROR(pDebugTrace->hReport, HAL_HW_DATA_MODULE_LOG,
570            ("whal_DebugTrace_t_handleBuffer: wlan_memMngrAllocMSDU error\n"));
571        return ;
572    }
573
574    /* set the lastBDPtr */
575    pBd = pMsdu->firstBDPtr;
576    while (pBd->nextBDPtr != NULL)
577        pBd = pBd->nextBDPtr;
578
579    pMsdu->lastBDPtr = pBd;
580
581    /* Get the Address of the Data filed in the Msdu */
582    srcDataPtr = (UINT8 *)memMgr_MsduHdrAddr(pMsdu);
583
584    /* Copy the Frame Header */
585    os_memoryCopy(pDebugTrace->hOs, srcDataPtr, &pDebugTrace->FrameHeader, sizeof(pDebugTrace->FrameHeader));
586
587    /* Copy the Trace Data */
588    os_memoryCopy(pDebugTrace->hOs, srcDataPtr + sizeof(pDebugTrace->FrameHeader), pDebugTrace->debugWords, pDebugTrace->TraceBufferSize);
589
590    memMgr_BufLength(pMsdu->firstBDPtr) = AcxMpduLen;
591
592    pMsdu->dataLen = AcxMpduLen;
593
594    /* send the packet to the OS */
595    os_receivePacket(pDebugTrace->hOs, pMsdu, (UINT16)pMsdu->dataLen);
596}
597
598 /****************************************************************************
599 *                      debugTrace_BuildFrame()
600 *****************************************************************************
601 * DESCRIPTION: Build the Trace Frame to be send to the OS
602 *
603 * INPUTS:  pDebugTrace - Debug Trace object
604 *          MacAddress  - for the Ethernet Header
605 * RETURNS:
606 *
607 *****************************************************************************/
608static void debugTrace_BuildFrame(DebugTrace_t *pDebugTrace, UINT8* MacAddress)
609{
610    TraceFrame *Frame =  &pDebugTrace->FrameHeader;
611    UINT32 i;
612    UINT16 local_csum = 0;
613    UINT16 *pShortData = (UINT16 *)&Frame->IP_Header;
614
615    /*
616     *  Calculate each Frame Length
617     */
618    /* UDP length should Be !024 of Trace Buffet Size + 8 Byte of UDP header 1032) */
619    Frame->UDP_Header.UDP_len = wlan_htons(pDebugTrace->TraceBufferSize + sizeof(Frame->UDP_Header));
620
621    /* IP length should Be UDP length + IP header  */
622    Frame->IP_Header.Totallen = wlan_htons(wlan_htons(Frame->UDP_Header.UDP_len) + sizeof(Frame->IP_Header));
623
624    /*
625     * initialize the Ethernet Header
626     */
627    os_memoryCopy(pDebugTrace->hOs, (UINT8 *)Frame->Ether_Header.ether_dst,
628                  MacAddress, 6);
629
630    Frame->Ether_Header.ether_Type  = wlan_htons (Ether_Type);
631
632    /*
633     *  initialize the IP Header
634     */
635    Frame->IP_Header.IpVer = IP_Version;
636
637    Frame->IP_Header.TimeToLive = IP_TimeToLive;
638
639    Frame->IP_Header.protocol = IP_Protocol;
640
641    /* Set the Local host IP */
642    Frame->IP_Header.dst[0] = Frame->IP_Header.src[0] = 127;
643    Frame->IP_Header.dst[1] = Frame->IP_Header.src[1] = 0 ;
644    Frame->IP_Header.dst[2] = Frame->IP_Header.src[2] = 0;
645    Frame->IP_Header.dst[3] = Frame->IP_Header.src[3] = 1;
646
647    /* calculate check sum on words of 16 bits */
648    for (i=0; i<sizeof(Frame->IP_Header)/2; i++)
649        local_csum += pShortData[i];
650
651    Frame->IP_Header.csum = 0xFFFF - local_csum;
652
653    /*
654     *  initialize the UDP Header
655     */
656    Frame->UDP_Header.src_port = wlan_htons( Source_Port );
657    Frame->UDP_Header.dst_port = wlan_htons( Destination_Port );
658}
659#endif /* !defined(GWSI_DRIVER) && !defined(GWSI_LIB) */
660
661#endif /* TI_DBG */
662
663