Subversion Repositories openrisc

/* uart.c. UART support functions

   Copyright (C) 2004, Jacob Bower

   Copyright (C) 2010, Embecosm Limited <info@embecosm.com>

   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

   This file is part of Newlib.

   The original work by Jacob Bower is provided as-is without any kind of

   warranty. Use it at your own risk!

   All subsequent work is bound by version 3 of the GPL as follows.

   This program is free software; you can redistribute it and/or modify it

   under the terms of the GNU General Public License as published by the Free

   Software Foundation; either version 3 of the License, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful, but WITHOUT

   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

   more details.

   You should have received a copy of the GNU General Public License along

   with this program.  If not, see <http:#www.gnu.org/licenses/>.             */

/* -------------------------------------------------------------------------- */

/* This program is commented throughout in a fashion suitable for processing

   with Doxygen.                                                              */

/* -------------------------------------------------------------------------- */

#include "or1ksim-board.h"

#include "uart.h"

/*! Macro to access a UART register */

#define UREG8(reg) REG8 (UART_BASE + reg)

/*! Macro to check if transmit and transmit holding registers are both empty. */

#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)

/*! Macro to wait until a char has been transmitted */

#define WAIT_FOR_XMITR                          \

  do                                            \

    {                                           \

      lsr = UREG8 (UART_LSR);                   \

    }                                           \

  while ((lsr & BOTH_EMPTY) != BOTH_EMPTY)

/*! Macro to wait until a char can be transmitted */

#define WAIT_FOR_THRE                           \

  do                                            \

    {                                           \

      lsr = UREG8 (UART_LSR);                   \

    }                                           \

  while ((lsr & UART_LSR_THRE) != UART_LSR_THRE)

/* Macro to see if a character has been received */

#define CHECK_FOR_CHAR (UREG8 (UART_LSR) & UART_LSR_DR)

/* Macro to wait until a character is received */

#define WAIT_FOR_CHAR \

         do { \

                lsr = UREG8 (UART_LSR); \

         } while ((lsr & UART_LSR_DR) != UART_LSR_DR)

/* -------------------------------------------------------------------------- */

/*!Initialize the UART                                                        */

/* -------------------------------------------------------------------------- */

void

_uart_init ()

{

        int divisor;

        /* Reset receiver and transmiter */

        UREG8 (UART_FCR) = UART_FCR_ENABLE_FIFO |

                           UART_FCR_CLEAR_RCVR  |

                           UART_FCR_CLEAR_XMIT  |

                           UART_FCR_TRIGGER_14;

        /* Disable all interrupts */

        UREG8 (UART_IER) = 0x00;

        /* Set 8 bit char, 1 stop bit, no parity */

        UREG8 (UART_LCR) = UART_LCR_WLEN8 & ~(UART_LCR_STOP | UART_LCR_PARITY);

        /* Set baud rate */

        divisor = IN_CLK / (16 * UART_BAUD_RATE);

        UREG8 (UART_LCR) |= UART_LCR_DLAB;

        UREG8 (UART_DLL)  = divisor & 0x000000ff;

        UREG8 (UART_DLM)  = (divisor >> 8) & 0x000000ff;

        UREG8 (UART_LCR) &= ~(UART_LCR_DLAB);

}       /* _uart_init () */

/* -------------------------------------------------------------------------- */

/*!Put a character out on the UART

   @param[in] c  The character to output                                      */

/* -------------------------------------------------------------------------- */

void _uart_putc (char  c)

{

  unsigned char lsr;

  /* Wait until we are free to transmit */

  WAIT_FOR_THRE;

  /* Put the character to be transmitted and wait until it has gone. */

  UREG8 (UART_TX) = c;

  WAIT_FOR_XMITR;

}       /* _uart_putc () */

/* -------------------------------------------------------------------------- */

/*!Get a character from the UART

   @reurn  The character read.                                                */

/* -------------------------------------------------------------------------- */

char

_uart_getc ()

{

  unsigned char lsr;

  char c;

  /* Wait until a char is available, then get it. */

  WAIT_FOR_CHAR;

  return  UREG8 (UART_RX);

}       /* _uart_getc () */