printf_a9.c

来自「OMAP1030 处理器的ARM 侧硬件测试代码 OMAP1030 是TI」· C语言 代码 · 共 579 行

/*============================================================================
*
*            TEXAS INSTRUMENTS INCORPORATED PROPRIETARY INFORMATION
*
*   Property of Texas Instruments
*   For Unrestricted Internal Use Only
*   Unauthorized reproduction and/or distribution is strictly prohibited.
*   This product is protected under copyright law and trade secret law as an unpublished work.
*   Created 2004, (C) Copyright 2004 Texas Instruments.  All rights reserved.
*
*   File: uartdrv.c
*
*    project: UART Drivers for NEPTUNE
*
* =============================================================================*/

/* ============================================================================
* STANDARD INCLUDE FILE
* =============================================================================*/
#include "printf_a9.h"


/* ============================================================================
* GLOBAL VARIABLES DECLARATIONS
* =============================================================================*/
UWORD16 uart_in_use = 0;


/* ============================================================================
* FUNCTIONS
* =============================================================================*/
void UART_reset(void *inBaseAddress)
/*
 * Reset UART_MODEM from sw control and verify UART state
 */
{
  UART_MODEM_SYSC(inBaseAddress) |= 0x02;
  while (UART_MODEM_SYSS(inBaseAddress) != 0x01);

  /* TBD: Need an escape? */
  while ((UART_MODEM_MDR1(inBaseAddress) & 0x07) != 0x07);

  return;
}

/* ============================================================================ */

void UART_configure(void *inBaseAddress)
/*
 *
 */
{
  
  /* disable all interrupts */
  UART_MODEM_IER(inBaseAddress)  = 0x00;

  UART_MODEM_EFR(inBaseAddress)  = 0x00;        // No Flow control

  UART_MODEM_SCR(inBaseAddress)  = 0x00;	// ensure preassigned buffer levels from FCR settings

  UART_MODEM_LCR(inBaseAddress)  = 0xBF;        // set to access EFR
  
  UART_MODEM_EFR(inBaseAddress) |= (1 << 4);
  
  UART_MODEM_LCR(inBaseAddress)  = 0x00;  

  UART_MODEM_MCR(inBaseAddress) |= (1 << 6);

  UART_MODEM_TLR(inBaseAddress)  = 0x00;        // set to make FCR effective for 56 spaces on tx and 8 rx chars

  UART_MODEM_FCR(inBaseAddress)  = 0x37;        // dis dma, clear fifo rx = 8 chars and tx = 56 spaces

  UART_MODEM_LCR(inBaseAddress)  = (1 << 7);
  
  UART_MODEM_DLL(inBaseAddress)  = 26;		// 0x01 = 3.6864 Mbps in 13x mode
                              			// 0x04 = 921.6 Kbps in 13x mode
		                                // 0x08 = 461.54 Kbps in 13x mode
  
  UART_MODEM_DLH(inBaseAddress)  = 0x00;
  
  UART_MODEM_LCR(inBaseAddress)  = 0x00;

  #define UART_MODE 0x00
  /* program mode after dlh and dll are written */
  UART_MODEM_MDR1(inBaseAddress) = UART_MODE;		    // uart 16x = 0x00
  	                                                // uart 13x = 0x03  
  
  /* TBD: Need an escape? */
  while ((UART_MODEM_MDR1(inBaseAddress)) != UART_MODE);

  
  UART_MODEM_LCR(inBaseAddress) =
               ((0 << UART_MODEM_LCR_DIV_EN_POS) |
                (0 << UART_MODEM_LCR_BREAK_EN_POS) |
                (0 << UART_MODEM_LCR_PARITY_TYPE_2_POS) |
                (1 << UART_MODEM_LCR_PARITY_TYPE_1_POS) |
                (0 << UART_MODEM_LCR_PARITY_EN_POS) |     // 0 Parity bits
                (0 << UART_MODEM_LCR_NB_STOP_POS) |       // 1 Stop bits
                (3 << UART_MODEM_LCR_CHAR_LENGTH_POS));   // 8 Data bits
  
  // enable RHR interrupt
  UART_MODEM_IER(inBaseAddress) = 0x00;     	// INTS INFO
                            			// 0 - rhr            0
                            			// 1 - thr            0
		                                // 2 - line status    0
                    			        // 3 - modem status   0
  
  
   return;
}

/* ============================================================================ */

void UART_intRxHandler(UWORD8 inInterrupt,
                       void *inBaseAddress)
{
  /*
   * Make sure that it is OK to read from this device
   */
  if(!stdin->buff_stop)
    stdin->buff_stop = stdin->pos;

  /*
   * Append the next characters from the device
   * to the buffer and adjust the buffer pointer
   */
  while((UART_MODEM_LSR(inBaseAddress) & (1 << UART_MODEM_LSR_RX_FIFO_E_POS)) &&
        (stdin->buff_stop < stdin->bufend))
    *stdin->buff_stop++ = UART_MODEM_RHR(inBaseAddress);

  return;
}

/* ============================================================================ */

void UART1_intRxHandler(UWORD8 inInterrupt)
{
  UART_intRxHandler(inInterrupt,
            (void *)UART_MODEM1_ADDRESS);

  return;
}

/* ============================================================================ */

void UART2_intRxHandler(UWORD8 inInterrupt)
{
  UART_intRxHandler(inInterrupt,
            (void *)UART_MODEM2_ADDRESS);

  return;
}

/* ============================================================================ */

void UART3_intRxHandler(UWORD8 inInterrupt)
{
  UART_intRxHandler(inInterrupt,
            (void *)UART_MODEM3_ADDRESS);

  return;
}

/* ============================================================================ */

int UARTopen(void *inBaseAddress)
{
  UART_reset(inBaseAddress);
  UART_configure(inBaseAddress);

  return(0);
}

/* ============================================================================ */

int UART1open(const char *inPath,
                 unsigned inFlags,
                      int inFileDescriptor)
{
   
    /* Set up UART1 signals on Neptune Top Level pinout */
    //config uart1_rx multiplexing pin conf_usb_0_dat0 mode 1
    CONFIG_SetModePin(IO_CONFIGURATION_BASE_ADDR_ARM+IO_CONFIGURATION_CONF_USB_0_DAT_OFFSET,MODE1);

    //config uart1_tx multiplexing pin conf_usb_0_se0 mode 1
    CONFIG_SetModePin(IO_CONFIGURATION_BASE_ADDR_ARM+IO_CONFIGURATION_CONF_USB_0_SE0_OFFSET,MODE1);

    //config uart1_rts multiplexing pin conf_usb_0_txen mode 1
    CONFIG_SetModePin(IO_CONFIGURATION_BASE_ADDR_ARM+IO_CONFIGURATION_CONF_USB_0_TXEN_OFFSET,MODE1);

    //config uart1_cts multiplexing pin conf_usb_0_rcv mode 1
    CONFIG_SetModePin(IO_CONFIGURATION_BASE_ADDR_ARM+IO_CONFIGURATION_CONF_USB_0_RCV_OFFSET,MODE1);
    
    // FPGA Enable
    FPGA_EnableUART1();
    
    /* enable clock for uart1 */
    ULPD_SoftReqEnable(UART1);        

   return(UARTopen((void *)UART_MODEM1_ADDRESS));
}

/* ============================================================================ */

int UART2open(const char *inPath,
                 unsigned inFlags,
                      int inFileDescriptor)
{

    /* Set up UART2 signals on Neptune Top Level pinout */
    //CONFIG_IO_Appli0();
    
    /* enable clock for uart2 */
    ULPD_SoftReqEnable(UART2);     

  return(UARTopen((void *)UART_MODEM2_ADDRESS));
}

/* ============================================================================ */

int UART3open(const char *inPath,
                 unsigned inFlags,
                      int inFileDescriptor)
{

    /* Set up UART3 signals on Neptune Top Level pinout */
    //CONFIG_IO_Appli0();
    
    /* enable clock for uart3 */
    ULPD_SoftReqEnable(UART3);     

  return(UARTopen((void *)UART_MODEM3_ADDRESS));
}

/* ============================================================================ */

int UARTclose(void *inBaseAddress)
{
  UART_reset(inBaseAddress);

  return(0);
}

/* ============================================================================ */

int UART1close(int inFileDescriptor)
{

  UARTclose((void *)UART_MODEM1_ADDRESS);
  
  ULPD_SoftReqDisable(UART1);
  
  return(0);
}

/* ============================================================================ */

int UART2close(int inFileDescriptor)
{

  UARTclose((void *)UART_MODEM2_ADDRESS);

  ULPD_SoftReqDisable(UART2);

  return(0);
}

/* ============================================================================ */

int UART3close(int inFileDescriptor)
{

  UARTclose((void *)UART_MODEM3_ADDRESS);
  
  ULPD_SoftReqDisable(UART3);

  return(0);
}

/* ============================================================================ */

int UARTread(void *inBaseAddress,
             char *inBuffer,
          unsigned inCount)
{
  register int lvCounter;

  for (lvCounter = 0;
       lvCounter < inCount;
       lvCounter++)
  {
    while(!(UART_MODEM_LSR(inBaseAddress) & (1 << UART_MODEM_LSR_RX_FIFO_E_POS)));

    if((*inBuffer++ = UART_MODEM_RHR(inBaseAddress)) == '\0')
      break;
  }

  return inCount ? lvCounter :
    (UART_MODEM_LSR(inBaseAddress) & (1 << UART_MODEM_LSR_RX_FIFO_E_POS));
}

/* ============================================================================ */

int UART1read(int inFileDescriptor,
            char *inBuffer,
         unsigned inCount)
{
  return(UARTread((void *)UART_MODEM1_ADDRESS,
                  inBuffer,
                  inCount));
}

/* ============================================================================ */

int UART2read(int inFileDescriptor,
            char *inBuffer,
         unsigned inCount)
{
  return(UARTread((void *)UART_MODEM2_ADDRESS,
                  inBuffer,
                  inCount));
}

/* ============================================================================ */

int UART3read(int inFileDescriptor,
            char *inBuffer,
         unsigned inCount)
{
  return(UARTread((void *)UART_MODEM3_ADDRESS,
                  inBuffer,
                  inCount));
}

/* ============================================================================ */

int UARTwrite(void *inBaseAddress,
        const char *inBuffer,
           unsigned inCount)
{
  register int lvCounter;

  for (lvCounter = 0;
       lvCounter < inCount;
       lvCounter++)
  {
    while (!(UART_MODEM_LSR(inBaseAddress) & (1 << UART_MODEM_LSR_TX_FIFO_E_POS)));
//  while (UART_MODEM_SSR(inBaseAddress) & (1 << UART_MODEM_SSR_TX_FIFO_FULL_POS));

    UART_MODEM_THR(inBaseAddress) = *inBuffer++;
  }

  return lvCounter;
}

/* ============================================================================ */

int UART1write(int inFileDescriptor,
       const char *inBuffer,
          unsigned inCount)
{
  return(UARTwrite((void *)UART_MODEM1_ADDRESS,
                   inBuffer,
                   inCount));
}

/* ============================================================================ */

int UART2write(int inFileDescriptor,
       const char *inBuffer,
          unsigned inCount)
{
  return(UARTwrite((void *)UART_MODEM2_ADDRESS,
                   inBuffer,
                   inCount));
}

/* ============================================================================ */

int UART3write(int inFileDescriptor,
       const char *inBuffer,
          unsigned inCount)
{
  return(UARTwrite((void *)UART_MODEM3_ADDRESS,
                   inBuffer,
                   inCount));
}

/* ============================================================================ */

long UARTseek(int inFileDescriptor,
             long inOffset,
              int inOrigin)
{
  return(EOF);
}

/* ============================================================================ */

int UARTrename(const char *inOldName,
               const char *inNewName)
{
  return(~0);
}

/* ============================================================================ */

int UARTunlink(const char *inPath)
{
  return(-1);
}

/* ============================================================================ */

const _DEVICE devUART[] =
{
  {
    "UART1",
    _SSA,
    UART1open,
    UART1close,
    UART1read,
    UART1write,
    UARTseek,
    UARTunlink,
    UARTrename
  },
  {
    "UART2",
    _SSA,
    UART2open,
    UART2close,
    UART2read,
    UART2write,
    UARTseek,
    UARTunlink,
    UARTrename
  },
  {
    "UART3",
    _SSA,
    UART3open,
    UART3close,
    UART3read,
    UART3write,
    UARTseek,
    UARTunlink,
    UARTrename
  }
};

/* ============================================================================ */

const char *ioConfigure(const _DEVICE *inDevice)
{
  /* Set stdin/stdout as unbuffered files */
  setvbuf(stdin, NULL, _IONBF, 0);
  setvbuf(stdout, NULL, _IONBF, 0);

 // _stream[0].dev = /* stdin */
 // _stream[1].dev = /* stdout */
//  _stream[2].dev = /* stderr */
       (_DEVICE *)inDevice;

  uart_in_use = (inDevice - devUART) + 1;

  return(inDevice->name);
}

/* ============================================================================ */

_DEVICE * ioChange(const _DEVICE *inDevice)
{
int uart_in_use_by_user;

 if(!inDevice)
    return(NULL);

   if(uart_in_use){
    // Switch to UART 2
    printf(" Be careful the UART used will switched to UART%i \r\n", (inDevice - devUART) + 1);
    printf(" Connect you UART cable to UART%i then press y \r\n",(inDevice - devUART) + 1);
    devUART[uart_in_use-1].CLOSE(NULL);
  }

  uart_in_use_by_user = uart_in_use;

  ioInitialize(inDevice);

  uiGetYesNo("");
  if (uart_in_use_by_user)
   return (_DEVICE *)&devUART[uart_in_use_by_user - 1];
  else 
   return NULL;
}
/* ============================================================================ */

const char *ioInitialize(const _DEVICE *inDevice)
{
extern UARTMOD_UartType_t UartSerialType;
        
  if(!inDevice)
    return(NULL);

  if(inDevice->OPEN(NULL, 0, 0) < 0)
    return NULL;
 
  if (inDevice == UART1_CCS) {
        UartSerialType = UART_MODEM1;          
	SSW_Release(UART_2);
  	SSW_Release(UART_3);
  	SSW_Grab(UART_1);
        
  } 
   
  else if (inDevice == UART2_CCS) {
        UartSerialType = UART_MODEM2;  
        SSW_Release(UART_1);
  	SSW_Release(UART_3);
  	SSW_Grab(UART_2);          
  } 
   
  else if (inDevice == UART3_CCS) {
  	UartSerialType = UART_MODEM3; 
        SSW_Release(UART_1);
  	SSW_Release(UART_2);
  	SSW_Grab(UART_3);
   }              
  
  return(ioConfigure(inDevice));
}

/* ============================================================================ */

int io_KeyboardHit(void)
{
  char lvCharacter;
  int lvRetVal;

  if(!uart_in_use)
    lvRetVal = scanf("%c", &lvCharacter);
  else
  if(lvRetVal = read(stdin->fd,  NULL, 0))
    /* Flush the character */
    read(stdin->fd, &lvCharacter, 1);

  return(lvRetVal);
}

/* ============================================================================ */

void uiWaitKeyboard(void)
{
  printf("\r\n\nPress any key to continue");
  while(!io_KeyboardHit());
  printf("\r\n");

  return;
}

/* ============================================================================ */

int uiGetYesNo(char *inPromptString)
{
  int lvResult;

  fflush(stdin);

  printf("%s?[y/n]: ", inPromptString);

  lvResult = (getchar() == 'y');

  printf(lvResult ? "Yes" : "No");
  printf("\r\n");

  return(lvResult);
}