debug.c

CIRRUS 公司EP93XX系列CPU的WINCE下的BSP

//**********************************************************************
//                                                                      
// Filename: debug.c
//                                                                      
// Description: OEM Debug Serial Monitor Routines
//                                                                      
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
// Copyright(c) Cirrus Logic Corporation 2001, All Rights Reserved                       
//                                                                      
//**********************************************************************

/*****************************************************************************
* 
*   @doc EXTERNAL OEM
*
*   @module debug.c | OEM Debug Serial Monitor Routines
*
******************************************************************************/
#include <windows.h>
#include <nkintr.h>
#include <halether.h>
#include <drv_glob.h>
#include <mdppfs.h>
#include "ethdbg.h"
#include <hwdefs.h>
#include <options.h>
#include <clocks.h>




//****************************************************************************
// Uart Routines prototype
//****************************************************************************
// 
// 
//
void UART1_Start();
void UART1_Stop();
void UART2_Start();
void UART2_Stop();
void UART3_Start();
void UART3_Stop();
void UART1_Write(unsigned char);
void UART2_Write(unsigned char);
void UART3_Write(unsigned char);
int  UART1_Read();
int  UART2_Read();
int  UART3_Read();
void UART1_ClearError();
void UART2_ClearError();
void UART3_ClearError();

#ifndef DEBUG_UART_PORT
#define DEBUG_UART_PORT     3
#endif // DEBUG_UART_PORT

#if  (DEBUG_UART_PORT ==1)
#define UartStart       UART1_Start
#define UartStop        UART1_Stop
#define UartWrite       UART1_Write
#define UartRead        UART1_Read
#define UartClearError  UART1_ClearError
#endif

#if  (DEBUG_UART_PORT ==2)
#define UartStart       UART2_Start
#define UartStop        UART2_Stop
#define UartWrite       UART2_Write
#define UartRead        UART2_Read
#define UartClearError  UART2_ClearError
#endif


#if (DEBUG_UART_PORT ==3)
#define UartStart       UART3_Start
#define UartStop        UART3_Stop
#define UartWrite       UART3_Write
#define UartRead        UART3_Read
#define UartClearError  UART3_ClearError
#endif 

#ifndef DEBUG_UART_SPEED
#define DEBUG_UART_SPEED        38400    
#endif // DEBUG_UART_SPEED

unsigned int giSerialInitialized;
#define SERIAL_INITIALIZED_CHECK     0x12345678

//****************************************************************************
// OEMInitDebugSerial
//****************************************************************************
// Initializes the Debug serial port.
// 
//
void OEMInitDebugSerial(void) 
{
    if(giSerialInitialized !=SERIAL_INITIALIZED_CHECK)
    {
        UartStart();
        giSerialInitialized = SERIAL_INITIALIZED_CHECK;
    }
}

//****************************************************************************
// OEMWriteDebugLED
//****************************************************************************
// Display value to specified LED port.
//
// The wIndex parameter can be used to specify a write to the discrete LEDS (if
// 0xffff), otherwise is used as an offset (DWORD aligned) for the Alpha LEDS
// for triggering.
//
void OEMWriteDebugLED(WORD wIndex, DWORD dwPattern)
{
    if (wIndex == 0)
    {

        *GPIO_PEDR  = (dwPattern & (GPIOE_RLED | GPIOE_GLED)) |
                      (*GPIO_PEDR & ~(GPIOE_RLED | GPIOE_GLED)) ;
    }        
}


//****************************************************************************
// OEMWriteDebugString
//****************************************************************************
// Display string to the monitor port.
// 
// 
void OEMWriteDebugString(unsigned short *str) 
{
    //
    // Send message to serial port
    //
    while ( *str )
    {
        OEMWriteDebugByte((unsigned char)*str++);
    }        
}

//****************************************************************************
// OEMWriteDebugByte
//****************************************************************************
// Parameters:  unsigned char 
//              Points to the output Character.
//
void OEMWriteDebugByte(UCHAR ch) 
{
    UartWrite(ch);
}


//****************************************************************************
// OEMReadDebugByte
//****************************************************************************
//  Returns the following:
//     OEM_DEBUG_COM_ERROR        Error detected
//     OEM_DEBUG_READ_NODATA      No data is available at the port.
//     ch                         If data is available.
//
int
OEMReadDebugByte() 
{
   return(UartRead());
}



//****************************************************************************
// OEMClearDebugCommError
//****************************************************************************
// Resets the UART to clear any Uart errors out.
// 
void OEMClearDebugCommError(void) 
{
    UartClearError();
}


//****************************************************************************
// OEMUartStop
//****************************************************************************
// Stops the UART port.
// 
void OEMUartStop(void) 
{
    UartStop();
    giSerialInitialized = 0;
}


//****************************************************************************
// UART1_Start
//****************************************************************************
// Start uart1.
// 
void UART1_Start(void)
{
    UART1_Stop();

    //
    // Set up default baudrate
    //
   *UART1_LCR_M = 0 ;                
   *UART1_LCR_L = UART_DIVISOR(DEBUG_UART_SPEED); 

    //
    // Setup mode 8 bits, no parity, 1 stop bit, fifo enabled.
    //
    *UART1_LCR_H = LCR_H_DATABITS_8 | LCR_H_FIFO_ENABLE;

    
    // Clear old status.
    *UART1_SR  = 0;                           
    *UART1_MCR  = MCR_RTS | MCR_DTR;
    *UART1_IIR = 0;

    //
    // enable this uart
    //
    *UART1_CR |= CR_UARTE;                      

    return;
}//end uart1_start

//****************************************************************************
// UART2_Start
//****************************************************************************
// Start uart2.
// 
void UART2_Start(void)
{
    UART2_Stop();

    //
    // Set up default baudrate
    //
   *UART2_LCR_M = 0 ;                
   *UART2_LCR_L = UART_DIVISOR(DEBUG_UART_SPEED); 

    //
    // Setup mode 8 bits, no parity, 1 stop bit, fifo enabled.
    //
    *UART2_LCR_H = LCR_H_DATABITS_8 | LCR_H_FIFO_ENABLE;

    
    // Clear old status.
    *UART2_SR  = 0;                           
    // *UART2_MCR  = MCR_RTS | MCR_DTR;
    *UART2_IIR = 0;

    //
    // enable this uart
    //
    *UART2_CR |= CR_UARTE;                      

    return;
}//end uart1_start

//****************************************************************************
// UART3_Start
//****************************************************************************
// Routine to start UART 3.
// 
//
void UART3_Start(void)
{
    //
    // Uart3 stop.
    //
    UART3_Stop();

    //
    // Program uart divisor.
    //
    *UART3_LCR_L = UART_DIVISOR(DEBUG_UART_SPEED); 
    *UART3_LCR_M = 0 ;                

    //
    // setup mode 8 data bits, 1 stop bit, no parity.
    //
    *UART3_LCR_H = LCR_H_DATABITS_8 ;   

    //
    // Clear old status.
    //
    *UART3_SR  = 0;                           

    //
    //clr intrpts
    //
    *UART3_IIR = 0;

    //
    // enable this uart
    //
    *UART3_CR = CR_UARTE;                      

    return;

}//end uart3_start

//****************************************************************************
// UART1_Stop
//****************************************************************************
// Stop UART 1.
// 
void UART1_Stop(void)
{

    //
    // Disable this uart
    //
    *UART1_CR    = 0;   

    *UART1_LCR_H = 0;
    *UART1_LCR_M = 0;
    *UART1_LCR_L = 0;

    //
    // Clear status bits.
    //
    *UART1_SR = 0;        
    return;
}

//****************************************************************************
// UART2_Stop
//****************************************************************************
// Stop UART 2.
// 
void UART2_Stop(void)
{

    //
    // Disable this uart
    //
    *UART2_CR    = 0;   

    *UART2_LCR_H = 0;
    *UART2_LCR_M = 0;
    *UART2_LCR_L = 0;

    //
    // Clear status bits.
    //
    *UART2_SR = 0;        
    return;
}


//****************************************************************************
// UART3_Stop
//****************************************************************************
// Stop UART 3.
// 
void UART3_Stop(void)
{
    //
    // disable this uart
    //
    *UART3_CR    = 0;   

    *UART3_LCR_H = 0;
    *UART3_LCR_M = 0;
    *UART3_LCR_L = 0;


    // Clear status bits.
    *UART3_SR = 0;        

    return;
}



//****************************************************************************
// UART1_Write
//****************************************************************************
//
void UART1_Write(UCHAR ch) 
{
    //
    // txfe  see if the tx fifo is empty
    //
    while ((*UART1_FR & FR_TXFE) != FR_TXFE)         
        /* - do nothing until fifo is empty; ie character is gone */
        ;

    *UART1_DR = (int)ch;
}

//****************************************************************************
// UART2_Write
//****************************************************************************
//
void UART2_Write(UCHAR ch) 
{
    //
    // txfe  see if the tx fifo is empty
    //
    while ((*UART2_FR & FR_TXFE) != FR_TXFE)         
        /* - do nothing until fifo is empty; ie character is gone */
        ;

    *UART2_DR = (int)ch;
}


//****************************************************************************
// UART3_Write
//****************************************************************************
//
void UART3_Write(UCHAR ch) 
{
    //
    // txfe  see if the tx fifo is empty
    //
    while ((*UART3_FR & FR_TXFE) != FR_TXFE)         
        /* - do nothing until fifo is empty; ie character is gone */
        ;

    *UART3_DR = (int)ch;
}



//****************************************************************************
// UART1_Read
//****************************************************************************
// Routine to Read Uart 1.
// 
//
int UART1_Read(void)
{
    int     nReadChar;
    ULONG   ulFlagRegister; 
    ULONG   ulStatusRegister;

    ulFlagRegister      = *UART1_FR;
    ulStatusRegister    = *UART1_SR;
    
    if(ulStatusRegister & SR_OE)
    {
        nReadChar = OEM_DEBUG_COM_ERROR;
    }
    else if(!(ulFlagRegister & FR_RXFE))
    {
        nReadChar = (*UART1_DR & 0xFF);
    }
    else
    {
        nReadChar = OEM_DEBUG_READ_NODATA;
    }
    
    return nReadChar;
}

//****************************************************************************
// UART2_Read
//****************************************************************************
// Routine to Read Uart 2.
// 
//
int UART2_Read(void)
{
    int     nReadChar;
    ULONG   ulFlagRegister; 
    ULONG   ulStatusRegister;

    ulFlagRegister      = *UART2_FR;
    ulStatusRegister    = *UART2_SR;
    
    if(ulStatusRegister & SR_OE)
    {
        nReadChar = OEM_DEBUG_COM_ERROR;
    }
    else if(!(ulFlagRegister & FR_RXFE))
    {
        nReadChar = (*UART2_DR & 0xFF);
    }
    else
    {
        nReadChar = OEM_DEBUG_READ_NODATA;
    }
    
    return nReadChar;
}

//****************************************************************************
// UART3_Read
//****************************************************************************
// Routine to Read Uart 3.
// 
//
int UART3_Read(void)
{
    int     nReadChar;
    ULONG   ulFlagRegister; 
    ULONG   ulStatusRegister;

    ulFlagRegister      = *UART1_FR;
    ulStatusRegister    = *UART1_SR;
    
    if(ulStatusRegister & SR_OE)
    {
        nReadChar = OEM_DEBUG_COM_ERROR;
    }
    else if(!(ulFlagRegister & FR_RXFE))
    {
        nReadChar = (*UART3_DR & 0xFF);
    }
    else
    {
        nReadChar = OEM_DEBUG_READ_NODATA;
    }
    
    return nReadChar;
}


//****************************************************************************
// UART1_ClearError
//****************************************************************************
// Clears errors for UART1.
// 
//
void UART1_ClearError()
{
    //
    // Partial stop and disable this uart
    //
    *UART1_CR  = 0;   

    //
    // Clear status bits.
    //
    *UART1_SR  = 0;        

    //
    // partial startup,clr interrupts
    //
    *UART1_IIR = 0;        
    
    //
    // enable this uart
    //
    *UART1_CR = CR_UARTE; 
}    

//****************************************************************************
// UART2_ClearError
//****************************************************************************
// Clears errors for UART1.
// 
//
void UART2_ClearError()
{
    //
    // Partial stop and disable this uart
    //
    *UART2_CR  = 0;   

    //
    // Clear status bits.
    //
    *UART2_SR  = 0;        

    //
    // partial startup,clr interrupts
    //
    *UART2_IIR = 0;        
    
    //
    // enable this uart
    //
    *UART2_CR = CR_UARTE; 
}    


//****************************************************************************
// UART3_ClearError
//****************************************************************************
// Clears errors for UART3.
// 
//
void UART3_ClearError()
{
    //
    // Partial stop and disable this uart
    //
    *UART3_CR  = 0;   

    //
    // Clear status bits.
    //
    *UART3_SR  = 0;        

    //
    // partial startup,clr interrupts
    //
    *UART3_IIR = 0;        
    
    //
    // enable this uart
    //
    *UART3_CR = CR_UARTE; 
}