evm50100.h

本source code 為s3c4510的bootloader

#ifndef _EVM50100_H_
#define _EVM50100_H_


/* 			*/
/* Modified by 		*/
/* Dmitriy Cherkashin 	*/
/* [e-mail]	*/
/* 2002, 2003		*/
/*/			*/

#ifdef  _S3C4530_	
#define _KS32C50100_
#else
#ifndef _KS32C50100_ 
#define _KS32C50100_ 
#endif
#endif 								// _S3C4530_

/*=====================================================================*/
/*                                                                     */
/*                     SYSTEM CLOCK CONTROL                            */
/*                                                                     */
/*   * fMCLK   SYSTEM CLOCK Oscillator frequency                       */
/*   * REF_CYCLE  Unit[ms], Default refresh cycle is 14ms              */
/*                                                                     */
/*=====================================================================*/
#define MHz      1000000

#ifdef  _S3C4530_
/* compiled with S3C4530 support */
#define fMCLK                 50*MHz       
#define MCLK2                 (fMCLK/2)
#define fMCLK_MHz	      50 		
#else
#ifdef  _KS32C50100_
/* compiled without S3C4530 support */
#define fMCLK                 50*MHz       
#define MCLK2                 (fMCLK/2)
#define fMCLK_MHz	      50 		// unit MHz 	
#else
/* KS32C5000(A)*/
#define fMCLK                 33*MHz       
#endif
#endif

// Delay for clock stabilization when CPU clock change
#define Delay4ClkCange    100      
#define REF_CYCLE          16      // Unit[ms]. default refresh cycle 16ms. 	/* - */

/*=====================================================================*/
/*                                                                     */
/*                      DRAM MEMORY                                    */
/*                                                                     */
/*                                                                     */
/*=====================================================================*/
//#define DownLoadArea	0x1000050   //User code down load area


////////////////////////////////////////////////////////////////////////////////
// SERIAL CHANNEL (UART0/UART1) ////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#define baudrate       38400    

////////////////////////////////////////////////////////////////////////////////
// TIMER ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/* This is the number of timer ticks that occur per second. */
#define TICKS_PER_SECOND        100

/* Number of ticks for one second  */
#define ONE_SECOND              1000    


/* Define data types for ks32c6x00 */

#define U8            unsigned char
#define S8            signed char
#define U16           unsigned short
#define S16           signed short
#define U32           unsigned long
#define S32           signed long
#define REG8          volatile unsigned char
#define REG16         volatile unsigned short
#define REG32         volatile unsigned long
#define BYTE          U8

/* max/mins */
#define USHORT_MAX   65535  /* The maximum value of a uint16 variable. */

#ifndef NULL
#define NULL 0
#endif

////////////////////////////////////////////////////////////////////////////////
// main.c //////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

extern U32 syscfg_pd_id;		// SYSCFG PD_ID field

#ifdef  _S3C4530_ 
#define is_s3c4530(id) ( ((id) == SYSCFG_PD_S3C4530X) || ((id) == SYSCFG_PD_S3C4530A) )
#else
#define is_s3c4530(id) (0)
#endif								/* _S3C4530_ */

#ifndef __GNUC__
extern char Image$$RO$$Base[];		// Image Read Only Base
extern char Image$$RO$$Limit[];		// Image Read Only Limit
extern char Image$$RW$$Base[];		// Image Read/Write Base
extern char Image$$RW$$Limit[];		// Image Read/Write Limit
extern char Image$$ZI$$Base[];		// Image Zero Init Base 
extern char Image$$ZI$$Limit[];		// Image Zero Init Limit

#define Image_RO_Base	Image$$RO$$Base
#define Image_RO_Limit	Image$$RO$$Limit
#define Image_RW_Base	Image$$RW$$Base
#define Image_RW_Limit	Image$$RW$$Limit
#define Image_ZI_Base	Image$$ZI$$Base
#define Image_ZI_Limit	Image$$ZI$$Limit
#else 

extern char _stext[];
extern char _etext[];
extern char _sdata[];
extern char _edata[];
extern char _sbss[];
extern char _ebss[];

#define Image_RO_Base	_stext	
#define Image_RO_Limit	_etext
#define Image_RW_Base	_sdata
#define Image_RW_Limit	_edata
#define Image_ZI_Base	_sbss
#define Image_ZI_Limit	_ebss
#endif 								/* __GNUC__ */

extern void Main(void);			// main Menu function 
extern void InitEvb(void);		// Init evaluation board
extern void ViewSysConfig(void);  	// View System Configureation


////////////////////////////////////////////////////////////////////////////////
// isr.c ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


/* Macro fucntions */

#define	Enable_Int(n)       INTMASK &= ~(1<<(n))/* clear interrupt source bit */ 
#define	Disable_Int(n)	    INTMASK |= (1<<(n))	/* set interrupt source bit */
#define Clear_PendingBit(n) INTPEND  = (1<<(n))	/* clear pending pit */
#define SetPendingBit(n)    INTPNDTST= (1<<(n))  /* set pending bit via Interrupt Pending Test Register */ 


/* 
 *     Prototype for interrupt functions 
 */


#define	MAXHNDLRS	21			/* Maximum # of interrupt  handlers */

/* Function Prototype for Interrupt. ATTENTION : call before enable interrupt */
extern void InitInterrupt(void);
/* Clear all interrupt related register. Disable all interrupts (include interrupt mask 
register global bit), clear pending register, all interrupt FIQ interrupts  */
extern void ClrIntStatus(void);  		

/* Function Prototype for Exception Vector */
extern void ISR_UndefHandler(REG32 *adr);	/* Undefined instruction  */
extern void ISR_PrefetchHandler(REG32 *adr);	/* Prefetch Abort */
extern void ISR_AbortHandler(REG32 *adr);	/* Data abort handler */
extern void ISR_SwiHandler(void);		/* Software interrupt */
extern void ISR_IrqHandler(void);		/* IRQ */	
extern void ISR_FiqHandler(void);		/* FIQ */

/* Function Prototype for Interrupt Setup */
extern void SysSetInterrupt(int vector, void (*)(void));
extern void * SysGetInterrupt(int vector);

extern void ViewIntConfig(void);		/* Print INTMODE, INTMASK, INTPRI, INTPEND, INTOFFSET */
extern void IntTest(void);			

/* Interactive request to enter interruspts priority for each of 21 sources */
extern void SetPriority(void);			
/* Interactive set interrupt mode register, interrupt mask register */
extern void SetIntMode(void);			

////////////////////////////////////////////////////////////////////////////////
// uart.c //////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// SYMBOL DEFINITIONS //////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#define KEY_NL          0x0A		/* new line LF */
#define KEY_CR          0x0D		/* carriage return */
#define KEY_BSP         0x08		/* back space */
#define KEY_ESC         0x1B		/* escape */
#define KEY_CTRLZ       0x1A
#define KEY_RUBOUT      0x7F

#define CONSOLE            0  		/* default console channel */

////////////////////////////////////////////////////////////////////////////////
// UART INITIALIZE FUNCTIONS ///////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
extern U32  UART_Initialize(void);	/* Init UART0, UART1 parameters in sysconf.h */
extern int  UARTSetSpeed(U32 ch,int sp);/* set UART channel speed */
extern int  UARTGetSpeed(U32 ch);	/* read UART channel speed */ 
extern int  UARTWaitTxComp(int /*ch*/); /* wait tx completion in polling mode */
extern int  UARTSetLoopBack(int /*ch*/, int on);/* set loop back mode */
 
////////////////////////////////////////////////////////////////////////////////
// UART INTERRUPT SERVICE ROUTINES & CONTROL FUNCTIONS /////////////////////////
////////////////////////////////////////////////////////////////////////////////

extern void UARTTxIntOn(int /*ch*/);	/* Enable UART0/1 Tx interrupt, Set UART0/1 Tx Interrupt pending bit */
extern void UARTTxIntOff(int /*ch*/);	/* Diasable UART0/1 Tx Interrupt, Clear UART0/1 Tx Interrupt pending bit*/	
extern void UARTRxIntOn(int /*ch*/);	/* Enable UART0/1 Rx&Status Interrupt */	
extern void UARTRxIntOff(int /*ch*/);	/* Disable UART0/1 Rx&Status Interrupt */	
 				 
/************************************************************************/
/*            UART STANDARD I/O FUNCTIONS FOR INTERRUPT             	*/
/************************************************************************/
extern  int  i_getc(int /*channel*/, U8 * /*ch*/); /* get char in interrupt Rx queue*/ 		
//extern  U32  i_gets(U32 /*channel*/, U8 *);	/* unused contain ERROR */
/* put char in interrupt mode, if last transmission not completed, return 0  */
extern  int  i_putc(int /*channel*/, U8 /*ch*/);
/* put string to UART */
extern  int  i_puts(int /*channel*/, char * /*string*/);
/* formatted output to console */
extern  int  i_flush(int /*channel */);

/************************************************************************/
/*            UART STANDARD I/O FUNCTIONS FOR POLLING               	*/
/************************************************************************/
/* put char to UART0/UART1 in polling mode */
extern int  put_char(int /*channel*/, char /*data*/);	
extern int  put_str(int /* ch */, char * /*str*/);
/* get char from UART0/UART1 in polling mode */ 
extern char get_char(int /*channel*/); 			
extern int  rcv_char(int /* ch */, U8 * /*val*/);

/* Can be used in polling mode */
extern void put_byte(char /* ch */);	/* put char to console */
extern char get_byte(void);		/* get char from console */
extern char get_upper(void);		/* get upper char from console */ 
extern char get_last(void);		/* get last received from console charecter */ 
extern int  kbd_hit(void);		/* return 1, if console buffer not empty */			

////////////////////////////////////////////////////////////////////////////////
extern void  UartTest(void);		/* main UART test menu */
extern U32   UARTAutoLoopBack(int);  	/* Internal loopback poll */
extern void  StringEcho(U32 /*ch*/);	/* String echo in interrupt mode */
extern void  UARTConfigView(void);	/* View UART0/UART1 configuration */

extern void PrintMBIT(char * mes);
extern void PrintUBIT(int ch, char * mes, U32 * val, U32 msk);
extern void PrintSBIT(int ch, char * mes, U32 * st, U32 msk, char * v1, char * v0);
extern void PrintEBIT(int ch, char * mes, U32 * st, U32 msk);

typedef struct 
{
 char * str;
 U32    val;
}ABIT;

extern void PrintABIT(int ch, char * mes, U32 * st, U32 msk, ABIT * abit);


////////////////////////////////////////////////////////////////////////////////
// memory.c ////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


// return free dram regions, in input size - sizeof arrays base, limit,
// in output count of free regions 
extern int FreeDramRegions(U32 * base, U32 * limit, int *size);


/* constants for memory allocation functions from cacheble and notcachable areas */

/* DRAM1 (if used)............0x2000000 */
/* DRAM0 (16Mbyte)............0x1000000 */