2410lib.c

S3C2410 USB Mass storage 源码.

    
    if(string[0]=='0' && (string[1]=='x' || string[1]=='X'))
    {
        base    = 16;
        string += 2;
    }
    
    lastIndex = strlen(string) - 1;
    
    if(lastIndex<0)
        return -1;
    
    if(string[lastIndex]=='h' || string[lastIndex]=='H' )
    {
        base = 16;
        string[lastIndex] = 0;
        lastIndex--;
    }

    if(base==10)
    {
        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 0
    if(whichUart==0)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT0 & 0x2));
            Delay(15);                 //because the slow response of hyper_terminal 
            WrUTXH0('\r');
        }
        while(!(rUTRSTAT0 & 0x2));   //Wait until THR is empty.
        Delay(15);
        WrUTXH0(data);
    }
    else if(whichUart==1)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT1 & 0x2));
            Delay(15);                 //because the slow response of hyper_terminal 
            rUTXH1 = '\r';
        }
        while(!(rUTRSTAT1 & 0x2));   //Wait until THR is empty.
        Delay(15);
        rUTXH1 = data;
    }   
    else if(whichUart==2)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT2 & 0x2));
            Delay(15);                 //because the slow response of hyper_terminal 
            rUTXH2 = '\r';
        }
        while(!(rUTRSTAT2 & 0x2));   //Wait until THR is empty.
        Delay(15);
        rUTXH2 = data;
    }       
#else
    if(whichUart==0)
    {
        if(data=='\n')
        {
            WrUTXH0('\r');
            while(!(rUTRSTAT0 & 0x2));
        }
	else
	{
        	WrUTXH0(data);
        	while(!(rUTRSTAT0 & 0x2));   //Wait until THR is empty.
	}
    }
    else if(whichUart==1)
    {
        if(data=='\n')
        {
            rUTXH1 = '\r';
            while(!(rUTRSTAT1 & 0x2));
        }
 	else
	{
	       rUTXH1 = data;
       	 while(!(rUTRSTAT1 & 0x2));   //Wait until THR is empty.
 	}
    }   
    else if(whichUart==2)
    {
        if(data=='\n')
        {
            rUTXH2 = '\r';
            while(!(rUTRSTAT2 & 0x2));
        }
 	else
	{
       	rUTXH2 = data;
        	while(!(rUTRSTAT2 & 0x2));   //Wait until THR is empty.
 	}
    }       
#endif
}               

//====================================================================
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);
}

// *************** For ARM9-UDP LED control *****************
void Led(char data)
{
//Active is low.(LED On)
// GPA17-GPA22
// (LED2-LED7)
   switch (data)
   {
   case LED2_ON:
   	rGPADAT&=0x7dffff;
   	break;
   case LED2_OFF:
   	rGPADAT|=0x020000;
   	break;
   case LED3_ON:
   	rGPADAT&=0x7bffff;
   	break;
   case LED3_OFF:
   	rGPADAT|=0x040000;
   	break;
   case LED4_ON:
   	rGPADAT&=0x77ffff;
   	break;
   case LED4_OFF:
   	rGPADAT|=0x080000;
   	break;
   case LED5_ON:
   	rGPADAT&=0x6fffff;
   	break;
   case LED5_OFF:
   	rGPADAT|=0x100000;
   	break;
   case LED6_ON:
   	rGPADAT&=0x5fffff;
   	break;
   case LED6_OFF:
   	rGPADAT|=0x200000;
   	break;
   case LED7_ON:
   	rGPADAT&=0x3fffff;
   	break;
   case LED7_OFF:
   	rGPADAT|=0x400000;
   	break;
   case LEDALL_ON:
   	rGPADAT&=0x01ffff;
   	break;
   case LEDALL_OFF:
   	rGPADAT|=0x7e0000;
   	break;
   }
}

//*************************[ Timer ]********************************
void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON = ((PCLK/1000000-1)<<8)|(divider<<3);  //Watch-dog timer control register
    rWTDAT = 0xffff;  //Watch-dog timer data register
    rWTCNT = 0xffff;  //Watch-dog count register

    // Watch-dog timer enable & interrupt  disable
    rWTCON = rWTCON |(1<<5) & !(1<<2);  
}

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


//*************************[ MPLL ]*******************************
void ChangeMPllValue(int mdiv,int pdiv,int sdiv)
{
    rMPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;// MPLLCON=0x4C000004
    //FCLK setting
}

//**************************[ UPLL ]*******************************
void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
    rUPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;// UPLLCON=0x4C000008
    //For USBD - 48MHz
}

//************************[ HCLK, PCLK ]***************************
void ChangeClockDivider(int hdivn,int pdivn)
{
     // hdivn,pdivn     FCLK: HCLK :PCLK
     //     0,0         FCLK:FCLK/1:FCLK/1 = 1:1:1 
     //     0,1         FCLK:FCLK/1:FCLK/2 = 1:1:2
     //     1,0         FCLK:FCLK/2:FCLK/2 = 1:2:2
     //     1,1         FCLK:FCLK/2:FCLK/4 = 1:2:4
    rCLKDIVN = (hdivn<<1) | pdivn;    

    if(hdivn)
        MMU_SetAsyncBusMode();
    else 
        MMU_SetFastBusMode();
}

//*************************[ 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;
}