dma.c

s3c4510的开发板snds100的源代码。

        GdmaIntDisable(gdma_channel);

        Print("\rGDMA%d:Compare source & destination Memory...",gdma_channel);  
        if ( !bcomp((U32 *)rGDMA.SRC, (U32 *)rGDMA.DST, (int)rGDMA.CNT) ) 
			{
			Print("Fail.") ;
			return 0 ;
			}
	else  
		{
		Print("Ok.") ;
		return 1 ;
		}
}



void GdmaRegTest(void)
{
     int gdma_channel;
     char ch;
     unsigned int i;

     /* Get GDMA Channel */      
     gdma_channel = GetGdmaChannel();
     Print("\rGDMA%d register read&write test.",gdma_channel);


     do {
          /* GDMASRC read,write test */
          Print("\r$ Enter GDMASRC%d register value?[8 hexdigit]_",gdma_channel);
          i = gethex2dec(8); get_byte(); //dummy for carrige return
          if(gdma_channel) {
              GDMASRC1 = i;
              Print("\r$GDMASRC1[0x%08x] = 0x%08x\r", &GDMASRC1,GDMASRC1); 
          }
          else {
                 GDMASRC0 = i;
                 Print("\r$GDMASRC0[0x%08x] = 0x%08x\r", &GDMASRC0,GDMASRC0); 
          }

          /* GDMADST read,write test */
          Print("\r$ Enter GDMADST%d register value?[8 hexdigit]_",gdma_channel);
          i = gethex2dec(8); get_byte(); //dummy for carrige return
          if(gdma_channel) {
               GDMADST1 = i;
               Print("\r$GDMADST1[0x%08x] = 0x%08x\r", &GDMADST1,GDMADST1); 
          }
          else {
                GDMADST0 = i;
                Print("\r$GDMADST0[0x%08x] = 0x%08x\r", &GDMADST0,GDMADST0); 
          }

          /* GDMACNT read,write test */
          Print("\r$ Enter GDMACNT%d register value?[8 hexdigit]_",gdma_channel);
          i = gethex2dec(8); get_byte(); //dummy for carrige return
          if(gdma_channel) {
                GDMACNT1 = i;
                Print("\r$GDMACNT1[0x%08x] = 0x%08x\r", &GDMACNT1,GDMACNT1); 
          }
          else {
                GDMACNT0 = i;
                Print("\r$GDMACNT0[0x%08x] = 0x%08x\r", &GDMACNT0,GDMACNT0); 
          }
    

           /* GDMACON read,write test */
           Print("\r$ Enter GDMACON%d register value?[4 hexdigit]_",gdma_channel);
           i = gethex2dec(4); get_byte(); //dummy for carrige return
           if(gdma_channel) {
               GDMACON1 = i;
               Print("\r$GDMACON1[0x%08x] = 0x%08x\r", &GDMACON1,GDMACON1); 
               Print("\r$GDMASRC1[0x%08x] = 0x%08x\r", &GDMASRC1,GDMASRC1); 
               Print("\r$GDMADST1[0x%08x] = 0x%08x\r", &GDMADST1,GDMADST1); 
               Print("\r$GDMACNT1[0x%08x] = 0x%08x\r", &GDMACNT1,GDMACNT1); 
           }
           else {
                 GDMACON0 = i;
                 Print("\r$GDMACON0[0x%08x] = 0x%08x\r", &GDMACON0,GDMACON0); 
                 Print("\r$GDMASRC0[0x%08x] = 0x%08x\r", &GDMASRC0,GDMASRC0); 
                 Print("\r$GDMADST0[0x%08x] = 0x%08x\r", &GDMADST0,GDMADST0); 
                 Print("\r$GDMACNT0[0x%08x] = 0x%08x\r", &GDMACNT0,GDMACNT0); 
           }

           Print("\r$Continuing GDMA Register R/W test?[Y/N]_"); 
     } while(((ch=get_byte()) != 'N')&& (ch != 'n'));          
}


void GdmaUart0Mem(void)
{
     if(rGDMA.CON&GDMA_MEM2UART) 
           Memory2UartTest(SERIAL_DEV0);
     else 
           Uart2MemoryTest(SERIAL_DEV0);
}



void GdmaUart1Mem(void)
{
     if(rGDMA.CON&GDMA_MEM2UART) 
           Memory2UartTest(SERIAL_DEV1);
     else 
           Uart2MemoryTest(SERIAL_DEV1);
}


void Uart2MemoryTest(unsigned uart_channel)
{
    int gdma_channel;

        gdma_channel = GetGdmaChannel(); 
        GdmaIntEnable(gdma_channel);

        SetupUart4Gdma(uart_channel,gdma_channel);

        tmReset(TIMER_DEV1);
	tm_init(TIMER_DEV1,(ONE_SECOND/TICKS_PER_SECOND));
	TimerStart(TIMER_DEV1);

        if(gdma_channel) while(!Gdma1DoneFlag)  DisplayGdma(gdma_channel);
        else while(!Gdma0DoneFlag)  DisplayGdma(gdma_channel);
        Timer1Stop();

        //UARTPollInit(uart_channel);
        Print("\r\r\r");
        PrtSysTime(TIMER_DEV1,"GDMA Transfer time"); tmReset(TIMER_DEV1);

        GdmaIntDisable(gdma_channel);
}


/* 
 * UART to Memory data transfer through GDMA continually.
 */
void DataDownLoad(void)
{
    int RxDataSize;
    char ch;
   
    do { RxDataSize = GdmaDownLoad();
         MemDump((U32 *)DmaCodeArea,(U32 *)(DmaCodeArea+RxDataSize)); 
         Print("\nTo exit, type ESC key!!!\n"); 
         if(is_space(ch=get_byte()));
    }while(ch != ESC); 
}


/*
 * GDMA Down Load 
 */
unsigned GdmaDownLoad(void)
{
     unsigned RcvDataSize;

     // Interrupt Enable
     Enable_Int(nGLOBAL_INT);
     GdmaIntEnable(SERIAL_DEV0);

     Print("\r\r\r$ Download data UART0 to Memory through GDMA0....\r") ;

     GdmaReset(0);  //Reset Channel of GDMA0
     rGDMA.DST=(U32)DmaCodeArea; //default source addrmaTestDst
     RcvDataSize = GetDataSize(SERIAL_DEV0); //Include CRC value
     rGDMA.CNT = RcvDataSize+8;
 
     //Print("\r$ Receive data size = 0x%08x", rGDMA.CNT);
     //Print("\r$ DownLoad area = 0x%08x\r\r\r", rGDMA.DST);

     //Set GDMA Mode for transferring data Uart to memory through GDMA
     rGDMA.CON = GDMA_INT_ENABLE|GDMA_U0MODE|GDMA_SRC_FIX;  
     GDMARegWrite(0);
     UARTCONT0 = UCON_RXM_GDMA0REQ ; // Set UART to GDMA request mode
	//put_byte(UARTRXB0) ;
     GdmaRunEnable(0);

     //tm_init_ms(TIMER0);  // Timer initialize & start  
     while(!Gdma0DoneFlag) ;  //DisplayGdma(0);
     Print("\r Gdma Done") ;

     GdmaIntDisable(SERIAL_DEV0);

/*
     if(CRCErrorCheck((char *)DmaCodeArea,RcvDataSize))  
	 Print("\rCRC Check Ok .."); 
     else  Print("\rCRC Check Error Occured!!!"); 
*/

     return((unsigned)RcvDataSize);
}



/*
 * Setup UART for GDMA down load 
 */
void SetupUart4Gdma(unsigned uart_channel,unsigned gdma_channel)
{
     int RcvDataSize ;


	Print("\r\r\r$ Download User Program use by GDMA...\r\r") ;

	rGDMA.DST=(U32)DmaCodeArea; //default source addrmaTestDst

	RcvDataSize = GetDataSize(uart_channel); //Include CRC value
	rGDMA.CNT = RcvDataSize+4;
 
        Print("\r$ Receive data size = 0x%08x", rGDMA.CNT);
        Print("\r$ GDMA DownLoad area = 0x%08x\r\r\r", rGDMA.DST);


        /* GDMA MODE SET for UART to MEMORY Transfer test */
        if(!rGDMA.DIALOG) {
               //default set for Uart to memory test 
               Uart2MemRun(uart_channel,gdma_channel); 
               GDMARegWrite(gdma_channel);
        }
        else {
               // GDMA related register all clear to reset state
               GdmaReset(gdma_channel);  
               GDMARegWrite(gdma_channel);
               //GDMARegPrint(gdma_channel);
        }

        /* Setup UART channel for GDMA Request */
        SetGdmaRxReqMode(uart_channel, gdma_channel);
        GdmaRunEnable(gdma_channel);
}

/*
 * Set UART to GDMA channel request mode
 */
void SetGdmaRxReqMode(unsigned uart_channel, unsigned gdma_channel)
{
        if(uart_channel) {
             if(gdma_channel) UARTCONT1 = UCON_RXM_GDMA1REQ;
             else UARTCONT1 = UCON_RXM_GDMA0REQ;
        }
        else {
               if(gdma_channel) UARTCONT0 = UCON_RXM_GDMA1REQ;
               else UARTCONT0 = UCON_RXM_GDMA0REQ;
        }
}



/*
 * Set UART GDMA channel request mode
 */
void SetGdmaTxReqMode(unsigned uart_channel, unsigned gdma_channel)
{
        if(uart_channel) {
             if(gdma_channel) UARTCONT1 = UCON_TXM_GDMA1REQ;
             else UARTCONT1 = UCON_TXM_GDMA0REQ;
        }
        else {
               if(gdma_channel) UARTCONT0 = UCON_TXM_GDMA1REQ;
               else UARTCONT0 = UCON_TXM_GDMA0REQ;
        }
}



void Memory2UartTest(unsigned uart_channel)
{
    int gdma_channel;

        gdma_channel = GetGdmaChannel(); 
        GdmaIntEnable(gdma_channel);
      
        //if(uart_channel) rGDMA.DST = (U32)&UARTTXH1; //Uart1 receive buffer register
        //else rGDMA.DST = (U32)&UARTTXH0; //Uart0 receive buffer register

        Print("\r>>Input source Address[0x1500000]> 0x");
        rGDMA.SRC = get_num() ;
        if (rGDMA.SRC==0) rGDMA.SRC=(U32)DmaTestSrc;  //default source addr

        Print("\r>>Input Memory Test Size[0x10000]> 0x") ;
        rGDMA.CNT = get_num() ;
        if (rGDMA.CNT==0) rGDMA.CNT=(U32)DmaTestSize;

        /*Initialize source memory with random pattern */
        GdmaMemInit((void *)rGDMA.SRC, (int)rGDMA.CNT); 

        /* GDMA MODE SET for memory word test*/
        if(!rGDMA.DIALOG) {//default set for memory to uart test 
                Mem2UartRun(uart_channel, gdma_channel); 
                GDMARegWrite(gdma_channel);
        }
        else {
               GdmaReset(gdma_channel);  
               GDMARegWrite(gdma_channel);
               //GDMARegPrint(gdma_channel);
        }

        SetGdmaTxReqMode(uart_channel, gdma_channel);
        GdmaRunEnable(gdma_channel);

        tmReset(TIMER_DEV1);
	tm_init(TIMER_DEV1,(ONE_SECOND/TICKS_PER_SECOND));
	TimerStart(TIMER_DEV1);

        if(gdma_channel) while(!Gdma1DoneFlag)  DisplayGdma(gdma_channel);
        else while(!Gdma0DoneFlag)  DisplayGdma(gdma_channel);

        Timer1Stop();
        //UARTPollInit(uart_channel);
        put_byte('\r');
        PrtSysTime(TIMER_DEV1,"GDMA Transfer time"); tmReset(TIMER_DEV1);

        GdmaIntDisable(gdma_channel);
}


/* 
 * Initialize GDMA Memory with ASCII pattern for test  
 */
void GdmaMemInit(void *src, int tsize)
{
	U8  *InitSrcAddr;
	int cnt ;
	int ascii=48;

	InitSrcAddr = (U8 *)src;
	cnt = tsize ;

        while(cnt--) {
              if(ascii < 123) *InitSrcAddr++ = (U32)ascii;
              else ascii = 48;
              ascii++;
        }
}


/*
 * External GDMA Request test 
 */
void ExtGdmaReqTest(void)
{
    int gdma_channel;

        gdma_channel = GetGdmaChannel(); 

        GdmaIntEnable(gdma_channel);
      
        Print("\r>>Input source Address[0x1500000]> 0x");
        rGDMA.SRC = get_num() ;
        if (rGDMA.SRC==0) rGDMA.SRC=(U32)DmaTestSrc;  //default source addr

        Print("\r>>Input destination Address[0x1600000]> 0x");
        rGDMA.DST = get_num() ;
        if (rGDMA.DST==0) rGDMA.DST=(U32)DmaTestDest;  //default source addr

        Print("\r>>Input Memory Test Size[0x10000]> 0x") ;
        rGDMA.CNT = get_num() ;
        if (rGDMA.CNT==0) rGDMA.CNT=(U32)DmaTestSize;

        /*Initialize source memory with random pattern */
        MemTestInit((U32 *)rGDMA.SRC, (int)rGDMA.CNT); 
        Print("\rSource Address Initialize done!\r");

        /* GDMA MODE SET for memory word test*/
        if(!rGDMA.DIALOG) {//default set for memory to uart test 
                ExtDreqRun(gdma_channel); 
                GDMARegWrite(gdma_channel);
        }
        else { // Set use by StartUp dialog
               GdmaReset(gdma_channel);  
               GDMARegWrite(gdma_channel);
        }
     
        tmReset(TIMER_DEV1);
	tm_init(TIMER_DEV1,(ONE_SECOND/TICKS_PER_SECOND));
	TimerStart(TIMER_DEV1);

        put_byte('\r');
        if(gdma_channel) 
             while(!Gdma1DoneFlag) DisplayGdma(gdma_channel);
        else
             while(!Gdma0DoneFlag) DisplayGdma(gdma_channel);

        Timer1Stop();
        put_byte('\r');
        PrtSysTime(TIMER_DEV1,"GDMA Transfer time"); tmReset(TIMER_DEV1);

        GdmaIntDisable(gdma_channel);
}

/******************************************************************/
/*        GDMA0, GDMA1 FUNCTION MODULE FOR EACH MODE              */
/******************************************************************/
/*
 * External GDMA Request run
 */
void ExtDreqRun(unsigned gdma_channel)
{
    // GDMA related register all clear to reset state
    GdmaReset(gdma_channel);  
    rGDMA.CON |= GDMA_RUN|GDMA_INT_ENABLE|GDMA_EXTDREQ;  
}


/*
 * GDMA Uart versa Memory
 */
void Uart2MemRun(unsigned uart_channel,unsigned gdma_channel)
{
    GdmaReset(gdma_channel);  // GDMA related register all clear to reset state

    if(uart_channel) 
         rGDMA.CON = GDMA_INT_ENABLE|GDMA_U1MODE|GDMA_SRC_FIX;  
    else 
         rGDMA.CON = GDMA_INT_ENABLE|GDMA_U0MODE|GDMA_SRC_FIX;  
}

void Mem2UartRun(unsigned uart_channel,unsigned gdma_channel)
{
    GdmaReset(gdma_channel);  // GDMA related register all clear to reset state

    if(uart_channel) 
        rGDMA.CON = GDMA_INT_ENABLE|GDMA_U1MODE|GDMA_MEM2UART|GDMA_DST_FIX;  
    else
        rGDMA.CON = GDMA_INT_ENABLE|GDMA_U0MODE|GDMA_MEM2UART|GDMA_DST_FIX;  

    //GDMARegPrint(gdma_channel);
    //GDMARegWrite(gdma_channel);
}