PRSDK-4301 Add UART print console support
[keystone-rtos/mcbsp-lld.git] / example / c6657 / MCBSPDigLpbk / mcbspMasterDigLpbk.c
1 /*
2  * mcbspMasterDigLpbk.c
3  *
4  * This file contains the test / demo code to demonstrate the McBSP driver
5  * master functionality using Digital Loopback setup. The file configures 
6  * the EVM in master mode.
7  *
8  * Copyright (C) 2012 - 2018 Texas Instruments Incorporated - http://www.ti.com/
9  *
10  *
11  *  Redistribution and use in source and binary forms, with or without
12  *  modification, are permitted provided that the following conditions
13  *  are met:
14  *
15  *    Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  *
18  *    Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the
21  *    distribution.
22  *
23  *    Neither the name of Texas Instruments Incorporated nor the names of
24  *    its contributors may be used to endorse or promote products derived
25  *    from this software without specific prior written permission.
26  *
27  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38  *
39 */
41 /* ========================================================================== */
42 /*                            INCLUDE FILES                                   */
43 /* ========================================================================== */
45 #include <ti/sysbios/BIOS.h>
46 #include <xdc/std.h>
47 #include <ti/sysbios/knl/Task.h>
48 #include <string.h>
49 #include <ti/sysbios/knl/Queue.h>
50 #include <xdc/runtime/System.h>
52 #include <xdc/cfg/global.h>
53 #include <board.h>
54 #include <MCBSP_log.h>
56 /* Include EDMA3 Driver */
57 #include <ti/sdo/edma3/drv/edma3_drv.h>
59 /* CSL Chip Functional Layer */
60 //#include <ti/csl/csl_chip.h>
62 /* CSL Cache Functional Layer */
63 //#include <ti/csl/csl_cacheAux.h>
65 /* CSL CPINTC Include Files. */
66 //#include<ti/csl/csl_cpIntc.h>
68 /* MCBSP Driver Include File. */
69 #include <ti/drv/mcbsp/mcbsp_drv.h>
70 #include <ti/drv/mcbsp/mcbsp_osal.h>
72 /* PlatformLib Include File */
73 //#include <ti/platform/platform.h>
76 extern EDMA3_DRV_GblConfigParams sampleEdma3GblCfgParams[];
77 extern EDMA3_RM_InstanceInitConfig sampleInstInitConfig[2][8];
78 /* ========================================================================== */
79 /*                        EXTERNAL FUNCTIONS                                  */
80 /* ========================================================================== */
82 extern EDMA3_DRV_Handle edma3init(unsigned int edma3Id, EDMA3_DRV_Result *);
84 extern void McbspDevice_init(void);
86 extern int32_t Osal_dataBufferInitMemory(uint32_t dataBufferSize);
88 extern void McbspXmtInterrupt_init(void *mcbspTxChan);
89 extern void McbspRcvInterrupt_init(void *mcbspRxChan);
91 extern Board_STATUS Board_init(Board_initCfg);
93 /* FPGA Configuration Misc-1 Register offset */
94 #define MCBSP_FPGA_MISC_REG_OFFSET (0x0C)
96 /* ========================================================================== */
97 /*                           MACRO DEFINTIONS                                 */
98 /* ========================================================================== */
100 #define NUM_BUFS                     2          /* Max of buffers used in each direction */
101 #define FRAMESIZE                   40          /* e.g 5 ms 8 KHz samples         */
102 #define NUM_OF_ENABLED_CHANNELS      8          /* Number of slots to be used     */
103 #define NUM_OF_MAX_CHANNELS            128                      /* Maximum number of time slots available based on clock settings   */
104 #define BUFSIZE                   (NUM_OF_ENABLED_CHANNELS * FRAMESIZE)        /* Total buffer size per frame */
106 /* Defines the core number responsible for system initialization. */
107 #define CORE_SYS_INIT         0
108 /* Number of iterations to execute test: Only applicable to INTERNAL CLOCK Loopback test */
109 #define NUM_OF_ITERATIONS 10
111 /* Number of MCBSP Frame structures used for submit channel */
112 #define NUM_OF_MCBSP_FRAMES 2
114 /* Number of buffers initially submitted to Mcbsp lld: Only applicable to
115    External clock test ; Note: This should be set to 2*/
116 #define INIT_SUBMIT_Q_CNT 2
118 /*============================================================================*/
119 /*                            GLOBAL VARIABLES                                */
120 /*============================================================================*/
122 /* Shared Memory Variable to ensure synchronizing MCBSP initialization
123  * with all the other cores. */
124 /* Created an array to pad the cache line with MCBSP_CACHE_LENGTH size */
125 #pragma DATA_ALIGN   (isMCBSPInitialized, MCBSP_MAX_CACHE_ALIGN)
126 #pragma DATA_SECTION (isMCBSPInitialized, ".mcbspSharedMem");
127 volatile Uint32 isMCBSPInitialized[(MCBSP_CACHE_LENGTH / sizeof(Uint32))] = { 0 };
129 /* Handle to the EDMA driver instance */
130 #pragma DATA_ALIGN   (hEdma, MCBSP_MAX_CACHE_ALIGN)
131 EDMA3_DRV_Handle hEdma[(MCBSP_CACHE_LENGTH / sizeof(EDMA3_DRV_Handle))] = { NULL };
133 /* Handle to MCBSP driver instance */
134 typedef void* Mcbsp_DevHandle;
135 Mcbsp_DevHandle  hMcbspDev;
137 /* Handle to MCBSP driver channel instance */
138 typedef void* Mcbsp_ChanHandle;
139 Mcbsp_ChanHandle  hMcbspTxChan;
140 Mcbsp_ChanHandle  hMcbspRxChan;
142 /* Core Number Identifier */
143 UInt32 coreNum = 0xFFFF;
145 /* Array to hold the pointer to the allocated buffers     */
146 void* bufRx[NUM_BUFS];
147 void* bufTx[NUM_BUFS];
149 #ifdef MCBSP_LOOP_PING_PONG
150 /* Ping pong buffers used to submit to Mcbsp lld, which will be used in a loop */
151 void* bufRxPingPong[INIT_SUBMIT_Q_CNT];
152 void* bufTxPingPong[INIT_SUBMIT_Q_CNT];
153 #endif
154 /* Global Error call back function prototype */
155 void mcbsp_GblErrCallback(uint32_t chanHandle,uint32_t spcr_read,uint32_t Arg3);
157 /* Variables to indicate status of EDMA TX and RX requests */
158 volatile uint32_t edmaTxDone = 0;
159 volatile uint32_t edmaRxDone = 0;
160 /* Global variables to track number of buffers submitted, number of iterations, error counts etc */
161 int rxSubmitCount=0, txSubmitCount=0;
162 uint32_t num_iterations=0;
163 uint32_t num_rx_Call_backs=0, num_tx_Call_backs=0, dummy_call_backs=0;
164 uint32_t rxunderflowcnt=0, txunderflowcnt=0;
165 uint32_t errBuffCount=0;
166 /* Debug variables */
167 volatile int debugVar=1;  /* This can be used to maintain a while loop, If set to 0 will exit loop */
168 volatile int debugCommand=1;  /* This can be used to set to value below to send command to restart channel  */
170 #define DEBUG_COMMAND_RESTART_CHANNELS 1
171 /**
172  * \brief    Mcbsp Sample rate generator default parameters.
173  *
174  */
175 Mcbsp_srgConfig mcbspSrgCfg =
177     FALSE,                     /* No gsync to be used as input is not CLKS    */
178     Mcbsp_ClkSPol_RISING_EDGE, /* Dont care as input clock is not clks        */
179     Mcbsp_SrgClk_CLKCPU,       /* McBSP internal clock to be used             */
180     //166666667,                 /* Mcbsp internal clock frequency(PLL-SYSCLK6) */
181     333333333, //sys_oscclk or cpu_clk/3
182     0                          /* frame sync pulse width (val+1) is used      */
183 };
185 /**
186  * \brief    Mcbsp device creation default parameters.
187  *
188  */
189 const Mcbsp_Params Mcbsp_PARAMS =
191     Mcbsp_DevMode_McBSP,       /* Use the device as MCBSP                     */
192     Mcbsp_OpMode_DMAINTERRUPT, /* Use DMA mode of operation                   */
193     TRUE,                      /* cache coherency taken care of by driver     */
194     Mcbsp_EmuMode_FREE,        /* Emulation mode free is to be enabled        */
195 #ifdef    MCBSP_EXTERNAL_CLOCK
196     Mcbsp_Loopback_DISABLE,    /* Loop back mode disabled                     */
197 #else
198     Mcbsp_Loopback_ENABLE,     /* Loop back mode enabled                      */
199 #endif
200     &mcbspSrgCfg,              /* sample rate generator configuration         */
201     NULL,                      /* TX pending buffer queue from application    */
202     NULL,                      /* TX floating buffer queue in DMA             */
203     NULL,                      /* RX pending buffer queue from application    */
204     NULL                       /* RX floating buffer queue in DMA             */
205 };
207 #pragma DATA_ALIGN(loopTxJob, MCBSP_MAX_CACHE_ALIGN)
208 static Int32 loopTxJob[16] = {
209     /* Filling with Mu law silence pattern : Can be any user defined pattern */
210     0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f,
211     0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f
212 };
213 #pragma DATA_ALIGN(loopRxJob, MCBSP_MAX_CACHE_ALIGN)
214 static Int32 loopRxJob[16] = {
215     0, 0, 0, 0, 0, 0, 0, 0,
216     0, 0, 0, 0, 0, 0, 0, 0
217 };
219 /**< settings to configure the TX or RX hardware sections                 */
220 Mcbsp_DataConfig mcbspChanConfigTx =
222     Mcbsp_Phase_SINGLE,
223     Mcbsp_WordLength_8,
224     Mcbsp_WordLength_8,    /* Dont care for single phase*/
225     NUM_OF_MAX_CHANNELS,
226     NUM_OF_MAX_CHANNELS,      // Only used with dual phase
227     Mcbsp_FrmSync_DETECT,
228 #ifdef MCBSP_EXTERNAL_CLOCK
229     Mcbsp_DataDelay_0_BIT,
230 #else
231     Mcbsp_DataDelay_1_BIT,
232 #endif
233     Mcbsp_Compand_OFF_MSB_FIRST,
234     Mcbsp_BitReversal_DISABLE,
235     Mcbsp_IntMode_ON_SYNCERR,
236     Mcbsp_RxJust_RZF,  /* Dont care for TX         */
237     Mcbsp_DxEna_OFF
238 };
240 /**< settings to configure the TX or RX hardware sections                 */
241 Mcbsp_DataConfig mcbspChanConfigRx =
243     Mcbsp_Phase_SINGLE,
244     Mcbsp_WordLength_8,
245     Mcbsp_WordLength_8,    /* Dont care for single phase*/
246     NUM_OF_MAX_CHANNELS,
247     NUM_OF_MAX_CHANNELS,      // Only used with dual phase
248     Mcbsp_FrmSync_DETECT,
249 #ifdef MCBSP_EXTERNAL_CLOCK
250     Mcbsp_DataDelay_0_BIT,
251 #else
252     Mcbsp_DataDelay_1_BIT,
253 #endif
254     Mcbsp_Compand_OFF_MSB_FIRST,
255     Mcbsp_BitReversal_DISABLE,
256     Mcbsp_IntMode_ON_SYNCERR,
257     Mcbsp_RxJust_RZF,  /* Dont care for TX         */
258     Mcbsp_DxEna_OFF
259 };
260 /**< clock setup for the TX section                     */
261 Mcbsp_ClkSetup mcbspClkConfigTx =
263 #ifdef MCBSP_EXTERNAL_CLOCK
264     Mcbsp_FsClkMode_EXTERNAL,
265     8000,                   /* 8KHz                   */
266     Mcbsp_TxRxClkMode_EXTERNAL,
267 #else
268     Mcbsp_FsClkMode_INTERNAL,
269     8000,                   /* 8KHz                   */
270     Mcbsp_TxRxClkMode_INTERNAL,
271 #endif
272     Mcbsp_FsPol_ACTIVE_HIGH,
273     Mcbsp_ClkPol_RISING_EDGE
274 };
276 /**< clock setup for the RX section                     */
277 Mcbsp_ClkSetup mcbspClkConfigRx =
279 #ifdef MCBSP_EXTERNAL_CLOCK
280     Mcbsp_FsClkMode_EXTERNAL,
281     8000,                   /* 8KHz                   */
282     Mcbsp_TxRxClkMode_EXTERNAL,
283 #else
284     Mcbsp_FsClkMode_INTERNAL,
285     8000,                   /* 8KHz                   */
286     Mcbsp_TxRxClkMode_INTERNAL,
287 #endif
288     Mcbsp_FsPol_ACTIVE_HIGH,
289     Mcbsp_ClkPol_FALLING_EDGE
290 };
292 /**< Multi channel setup                                                      */
293 Mcbsp_McrSetup mcbspMultiChanCtrl =
295     Mcbsp_McmMode_ALL_CHAN_DISABLED_UNMASKED,
296     Mcbsp_PartitionMode_CHAN_0_15,
297     Mcbsp_PartitionMode_CHAN_16_31,
298     Mcbsp_PartitionMode_2
299 };
302 Mcbsp_ChanParams mcbspChanparamTx =
304     Mcbsp_WordLength_8,  /* wordlength configured    */
305     &loopTxJob[0],          /* loop job buffer internal */
306     8,                    /* user loopjob length      */
307     mcbsp_GblErrCallback, /* global error callback    */
308     NULL,                 /* edma Handle              */
309     1,                    /* EDMA event queue         */
310     8,                    /* hwi number               */
311     Mcbsp_BufferFormat_MULTISLOT_NON_INTERLEAVED,
312     TRUE,                 /* FIFO mode enabled        */
313     &mcbspChanConfigTx,   /* channel configuration    */
314     &mcbspClkConfigTx,    /* clock configuration      */
315     &mcbspMultiChanCtrl,  /* multi channel control    */
316     0x7531,  /* Enabled timeslots: 0, 4, 5, 8, 10, 12, 13, 14 */
317     0x00,
318     0x00,
319     0x00,
320     NUM_OF_ENABLED_CHANNELS    /* Total number of channels enabled*/
321 };
323 Mcbsp_ChanParams mcbspChanparamRx =
325     Mcbsp_WordLength_8,  /* wordlength configured    */
326     &loopRxJob[0],          /* loop job buffer internal */
327     8,                    /* user loopjob length      */
328     mcbsp_GblErrCallback, /* global error callback    */
329     NULL,                 /* edma Handle              */
330     1,                    /* EDMA event queue         */
331     8,                    /* hwi number               */
332     Mcbsp_BufferFormat_MULTISLOT_NON_INTERLEAVED,
333     TRUE,                 /* FIFO mode enabled        */
334     &mcbspChanConfigRx,   /* channel configuration    */
335     &mcbspClkConfigRx,    /* clock configuration      */
336     &mcbspMultiChanCtrl,  /* multi channel control    */
337     0x7531,  /* Enabled timeslots: 0, 4, 5, 8, 10, 12, 13, 14 */
338     0x00,
339     0x00,
340     0x00,
341     NUM_OF_ENABLED_CHANNELS    /* Total number of channels enabled*/
342 };
345 /* ========================================================================== */
346 /*                           FUNCTION DEFINITIONS                             */
347 /* ========================================================================== */
349 /*
350  *   This is the application's callback function. The driver will
351  *   call this function whenever an EDMA I/O operation is over.
352  *
353  */
354 void mcbspAppCallback(void* arg, Mcbsp_IOBuf *ioBuf)
356     int32_t mode;
357     int32_t *pmode = (int32_t *)arg;
359     mode = *pmode;
360     if (mode == MCBSP_MODE_OUTPUT)
361     {
362         if(ioBuf) {
363             num_tx_Call_backs++;
364             edmaTxDone = 1;
365         }else
366             txunderflowcnt++;
367     }
368     else if (mode == MCBSP_MODE_INPUT)
369     {
370         if(ioBuf) {
371             num_rx_Call_backs++;
372             edmaRxDone = 1;
373         }else
374             rxunderflowcnt++;
375     }else
376         dummy_call_backs++;
377     return;
380 /*
381  *   This is the application's Global error callback function 
382  */
383 void mcbsp_GblErrCallback(uint32_t chanHandle,uint32_t spcr_read,uint32_t Arg3)
385     MCBSP_log ("Debug(Core %d): ERROR callback called SPCR: %x", coreNum, spcr_read);
388 /*
389  * \brief   This function demostrates the use of Mcbsp using digital loopback
390  *          communication setup.
391  *
392  * \param   None
393  *
394  * \return  None
395  */
396 void mcbspDigLpbkApp(UArg arg0, UArg arg1)
398     /**< Mcbsp device params                                                  */
399     Mcbsp_Params  mcbspParams;
401     /**< Queue to hold the pending packets received from the application      */
402     Queue_Struct  txQueuePendingList, rxQueuePendingList;
403     /**< Queue to manage floating packets in DMA                              */
404     Queue_Struct  txQueueFloatingList, rxQueueFloatingList;
406     uint32_t count   = 0, tempCount = 0;
407     int32_t  status  = 0, retval = 0;
408     int32_t  txChanMode = MCBSP_MODE_OUTPUT;
409     int32_t  rxChanMode = MCBSP_MODE_INPUT;
410     uint32_t mcbspTxDone = 0, mcbspRxDone = 0;
411     Mcbsp_IOBuf txFrame[NUM_OF_MCBSP_FRAMES], rxFrame[NUM_OF_MCBSP_FRAMES];
412     int txFrameIndex=0, rxFrameIndex=0;
413     int init_count=0;
414 #ifdef MCBSP_LOOP_PING_PONG
415     int pingPongIndex=0;
416 #endif
418     /* Initialize the OSAL */
419     if (Osal_dataBufferInitMemory(BUFSIZE) < 0)
420     {
421         MCBSP_log ("Debug(Core %d): Error: Unable to initialize the OSAL. \n", coreNum);
422         return;
423     }
425     /* update EDMA3 handle to channel parameters */
426     mcbspChanparamTx.edmaHandle = hEdma[0];
427     mcbspChanparamRx.edmaHandle = hEdma[0];
429     /* create the pending and floating queue for the TX channel           */
430     Queue_construct(&txQueuePendingList, NULL);
431     Queue_construct(&txQueueFloatingList, NULL);
433     /* create the pending and floating queue for the RX channel           */
434     Queue_construct(&rxQueuePendingList, NULL);
435     Queue_construct(&rxQueueFloatingList, NULL);
438     mcbspParams                 = Mcbsp_PARAMS;
439     mcbspParams.txQPendingList  = &txQueuePendingList;
440     mcbspParams.txQFloatingList = &txQueueFloatingList;
441     mcbspParams.rxQPendingList  = &rxQueuePendingList;
442     mcbspParams.rxQFloatingList = &rxQueueFloatingList;
445     /* Bind the driver instance with device instance */
446     status = mcbspBindDev(&hMcbspDev, coreNum, &mcbspParams);
448     if (status != MCBSP_STATUS_COMPLETED)
449     {
450         MCBSP_log ("Debug(Core %d): MCBSP LLD Bind Device Failed\n", coreNum);
451         return;
452     }
454     /* If the user loopjob buffer is in local L2 memory: Convert into Global memory address space */
455     if(mcbspChanparamRx.userLoopJobBuffer)
456         mcbspChanparamRx.userLoopJobBuffer = (void *)Mcbsp_osalLocal2Global(mcbspChanparamRx.userLoopJobBuffer);
458     /* Create a RX channel for receiving */
459     status = mcbspCreateChan(&hMcbspRxChan, hMcbspDev, MCBSP_MODE_INPUT, &mcbspChanparamRx, mcbspAppCallback, &rxChanMode);
460     if (MCBSP_STATUS_COMPLETED != status)
461     {
462         MCBSP_log ("Debug(Core %d): Error: Create Channel (RX) failed\n", coreNum);
463         return;
464     }
466     /* If the user loopjob buffer is in local L2 memory: Convert into Global memory address space */
467     if(mcbspChanparamTx.userLoopJobBuffer)
468         mcbspChanparamTx.userLoopJobBuffer = Mcbsp_osalLocal2Global(mcbspChanparamTx.userLoopJobBuffer);
470     /* Create a TX channel for the transmission */
471     status = mcbspCreateChan(&hMcbspTxChan, hMcbspDev, MCBSP_MODE_OUTPUT, &mcbspChanparamTx, mcbspAppCallback, &txChanMode);
472     if (MCBSP_STATUS_COMPLETED != status)
473     {
474         MCBSP_log ("Debug(Core %d): Error: Create Channel (TX) failed\n", coreNum);
475         return;
476     }
478     /* Register mcbsp interrupts */
479     //McbspRcvInterrupt_init(hMcbspRxChan);
480     //McbspXmtInterrupt_init(hMcbspTxChan);
482     /* create the buffers required for the TX and RX operations */
483     for (count = 0; count < (NUM_BUFS); count++)
484     {
485         bufTx[count] = (uint8_t *)Osal_mcbspDataBufferMalloc(BUFSIZE);
486         bufRx[count] = (uint8_t *)Osal_mcbspDataBufferMalloc(BUFSIZE);
488         if (bufTx[count] == NULL)
489         {
490             MCBSP_log ("Debug(Core %d): Error: Tx Buffer (%d) Memory Allocation Failed\n", coreNum, count);
491             return;
492         }
493         if (bufRx[count] == NULL)
494         {
495             MCBSP_log ("Debug(Core %d): Error: Rx Buffer (%d) Memory Allocation Failed\n", coreNum, count);
496             return;
497         }
498     }
499 #ifdef MCBSP_LOOP_PING_PONG
500     /* create the ping pong buffers required for the TX and RX operations */
501     for (count = 0; count < (NUM_BUFS); count++)
502     {
503         bufRxPingPong[count] = (uint8_t *)Osal_mcbspDataBufferMalloc(BUFSIZE);
504         bufTxPingPong[count] = (uint8_t *)Osal_mcbspDataBufferMalloc(BUFSIZE);
506         if (bufTxPingPong[count] == NULL)
507         {
508             MCBSP_log ("Debug(Core %d): Error: Tx Ping pong Buffer (%d) Memory Allocation Failed\n", coreNum, count);
509             return;
510         }
511         if (bufRxPingPong[count] == NULL)
512         {
513             MCBSP_log ("Debug(Core %d): Error: Rx Ping pong Buffer (%d) Memory Allocation Failed\n", coreNum, count);
514             return;
515         }
516     }
517 #endif
518     /* Fill the buffers with known data and transmit the same and 
519        check if the same pattern is received */
520     for (count = 0; count < (NUM_BUFS); count++)
521     {
522         memset((uint8_t *)bufTx[count], 0, BUFSIZE);
523         for (tempCount = 0; tempCount < BUFSIZE; tempCount++)
524         {
525             ((uint8_t *)bufTx[count])[tempCount] = (tempCount % 0x100);
526         }
527     }
528     MCBSP_log ("Debug(Core %d): If required to restart set debugCommand variable to %d\n", coreNum, DEBUG_COMMAND_RESTART_CHANNELS);
530 restart_mcbsp_point:
531     txFrameIndex=0;
532     rxFrameIndex=0;
533     init_count=0;
534 #ifdef MCBSP_EXTERNAL_CLOCK
535     /* Initial loading of ping ping buffers */
536     for(init_count =0 ; init_count < INIT_SUBMIT_Q_CNT; init_count++)
537     {
538 #ifdef MCBSP_LOOP_PING_PONG
539         memset((uint8_t *)bufRxPingPong[init_count], 0, BUFSIZE);
541         /* RX frame processing */
542         rxFrame[rxFrameIndex].cmd = Mcbsp_IOBuf_Cmd_READ;
543         rxFrame[rxFrameIndex].addr = (void*)bufRxPingPong[init_count];
544 #else
545         memset((uint8_t *)bufRx[init_count], 0, BUFSIZE);
548         /* RX frame processing */
549         rxFrame[rxFrameIndex].cmd = Mcbsp_IOBuf_Cmd_READ;
550         rxFrame[rxFrameIndex].addr = (void*)bufRx[init_count];
551 #endif
553         rxFrame[rxFrameIndex].size = BUFSIZE;
554         rxFrame[rxFrameIndex].arg = (uint32_t) hMcbspRxChan;
555         rxFrame[rxFrameIndex].status = MCBSP_STATUS_COMPLETED;
556         rxFrame[rxFrameIndex].misc = 1;   /* reserved - used in callback to indicate asynch packet */
558         status = mcbspSubmitChan(hMcbspRxChan, (void *)&rxFrame[rxFrameIndex]);
559         if (status != MCBSP_STATUS_PENDING)
560         {
561             MCBSP_log ("Debug(Core %d): Error: RX buffer #%d submission FAILED\n", coreNum, init_count);
562             retval = 1;
563         }
564         else
565         {
566 #ifdef MCBSP_APP_VERBOSE
567             MCBSP_log ("Debug(Core %d): RX buffer #%d is submitted to MCBSP driver\n", coreNum, init_count);
568 #endif
569         }
570         rxFrameIndex++;
571         rxFrameIndex = (rxFrameIndex >= (NUM_OF_MCBSP_FRAMES)) ? 0 : rxFrameIndex;
573         rxSubmitCount++;
575         /* TX frame processing */
576         txFrame[txFrameIndex].cmd = Mcbsp_IOBuf_Cmd_WRITE;
577 #ifdef MCBSP_LOOP_PING_PONG
578         txFrame[txFrameIndex].addr = (void*)bufTxPingPong[init_count];
579 #else
580         txFrame[txFrameIndex].addr = (void*)bufTx[init_count];
581 #endif
582         txFrame[txFrameIndex].size = BUFSIZE;
583         txFrame[txFrameIndex].arg = (uint32_t)hMcbspTxChan;
584         txFrame[txFrameIndex].status = MCBSP_STATUS_COMPLETED;
585         txFrame[txFrameIndex].misc = 1;   /* reserved - used in callback to indicate asynch packet */
587         status = mcbspSubmitChan(hMcbspTxChan, (void *)&txFrame[txFrameIndex]);
588         if (status != MCBSP_STATUS_PENDING)
589         {
590             MCBSP_log ("Debug(Core %d): Error: TX buffer  #%d submission FAILED\n", coreNum, init_count);
591             retval = 1;
592         }
593         else
594         {
595 #ifdef MCBSP_APP_VERBOSE
596             MCBSP_log ("Debug(Core %d): TX buffer  #%d submission is submitted to MCBSP driver\n", coreNum, init_count);
597 #endif
598         }
599         txFrameIndex++;
600         txFrameIndex = (txFrameIndex >=(NUM_OF_MCBSP_FRAMES)) ? 0 : txFrameIndex;
602         txSubmitCount++;
603     }
605     /* Wait for TX and RX processing to complete */
606     while (1)
607     {
608         if (edmaTxDone == 1)
609         {
610 #ifdef MCBSP_APP_VERBOSE
611             MCBSP_log ("Debug(Core %d): EDMA -> Iteration-%d frames are transmitted to TX path\n", coreNum, count);
612 #endif
613             edmaTxDone = 0; /* Reset for next iteration */
614             mcbspTxDone = 1;
615         }
616         if (edmaRxDone == 1)
617         {
618 #ifdef MCBSP_APP_VERBOSE
619             MCBSP_log ("Debug(Core %d): EDMA -> Iteration-%d frames are received from RX path\n", coreNum, count);
620 #endif
621             edmaRxDone = 0;  /* Reset for next iteration */
622             mcbspRxDone = 1;
623         }
624         if ((mcbspTxDone == 1) && (mcbspRxDone == 1))
625         {
626             mcbspTxDone = 0;  /* Reset for next iteration */
627             mcbspRxDone = 0;  /* Reset for next iteration */
628             break;
629         }
630     }
631 #ifdef MCBSP_LOOP_PING_PONG
632     /* Change ping Pong Index */
633     init_count=0;
634 #endif
635 #endif /* MCBSP_EXTERNAL_CLOCK */
637     /* Start main loop to iterate through frames */
638     while(debugVar)
639     {
640         /* submit frames to the driver */
641         for (count = init_count; count < NUM_BUFS; count++)
642         {
643 #ifdef MCBSP_EXTERNAL_CLOCK
644 /*   With External clock the data coming from the RX side is copied to loop back to the Tx side */
645             memcpy((uint8_t *)bufTx[count], (uint8_t *)bufRx[count], BUFSIZE);
646 #endif
647 #ifdef MCBSP_LOOP_PING_PONG
648             memset((uint8_t *)bufRxPingPong[pingPongIndex], 0, BUFSIZE);
649 #else
650             memset((uint8_t *)bufRx[count], 0, BUFSIZE);
651             /* RX frame processing */
652             rxFrame[rxFrameIndex].cmd = Mcbsp_IOBuf_Cmd_READ;
653             rxFrame[rxFrameIndex].addr = (void*)getGlobalAddr(bufRx[count]);
654             rxFrame[rxFrameIndex].size = BUFSIZE;
655             rxFrame[rxFrameIndex].arg = (uint32_t) hMcbspRxChan;
656             rxFrame[rxFrameIndex].status = MCBSP_STATUS_COMPLETED;
657             rxFrame[rxFrameIndex].misc = 1;   /* reserved - used in callback to indicate asynch packet */
659             status = mcbspSubmitChan(hMcbspRxChan, (void *)&rxFrame[rxFrameIndex]);
660             if (status != MCBSP_STATUS_PENDING)
661             {
662                 MCBSP_log ("Debug(Core %d): Error: RX buffer #%d submission FAILED\n", coreNum, count);
663                 retval = 1;
664             }
665             else
666             {
667 #ifdef MCBSP_APP_VERBOSE
668                 MCBSP_log ("Debug(Core %d): RX buffer #%d is submitted to MCBSP driver\n", coreNum, count);
669 #endif
670             }
671             rxFrameIndex++;
672             rxFrameIndex = (rxFrameIndex >= (NUM_OF_MCBSP_FRAMES)) ? 0 : rxFrameIndex;
673 #endif
674             rxSubmitCount++;
675 #ifdef MCBSP_LOOP_PING_PONG
676             /* Copy buffer from buffer to ping pong buffer*/
677             memcpy((uint8_t *)bufTxPingPong[pingPongIndex], (uint8_t *)bufTx[count],BUFSIZE);
678 #else
679             /* TX frame processing */
680             txFrame[txFrameIndex].cmd = Mcbsp_IOBuf_Cmd_WRITE;
681             txFrame[txFrameIndex].addr = (void*)getGlobalAddr(bufTx[count]);
682             txFrame[txFrameIndex].size = BUFSIZE;
683             txFrame[txFrameIndex].arg = (uint32_t)hMcbspTxChan;
684             txFrame[txFrameIndex].status = MCBSP_STATUS_COMPLETED;
685             txFrame[txFrameIndex].misc = 1;   /* reserved - used in callback to indicate asynch packet */
687             status = mcbspSubmitChan(hMcbspTxChan, (void *)&txFrame[txFrameIndex]);
688             if (status != MCBSP_STATUS_PENDING)
689             {
690                 MCBSP_log ("Debug(Core %d): Error: TX buffer  #%d submission FAILED\n", coreNum, count);
691                 retval = 1;
692             }
693             else
694             {
695 #ifdef MCBSP_APP_VERBOSE
696                 MCBSP_log ("Debug(Core %d): TX buffer  #%d is submitted to MCBSP driver\n", coreNum, count);
697 #endif
698             }
699             txFrameIndex++;
700             txFrameIndex = (txFrameIndex >= (NUM_OF_MCBSP_FRAMES)) ? 0 : txFrameIndex;
701 #endif
702             txSubmitCount++;
704             /* Wait for TX and RX processing to complete */
705             while (1)
706             {
707                 if (edmaTxDone == 1)
708                 {
709 #ifdef MCBSP_APP_VERBOSE
710                     MCBSP_log ("Debug(Core %d): EDMA -> Buffer #-%d is transmitted to TX path\n", coreNum, count);
711 #endif
712                     edmaTxDone = 0; /* Reset for next iteration */
713                     mcbspTxDone = 1;
714                 }
715                 if (edmaRxDone == 1)
716                 {
717 #ifdef MCBSP_APP_VERBOSE
718                     MCBSP_log ("Debug(Core %d): EDMA -> Buffer #-%d is received from RX path\n", coreNum, count);
719 #endif
720                     edmaRxDone = 0;  /* Reset for next iteration */
721                     mcbspRxDone = 1;
722                 }
723                 if ((mcbspTxDone == 1) && (mcbspRxDone == 1))
724                 {
725                     mcbspTxDone = 0;  /* Reset for next iteration */
726                                     mcbspRxDone = 0;  /* Reset for next iteration */
727                                     break;
728                 }
729             }
730 #ifdef MCBSP_LOOP_PING_PONG
731             /* Change ping Pong Index */
732             pingPongIndex=(pingPongIndex)?0:1;
734             /* Copy buffer from buffer to other buffer*/
735             memcpy((void*)bufRx[count], (uint8_t *)bufRxPingPong[pingPongIndex],BUFSIZE);
736 #endif
737             /* compare buffer contents */
738             for (tempCount = 0; tempCount < BUFSIZE; tempCount++)
739             {
740                 if (((char *)bufTx[count])[tempCount] != ((char *)bufRx[count])[tempCount])
741                 {
742 #ifdef MCBSP_APP_VERBOSE
743                     MCBSP_log("Debug(Core %d): Error: TX and RX frame data DOES NOT match in Buffer #-%d\n",
744                         coreNum, count);
745                     MCBSP_log("Debug(Core %d): Error: Buffer index = %d, Tx data = %d, Rx data = %d\n", coreNum,
746                         tempCount, ((char *)bufTx[count])[tempCount], ((char *)bufRx[count])[tempCount]);
747 #endif
748                     errBuffCount++;
749                     break;
750                 }
751             }
752             if (tempCount >= BUFSIZE)
753             {
754 #ifdef MCBSP_APP_VERBOSE
755                 MCBSP_log("Debug(Core %d): TX and RX frames data match in iteration-%d !!!\n", coreNum, count);
756 #endif
757             }
758         }
759         init_count=0;
760         num_iterations++;
761 #ifndef   MCBSP_EXTERNAL_CLOCK
762         if(num_iterations >= NUM_OF_ITERATIONS)
763             break;
764 #endif
765         switch(debugCommand)
766         {
767         case DEBUG_COMMAND_RESTART_CHANNELS:
768             debugCommand=0;
769             /* Close channel and reopen */
770             /* Delete  RX channel */
771             status = mcbspDeleteChan(hMcbspRxChan);
772             if (MCBSP_STATUS_COMPLETED != status)
773             {
774                 MCBSP_log ("Debug(Core %d): Error: Delete Channel (RX) failed\n", coreNum);
775                 return;
776             }
778             /* Delete TX channel*/
779             status = mcbspDeleteChan(hMcbspTxChan);
780             if (MCBSP_STATUS_COMPLETED != status)
781             {
782                 MCBSP_log ("Debug(Core %d): Error: Delete Channel (TX) failed\n", coreNum);
783                 return;
784             }
785             /* Create a RX channel for receiving */
786             status = mcbspCreateChan(&hMcbspRxChan, hMcbspDev, MCBSP_MODE_INPUT, &mcbspChanparamRx, mcbspAppCallback, &rxChanMode);
787             if (MCBSP_STATUS_COMPLETED != status)
788             {
789                 MCBSP_log ("Debug(Core %d): Error: Create Channel (RX) failed\n", coreNum);
790                 return;
791             }
793             /* Create a TX channel for the transmission */
794             status = mcbspCreateChan(&hMcbspTxChan, hMcbspDev, MCBSP_MODE_OUTPUT, &mcbspChanparamTx, mcbspAppCallback, &txChanMode);
795             if (MCBSP_STATUS_COMPLETED != status)
796             {
797                 MCBSP_log ("Debug(Core %d): Error: Create Channel (TX) failed\n", coreNum);
798                 return;
799             }
800             edmaTxDone = 0;   /* Reset for next iteration */
801             edmaRxDone = 0;   /* Reset for next iteration */
802             mcbspTxDone = 0;  /* Reset for next iteration */
803             mcbspRxDone = 0;  /* Reset for next iteration */
804             goto restart_mcbsp_point;
806         default:
807             debugCommand=0;
808             break;
810         }
812     }
814     if ((errBuffCount == 0 ) & (retval ==0))
815     {
816         MCBSP_log("Debug(Core %d): MCBSP Digital Loopback Application completed successfully : "\
817             "Num iterations %d  Num buffers per iteration %d!!!\n",
818             coreNum, num_iterations, NUM_BUFS);
819         MCBSP_log("\n All tests have passed \n");
820     }
821     else
822     {
823         MCBSP_log("Debug(Core %d): MCBSP Digital Loopback application FAILED :  "\
824             "Num iterations %d  Num buffers per iteration %d Failed buffers %d!!!\n",
825             coreNum, num_iterations, NUM_BUFS, errBuffCount);
826     }
828     /* Delete  RX channel */
829     status = mcbspDeleteChan(hMcbspRxChan);
830     if (MCBSP_STATUS_COMPLETED != status)
831     {
832         MCBSP_log ("Debug(Core %d): Error: Delete Channel (RX) failed\n", coreNum);
833         return;
834     }
836     /* Delete TX channel*/
837     status = mcbspDeleteChan(hMcbspTxChan);
838     if (MCBSP_STATUS_COMPLETED != status)
839     {
840         MCBSP_log ("Debug(Core %d): Error: Delete Channel (TX) failed\n", coreNum);
841         return;
842     }
843     return;
846 /*
847  * \brief  Void main(Void)
848  *
849  *         Main function of the sample application. This function calls the
850  *         function to configure the mcbsp instance.
851  *
852  * \param  None
853  *
854  * \return None
855  */
856 #include "ti/sysbios/hal/Cache.h"
858 Void main(Void)
860     Task_Params taskParams;
861     EDMA3_DRV_Result edmaResult = 0;
862 #ifdef SIMULATOR_SUPPORT
863     uint8_t uchValue, uchReadValue;
864 #endif
866     Board_initCfg arg = BOARD_INIT_MODULE_CLOCK | BOARD_INIT_PINMUX_CONFIG | BOARD_INIT_UART_STDIO;
867     Board_init(arg);
869     uint32_t temp;
870     /* Get the core number. */
871     coreNum = 0; //CSL_chipReadReg (CSL_CHIP_DNUM);
873 #ifdef SIMULATOR_SUPPORT
874 #warn MCBSP Digital Loopback example is not supported on SIMULATOR !!!
875     MCBSP_log ("MCBSP Digital Loopback example is not supported on SIMULATOR. Exiting!\n");
876     return;
877 #else
878     MCBSP_log ("Debug(Core %d): Running MCBSP Digital Loopback example on the DEVICE\n", coreNum);
879 #endif
881     /* Initialize the system only if the core was configured to do so. */
882     if (coreNum == CORE_SYS_INIT)
883     {
884 #if 0
885         MCBSP_log ("Debug(Core %d): System Initialization for MCBSP\n", coreNum);
886         /* Read FPGA register */
887         if (0 != (platform_fpgaReadConfigReg(MCBSP_FPGA_MISC_REG_OFFSET, &uchReadValue)))
888         {
889             MCBSP_log ("Debug(Core %d): FPGA McBSP_AMC_EN# register READ failed \n", coreNum);
890             return;
891         }
892         /* Clear field for configuration */
893         uchValue = (uchReadValue & (~0x3));
894 #ifndef PLATFORM_FPGA_MCBSP_AMC_EN
895         uchValue |=  0x3;
896 #endif
897         /* Drive McBSP_AMC_EN# high. Output SLCLKs, TxCLKs, RxCLKs, FSTs, FSRs as Hi-Z. 
898          * These clocks and syncs are tri-stated and McBSP is accessed over 80-pin header */
899         if (0 != (platform_fpgaWriteConfigReg(MCBSP_FPGA_MISC_REG_OFFSET, (uchValue))))
900         {
901             MCBSP_log ("Debug(Core %d): FPGA McBSP_AMC_EN# register WRITE failed \n", coreNum);
902             return;
903         }
905         /* DEBUG: Verify if FPGA register is configured correctly */
906         if (0 != (platform_fpgaReadConfigReg(MCBSP_FPGA_MISC_REG_OFFSET, &uchReadValue)))
907         {
908             MCBSP_log ("Debug(Core %d): FPGA McBSP_AMC_EN# register READ failed \n", coreNum);
909             return;
910         }
912         if (uchValue != uchReadValue)
913         {
914             MCBSP_log ("Debug(Core %d): FPGA McBSP_AMC_EN# register setting failed \n", coreNum);
915             return;
916         }
917         else
918         {
919             MCBSP_log ("Debug(Core %d): FPGA McBSP_AMC_EN# register is set to %d \n", coreNum, uchValue);
920         }
921 #endif
922         /* MCBSP Driver Initialization: This should always be called before
923          * invoking the MCBSP Driver. */
924         mcbspInit();
926         /* Device Specific MCBSP Initializations */
927         McbspDevice_init();
928         
929         /* MCBSP Driver is operational at this time. */
930         MCBSP_log ("Debug(Core %d): MCBSP Driver Initialization Done\n", coreNum);
932         /* Write to the SHARED memory location at this point in time. The other cores cannot execute
933          * till the MCBSP Driver is up and running. */
934         isMCBSPInitialized[0] = 1;
936         /* The MCBSP IP block has been initialized. We need to writeback the cache here because it will
937          * ensure that the rest of the cores which are waiting for MCBSP to be initialized would now be
938          * woken up. */
939         //CACHE_wbL1d ((void *) &isMCBSPInitialized[0], MCBSP_MAX_CACHE_ALIGN, CACHE_FENCE_WAIT);
940         Cache_wb ((void *) &isMCBSPInitialized[0], MCBSP_CACHE_LENGTH,0x7fff, 1);
941     }
942     else
943     {
944         /* All other cores need to wait for the MCBSP to be initialized before they proceed with the test. */ 
945         MCBSP_log ("Debug(Core %d): Waiting for MCBSP to be initialized.\n", coreNum);
947         /* All other cores loop around forever till the MCBSP is up and running. 
948          * We need to invalidate the cache so that we always read this from the memory. */
949         while (isMCBSPInitialized[0] == 0)
950             //CACHE_invL1d ((void *) &isMCBSPInitialized[0], MCBSP_MAX_CACHE_ALIGN, CACHE_FENCE_WAIT);
951                 Cache_inv ((void *) &isMCBSPInitialized[0], MCBSP_CACHE_LENGTH, 0x7fff, 1);
954         MCBSP_log ("Debug(Core %d): MCBSP can now be used.\n", coreNum);
955     }
956     /* Enabling the dmaChannel MCBSP Events to EDMA (36-40) */
957     temp=sampleEdma3GblCfgParams[0].dmaChannelHwEvtMap[1];
958     sampleEdma3GblCfgParams[0].dmaChannelHwEvtMap[1]= temp | 0x000000F0;
960     /* Let RM Own the dmaChannels (36-40) */
961      temp=sampleInstInitConfig[0][0].ownDmaChannels[1];
962      sampleInstInitConfig[0][0].ownDmaChannels[1]=temp | 0x000000F0;
964      /* Let RM Own the TCCs (36-40) */
965      temp=sampleInstInitConfig[0][0].ownTccs[1];
966      sampleInstInitConfig[0][0].ownTccs[1]= temp | 0x000000F0;
968     /* Initialize EDMA3 library */
969     hEdma[0] = edma3init(0, &edmaResult);
971     if (edmaResult != EDMA3_DRV_SOK)
972     {
973         /* Report EDMA Error */
974         MCBSP_log("Debug(Core %d): EDMA Driver Initialization FAILED\n", coreNum);
975     }
976     else
977     {
978         MCBSP_log("Debug(Core %d): EDMA Driver Initialization Done\n", coreNum);
979     }
981     /* Create the Digital Loopback Application Task */
982     Task_Params_init(&taskParams);
983     Task_create(mcbspDigLpbkApp, &taskParams, NULL);
985     /* Start BIOS */
986     BIOS_start();
988     return;
991 /* ========================================================================== */
992 /*                                END OF FILE                                 */
993 /* ========================================================================== */