sf_extract.c

DM642 DMA测试最新例程

/*****************************************************************************/
/* sf_extract.c                                                              */
/* written by David Bell                                                     */
/*         on 6/24/99                                                        */
/* last modified 12/19/00 : Use CSL                                          */
/*                                                                           */
/* sf_extract uses the QDMA to extract a subframe of data from an            */
/* array stored in external (CE0) memory. The data is transferred to         */
/* a buffer in internal (L2) memory.                                         */
/*****************************************************************************/

#include <csl.h>
#include <csl_dat.h>


/* definitions */
#define MEM_SRC     0x80000000         /* Source address for transfer        */
#define MEM_DST     0x00008000         /* Destination address for transfer   */
#define EL_COUNT    16                 /* Number of 16-bit elements per line */
#define LN_COUNT    12                 /* Number of lines                    */
#define LN_PITCH    32                 /* Pitch between lines (start->start) */

/* prototypes */
void cfg_data(void);
void submit_qdma(Uint32 xfr_id);
void wait(Uint32 xfr_id);
int check_data(void);


/***********************************cfg_data**********************************/
/* Store a data ramp in the source memory space. This data will be trans-    */
/* ferred by the EDMA.                                                       */
/*****************************************************************************/
void
cfg_data()
{
unsigned short  *val;
unsigned short   i = 0;

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


/**********************************submit_qdma********************************/
/* Submit a QDMA request to extract a subframe of data from a 640x480 video  */
/* image. The subframe is transferred from external (CE2) to internal (L2)   */
/* memory.                                                                   */
/*****************************************************************************/
void
submit_qdma(Uint32 xfr_id)
{
EDMA_Config config;

      config.opt = (Uint32)                                    /* 0x4D310001 */
                   ((EDMA_OPT_PRI_LOW            << _EDMA_OPT_PRI_SHIFT   )
                  | (EDMA_OPT_ESIZE_16BIT        << _EDMA_OPT_ESIZE_SHIFT )
                  | (EDMA_OPT_2DS_YES            << _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(xfr_id)     << _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;                            /* 0x80000000 */
      config.cnt = (Uint32)(((LN_COUNT-1)<<16)|EL_COUNT);      /* 0x000B0010 */ 
      config.dst = (Uint32)MEM_DST;                            /* 0x00008000 */
      config.idx = (Uint32)((LN_PITCH - EL_COUNT)<<1<<16);     /* 0x00200000 */

      EDMA_qdmaConfig(&config);
      
} /* 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(Uint32 xfr_id)
{
//      while (!(EDMA_getPriQStatus() & EDMA_OPT_PRI_LOW));
      while (!((EDMA_CIPR)&(1<<xfr_id)));
      EDMA_CIPR = EDMA_CIPR_OF(1<<xfr_id);

} /* end wait */


/***********************************check_data********************************/
/* Verify that the data was properly transferred by comparing the source data*/
/* to the destination data.                                                  */
/*****************************************************************************/
int
check_data(void)
{
unsigned short *src = (unsigned short *)MEM_SRC,
               *dst = (unsigned short *)MEM_DST,
                source = 0,
                dest = 0;
short           i, j = 0;
int             err = 0;
      
      for (i = 0; i < LN_COUNT; i++){
         for (j = 0; j < EL_COUNT; j++){
            dest   = dst[j];
            source = src[j];

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

} /* end check_data */


/*************************************main************************************/
/* Main code body.                                                           */
/*****************************************************************************/
void
main(void)
{
Uint32 xfr_id = 1;
Uint32 error  = 0;

      cfg_data();
#if 1
      submit_qdma(xfr_id);
      wait(xfr_id);
#else
      DAT_open(DAT_CHAANY, DAT_PRI_LOW, 0);
      xfr_id = DAT_copy2d(DAT_2D1D, (void *)MEM_SRC, (void *)MEM_DST,
               (Uint16)(EL_COUNT<<1), (Uint16)LN_COUNT, (Uint16)(LN_PITCH<<1));
      DAT_wait(xfr_id);
      DAT_close();
#endif

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

} /* end main */