sorting.c

DM642 DMA测试最新例程

/********************************************************************************/
/* sorting.c                                                                    */
/* written by David Bell                                                        */
/*         on 12/20/00                                                          */
/*                                                                              */
/* sorting.c uses the QDMA to perform a transfer from external (CE0) memory to  */
/* internal (L2) memory. The data is arranged in contiguous arrays and is to be */
/* re-ordered according to position within the array.                           */
/* i.e. from A0, A1, ..., An    to A0, B0, ..., N0                              */
/*           B0, B1, ..., Bn       A1, B1, ..., N1                              */
/*            :   :    :   :        :   :    :   :                              */
/*           N0, N1, ..., Nn       An, Bn, ..., Nn                              */
/********************************************************************************/

#include <csl.h>
#include <csl_dat.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    32                      /* Element count per array          */
#define AR_COUNT    12                      /* Number of arrays                 */
#define EL_SIZE     2                       /* Element size in bytes            */
#define EL_INDEX    AR_COUNT * EL_SIZE      /* Index equals the array length    */

/* prototypes */
void cfg_data(void);
void submit_qdma(void);
void wait(void);
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 = (Uint16 *)MEM_SRC;
      
      /* Set up transfer data */
      for (i = 0; i < (AR_COUNT * EL_COUNT); i++){
            *val++ = i;
      } /* end for */
      
} /* end cfg_data */


/***********************************submit_qdma**********************************/
/* Submit a QDMA request to transfer the data.                                  */
/********************************************************************************/
void
submit_qdma(void)
{
Uint16      i;
EDMA_Config config;

      config.opt = (Uint32)                           /* 0xA0000000 */
                   ((EDMA_OPT_PRI_LOW      << _EDMA_OPT_PRI_SHIFT   )
                  | (EDMA_OPT_ESIZE_16BIT  << _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_IDX      << _EDMA_OPT_DUM_SHIFT   )
                  | (EDMA_OPT_TCINT_NO     << _EDMA_OPT_TCINT_SHIFT )
                  | (EDMA_OPT_TCC_DEFAULT  << _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_NO      << _EDMA_OPT_LINK_SHIFT  )
                  | (EDMA_OPT_FS_YES       << _EDMA_OPT_FS_SHIFT    ));

      config.src = (Uint32)MEM_SRC;                    /* 0xA0000000 */
      config.cnt = (Uint32)EL_COUNT;                   /* 0x00000100 */ 
      config.dst = (Uint32)MEM_DST;                    /* 0x00002000 */
      config.idx = (Uint32)EL_INDEX;                   /* 0x00000000 */

      EDMA_qdmaConfig(&config);

#if 1      
      for (i = 0; i < AR_COUNT - 1; i++){
            config.src += EL_COUNT * EL_SIZE;
            config.dst += EL_SIZE;
            EDMA_qdmaConfig(&config);
            /*********************************************************/
            /* To reduce the number of additional writes to only two */
            /* For each array, you can specify the updates rather    */
            /* than using qdmaConfig. To do so, replace the above    */
            /* line with:                                            */
            /*   base = (volatile Uint32 *)(_EDMA_QOPT_ADDR);        */
            /*   base[_EDMA_QSRC_OFFSET]  = config.src;              */
            /*   base[_EDMA_QSDST_OFFSET] = config.dst;              */
            /* Note that you must declare base above                 */
            /*********************************************************/

      } /* end for i */
#endif
      
} /* end submit_qdma */


/**************************************wait**************************************/
/* Wait until the transfer completes, as indicated by the status of the low-    */
/* priority queue in the queue status register (QSR).                           */
/********************************************************************************/
void
wait(void)
{
      while (!(EDMA_getPriQStatus() & EDMA_OPT_PRI_HIGH));

} /* 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 = (unsigned short *)MEM_SRC,
       *dst = (unsigned short *)MEM_DST,
        source = 0,
        dest = 0;
Uint16  i, j;
Int32   err = 0;
      
      for (i = 0; i < AR_COUNT; i++){
         for (j = 0; j < EL_COUNT; j++){
            dest = dst[AR_COUNT * j];
            source = src[j];

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

} /* end check_data */


/**************************************main**************************************/
/* Main code body.                                                              */
/********************************************************************************/
void
main(void)
{
Uint16 i;
Uint32 xfr_id = 0;
Uint32 error  = 0;
Uint8 *source = (Uint8 *)MEM_SRC;
Uint8 *dest   = (Uint8 *)MEM_DST;

      cfg_data();
#if 1
      submit_qdma();
      wait();
#else
      DAT_open(DAT_CHAANY, DAT_PRI_LOW, 0);
      for (i = 0; i < AR_COUNT ; i++){
            xfr_id = DAT_copy2d(DAT_1D2D, (void *)source, (void *)dest,
                     (Uint16)EL_SIZE, (Uint16)(EL_COUNT*EL_SIZE),
                     (Uint16)(AR_COUNT*EL_SIZE));
            source += EL_COUNT * EL_SIZE;
            dest   += EL_SIZE;
      } /* end for i */
      DAT_wait(xfr_id);
      DAT_close();
#endif

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

} /* end main */