Subversion Repositories scarts

/* UART device driver for SCARTS.

 * Copyright (C) 2010, 2011 Embedded Computing Systems Group,

 * Department of Computer Engineering, Vienna University of Technology.

 * Contributed by Martin Walter <mwalter@opencores.org>

 *

 * The authors hereby grant permission to use, copy, modify, distribute,

 * and license this software and its documentation for any purpose, provided

 * that existing copyright notices are retained in all copies and that this

 * notice is included verbatim in any distributions. No written agreement,

 * license, or royalty fee is required for any of the authorized uses.

 * Modifications to this software may be copyrighted by their authors

 * and need not follow the licensing terms described here, provided that

 * the new terms are clearly indicated on the first page of each file where

 * they apply.

 */

#include "UART.h"

#include "modules.h"

static int  UART_getc (char *c);

static void UART_putc (const char c);

static int

UART_getc (char *c)

{

  int err = 0;

  uint16_t msg;

  /* Start the receiver. */

  MINI_UART_CMD = (1 << MINI_UART_CMD_AA_2);

  /* Wait until the receiver is ready. */

  while ((MINI_UART_STATUS_C & (1 << MINI_UART_STATUS_C_RBR)) == 0)

    asm ("nop");

  /* Check for errors from the receiver. */

  if ((MINI_UART_STATUS_C & (1 << MINI_UART_STATUS_C_FE)) != 0)

    err = EFRAME;

  if ((MINI_UART_STATUS_C & (1 << MINI_UART_STATUS_C_PE)) != 0)

    err = EPARITY;

  if ((MINI_UART_STATUS_C & (1 << MINI_UART_STATUS_C_OV)) != 0)

    err = EOVFLOW;

  msg = MINI_UART_MSG;

  /* Stop the receiver. */

  MINI_UART_CMD = (1 << MINI_UART_CMD_AA_2) | (1 << MINI_UART_CMD_AA_0);

  if (err == 0)

    *c = (char) msg;

  return err;

}

static void

UART_putc (const char c)

{

  /* Wait until transmitter is ready. */

  while ((MINI_UART_STATUS_C & (1 << MINI_UART_STATUS_C_TBR)) == 0)

    asm ("nop");

  MINI_UART_MSG = c;

  /* Start the transmitter. */

  MINI_UART_CMD = (1 << MINI_UART_CMD_AA_1) | (1 << MINI_UART_CMD_AA_0);

  while ((MINI_UART_STATUS_C & (1 << MINI_UART_STATUS_C_TBR)) == 0)

    asm ("nop");

  MINI_UART_CMD = 0;

}

int

UART_close (int file)

{

  return 0;

}

void

UART_init (UART_Cfg cfg)

{

  uint16_t ubrs;

  if (cfg.baud == 0)

    return;

  MINI_UART_CFG = 0;

  /* Set the parity bits. */

  if (cfg.frame.parity != UART_CFG_PARITY_NONE)

  {

    MINI_UART_CFG |= (1 << MINI_UART_CFG_PARENA);

    if (cfg.frame.parity == UART_CFG_PARITY_ODD)

      MINI_UART_CFG |= (1 << MINI_UART_CFG_ODD);

  }

  /* Set the stop bits. */

  if (cfg.frame.stop_bits == UART_CFG_STOP_BITS_2)

    MINI_UART_CFG |= (1 << MINI_UART_CFG_STOP);

  /* Set the message length. */

  if (cfg.frame.msg_len & 8)

    MINI_UART_CFG |= (1 << MINI_UART_CFG_MSGLEN_3);

  if (cfg.frame.msg_len & 4)

    MINI_UART_CFG |= (1 << MINI_UART_CFG_MSGLEN_2);

  if (cfg.frame.msg_len & 2)

    MINI_UART_CFG |= (1 << MINI_UART_CFG_MSGLEN_1);

  if (cfg.frame.msg_len & 1)

    MINI_UART_CFG |= (1 << MINI_UART_CFG_MSGLEN_0);

  /* Enable transmission control. */

  MINI_UART_CFG |= (1 << MINI_UART_CFG_TRCTRL);

  /* Set the baud rate. */

  ubrs = (uint16_t) (cfg.fclk / cfg.baud) << 4;

  MINI_UART_UBRS_H = (ubrs >> 8) & 0xFF;

  MINI_UART_UBRS_L = ubrs & 0xFF;

}

int

UART_open (const char *name, int flags, int mode)

{

  return 0;

}

int

UART_read (int file, char *ptr, int len)

{

  char c;

  int i;

  i = 0;

  if (len <= 0)

    return 0;

  do

  {

    if (UART_getc (&c) != 0)

      break;

    ptr[i++] = c;

  }

  while (i < len);

  return i;

}

int

UART_read_line (int file, char *ptr, int len)

{

  char c;

  int i;

  i = 0;

  if (len <= 0)

    return 0;

  do

  {

    if (UART_getc (&c) != 0)

      break;

    if (c == '\r')

      continue;

    if (c == '\n')

      break;

    ptr[i++] = c;

  }

  while (i < len);

  ptr[i] = '\0';

  return i;

}

int

UART_write (int file, char *ptr, int len)

{

  int i;

  if (len <= 0)

    return 0;

  for (i = 0; i < len; ++i)

    UART_putc (ptr[i]);

  return len;

}