uhal.c

44b0x ucos 原版官方移植程序S3C3410X-ucos-ii.zip

/* ARM board targetting source file.
   file name: uhal.c
   date: 2000. 2. 14
   made by COiNS
*/

#include <stdarg.h>
#include <string.h>
#include "uhal.h"
#include "../ks32c40100/k401.h"

//     rTCON0=(1<<6)+(0<<3)+(0<<2); 	// Clear Counter Register, Interval Mode, Internal Clock
//     rTPRE0=256-1; 			// 40.320MHz/256=157.5KHz
//     rTDAT0=(157500/10)-1;		// 10Hz Period
//MCLK = 40000000 Hz
//40000000 Hz / 256(Timer Pre-scaler) = 156250 Hz
//#define _TICK	1000				//  1/1000 sec
#define _TICK	100				//  1/100 sec
//#define _TICK	10				//  1/10 sec
#define _CLOCK	(156250/_TICK)
//#define _CLOCK	156250			// 1 sec


#define MAX_TBUF	2048
static char tbuf[MAX_TBUF]= {0, };	//for uHALr_printf
/**********************************************************************/
//for debugging
void BreakPoint(void);
void DebugUNDEF(void);
void DebugSWI(void);
void DebugABORT(void);
void DebugFIQ(void);

//utilities
void Uart_SendByte(int data);


//timer interrupt handler routine
extern void TickHandler(void);


//for interrupt enable or disable
extern void ARMDisableInt(void);
extern void ARMEnableInt(void);


//Output through LCD or serial port to print information.
extern int vsprintf(const char *format, ...);

/**********************************************************************/
int uHALr_printf(const char *format, ...)
{
	va_list v_list;
	char *ptr;
	int i= 0;


	va_start(v_list, format);     // Initialize variable arguments. 
	vsprintf(tbuf, format, v_list ); 
	va_end(v_list);


	ptr= tbuf;
	while( (*ptr) && i<MAX_TBUF) {
		Uart_SendByte(*ptr);
		ptr++;	i++;
	}//while

	return 1;
}//uHALr_printf


/**********************************************************************/
/*** Called by ARMTargetInit() ***/

//disable memory management unit.
void uHALr_ResetMMU(void)
{
}//uHALrResetMMU
/**********************************************************************/

void (*pre_isr)(void);
void *(*post_isr)(void);

//Define pre & post-process routines for Interrupt.
void uHALir_DefineIRQ(void *is, void *iq, void *n)
{
	pre_isr= (void (*)(void))is;
	post_isr= (void *(*)(void))iq;
}//uHALir_DefineIRQ

/**********************************************************************/
//Initialze interrupts.
void uHALr_InitInterrupts(void)
{
	// All=IRQ mode
	rINTMOD=0x0;

	// Disable Global Interrupt
	rSYSCON&=~BIT_GLOBAL;
	
	// All interrupt is masked.
	rINTMSK=BIT_TMC0;

	//set interrupt vector routine
//	pISR_RESET= (unsigned) Reset;	//must be reserved
	pISR_UNDEF= (unsigned) DebugUNDEF;
	pISR_SWI= (unsigned) DebugSWI;
	pISR_PABORT= (unsigned) DebugABORT;
	pISR_DABORT= (unsigned) DebugABORT;
	pISR_RESERVED= (unsigned) BreakPoint;		//not used
//	pISR_IRQ= (unsigned) 0;			//must be reserved
	pISR_FIQ= (unsigned) DebugFIQ;

	pISR_EINT0= (unsigned) BreakPoint;
	pISR_EINT1= (unsigned) BreakPoint;
	pISR_URX= (unsigned) BreakPoint;
	pISR_UTX= (unsigned) BreakPoint;
	pISR_UERR= (unsigned) BreakPoint;
	pISR_DMA0= (unsigned) BreakPoint;
	pISR_DMA1= (unsigned) BreakPoint;
	pISR_TOF0= (unsigned) BreakPoint;
//	pISR_TMC0= (unsigned) BreakPoint;
	pISR_TOF1= (unsigned) BreakPoint;
	pISR_TMC1= (unsigned) BreakPoint;
	pISR_TOF2= (unsigned) BreakPoint;
	pISR_TMC2= (unsigned) BreakPoint;
	pISR_TOF3= (unsigned) BreakPoint;
	pISR_TMC3= (unsigned) BreakPoint;
	pISR_TOF4= (unsigned) BreakPoint;
	pISR_TMC4= (unsigned) BreakPoint;
	pISR_BT= (unsigned) BreakPoint;
	pISR_SIO0= (unsigned) BreakPoint;
	pISR_SIO1= (unsigned) BreakPoint;
	pISR_IIC= (unsigned) BreakPoint;
	pISR_RTCA= (unsigned) BreakPoint;
	pISR_RTCT= (unsigned) BreakPoint;
	pISR_TF= (unsigned) BreakPoint;
	pISR_EINT2= (unsigned) BreakPoint;
	pISR_EINT3= (unsigned) BreakPoint;
	pISR_EINT4= (unsigned) BreakPoint;
	pISR_ADC= (unsigned) BreakPoint;
	pISR_EINT8= (unsigned) BreakPoint;
	pISR_EINT9= (unsigned) BreakPoint;
	pISR_EINT10= (unsigned) BreakPoint;
	pISR_EINT11= (unsigned) BreakPoint;

	//handler setting
	pISR_TMC0 = (unsigned) TickHandler;
	
	// Enable Global Interrupt
	rSYSCON|=BIT_GLOBAL;
}//uHALr_InitInterrupts


/**********************************************************************/
//Initialize timer that is used OS.
void uHALr_InitTimers(void)
{
     rINTPND=~(BIT_TMC0);		// Clear pending bits
     
     rTCON0=(1<<6)+(0<<3)+(0<<2); 	// Clear Counter Register, Interval Mode, Internal Clock
     rTPRE0=256-1; 			// 40.320MHz/256=157.5KHz
     rTDAT0=(157500/100)-1;		// 100 Hz Period
		
     rTCON0|=(1<<7);			// Enable Timer0
}//uHALr_InitTimers

/**********************************************************************/
/*** Called by ARMTargetStart() ***/

//Request the system timer.
//return value 1:success   0:fail
int uHALr_RequestSystemTimer(void *tick, const unsigned char *str)
{
	return 1;
}//uHALr_RequestSystemTimer

/**********************************************************************/
//Start system timer & enable the interrupt.
void uHALr_InstallSystemTimer(void)
{
     uHALr_InitTimers();
     
     // TMC0.
     rINTMSK=BIT_TMC0;
     
     // Enable Global Interrupt
     rSYSCON|=BIT_GLOBAL;
}//uHALr_InstallSystemTimer

/**********************************************************************/
//////////////////////////////////////////////////////////////////
//utilities 
//////////////////////////////////////////////////////////////////
void Delay(int time)
// time=0: adjust the Delay function by WatchDog timer.
// 100us resolution.

// 颇扼固磐 蔼栏肺 '0' 阑 持绰版快啊 绝栏骨肺,
// 颇扼固磐 '0' 俊措茄 内靛甫 昏力茄促.
{
    int i;
    // int adjust=0;
    int delayLoopCount= 400;
 
	/* --------------------------------------------------------
	if(time==0) {
		time=200;adjust=1;
		delayLoopCount=400;
		rWTCON=((MCLK/1000000-1)<<8)|(2<<3);
		rWTDAT=0xffff;
		rWTCNT=0xffff;	 
		rWTCON=((MCLK/1000000-1)<<8)|(2<<3)|(1<<5); // 1/64/(65+1),nRESET,interrupt  disable
    }//if	
         -------------------------------------------------------- */
         
    for(;time>0;time--)
		for(i=0;i<delayLoopCount;i++);
		
	/* --------------------------------------------------------
    if(adjust==1) {
		rWTCON=((MCLK/1000000-1)<<8)|(2<<3);
		i=0xffff-rWTCNT;   //  1count/16us
		delayLoopCount=8000000/(i*64);	//400*100/(i*64/200)   
    }//if
    	-------------------------------------------------------- */
}//Delay


/**********************************************************************/
void Uart_SendByte(int data)
{
	/*
	int whichUart= 0;	//COM port number for use
		
    if(whichUart==0) {
		if(data=='\n') {
		    while(!(rUSTAT0 & 0x40));
		    Delay(4);	//because the slow response of hyper_terminal 
		    WrUTXH0('\r');
		}
		while(!(rUSTAT0 & 0x40)); //Wait until THR is empty.
		Delay(4);
		WrUTXH0(data);
	}
    else {
		if(data=='\n') {
			while(!(rUSTAT1 & 0x40));
			Delay(4);	//because the slow response of hyper_terminal 
			rUTXH1='\r';
		}
		while(!(rUSTAT1 & 0x40));  //Wait until THR is empty.
		Delay(4);
		rUTXH1=data;
	*/
	// ------------------------------------------------
	// 酒贰 荐沥秦 初疽澜
	// ------------------------------------------------
	
	if(data=='\n')
    {
	while(!(rUSTAT & UART_STAT_XMT_HOLDING_EMPTY));
	Delay(4);	//because the slow response of hyper_terminal 
	rUTXH='\r';
    }

    while(!(rUSTAT & UART_STAT_XMT_HOLDING_EMPTY));  
    					//Wait until THR is empty.
    Delay(4);
    rUTXH=data;	
    

}//Uart_SendByte

/**********************************************************************/
void Led_Display(int data)
{
    //rPDATE=(rPDATE & 0xf0)|(data&0xf);	// 酒贰荐沥
    rPDAT7=data;
}//Led_Display


/**********************************************************************/
//////////////////////////////////////////////////////////////////
//routines for debugging
//////////////////////////////////////////////////////////////////
void OutDebug(unsigned int num)
{
	uHALr_printf("\r\n***STACK***:%d\r\n", num);
}//OutDebug
/**********************************************************************/
void BreakPoint(void)
{
	uHALr_printf("!!!Enter break point.");	

	while(1) {
		Led_Display(0xf);
		Delay(1000);
		Led_Display(0x0);
		Delay(1000);
	}//while
}//BreakPoint

/**********************************************************************/
extern int I_COUNT= 0;
void DebugUNDEF(void)
{
	uHALr_printf("!!!Enter UNDEFINED. %d\r\n", I_COUNT);	
	BreakPoint();
}

/**********************************************************************/
void DebugSWI(void)
{
	uHALr_printf("!!!Enter SWI. %d\r\n", I_COUNT);	
	BreakPoint();
}
/**********************************************************************/
void DebugABORT(void)
{
	uHALr_printf("!!!Enter ABORT %d\r\n", I_COUNT);	
	BreakPoint();
}
/**********************************************************************/
void DebugFIQ(void)
{
	uHALr_printf("!!!Enter FIQ. %d\r\n", I_COUNT);	
	BreakPoint();
}
/**********************************************************************/