b_perph.c

DSP EDMA入门源代码

/********************************************************************************/
/* b_perph.c                                                                    */
/* written by David Bell                                                        */
/*         on 01/09/01                                                          */
/*                                                                              */
/* b_perph uses a single EDMA channel to service an external AFE. Channel 4 is  */
/* used to burst a frame of data for every EXT_INT4 event received. The data is */
/* transferred from the AFE to L2 memory.                                       */
/********************************************************************************/

#include <csl.h>
#include <csl_edma.h>


/* definitions */
#define MEM_SRC     0x80000000              /* Source address for transfer      */
#define MEM_DST     0x00008000              /* Destination address for transfer */
#define EL_COUNT    16                      /* Element count for transfer       */
#define FR_COUNT    16

/* prototypes */
void cfg_data(void);
Int32 cfg_edma(EDMA_Handle *hEdma_ch4);
void wait(EDMA_Handle *hEdma_ch4);
Int32 check_data(void);


/************************************cfg_data************************************/
/* Store a data ramp in the source memory space. This data will be transferred  */
/* by the EDMA.                                                                 */
/********************************************************************************/
void
cfg_data()
{
Uint16  *val;
Uint16   i = 0;

      val = (unsigned short *)MEM_SRC;
      
      /* Set up transfer data */
      for (i = 0; i < (FR_COUNT * EL_COUNT)<<1; i++){
            *val++ = i;
      } /* end for */
      
} /* end cfg_data */


/*************************************cfg_edma***********************************/
/* Program EDMA channels 4 to service an external AFE. The channel will submit  */
/* a transfer request to read a frame of data from the external AFE to inter-   */
/* nal L2 memory for every EXT_INT4 event received.                             */
/********************************************************************************/
Int32
cfg_edma(EDMA_Handle *hEdma_ch4)
{
Uint32 link_address;
EDMA_Config config;
EDMA_Handle hEdma_NULL;

      if (!EDMA_allocTableEx(1, &hEdma_NULL)) return(-1);
      EDMA_reset(hEdma_NULL);
      link_address = EDMA_getTableAddress(hEdma_NULL);
      
      *hEdma_ch4 = EDMA_open(4, EDMA_OPEN_RESET);

      /* Configure channel (4) */
      config.opt = (Uint32)                          /* 0x41340003 */
                   ((EDMA_OPT_PRI_LOW      << _EDMA_OPT_PRI_SHIFT   )
                  | (EDMA_OPT_ESIZE_32BIT  << _EDMA_OPT_ESIZE_SHIFT )
                  | (EDMA_OPT_2DS_NO       << _EDMA_OPT_2DS_SHIFT   )
                  | (EDMA_OPT_SUM_INC      << _EDMA_OPT_SUM_SHIFT   )
                  | (EDMA_OPT_2DD_NO       << _EDMA_OPT_2DD_SHIFT   )
                  | (EDMA_OPT_DUM_INC      << _EDMA_OPT_DUM_SHIFT   )
                  | (EDMA_OPT_TCINT_YES    << _EDMA_OPT_TCINT_SHIFT )
                  | (EDMA_OPT_TCC_OF(4)    << _EDMA_OPT_TCC_SHIFT   )
#if (C64_SUPPORT)
                  | (EDMA_OPT_TCCM_DEFAULT << _EDMA_OPT_TCCM_SHIFT  )
                  | (EDMA_OPT_ATCINT_NO    << _EDMA_OPT_ATCINT_SHIFT)
                  | (EDMA_OPT_ATCC_DEFAULT << _EDMA_OPT_ATCC_SHIFT  )
                  | (EDMA_OPT_PDTS_DISABLE << _EDMA_OPT_PDTS_SHIFT  )
                  | (EDMA_OPT_PDTD_DISABLE << _EDMA_OPT_PDTD_SHIFT  )
#endif
                  | (EDMA_OPT_LINK_YES     << _EDMA_OPT_LINK_SHIFT  )
                  | (EDMA_OPT_FS_YES       << _EDMA_OPT_FS_SHIFT    ));

      config.src = (Uint32)MEM_SRC;                  /* 0x80000000 */
      config.cnt = (Uint32)(((FR_COUNT - 1)<< 16) |  /* 0x000F     */ \
                            (EL_COUNT & 0xffff));    /*     0x0010 */ 
      config.dst = (Uint32)MEM_DST;                  /* 0x00008000 */
      config.idx = (Uint32)0;                        /* 0x00000000 */
      config.rld = (Uint32)link_address & 0xffff;         /* &NULL */

      EDMA_config(*hEdma_ch4, &config);
      
      return(0);
      
} /* end cfg_edma */


/**************************************wait**************************************/
/* Wait until the transfer completes, as indicated by bit 12 of the Channel     */
/* Interrupt Pending Register (CIPR).                                           */
/********************************************************************************/
void
wait(EDMA_Handle *hEdma_ch4)
{
Uint16 i;
      for (i=0; i<FR_COUNT; i++){
            EDMA_setChannel(*hEdma_ch4);
            while (!(EDMA_getPriQStatus() & EDMA_OPT_PRI_LOW));
      } /* end for */
            
      while (!((Uint32)EDMA_RGET(CIPR) & (1 << 4)));

} /* end wait */


/***********************************check_data***********************************/
/* Verify that the data was properly transferred by comparing the source data   */
/* to the destination data.                                                     */
/********************************************************************************/
Int32
check_data(void)
{
Uint16 *src = (Uint16 *)MEM_SRC,
       *dst = (unsigned short *)MEM_DST,
       source = 0,
       dest = 0,
       i = 0;
Uint32 err = 0;
      
      for (i = 0; i < (FR_COUNT * EL_COUNT)<<1; i++){
            dest = *dst;
            source = *src;

            if (dest != source){
                  /* Set error value if incorrect data */
                  err = i;
                  break;
            } /* end if */
            dst += 1;
            src += 1;
      } /* end for i */
      return(err);

} /* end check_data */


/**************************************main**************************************/
/* Main code body.                                                              */
/********************************************************************************/
void
main(void)
{
Int32 error  = 0;
EDMA_Handle hEdma_ch4;

      cfg_data();
      error = cfg_edma(&hEdma_ch4);
      if (!error){
            EDMA_enableChannel(hEdma_ch4);
            wait(&hEdma_ch4);
            EDMA_close(hEdma_ch4);
      } /* end if !error */

      if (!error) error = check_data();
      
      while(error);
      while(!error);

} /* end main */