2410lib.c

利用IIS总线实现音频播放的功能实验代码

#include <vxworks.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "s3c2410.h"
#include "s3c2410sio.h"
#include "2410lib.h"
/*#include "mmu.h"*/

/*===========================[ SYSTEM ]===================================================*/
/*extern char Image$$RW$$Limit[];
Image$$RW$$Limit=0x0c200037;*/


/*void *mallocPt=0x0c200037;*/
static int delayLoopCount = FCLK/10000/10;
static int whichUart=0;

void Delay(int time);
void Port_Init(void);
void Uart_Init(int pclk,int baud);
void Uart_Select(int ch);
void Uart_TxEmpty(int ch);
char Uart_GetKey(void);
char Uart_Getch(void);
void Uart_SendByte(char data);
void Uart_SendString(char *pt);
void Uart_Printf(char *fmt,...);
void Uart_GetString(char *string);
char *Uart_String(void);
int Uart_GetIntNum(void);
void Timer_Start(int divider);
int Timer_Stop(void);
void ChangeMPllValue(int mdiv,int pdiv,int sdiv);
void ChangeUPllValue(int mdiv,int pdiv,int sdiv);
void ChangeClockDivider(int hdivn,int pdivn);
/*void * malloc(unsigned nbyte) ;
void free(void *pt);*/

/*===========================[ PORTS ]===================================================*/

void Delay(int time)
{  
    int i=0;
    int adjust=0;
    if(time==0)
    {
        time   = 200;
        adjust = 1;
        /*delayLoopCount = 400;//123~
            PCLK/1M,Watch-dog disable,1/64,interrupt disable,reset disable*/
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3); 
        rWTDAT = 0xffff;                              
        rWTCNT = 0xffff;                               
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3)|(1<<5);
    }
    for(;time>0;time--)
        for(i=0;i<delayLoopCount;i++);
    if(adjust==1)
    {
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3); 
        i = 0xffff - rWTCNT;                     
        delayLoopCount = 8000000/(i*64);        
    }
}




void Port_Init(void)
{
        
    rGPACON = 0x7fffff; 

    
    rGPBCON = 0x044555;
    rGPBUP  = 0x7ff;     

   
    rGPCCON = 0xaaaaaaaa;       
    rGPCUP  = 0xffff;    

   
    rGPDCON = 0xaaaaaaaa;       
    rGPDUP  = 0xffff;     

    
    rGPECON = 0xaaaaaaaa;       
    rGPEUP  = 0xffff;    
    rGPFCON = 0x55aa;
    rGPFUP  = 0xff;     
    rGPGCON = 0xff95ffba;
    rGPGUP  = 0xffff;   
    rGPHCON = 0x2afaaa;
    rGPHUP  = 0x7ff;   
    rEXTINT0 = 0x22222222;   
    rEXTINT1 = 0x22222222;    
    rEXTINT2 = 0x22222222;    
}



/*static int whichUart=0;*/

void Uart_Init(int pclk,int baud)
{
    int i;
    
    if(pclk == 0)
    pclk    = PCLK;
    rUFCON0 = 0x0;   
    rUFCON1 = 0x0;   
    rUFCON2 = 0x0;   
    rUMCON0 = 0x0;   
    rUMCON1 = 0x0;   

    

    rULCON0 = 0x3;   

    rUCON0  = 0x245;                        
    rUBRDIV0=( (int)(pclk/16./baud) -1 );
    

    rULCON1 = 0x3;
    rUCON1  = 0x245;
    rUBRDIV1=( (int)(pclk/16./baud) -1 );

    rULCON2 = 0x3;
    rUCON2  = 0x245;
    rUBRDIV2=( (int)(pclk/16./baud) -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)); 
          
    else if(ch==1)
        while(!(rUTRSTAT1 & 0x4)); 
        
    else if(ch==2)
        while(!(rUTRSTAT2 & 0x4)); 
}


char Uart_Getch(void)
{
    if(whichUart==0)
    {       
        while(!(rUTRSTAT0 & 0x1)); 
        return RdURXH0();
    }
    else if(whichUart==1)
    {       
        while(!(rUTRSTAT1 & 0x1));
        return RdURXH1();
    }
    else if(whichUart==2)
    {
        while(!(rUTRSTAT2 & 0x1));
        return RdURXH2();
    }
}


char Uart_GetKey(void)
{
    if(whichUart==0)
    {       
        if(rUTRSTAT0 & 0x1)  
            return RdURXH0();
        else
            return 0;
    }
    else if(whichUart==1)
    {
        if(rUTRSTAT1 & 0x1)  
            return RdURXH1();
        else
            return 0;
    }
    else if(whichUart==2)
    {       
        if(rUTRSTAT2 & 0x1)   
            return RdURXH2();
        else
            return 0;
    }    
}

void Uart_SendByte(char data)
{
    if(whichUart==0)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT0 & 0x2));
            Delay(10);                  
            WrUTXH0('\r');
        }
        while(!(rUTRSTAT0 & 0x2));  
        Delay(10);
        WrUTXH0(data);
    }
    else if(whichUart==1)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT1 & 0x2));
            Delay(10);                  
            rUTXH1 = '\r';
        }
        while(!(rUTRSTAT1 & 0x2));  
        Delay(10);
        rUTXH1 = data;
    }   
    else if(whichUart==2)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT2 & 0x2));
            Delay(10);               
            rUTXH2 = '\r';
        }
        
        while(!(rUTRSTAT2 & 0x2));
        Delay(10);
        rUTXH2 = data;
        
    }       
}               

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


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

char *Uart_String(void)
{

char *string;
char c;
int j=0;
while((c = Uart_Getch())!='\r')
    {
        
            string[j++] = c; 
      
    }
    string[j]='\0';
    Uart_SendByte('\n');
    return(string);
}


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 result   = 0;
    int lastIndex;    
    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(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 Timer_Start(int divider)  
{
    rWTCON = ((PCLK/1000000-1)<<8)|(divider<<3);  
    rWTDAT = 0xffff;  
    rWTCNT = 0xffff;  

      
    rWTCON = rWTCON | (1<<5) | ~(1<<2);  
}


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



void ChangeMPllValue(int mdiv,int pdiv,int sdiv)
{
    rMPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}



void ChangeClockDivider(int hdivn,int pdivn)
{
     /* hdivn,pdivn FCLK:HCLK:PCLK
     //     0,0         1:1:1 
     //     0,1         1:1:2 
     //     1,0         1:2:2
          1,1         1:2:4 */
    rCLKDIVN = (hdivn<<1) | pdivn;    
    
  /*  if(hdivn)
        MMU_SetAsyncBusMode();
    else 
        MMU_SetFastBusMode();*/
}


/*========================**[ UPLL ]==============================*/
void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
    rUPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}


/*========================*[ General Library ]=====================*/
/*void * malloc(unsigned nbyte) 

{
    void *returnPt = mallocPt;

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

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


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