dma.c

本source code 為s3c4510的bootloader

  {
   Gdma1DoneFlag = 0;			// clear gdma1 interrupt done flag  
   GDMA1_RUN_ENABLE = 1;		// start GDMA1	
   while(Gdma1DoneFlag == 0) {;} 	// wait GDMA1 done interrupt 
  }
 else  
  {
   Gdma0DoneFlag = 0;			// clear gdma0 interrupt done flag 
   GDMA0_RUN_ENABLE = 1;		// start GDMA0 
   while(Gdma0DoneFlag == 0) {;}  	// wait GDMA0 done interrupt
  }

// 
 Disable_Int(nGLOBAL_INT);		// disable global interrupt 
 GdmaIntDisable(gdma);			// disable GDMA channel

// restore UART configuration ////////////////////////////////////////////////// 

 uartcont = (uartcont & ~UARTCON_RXM) | UARTCON_RXM_INTREQ;
 if(uart == 1)
  {
   UARTCONT1 = uartcont;		// restore UART1 control register
  } 
 else
 if(uart == 0)
  {
   UARTCONT0 = uartcont;		// restore UART0 control register
  } 

// check destination buffer ////////////////////////////////////////////////////
 ptr = (U8 *) gdmadst;
 changed = 0;
 for(i = 0; i < size; ++i)
  {
   if(*ptr++ != i)
    {
     changed = 1;
    } 
  }

 if(changed == 0)
  {
// destination buffer not changed //////////////////////////////////////////////

   Print("\nFail. Destination buffer not changed.\n");
  }
 else
  {
// Destination buffer changed //////////////////////////////////////////////////

   Print("\nPrint received buffer [Y/N]");  
   changed = get_upper();
   if(changed == 'Y')
    {
// print content of destination buffer /////////////////////////////////////////
     Print("\n");
     MemDump((U32 *) gdmadst, (U32 *) gdmadst + size);
    }   
   Print("\n");
  }
}

//////////////////////////////////////////////////////////////////////////////// 
// GDMA Memory to UART0/UART1 transfer test //////////////////////////////////// 
//////////////////////////////////////////////////////////////////////////////// 

static void MemToUartTest(void)
{
 int uart;				// UART number
 int gdma;				// GDMA Channel 

 Print("\n\nGDMA memory to UART0/UART1 transfer test");

// Get GDMA Channel ////////////////////////////////////////////////////////////
 while(1)
  { 
   Print("\nSelect UART0/UART1               [0/1/Q]");
   uart = get_upper();			// get UART number from console
   if(uart == 'Q')
    {
     return;
    }
   else
   if( (uart == '1') || (uart == '0') )
    {
     uart -= '0';
     break;
    }
  }

// Get GDMA Channel ////////////////////////////////////////////////////////////
 while(1) 
  { 
   Print("\nSelect GDMA Channel              [0/1/Q]");
   gdma = get_upper();			// 
   if(gdma == 'Q')
    {
     return;
    } 
   else
   if( (gdma == '1') || (gdma == '0') )
    {
     gdma -= '0';
     break;
    }
  }

// GDMA Memory to Uart transfer test ///////////////////////////////////////////
 MemoryToUartTest(uart, gdma); 	 	// memory to UART 0 test
}

//////////////////////////////////////////////////////////////////////////////// 
// memory to UART transfer test ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// 


void MemoryToUartTest(int uart, int gdma)
{
 U32 uartcont;				// UART0/UART1 control register content
 U32 gdmasrc;				// GDMA source address
 U32 gdmadst;				// GDMA destination address
 U32 gdmacnt;				// GDMA transfer count register  
 U32 gdmacon;				// GDMA control register 
 U8 * ptr;				// source buffer pointer 
 int i;


// Source address //////////////////////////////////////////////////////////////
 Print("\nInput source Address (0x%08x) : 0x",  (U32) GDMATestSrc);
 gdmasrc = get_number(16,0);
 if(gdmasrc == 0) 
  {
   gdmasrc = (U32) GDMATestSrc;  	// default source addr
  }

// Source size /////////////////////////////////////////////////////////////////

 if(get_last() != KEY_CR) { Print("\n"); }
 Print("\rInput Memory Test Size (0x%08x) 0x",  (U32) GDMATestSize);
 gdmacnt = get_number(16,0);
 if(gdmacnt == 0) 
  {
   gdmacnt = (U32) GDMATestSize;
  }

 if(
   gdmasrc == (U32) GDMATestSrc &&	//
   gdmacnt <=       GDMATestSize
  )
  {
   U8 ch;				// 
// Initialize source memory ////////////////////////////////////////////////////

   ch = 48;
   ptr = (U8 *) gdmasrc;
   for(i = 0; i < gdmacnt; ++i)
    {
     *ptr++ = ch++;
     if(ch >= 128)
      {
       ch = 48;
      } 
    }
  } 

// default set for memory to uart test /////////////////////////////////////////

 GdmaReset(gdma);  	// GDMA related register all clear to reset state

 gdmacon = 
  GDMACON_SI        |			// GDMA Stop Interrupt Enable 
  GDMACON_TD_MEMTOU |			// Transfer direction Memory to UART
  GDMACON_DST_FIX   |  			// destination address fix
  GDMACON_TW_BYTE; 			// 0 transfer width - byte

 if(uart) 
  {
   gdmacon |= GDMACON_MODE_U1;		// UART channel 1 
   uartcont  = UARTCONT1;		// save UARTCONT1 
  }
 else
  {
   gdmacon |= GDMACON_MODE_U0;		// UART channel 0
   uartcont  =  UARTCONT0;		// save UARTCONT0
  }

//
 gdmadst = 0;

// Configure GDMA channel //////////////////////////////////////////////////////

 uartcont &= ~UARTCON_TXM;
 if(gdma) 
  { 
   uartcont |= UARTCON_TXM_GDMA1REQ;
//
   GDMASRC1 = gdmasrc;			// GDMA 1 source address
   GDMADST1 = gdmadst;			// GDMA 1 destination address
   GDMACNT1 = gdmacnt;			// GDMA 1 transfer count	
   GDMACON1 = gdmacon;			// GDMA 1 control register 
  }
 else 
  {
   uartcont |= UARTCON_TXM_GDMA0REQ;
//
   GDMASRC0 = gdmasrc;			// GDMA 0 source address
   GDMADST0 = gdmadst;			// GDMA 0 destination address
   GDMACNT0 = gdmacnt;			// GDMA 0 transfer count 
   GDMACON0 = gdmacon;			// GDMA 0 control register
  }

 Print("\n");
 PrintGDMASRC(gdma);			// GDMA  source address
 PrintGDMADST(gdma);			// GDMA  destination address
 PrintGDMACNT(gdma);			// GDMA  transfer count	
 PrintGDMACON(gdma);			// GDMA  control register 
 Print("\n");

 if(uart == 1)
  {
   UARTCONT1 = uartcont;		// restore UARTCONT1 
  }
 else
  {
   UARTCONT0 = uartcont;		// restotr UARTCONT0
  } 


// Enable GDMA Channel Interrupt, Clear Done Flag and Global enable interrupt //  
 GdmaIntEnable(gdma);
 Enable_Int(nGLOBAL_INT); 
 
// Run GDMA Channel ////////////////////////////////////////////////////////////

 if(gdma) 
  {
   Gdma1DoneFlag = 0;
   GDMA1_RUN_ENABLE = 1;
   while(Gdma1DoneFlag == 0)  
    {					// wait GDMA1 
    }					// done interrupt 
  }
 else  
  {
   Gdma0DoneFlag = 0;
   GDMA0_RUN_ENABLE = 1;
   while(Gdma0DoneFlag == 0)  
    {					// wait GDMA0 
    } 					// done interrupt 
  }

 
 Disable_Int(nGLOBAL_INT); 
 GdmaIntDisable(gdma);

// restore UART configuration //////////////////////////////////////////////////

 uartcont = (uartcont & ~UARTCON_TXM) | UARTCON_TXM_INTREQ;

 if(uart == 1)
  {
   UARTCONT1 = uartcont;		// restore UARTCONT1 
  }
 else
  {
   UARTCONT0 = uartcont;		// restotr UARTCONT0
  } 

//           
 Print("\n");
}

////////////////////////////////////////////////////////////////////////////////
// GDMA STARTUP DIALOG /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


void GDMAStartUpDialog(void)
{
 U32 gdmacon;				// GDMA control register 
 U32 gdmasrc;				// GDMA source addreess register
 U32 gdmadst;				// GDMA destination register
 U32 gdmacnt;				// GDMA control register
 U32 uartcont;				// UART0/UART1 control register content
 U32 iopcon;				// IO Port control register 
 U8  inpsrc;				// source address input flag 
 U8  inpdst;				// destination address input flag
 TIME tm;				// transfer time 
 int gdma;				// GDMA channel 
 U32 mode;				// transfer mode 
 int it;				// selected menu item 

// 
 inpsrc = 1;				// input source address
 inpdst = 1;				// input destination address

// Initialize GDMA global registers/////////////////////////////////////////////
 gdmacon = 0;				// control register				
 gdmasrc = 0;				// source address register
 gdmadst = 0;				// destination address register
 gdmacnt = 0;				// counter register

/* STARTUP DIALOG FOR GDMA CONFIGURATION */ 

 Print("\n\nStartup dialog for GDMA configuration"); 

////////////////////////////////////////////////////////////////////////////////
// input GDMA channel //////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

 while(1) 
  {
   Print("\nSelect GDMA channel                  [0/1/Q]");
   gdma = get_upper();			// read GDMA channel from console 
   if(gdma == 'Q')
    {
     return;
    }
   else
   if(gdma >= '0' && gdma <= '1')
    {
     gdma -= '0';			// to numerical value
     break;
    }
  }

////////////////////////////////////////////////////////////////////////////////
// input transfer mode /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

 while(1) 
  {
   Print("\nMode selection menu");
   Print("\n[0] SoftWare.");		// software (memory to memory)
   Print("\n[1] External EXTDREQ.");	// external request 
   Print("\n[2] UART0.");		// UART0 -> memory or memory -> UART0
   Print("\n[3] UART1.");		// UART1 -> memory ot memory -> UART1
   Print("\n[Q] Quit.");		//
   Print("\nSelect Item");
   it = get_upper();			// reag menu item from console
   if(it == 'Q')
    {
     return;
    }
   else  
   if(it >= '0' && it <= '3')
    {					// 
     break;
    } 
  } 

 switch(it) 
  {
   case '1' : 
// an external DMA request(nXDREQ) /////////////////////////////////////////////
    gdmacon |= GDMACON_MODE_EXTDREQ; 	// external DMA request 
    break; 

   case '2' : 
// the UART0 block /////////////////////////////////////////////////////////////
    gdmacon |= GDMACON_MODE_U0; 	// UART0 	
    break;      

   case '3' : 
// the UART1 block /////////////////////////////////////////////////////////////
    gdmacon |= GDMACON_MODE_U1; 	// UART1 	
    break;
   default  : 

// software (memory-to-memory) /////////////////////////////////////////////////
    gdmacon |= GDMACON_MODE_MEMMEM; 	// memory to memory
    break;  
  }

//
 mode = gdmacon & GDMACON_MODE;

////////////////////////////////////////////////////////////////////////////////
// GDMA_SI // [8] Stop interrupt enable (SI) ///////////////////////////////////       
////////////////////////////////////////////////////////////////////////////////

// Stop interrupt enable ///////////////////////////////////////////////////////

 while(1) 
  {
   Print("\nEnable stop interrupt                [Y/N/Q]");
   it = get_upper();
   if(it == 'Q')
    {
     return;
    }
   else  
   if(it == 'Y')
    {
     gdmacon |= GDMACON_SI;		// Stop Interrupt Enable 
     break;
    }
   else
   if(it == 'N')
    {
     break;
    }
  } 
        
////////////////////////////////////////////////////////////////////////////////
// GDMA_TD // [10] Transfer direction (for UART0/UART1 only) ///////////////////
////////////////////////////////////////////////////////////////////////////////

 if(
    (mode == GDMACON_MODE_U0) || 	// UART0
    (mode == GDMACON_MODE_U1)		// UART1 
  ) 
  {
   while(1) 
    {
     Print("\nTransfer Direction(UART0/UART1 only)");
     Print("\nMemory to [U]ART, UART to [M]emory   [U/M/Q]");
     it = get_upper();
     if(it == 'Q')
      {
       return;
      } 
     else
     if(it == 'U') 
      {
// GDMA_TD_MEMTOU // (memory to UART0/UART1) ///////////////////////////////////  

       gdmacon |= GDMACON_TD_MEMTOU;	// transfer direction = memory to UART
       gdmacon |= GDMACON_DST_FIX;	// fixed destination adress
       Print("\nDestination Addr Fixed.");
// 
       inpdst = 0;			// not input destination address
       break;
      }
     else 
     if(it == 'M') 
      {
// UART0/UART1 to memory ///////////////////////////////////////////////////////
       gdmacon |= GDMACON_TD_UTONEM;	// UART0/UART1 to memory
       gdmacon |= GDMACON_SRC_FIX;	// source address fix 
       Print("\nSource Addr Fixed.");

       inpsrc = 0;			// not input source adress 
       break;
      }