44blib.c

arm7 的音乐播放程序

/************************************************
 * NAME    : 44BLIB.C				            *
 *												*
 * Last Modified by YY in 2006.2.20				*
 ************************************************/


#include "44b.h"
#include "44blib.h"
#include "def.h"
#include "option.h"

#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

#define STACKSIZE    0xa00 //SVC satck size(do not use user stack)
#define HEAPEND     (_ISR_STARTADDRESS-STACKSIZE-0x500) // = 0xc7ff000
		//500byte heap before stack
	//SVC Stack Area:0xc(e)7ff000-0xc(e)7ffaff

//***************************************************************************
extern char Image$$RO$$Limit[];
extern char Image$$RO$$Base[];
extern char Image$$RW$$Limit[];
extern char Image$$RW$$Base[];
extern char Image$$ZI$$Limit[];
extern char Image$$ZI$$Base[];
//***************************************************************************

void *mallocPt=Image$$RW$$Limit;

void About_Function(void)
{ 
    Uart_Printf( "\n\t Image$$RO$$Base  = %x\n", Image$$RO$$Base );
	Uart_Printf( "\t Image$$RO$$Limit = %x\n", Image$$RO$$Limit );
	Uart_Printf( "\t Image$$RW$$Base  = %x\n", Image$$RW$$Base );
	Uart_Printf( "\t Image$$RW$$Limit = %x\n", Image$$RW$$Limit );
    Uart_Printf( "\t Image$$ZI$$Base  = %x\n", Image$$ZI$$Base );
    Uart_Printf( "\t Image$$ZI$$Limit = %x\n", Image$$ZI$$Limit );
    Uart_Printf( "\n" );
 }

/************************* SYSTEM *************************/

void Delay(int time)
{
    int i;
	int delayLoopCount=400;

    for(;time>0;time--)
	for(i=0;i<delayLoopCount;i++);
}

/************************* PORTS ****************************/  //[By cazy]

void Port_Init(void)
{
	// PORT A GROUP 
	/*  BIT 9	8	7	6	5	4	3	2	1	0	*/
	/*  A24	  A23	A22	A21	A20	A19	A18	A17	A16	A0	*/	      
	/*  0		1	1	1	1	1	1	1	1	1	*/
	//Set PA0~9 0 means : All these Port is seem as Address Signal 
	rPCONA = 0x1ff;	

	// PORT B GROUP
	/* BIT 10   9    8       7      6        5     4     	3     2     1     0    */
	/*     /CS5 /CS4 /CS3    /CS2   /CS1     CLK   MODE	/SRAS /SCAS SCLS  SCKE	*/
	/*     NC   NC   RTL8019 USBD12 NV_Flash L3    L3    	Sdram Sdram Sdram Sdram*/
	/*     1,   1,   1,      1,     1,       0,    0,    	1,    1,    1,    1    */
	//10~6,3~0 set to be their own function ,but is it for this board ?[by yy]	
	rPCONB = 0x7cf;// [by yy]	
	// rPDATB = 0x7cf; i think it should be rPCONB [by yy]

    
	//PORT C GROUP
	//BUSWIDTH=16														*/
	/*  PC15	14		13		12		11		10		9		8		*/
	/*	nCTS0	nRTS0	RxD1	TxD1	nCTS1	nRTS1	GPC9_o	GPC8_i[by yy]	*/
	/*   11		11		11		11		11		11		01		00		*/
	//fff4	[by yy]

	/*  PC7		6		5		4		3		2		1		0		*/
	/*   VD4	VD5		VD6		VD7		IISCLK	IISDI	IISDO	IISLRCK[by yy]*/
	/*   11		11		11		11		11		11		11		11		*/
	//ffff[by yy]
	
	rPCONC = 0xfff4ffff;//[by yy]
	
	rPDATC = 0x0200;	//All IO is low, except GPC9_o(/NAND Flash Chip Enable) [by yy]
	
	rPUPC  = 0x0000;	//disable all pull-up

	//PORT D GROUP
	/*  PORT D GROUP(I/O OR LCD)										*/
	/*  BIT7		6		5		4		3		2		1		0	*/
	/*      VF		VM		VLINE	VCLK	VD3		VD2		VD1		VD0	*/
	/*	    10		10		10		10		10		10		10		10	*/
	rPCOND= 0xaaaa;	
	rPUPD = 0x00;
	//These pins must be set only after CPU's internal LCD controller is enable
	
	//PORT E GROUP 
	/*  Bit 8			7		 6				5			4		3		2		1		0		*/
	/*		CODECLK	 	o(TP_CS) o(LCD_PWREN)	o(USB_SUSP) TOUT1	TOUT0	RxD0	TxD0	CLKOUT0	[by yy]*/ 
	/*      10			01		 01				01			10		10		10		10		11		[by yy]*/
	rPCONE	= 0x256ab;	//[by yy]
	rPDATE	= 0xe0;
	rPUPE	= 0x000;	//disable all pull-up 
	
	//PORT F GROUP
	/*  Bit8	7		6		5		4			3			2		1		0		*/
	/*	SIOCLK	SIORxD	SIORDY	SIOTxD	i(CF_RDY)	i(IDE_RDY)	nWAIT	IICSDA	IICSCL	*/
	/*	001		011		011		011		00			00			10		10		10		*/
	rPCONF = 0xB6C2A;
	rPUPF  = 0x000;		//disable all pull-up(both bit 4 and 3 ,i can't sure.... )[by yy]

	//PORT G GROUP
	/*  BIT7		6		5		4		3		2		1		0	 */
	/*	INT7		INT6	INT5	INT4	INT3	INT2	INT1	INT0	*/
	/*    CN7		CN7		CF		USBCtrl	NIC		IDE		8019	USB	*/
	/*      11      11      11      11      11      11      11      11       */
	rPCONG = 0xff3c;	//refer to the develop grade....
	rPUPG  = 0x00;		//disable all pull-up
	
//	rSPUCR = 0x7;  //D15-D0 pull-up disable
	rSPUCR = 0x6;  //D15-D0 pull-up enable
	
	rEXTINT = (4<<16)|(4<<8)|(4<<4);	//EINT1上升沿,EINT2上升沿,EINT4上升沿中断
//	rINTCON = 5;				// non vector mode, irq enable
//	rINTMOD = 0;				//all are irq mode
	
	//Define the Non_Cache area
	rNCACHBE0=(((Non_Cache_End)>>12)<<16)|((Non_Cache_Start)>>12);
	
	//SE0 = (End address + 1)/4K SA0 = Start address/4K
	 
}

/************************* UART ****************************/

static int whichUart=0;

void Uart_Init(int mclk,int baud)
{
    int i;
    if(mclk==0)
	mclk=MCLK;
    rUFCON0=0x0;     //FIFO disable
    rUFCON1=0x0;
    rUMCON0=0x0;
    rUMCON1=0x0;
//UART0
    rULCON0=0x3;     //Normal,No parity,1 stop,8 bit
    rUCON0=0x245;    //rx=edge,tx=level,disable timeout int.,enable rx error int.,normal,interrupt or polling
    rUBRDIV0=( (int)(mclk/16./baud + 0.5) -1 ); 
   

//UART1
    rULCON1=0x3;
    rUCON1=0x245;
    rUBRDIV1=( (int)(mclk/16./baud + 0.5) -1 );

    for(i=0;i<100;i++);
}


void Uart_Select(int ch)
{
    whichUart=ch;
}


void Uart_TxEmpty(int ch)
{
    if(ch==0)
	while(!(rUTRSTAT0 & 0x4)); //wait until tx shifter is empty.
    else
    	while(!(rUTRSTAT1 & 0x4)); //wait until tx shifter is empty.
}


char Uart_Getch(void)
{
    if(whichUart==0)
    {	    
	while(!(rUTRSTAT0 & 0x1)); //Receive data read
	return RdURXH0();
    }
    else
    {
	while(!(rUTRSTAT1 & 0x1)); //Receive data ready
	return	rURXH1;
    }
}


char Uart_GetKey(void)
{
    if(whichUart==0)
    {	    
	if(rUTRSTAT0 & 0x1)    //Receive data ready
    	    return RdURXH0();
	else
	    return 0;
    }
    else
    {
	if(rUTRSTAT1 & 0x1)    //Receive data ready
	    return rURXH1;
	else
	    return 0;
    }
}


void Uart_GetString(char *string)
{
    char *string2=string;
    char c;
    while((c=Uart_Getch())!='\r')
    {
	if(c=='\b')
	{
	    if(	(int)string2 < (int)string )
	    {
		Uart_Printf("\b \b");
		string--;
	    }
	}
	else 
	{
	    *string++=c;
	    Uart_SendByte(c);
	}
    }
    *string='\0';
    Uart_SendByte('\n');
}


int Uart_GetIntNum(void)
{
    char str[30];
    char *string=str;
    int base=10;
    int minus=0;
    int lastIndex;
    int result=0;
    int i;
    
    Uart_GetString(string);
    
    if(string[0]=='-')
    {
        minus=1;
        string++;
    }
    
    if(string[0]=='0' && (string[1]=='x' || string[1]=='X'))
    {
	base=16;
	string+=2;
    }
    
    lastIndex=strlen(string)-1;
    if( string[lastIndex]=='h' || string[lastIndex]=='H' )
    {
	base=16;
	string[lastIndex]=0;
	lastIndex--;
    }

    if(base==10)
    {
    /////////////////////fixed by yy///////////////////////////////////
    
	    for(i=0;i<=lastIndex;i++)
		{
			result *=10;
			result += ( string[i]-'0');		 
		}     
    ////////////////////fixed end/////////////////////////////////////////
	//result=atoi(string);
		result=minus ? (-1*result):result;
    }
    else
    {
	for(i=0;i<=lastIndex;i++)
	{
    	    if(isalpha(string[i]))
	    {
		if(isupper(string[i]))
		    result=(result<<4)+string[i]-'A'+10;
		else
		    result=(result<<4)+string[i]-'a'+10;
	    }
	    else
	    {
		result=(result<<4)+string[i]-'0';
	    }
	}
	result=minus ? (-1*result):result;
    }
    return result;
}


void Uart_SendByte(int data)
{
    if(whichUart==0)
    {
	if(data=='\n')
	{
	    while(!(rUTRSTAT0 & 0x2));
	    Delay(10);	//because the slow response of hyper_terminal 
	    WrUTXH0('\r');
	}
	while(!(rUTRSTAT0 & 0x2)); //Wait until THR is empty.
	Delay(10);
	WrUTXH0(data);
    }
    else
    {
	if(data=='\n')
	{
    	    while(!(rUTRSTAT1 & 0x2));
	    Delay(10);	//because the slow response of hyper_terminal 
	    rUTXH1='\r';
	}
	while(!(rUTRSTAT1 & 0x2));  //Wait until THR is empty.
	Delay(10);
	rUTXH1=data;
    }	
}		


void Uart_SendString(char *pt)
{
    while(*pt)
	Uart_SendByte(*pt++);
}


//if you don't use vsprintf(), the code size is reduced very much.
void Uart_Printf(char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    Uart_SendString(string);
    va_end(ap);
}

/************************* GetKey *******************************/
U8 GetKey(void)
{
	U8 m = 10 ;
	U8 whichkey ;
	U8 key ;
	
	rPCONG = rPCONG & (~(0x3f<<10)) ;		//PG5,PG6,PG7 is input
	
	while( m-- )
	{
		if( (rPDATG & 0xe0) != 0xe0 )
		{
			whichkey = (rPDATG & 0xe0) ;
			goto WHICH_KEY ;
		}
		else
		{
			whichkey = 0xe0 ;
			Delay(100);
		}
	}
	
	WHICH_KEY:		
	
//    if( whichkey != 0xe0 )
//    	Uart_Printf( "\nwhich key = 0x%x\n", whichkey ) ;
	
	switch( whichkey )
    {
		case 0xc0:
		    key = 1; break ;
		case 0xa0:
		    key = 2; break ;
		case 0x60:
		    key = 3; break ;
		default :
		    key = 0xff;
    }
    
    while( (rPDATG & 0xe0) != 0xe0 ) ;		//等待按键放下
    
    //if( key != 0xff )
    	//Uart_Printf( "\nkey = 0x%x\n", key ) ;

    return key ;
}
        
/************************* WaitKey *******************************/
U8 WaitKey(void)
{
	U8 k;
	
	Uart_Printf( "\nPlease press KEY2/KEY3/KEY4\n" ) ;
	while(1) 
	{
		k = GetKey() ;
		
		if( k != 0xff )
		{
    		Uart_Printf( "\nKEY is pressed, go to Next\n" ) ;
			return k;
		}
	}
}

/************************* ledblink *****************************/
void Led_Display(int LedStatus)
{
	(* (volatile unsigned char *)0x8000200)  = LedStatus;
}

/************************* beep *********************************/


/************************* beep *********************************/

void Beep(U32 freq, U32 ms)
{
	rTCON  	&= ~0xf0000;			// clear manual update bit, stop Timer3
	rTCFG0 	&= ~0xff00;				// set Timer 2&3 prescaler 0
	rTCFG1 	&= ~0xf000;				// set Timer 3 MUX 1/16
	rTCFG1  |= 0x3000;
	rTCNTB3	 = MCLK/(2100*16);		//if set inverter off, when TCNT2<=TCMP2, TOUT is high, TCNT2>TCMP2, TOUT is low
	rTCMPB3  = rTCNTB3>>1;			//if set inverter on,  when TCNT2<=TCMP2, TOUT is low,  TCNT2>TCMP2, TOUT is high
	rTCON	|= 0x20000;				// manual update
	rTCON	&= ~0x20000;			// clear manal update bit
	rTCON   |= 0xd0000;				// auto reload, inverter on, start Timer 2	
	
	Delay(ms);
	
	rTCON &= ~0x10000;
}

/************************* Timer ********************************/

void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3);
    rWTDAT=0xffff;
    rWTCNT=0xffff;   

    // 1/16/(65+1),nRESET & interrupt  disable
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3)|(1<<5);	
}


int Timer_Stop(void)
{
//    int i;
    rWTCON=((MCLK/1000000-1)<<8);
    return (0xffff-rWTCNT);
}


/************************* PLL ********************************/
void ChangePllValue(int mdiv,int pdiv,int sdiv)
{
    rPLLCON=(mdiv<<12)|(pdiv<<4)|sdiv;
}


/************************* General Library **********************/

void * malloc(unsigned nbyte) 
/*Very simple; Use malloc() & free() like Stack*/
//void *mallocPt=Image$$RW$$Limit;
{
    void *returnPt=mallocPt;

    mallocPt= (int *)mallocPt+nbyte/4+((nbyte%4)>0); //to align 4byte

    if( (int)mallocPt > HEAPEND )
    {
	mallocPt=returnPt;
	return NULL;
    }
    return returnPt;
}


void free(void *pt)
{
    mallocPt=pt;
}


void Cache_Flush(void)
{
    int i,saveSyscfg;
    
    saveSyscfg=rSYSCFG;

    rSYSCFG=SYSCFG_0KB; 		      
    for(i=0x10004000;i<0x10004800;i+=16)    
    {					   
	*((int *)i)=0x0;		   
    }
    rSYSCFG=saveSyscfg; 			    
}


int getyorn(void)		//New By cazy : Get yes or no
{
	char c;
	
	Uart_Printf(" [y/n] ");
	while(1) {		
		c = Uart_Getch();
		if((c=='y')||(c=='Y')||(c=='n')||(c=='N'))
			break;
	}
	//putch(c);
	//putch('\n');
	return c&1;	//y&Y are odd, n&N are even
}