Subversion Repositories scarts

/* SCARTS miniUART extension module code for the GNU simulator.
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   Free Software Foundation, Inc.
   Contributed by Martin Walter <mwalter@opencores.org>
 
   This file is part of the GNU simulators.
 
   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/>.  */
 
 
#define _XOPEN_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <termios.h>
#include <unistd.h>
#include "miniUART.h"
 
/* Macros for machine type. */
#if defined __SCARTS_16__
  #define SCARTS_ADDR_CTYPE  uint16_t
#elif defined __SCARTS_32__
  #define SCARTS_ADDR_CTYPE  uint32_t
#else
  #error "Unsupported target machine type"
#endif
 
/* Macros for the assigned action (ASA) in the CMD register. */
#define UART_CMD_ASA_BITMASK	0x38
#define UART_CMD_ASA_TxStart	(0x3 << 3)
#define UART_CMD_ASA_RxEnable	(0x4 << 3)
#define UART_CMD_ASA_RxDisable	(0x5 << 3)
 
/* Macros for the event selector (ES) in the CMD register. */
#define UART_CMD_ES_MASK	0x06
#define UART_CMD_ES_NoEvent	0x00
#define UART_CMD_ES_StartBitRec	(0x1 << 1)
#define UART_CMD_ES_RxComplete	(0x2 << 1)
#define UART_CMD_ES_TxStarted	(0x3 << 1)
 
/* Macros for bit manipulations. */
#define read_bit(regfile, bitpos) (((regfile) >> (bitpos)) & 1)
#define write_bit(regfile, bitpos, value) (void)((value) ? ((regfile) |= (1 << (bitpos))) : ((regfile) &= ~(1 << (bitpos))))
 
static miniuart_mem_t mem;
static int fdm          = -1; /* File handle of pseudo TTY master. */
static int rxEnabled    =  0; /* Does the simulated serial port accept any incoming data? */
static int txCnt        =  1; /* Simulates time the data transmission takes (cpu cycles). */
static int txMsgChanged =  0; /* Did MSG register contents change since last transmission? */
 
static void set_event_flag (void);
static int  stty_raw       (int fd);
 
static void
set_event_flag (void)
{
  /* Set the MINI_UART_STATUS_C_EF flag. */
  write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_EF, 1);
 
  /* Check if the MINI_UART_CMD_EI flag is set. */
  if (read_bit (mem.regfile.CMD, MINI_UART_CMD_EI))
    /* Trigger an interrupt. */
    write_bit (mem.regfile.STATUS, MINI_UART_STATUS_INT, 1);
}
 
static int
stty_raw (int fd)
{
  struct termios tty_state;
 
  bzero (&tty_state, sizeof (tty_state));
  tty_state.c_cflag = B38400 | CS8 | CLOCAL | CREAD;
  tty_state.c_iflag = IGNPAR;
  tty_state.c_oflag = 0;
 
  /* Configure for blocking read until 1 chars received. */
  tty_state.c_cc[VMIN]  = 1;
 
  /* Configure for inter-character timer being unused. */
  tty_state.c_cc[VTIME] = 0;
 
  if (tcsetattr (fd, TCSAFLUSH, &tty_state) < 0)
    return (-1);
 
  return 0;
}
 
uint8_t*
get_mem (void)
{
  return mem.raw;
}
 
void
get_mem_map (SCARTS_ADDR_CTYPE* start, SCARTS_ADDR_CTYPE* size)
{
  *start = MINI_UART_BADDR;
  *size  = MINI_UART_SIZE;
}
 
uint8_t*
get_status (void)
{
  return &mem.regfile.STATUS;
}
 
int
mem_read (SCARTS_ADDR_CTYPE offset, uint8_t *value)
{
  if (offset >= MINI_UART_SIZE)
    return 0;
 
  switch (offset)
  {
    /* STATUS_C */
    case 0:
      /* Reading the STATUS_C register resets the MINI_UART_STATUS_C_EF flag. */
      write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_EF, 1);
      break;
    /* MSG_LO */
    case 6:
    /* MSG_HI */
    case 7:
      if (read_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_RBR))
      {
        /* Reading a received message resets the following flags:
         * - MINI_UART_STATUS_C_FE
         * - MINI_UART_STATUS_C_PE
         * - MINI_UART_STATUS_C_OV
         * - MINI_UART_STATUS_C_RBR
         * - MINI_UART_STATUS_ERR
         */
        write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_FE, 0);
        write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_PE, 0);
        write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_OV, 0);
        write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_RBR, 0);
        write_bit (mem.regfile.STATUS, MINI_UART_STATUS_ERR, 0);
      }
 
      break;
  }
 
  *value = mem.raw[offset];
  return 1;
}
 
int
mem_write (SCARTS_ADDR_CTYPE offset, uint8_t value)
{
  if (offset >= MINI_UART_SIZE)
    return 0;
 
  switch (offset)
  {
    /* STATUS */
    case 0:
    /* STATUS_C */
    case 1:
      /* The STATUS and STATUS_C registers are read-only. */
      return 0;
    /* CONFIG */
    case 2:
      /* Write the MINI_UART_CONFIG_LOOW bit to MINI_UART_STATUS_LOOR. */
      write_bit (mem.regfile.STATUS, MINI_UART_STATUS_LOOR, read_bit (value, MINI_UART_CONFIG_LOOW));
 
      /* Check if an interrupt needs to be acknowledged. */
      if (read_bit (value, MINI_UART_CONFIG_INTA))
      { 
        write_bit (mem.regfile.STATUS, MINI_UART_STATUS_INT, 0);
        write_bit (value, MINI_UART_CONFIG_INTA, 0);
      }	
      break;	
    /* CMD */
    case 5:
      switch (value & UART_CMD_ASA_BITMASK)
      {
        /* Start the transmitter. */
        case UART_CMD_ASA_TxStart:
          /* Simulate some delay before starting the transmission. */
          txCnt = 1;
          break;
        /* Enable the receiver. */
        case UART_CMD_ASA_RxEnable:
          /* Reset all error flags. */
          write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_FE, 0);
          write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_PE, 0);
          write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_OV, 0);
          write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_RBR, 0);
          write_bit (mem.regfile.STATUS, MINI_UART_STATUS_ERR, 0);
          rxEnabled = 1;
          break;
        /* Stop the receiver. */
        case UART_CMD_ASA_RxDisable:
          rxEnabled = 0;
          break;
      }
 
      break;
    case 6:
      txMsgChanged = 1;
      break;
  }
 
  mem.raw[offset] = value;
  return 1;
}
 
void
reset (void)
{
  memset (mem.raw, 0, MINI_UART_SIZE);
}
 
void
tick (SCARTS_ADDR_CTYPE pc)
{
  char c;
 
  if (txMsgChanged && --txCnt == 0)
  {
    if (write (fdm, &mem.regfile.MSG_LO, 1) == -1)
      fprintf (stderr, "Error writing to pseudo-terminal master device: %s\n", strerror (errno));
 
    if ((mem.regfile.CMD & UART_CMD_ES_MASK) == UART_CMD_ES_TxStarted)
      set_event_flag ();
 
    /* The transmitter is ready to transmit data. */
    write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_TBR, 1);
 
    txCnt = 1;
    txMsgChanged = 0;
  }
 
  /* Check if there is something to receive. */
  if (rxEnabled && !read_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_RBR) && read (fdm, &c, 1) > 0)
  {
    mem.regfile.MSG_HI = 0;
    mem.regfile.MSG_LO = c;
 
    write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_RBR, 1);
 
    if ((mem.regfile.CMD & UART_CMD_ES_MASK) == UART_CMD_ES_RxComplete
     || (mem.regfile.CMD & UART_CMD_ES_MASK) == UART_CMD_ES_StartBitRec)
      set_event_flag ();
  } 
}
 
void __attribute__ ((constructor))
miniuart_init (void)
{
  extern char *ptsname ();
  char *slavename;
 
  /* Get a handle to the pseudo TTY master at MINIUART_TTY_DEV. */
  fdm = open (MINIUART_TTY_DEV, O_RDWR | O_NOCTTY | O_NONBLOCK);
  if (fdm == -1)
    fprintf (stderr, "Error opening backend device: %s\n", strerror (errno));
 
  if (stty_raw (fdm) != 0)
    fprintf (stderr, "Error putting serial device in raw mode: %s\n", strerror (errno));
 
  /* Grant access to the pseudo-terminal slave device. */
  if (grantpt (fdm) == -1)
    fprintf (stderr, "Error granting access to pseudo-terminal slave device: %s\n", strerror (errno));
 
  /* Unlock the pseudo-terminal master/slave pair. */
  if (unlockpt (fdm) == -1)
    fprintf (stderr, "Error unlocking the pseudo-terminal master/slave pair: %s\n", strerror (errno));
 
  /* Get the name of the pseudo-terminal slave device. */
  slavename = ptsname (fdm);
  if (slavename == NULL)
    fprintf (stderr, "Error getting name of pseudo-terminal slave device.\n");
 
  /* The transmitter is ready to transmit data. */
  write_bit (mem.regfile.STATUS_C, MINI_UART_STATUS_C_TBR, 1);
 
  fprintf (stdout, "miniUART pseudo-terminal master device: %s\n", MINIUART_TTY_DEV);
  fprintf (stdout, "miniUART pseudo-terminal slave device: %s\n", slavename);
}
 
void __attribute__ ((destructor))
miniuart_finish (void)
{
  if (fdm != -1)
    close (fdm);
}