xsuartdrv.c

usb 检验程序

		{}
		
	//FFUART_FFTHR = *pch;
}


/*
** send a char
*/
void XsUartDrv_SendChar(volatile UartRegsT *pUart, char *pch)
{
	pUart->UDATA = *pch;
	
	while( !(GET_BIT(&(pUart->LSR), LSR_TEMT_OFS)) )
		{}
}

void XsUartDrv_SendCharDef(char *pch)
{
	XsUartDrv_SendChar((volatile UartRegsT *)g_UartRegs, pch);
}

/*
** send data with length identified
*/
void XsUartDrv_SendData(volatile UartRegsT *pUart, char *pBuf, int len)
{
	int  i;
    while( !(GET_BIT(&(pUart->LSR), LSR_TEMT_OFS)) )
      	{}
    for(i = 0; i < len; i++)
    {
		// Write data
       	pUart->UDATA = *pBuf++;   

        // Wait for UART to complete transmition
        while( !(GET_BIT(&(pUart->LSR), LSR_TEMT_OFS)) )
        	{}
    }
}

//using default Uart Device
void XsUartDrv_SendDataDef(char *pBuf, int len)
{
	XsUartDrv_SendData((volatile UartRegsT *)g_UartRegs, pBuf, len);
}

/*
** send a string with '\0' termination, using FFUART's physical register
*/
void XsUartDrv_SendStrZ(volatile UartRegsT *pUart, char *pBuf)
{
	int  i;
	
    for(i = 0; pBuf[i]; i++)
    {
		// Write data
   		//pUart->UDATA = pBuf[i];   
    	
        // Wait for UART to complete transmition
       	while( !(GET_BIT(&(pUart->LSR), LSR_TEMT_OFS)) 	)
			{}

		// Write data
   		pUart->UDATA = pBuf[i];   
	}
}

//using default Uart Device
void XsUartDrv_SendStrZDef(char *pBuf)
{
	XsUartDrv_SendStrZ((volatile UartRegsT *)g_UartRegs, pBuf);
}

/*
*  This function is used to receive data via UART in polled mode operation
*/                  
int XsUartDrv_ReadUart(volatile UartRegsT *pUart, char * rxbufP, unsigned int len, unsigned int timeout)
{
    //int retry = RETRY;
    //use user defined timeout value
//    unsigned int retry = timeout;
    int i;
    unsigned TimeBase;
    
  
    for (i = 0; i < len; i++) 
    {
        // Wait for data to be available
        //while (((pUart->LSR & LSR_DR) == 0) && (--retry > 0))
        Util_GetTimeoutBase(&TimeBase);
        
        while (((pUart->LSR & LSR_DR) == 0))
        {   
        	if ((timeout!=0) & (Util_IsTimeOut(TimeBase, timeout)))
            	return i;
        }
            
        // Read data   
      //  if (retry > 0)
            *rxbufP++ = pUart->UDATA;
       // else
        //    break;
    }
    return i;
}

int XsUartDrv_ReadUart_Old(volatile UartRegsT *pUart, char * rxbufP, unsigned int len, unsigned int timeout)
{
    //int retry = RETRY;
    //use user defined timeout value
    unsigned int retry = timeout;
    int i;
  
    for (i = 0; i < len; i++) 
    {
        // Wait for data to be available
        while (((pUart->LSR & LSR_DR) == 0) && (--retry > 0))
        //while (((pUart->LSR & LSR_DR) == 0))
            Util_DelayMs(1);
            
        // Read data   
        if (retry > 0)
            *rxbufP++ = pUart->UDATA;
        else
            break;
    }
    return i;
}

//using default Uart Device
int XsUartDrv_ReadUartDef(char * rxbufP, unsigned int len, unsigned int timeout)
{
	return XsUartDrv_ReadUart((volatile UartRegsT *)g_UartRegs, rxbufP, len, timeout);
}

/*
* This function is used to clear receive FIFO of the UART
*/
int XsUartDrv_ClearRxUart(volatile UartRegsT *pUart)
{
    unsigned int data;
    int total = 0;
    
    // Clear the Rx FIFO 
    SET_BIT(&pUart->FCR, FCR_RESETRF_OFS);

    // Read data from FIFO until none is left
    while ((pUart->LSR & LSR_DR) != 0)
    {
        data = pUart->UDATA;
        total++;
    }
    
    return total;
}

int XsUartDrv_ClearRxUartDef()
{
	return XsUartDrv_ClearRxUart((volatile UartRegsT *)g_UartRegs);
}


#include "stdarg.h"

void doPrint(char * buffer, char * fmt, va_list ap)
{
    void *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10, *p11, *p12;

    p1 = va_arg(ap,void*);
    p2 = va_arg(ap,void*);
    p3 = va_arg(ap,void*);
    p4 = va_arg(ap,void*);

    p5 = va_arg(ap,void*);
    p6 = va_arg(ap,void*);
    p7 = va_arg(ap,void*);
    p8 = va_arg(ap,void*);

    p9 = va_arg(ap,void*);
    p10 = va_arg(ap,void*);
    p11 = va_arg(ap,void*);
    p12 = va_arg(ap,void*);

    sprintf(buffer,fmt,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12);
}

/*
* Replacement printf to redirect to the selceted UART device.
*/
void PrintfUart(volatile UartRegsT *pUart, char * fmt, ...)
{
    char buffer[256];
    va_list ap;

    va_start(ap,fmt);
    doPrint(buffer,fmt,ap);
	XsUartDrv_SendStrZ(pUart, buffer);
}

//using default Uart Device
void PrintfUartDef(char * fmt, ...)
{
    char buffer[256];
    va_list ap;

    va_start(ap,fmt);
    doPrint(buffer,fmt,ap);
	XsUartDrv_SendStrZ(((volatile UartRegsT *)g_UartRegs), buffer);
}

void PrintfUartFF(char * fmt, ...)
{
    char buffer[256];
    va_list ap;

    va_start(ap,fmt);
    doPrint(buffer,fmt,ap);
	XsUartDrv_SendStrZ((volatile UartRegsT *)FFUARTREG_PHY_BASE_ADDR, buffer);
}

void PrintfUartBT(char * fmt, ...)
{
    char buffer[256];
    va_list ap;

    va_start(ap,fmt);
    doPrint(buffer,fmt,ap);
	XsUartDrv_SendStrZ((volatile UartRegsT *)BTUARTREG_PHY_BASE_ADDR, buffer);
}

void PrintfUartST(char * fmt, ...)
{
    char buffer[256];
    va_list ap;

    va_start(ap,fmt);
    doPrint(buffer,fmt,ap);
	XsUartDrv_SendStrZ((volatile UartRegsT *)STUARTREG_PHY_BASE_ADDR, buffer);
}

void XsUartDrv_DumpAddr(unsigned base_address, int nWord)
{
    unsigned char* p;
    int i, j, size, tail;
    
	p = (unsigned char*)base_address;
    size = nWord * 4;
    tail = size - (size/8) * 8;

    for(i = 0; i < size/8; i++)
    {
    	for(j = 0; j < 8; j++)
    	{
	   		PrintfUartDef("%2.2x ", *p);
			p++;
    	}
    	
    	//output ascii char
    	p -= 8;
    	for(j = 0; j < 8; j++)
    	{
			if( (*p >= 33) && (*p <= 125) )
				PrintfUartDef("%c", *p);
			else
				PrintfUartDef("%c", '.');
			p++;
    	}

   	   	PrintfUartDef("\r\n");  
    }
    
	//tail bytes
    for(j = 0; j < tail; j++)
   	{
   		PrintfUartDef("%2.2x ", *p);
		p++;
   	}
   	PrintfUartDef("\r\n");  
}