*------------------------------------------------------------------------------
* FILENAME...... mcbsp.c
* DATE CREATED.. 03/11/2008
* LAST MODIFIED. 03/29/2008
\******************************************************************************/
#include <stdio.h>

#include <csl.h>
#include <csl_mcbsp.h>
#include <csl_irq.h>

/*----------------------------------------------------------------------------*/
#define N 20                 

/* In this example, the MCBSP is configured in digital loopback */
/* mode, with 32 bit data transfer, in multi-frame mode, using  */
/* sample rate generator to sync frames                         */
/* MCBSP setup is performed in a TSK function that executes on  */
/* exit from "main"                                             */

/* Create a MCBSP configuration structure */
 static MCBSP_Config ConfigLoopBack32= {
   MCBSP_SPCR1_RMK(
     MCBSP_SPCR1_DLB_ON,                    /* DLB    = 1 */
     MCBSP_SPCR1_RJUST_RZF,                 /* RJUST  = 0 */
     MCBSP_SPCR1_CLKSTP_DISABLE,            /* CLKSTP = 0 */
     MCBSP_SPCR1_DXENA_NA,                  /* DXENA  = 0 */
     MCBSP_SPCR1_ABIS_DEFAULT,              /* ABIS   = 0 */
     MCBSP_SPCR1_RINTM_RRDY,                /* RINTM  = 0 */
     MCBSP_SPCR1_RRST_DISABLE               /* RRST   = 0 */
   ),
   MCBSP_SPCR2_RMK(
     MCBSP_SPCR2_FREE_NO,                   /* FREE   = 0 */
     MCBSP_SPCR2_SOFT_NO,                   /* SOFT   = 0 */
     MCBSP_SPCR2_FRST_FSG,                  /* FRST   = 1 */
     MCBSP_SPCR2_GRST_CLKG,                 /* GRST   = 1 */
     MCBSP_SPCR2_XINTM_XRDY,                /* XINTM  = 0 */
     MCBSP_SPCR2_XRST_DISABLE               /* XRST   = 0 */
   ),
   MCBSP_RCR1_RMK(
    0,                                      /* RFRLEN1 = 0 */
    5                                       /* RWDLEN1 = 5 */
   ),
   MCBSP_RCR2_RMK(    
     MCBSP_RCR2_RPHASE_SINGLE,              /* RPHASE  = 0 */
     MCBSP_RCR2_RFRLEN2_OF(0),              /* RFRLEN2 = 0 */
     MCBSP_RCR2_RWDLEN2_16BIT,              /* RWDLEN2 = 2 */
     MCBSP_RCR2_RCOMPAND_MSB,               /* RCOMPAND = 0 */
     MCBSP_RCR2_RFIG_YES,                   /* RFIG    = 0 */
     MCBSP_RCR2_RDATDLY_0BIT                /* RDATDLY = 0 */
   ),  
   MCBSP_XCR1_RMK( 
    MCBSP_XCR1_XFRLEN1_OF(0),              /* XFRLEN1 = 0 */
    MCBSP_XCR1_XWDLEN1_32BIT               /* XWDLEN1 = 5 */
   ),   
   MCBSP_XCR2_RMK(   
     MCBSP_XCR2_XPHASE_SINGLE,              /* XPHASE  = 0 */
     MCBSP_XCR2_XFRLEN2_OF(0),              /* XFRLEN2 = 0 */
     MCBSP_XCR2_XWDLEN2_16BIT,              /* XWDLEN2 = 2 */
     MCBSP_XCR2_XCOMPAND_MSB,               /* XCOMPAND = 0 */
     MCBSP_XCR2_XFIG_YES,                   /* XFIG    = 0 */
     MCBSP_XCR2_XDATDLY_0BIT                /* XDATDLY = 0 */
   ),            
   MCBSP_SRGR1_RMK( 
     MCBSP_SRGR1_FWID_OF(1),                /* FWID    = 1 */
     MCBSP_SRGR1_CLKGDV_OF(1)               /* CLKGDV  = 1 */
   ),   
  MCBSP_SRGR2_RMK(  
     MCBSP_SRGR2_GSYNC_FREE,                /* FREE    = 0 */
     MCBSP_SRGR2_CLKSP_RISING,              /* CLKSP   = 0 */
     MCBSP_SRGR2_CLKSM_INTERNAL,            /* CLKSM   = 1 */
     MCBSP_SRGR2_FSGM_DXR2XSR,              /* FSGM    = 0 */
     MCBSP_SRGR2_FPER_OF(15)                /* FPER    = 15 */
  ),  
  MCBSP_MCR1_DEFAULT,
  MCBSP_MCR2_DEFAULT,
  MCBSP_PCR_RMK(
    MCBSP_PCR_XIOEN_SP,                   /* XIOEN    = 0  */
    MCBSP_PCR_RIOEN_SP,                   /* RIOEN    = 0  */
    MCBSP_PCR_FSXM_INTERNAL,              /* FSXM     = 1  */
    MCBSP_PCR_FSRM_EXTERNAL,              /* FSRM     = 0  */
    MCBSP_PCR_SCLKME_NO,                  /* SCLKME   = 0  */     
    MCBSP_PCR_CLKXM_OUTPUT,               /* CLKXM    = 1  */
    MCBSP_PCR_CLKRM_INPUT,                /* CLKRM    = 0  */
    MCBSP_PCR_FSXP_ACTIVEHIGH,            /* FSXP     = 0  */
    MCBSP_PCR_FSRP_ACTIVEHIGH,            /* FSRP     = 0  */
    MCBSP_PCR_CLKXP_RISING,               /* CLKXP    = 0  */
    MCBSP_PCR_CLKRP_FALLING               /* CLKRP    = 0  */
  ),
  0x0000u,                                /* RCERA */
  0x0000u,                                /* RCERB */
  0x0000u,                                /* RCERC */
  0x0000u,                                /* RCERD */
  0x0000u,                                /* RCERE */
  0x0000u,                                /* RCERF */
  0x0000u,                                /* RCERG */
  0x0000u,                                /* RCERH */
  0x0000u,                                /* XCERA */
  0x0000u,                                /* XCERB */
  0x0000u,                                /* XCERC */
  0x0000u,                                /* XCERD */
  0x0000u,                                /* XCERE */
  0x0000u,                                /* XCERF */
  0x0000u,                                /* XCERG */
  0x0000u                                 /* XCERH */
};     
 
/* Create data buffers for transfer */
Uint32 xmt[N], rcv[N]; 
void taskFunc(void);
/*----------------------------------------------------------------------------*/
void main() {
  Uint16 i;
  
  /* Initialize CSL library, this step is required */
  CSL_init();

  /* Initilize data buffers. xmt will be 32 bit value      */
  /* with element number in lower 16 bits and 2 * element  */
  /* in upper 16 bits.  i.e.  0x00020001, 0x00040002, etc. */
  for(i=0;i<=N-1;i++) {
    xmt[i] = (((Uint32)(i+1)<<17) + (i+1));
    rcv[i] = 0;
  }

  /* Call example function to perform task */
  taskFunc();
}


/*----------------------------------------------------------------------------*/
void taskFunc(void) {

  MCBSP_Handle mhMcbsp;
  Uint16 i;
  Uint16 err = 0;

  printf("<MCBSP>\n");

   
  /* Open MCBSP Port 0, this will return a MCBSP handle that will */
  /* be used in calls to other CSl functions.                     */ 
  mhMcbsp = MCBSP_open(MCBSP_PORT0, MCBSP_OPEN_RESET);

  /* Write configuration structure values to MCBSP control */
  /* registers                                             */
  MCBSP_config(mhMcbsp, &ConfigLoopBack32); 
   
  /* Take MCBSP receive and transmit out of reset */
  MCBSP_start(mhMcbsp, 
    MCBSP_RCV_START | MCBSP_XMIT_START, 
    0
  );

  /* Prime MCBSP DXR */
  while (!MCBSP_xrdy(mhMcbsp)) {
    ;
  }
  MCBSP_write32(mhMcbsp,xmt[0]);       

  /* Start the MCBSP and Sample Rate Generator */
  MCBSP_start(mhMcbsp, 
    MCBSP_SRGR_START | MCBSP_SRGR_FRAMESYNC, 
    0x200
  );

  /* Get First Element */ 
  while (!MCBSP_rrdy(mhMcbsp)) {
    ;
  }

 /* Read 32 bit value from DRR */
 rcv[0] = MCBSP_read32(mhMcbsp);               

 

  /* Begin data transfer loop. We will loop thru to transmit */
  /* and receive the data.                                   */  
  for (i=0; i<=N-1;i++) {
 
    /* Wait for XRDY signal before writing data to DXR */
    while (!MCBSP_xrdy(mhMcbsp));       
                 
    /* Write 32 bit data value to DXR */    
    MCBSP_write32(mhMcbsp,xmt[i]);       
 
    /* Wait for RRDY signal to read data from DRR */
    while (!MCBSP_rrdy(mhMcbsp));

    /* Read 32 bit value from DRR */
    rcv[i] = MCBSP_read32(mhMcbsp);               
  }    

  /* Check data to make sure transfer was successful */
  for(i=0; i<= N-1;i++) {
    if (xmt[i] != rcv[i]) {
       ++err;
       break;
    }
  }
 
  /* We are done with MCBSP, so close it */ 
  MCBSP_close(mhMcbsp);

  printf("%s\n",err?"TEST FAILED":"TEST PASSED");
  printf("<DONE>\n");                     
}