Subversion Repositories openrisc_2011-10-31

/* The remote-virtual-component simulator framework

   for GDB, the GNU Debugger.

   Copyright 2006, 2007, 2008 Free Software Foundation, Inc.

   This file is part of GDB.

   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/>.  */

#include "sim-main.h"

#include "hw-main.h"

#include "hw-tree.h"

#include <ctype.h>

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#else

#ifdef HAVE_STRINGS_H

#include <strings.h>

#endif

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

/* Not guarded in dv-sockser.c, so why here.  */

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#include <sys/socket.h>

/* DEVICE

   rv - Remote Virtual component

   DESCRIPTION

   Socket connection to a remote simulator component, for example one

   for testing a verilog construction.  Protocol defined below.

   There is a set of 32-bit I/O ports, with a mapping from local to

   remote addresses.  There is a set of interrupts expressed as a

   bit-mask, with a mapping from remote to local.  There is a set of

   memory ranges (actual memory defined elsewhere), also with a

   mapping from remote to local addresses, that is expected to be

   accessible to the remote simulator in 32-byte chunks (simulating

   DMA).  There is a mapping from remote cycles (or an appropriate

   elsewhere defined time-slice) to local cycles.

   PROPERTIES

   reg = <address> <size>

   The address (within the parent bus) that this device is to

   be located.

   remote-reg = <remote-address>

   The address of reg on the remote side.  Defaults to 0.

   mem = <address> <size>

   Specify an address-range (within the parent bus) that the remote

   device can access.  The memory is assumed to be already defined.

   If there's no memory defined but the remote side asks for a memory

   access, the simulation is aborted.

   remote-mem = <remote-address>

   The address of mem on the remote side.  Defaults to 0.

   mbox = <address>

   Address of the mailbox interface.  Writes to this address with the

   local address of a mailbox command, a complete packet with length

   and command; (4 or 6)) invokes the mailbox interface.  Reads are

   invalid.  Replies are written to the same address.  Address space

   from <address> up-to-and-including <address>+3 is allocated.

   max-poll-ticks = <local-count>

   Sets the maximum interval between polling the external component,

   expressed in internal cycles.  Defaults to 10000.

   watchdog-interval = <seconds>

   Sets the wallclock seconds between watchdog packets sent to the

   remote side (may be larger if there's no rv activity in that time).

   Defaults to 30.  If set to 0, no watchdog packets are sent.

   intnum = <local-int-0> <local-int-1> ... <local-int-31>

   Defines a map from remote bit numbers to local values to be emitted

   on the "int" port, with the external bit number as the ordinal - 1

   of the local translation.  E.g. 43 121 would mean map external

   (1<<0) to internal 43 and external (1<<1) to internal 121.  The

   default is unity; no translation.  If more than one bit is set in

   the remote interrupt word, the intmultiple property can be used to

   control the translation.

   intmultiple = <intvalue>

   When more than one bit is set in the remote interrupt word, you may

   want to map this situation to a separate interrupt value.  If this

   property is non-zero, it is used as that value.  If it is zero, the

   local value for the "int" port is the bitwise-or of the translated

   local values.

   host = <hostid>

   The hostname or address where the simulator to be used listens.

   Defaults to "127.0.0.1"

   port = <portnumber>

   The hostname or address where the simulator to be used listens.

   Defaults to 10000.

   dummy = <value>

    or

   dummy = <filename>

   Don't connect to a remote side; use initial dummy contents from

   <filename> (which has to be at least as big as the <size> argument

   of reg above) or filled with byte-value <value>.  Mailboxes are not

   supported (can be defined but can not be used) and remote-memory

   accesses don't apply.  The main purpose for this property is to

   simplify use of configuration and simulated hardware that is

   e.g. only trivially initialized but not actually used.

   PORTS

   int (output)

   Driven as a result of a remote interrupt request.  The value is a

   32-bit bitset of active interrupts.

   BUGS

   All and none.

   PROTOCOL

   This is version 1.0 of this protocol, defining packet format and

   actions in a supposedly upward-compatible manner where client and

   servers of different versions are expected to interoperate; the

   format and the definitions below are hopefully generic enough to

   allow this.

   Each connection has a server and a client (this code); the roles

   are known beforehand.  The client usually corresponds to a CPU and

   memory system and the server corresponds to a memory-mapped

   register hardware interface and/or a DMA controller.  They

   communicate using packets with specific commands, of which some

   require replies from the other side; most are intiated by the

   client with one exception.  A reply uses the same format as the

   command.

   Packets are at least three bytes long, where the first two bytes

   form a header, a 16-bit little-endian number that is the total

   length of the packet including the header.  There is also a

   one-byte command.  The payload is optional, depending on the

   command.

   [[16-bit-low-byte-of-length] [16-bit-high-byte-of-length]

    [command/reply] [payload byte 0] [payload byte 1]

    ... [payload byte (length-of-packet - 3)]]

   Commands:

   A client or server that reads an undocumented command may exit with

   a hard error.  Payload not defined or disallowed below is ignored.

   It is expected that future client versions find out the version of

   the server side by polling with base commands, assuming earlier

   versions if a certain reply isn't seen, with newly defined payload

   parts where earlier versions left it undefined.  New commands and

   formats are sent only to the other side after the client and server

   has found out each others version.  Not all servers support all

   commands; the type of server and supported set of commands is

   expected to be known beforehand.

   RV_READ_CMD = 0

   Initiated by the client, requires a reply from the server.  The

   payload from the client is at least 4 bytes, forming a 4-byte

   little-endian address, the rest being undefined.  The reply from

   the server is at least 8 bytes, forming the same address data as in

   the request and the second 4-byte data being the little-endian

   contents.

   RV_WRITE_CMD = 1

   Initiated by the client, requires a reply from the server.  Payload

   from the client is at least 8 bytes, forming a 4-byte little-endian

   word being the address, the rest being the little-endian contents

   to write.  The reply from the server is 8 bytes unless elsewhere

   agreed otherwise, forming the same address and data as in the

   request.  The data sent back may have been altered to correspond to

   defined parts but can safely be discarded.

   RV_IRQ_CMD = 2

   Initiated by the server, no reply.  The payload is 4 bytes, forming

   a little-endian word with bits numbers corresponding to currently

   active interrupt sources; value (1<<N) indicating interrupt source

   N being active.

   RV_MEM_RD_CMD = 3

   Initiated by the server, requires a reply.  A client must know

   beforehand when (in command sequence or constant) the server can

   send this command and if so must then not send any commands of its

   own (including watchdog commands); the server is allowed to assume

   that incoming data is only replies to this command.  The format is

   8 bytes of data; 4 bytes of little-endian address followed by a

   32-bit little endian word with the number of bytes to read.  The

   reply is the same address and number of bytes, followed by the data

   that had been read.

   RV_MEM_WR_CMD = 4

   Initiated by the server, no reply.  The format is the same as a

   reply to RV_MEM_RD_CMD; a 32-bit little-endian address, followed by

   the 32-bit little-endian number of bytes to write (redundant

   information but must be consistent with the packet header).

   RV_MBOX_HANDLE_CMD = 5

   Initiated by the client, requires a reply.  The payload is 4

   undefined bytes followed by an binary blob, the size of the

   blob given by the packet header.  The reply is a 32-bit little

   endian number at the same index as the undefined bytes.  Actual

   semantics are application-specific.

   RV_MBOX_PUT_CMD = 6

   Initiated by the client, requires a reply, with the reply using the

   RV_MBOX_HANDLE_CMD reply format (i.e. *both* that command and

   32-bit little-endian number).  The payload is a 32-bit little

   endian number followed by an undefined payload, at most 20 bytes

   long.  The reply is a 32-bit little endian number.  Actual

   semantics are application-specific.

   RV_WATCHDOG_CMD = 7

   Initiated by the client, no reply.  A version 1.0 client sends no

   payload; a version 1.0 server should ignore any such payload.  A

   version 1.0 server must not send a reply.

   Possible future enhancements:

   Synchronization; server and client reports the number of elapsed

   cycles (unit to-be-defined) at each request or notification.

   Pretty much the top-of-the-todo-list item.

   Large addresses; 1.0 being restricted to 32-bit addresses.

   Variable-size data; currently restricted to 32-bit register

   accesses.

   Specified data endianness (not the packet header) perhaps as part

   of an initial format request; currently little-endian only.

   Usage notes:

   When used with servers sending RV_MEM_RD_CMD but being

   narrow-minded about indata, set watchdog-interval to 0.  Use

   multiple rv instances when there are e.g. separate register and

   memory servers.  Alway log, setting "/rv/trace? true", at the

   development phase.  Borrow from the test-suite.

   */

#define RV_FAMILY_NAME "rv"

enum rv_command {

  RV_READ_CMD = 0,

  RV_WRITE_CMD = 1,

  RV_IRQ_CMD = 2,

  RV_MEM_RD_CMD = 3,

  RV_MEM_WR_CMD = 4,

  RV_MBOX_HANDLE_CMD = 5,

  RV_MBOX_PUT_CMD = 6,

  RV_WATCHDOG_CMD = 7

};

typedef struct _hw_rv_device

{

  /* Mapping of remote interrupt bit-numbers to local ones.  */

  unsigned32 remote_to_local_int[32];

  /* When multiple bits are set, a non-zero value here indicates that

     this value should be used instead.  */

  unsigned32 intmultiple;

  /* Local address of registers.  */

  unsigned32 reg_address;

  /* Size of register bank in bytes.  */

  unsigned32 reg_size;

  /* Remote address of registers.  */

  unsigned32 remote_reg_address;

  /* Local address of DMA:able memory.  */

  unsigned32 mem_address;

  /* Size of DMA:able memory in bytes.  */

  unsigned32 mem_size;

  /* Bitmask for valid DMA request size.  */

  unsigned32 mem_burst_mask;

  /* Remote address of DMA:able memory.  */

  unsigned32 remote_mem_address;

  /* (Local) address of mbox; where to put a pointer to the mbox to be

     sent.  */

  unsigned32 mbox_address;

  /* Probably not 127.0.0.1:10000.  */

  const char *host;

  int port;

  /* If non-NULL, points to memory to use instead of connection.  */

  unsigned8 *dummy;

  /* File descriptor for the socket.  Set to -1 when error.  Only one

     of dummy and this is active.  */

  int fd;

  /* Stashed errno, as we don't emit an error right away.  */

  int saved_errno;

  /* This, plus latency because the CPU might not be checking until a

     CTI insn (usually a branch or a jump) is the interval in cycles

     between the rv is polled for e.g. DMA requests.  */

  unsigned32 max_tick_poll_interval;

  /* Running counter for exponential backoff up to

     max_tick_poll_interval to avoid polling the connection

     unnecessarily often.  Set to 1 when rv activity (read/write

     register, DMA request) is detected.  */

  unsigned32 next_period;

  /* This is the interval in wall-clock seconds between watchdog

     packets are sent to the remote side.  Zero means no watchdog

     packets. */

  unsigned32 watchdog_interval;

  /* Last time we sent a watchdog packet.  */

  struct timeval last_wdog_time;

  /* Mostly used as a kludge for knowing which rv:s have poll events

     active.  */

  struct hw_event *poll_callback;

} hw_rv_device;

/* We might add ports in the future, so keep this an enumeration.  */

enum

  {

    INT_PORT

  };

/* Our ports.  */

static const struct hw_port_descriptor hw_rv_ports[] = {

  { "int", INT_PORT, 0, output_port },

  { NULL }

};

/* Send LEN bytes of data from BUF to the socket.  Abort on

   errors.  */

static void

hw_rv_write (struct hw *me,

             void *buf,

             unsigned int len)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  unsigned8 *bufp = buf;

  /* If we don't have a valid fd here, it's because we got an error

     initially, and we suppressed that error.  */

  if (rv->fd < 0)

    hw_abort (me, "couldn't open a connection to %s:%d because: %s",

              rv->host, rv->port, strerror (rv->saved_errno));

  while (len > 0)

    {

      ssize_t ret = write (rv->fd, bufp, len);

      if (ret < 0)

        /* FIXME: More graceful exit.  */

        hw_abort (me, "write to %s:%d failed: %s\n", rv->host, rv->port,

                  strerror (errno));

      len -= ret;

      bufp += ret;

    }

}

/* Read LEN bytes of data into BUF from the socket.  Set the file

   descriptor to -1 if there's an error.  */

static void

hw_rv_read (struct hw *me,

            void *buf,

            unsigned int len)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  unsigned8 *bufp = buf;

  while (len > 0)

    {

      ssize_t ret = read (rv->fd, bufp, len);

      /* We get all zero if the remote end quits, but no error

         indication; even select says there's data active.  */

      if (ret <= 0)

        {

          if (close (rv->fd) != 0)

            /* FIXME: More graceful exit.  */

            hw_abort (me, "read from %s:%d failed: %d\n", rv->host, rv->port, errno);

          rv->fd = -1;

          return;

        }

      len -= ret;

      bufp += ret;

    }

}

/* Construct and send a packet of data of type CMD and len

   LEN_NOHEADER (not counting the header...).  */

static void

hw_rv_send (struct hw *me,

            unsigned int cmd,

            void *msg,

            unsigned int len_noheader)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  unsigned8 buf[32+3];

  unsigned8 *bufp;

  unsigned int len = len_noheader + 3;

  int ret;

  buf[0] = len & 255;

  buf[1] = (len >> 8) & 255;

  buf[2] = cmd;

  if (len > sizeof (buf))

    {

      hw_rv_write (me, buf, 3);

      len = len_noheader;

      bufp = msg;

    }

  else

    {

      memcpy (buf + 3, msg, len_noheader);

      bufp = buf;

    }

  hw_rv_write (me, bufp, len);

}

/* Handle incoming DMA requests as per the RV_MEM_RD_CMD packet.

   Abort on errors.  */

static void

hw_rv_read_mem (struct hw *me, unsigned int len)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  /* If you change this size, please adjust the mem2 testcase.  */

  unsigned8 buf[32+8];

  unsigned8 *bufp = buf;

  unsigned32 leaddr;

  unsigned32 addr;

  unsigned32 lelen;

  unsigned32 i;

  if (len != 8)

    hw_abort (me, "expected DMA read request len 8+3, got %d+3", len);

  hw_rv_read (me, &leaddr, 4);

  hw_rv_read (me, &lelen, 4);

  len = LE2H_4 (lelen);

  addr = LE2H_4 (leaddr);

  if (addr < rv->remote_mem_address

      || addr >= rv->remote_mem_address + rv->mem_size)

    hw_abort (me, "DMA read at remote 0x%x; outside [0x%x..0x%x-1]",

              (unsigned) addr, (unsigned) rv->remote_mem_address,

              (unsigned) (rv->remote_mem_address + rv->mem_size));

  addr = addr - rv->remote_mem_address + rv->mem_address;

  if (len == 0)

    hw_abort (me, "DMA read request for 0 bytes isn't supported");

  if (len & ~rv->mem_burst_mask)

    hw_abort (me, "DMA trying to read %d bytes; not matching mask of 0x%x",

              len, rv->mem_burst_mask);

  if (len + 8 > sizeof (buf))

    bufp = hw_malloc (me, len + 8);

  HW_TRACE ((me, "DMA R 0x%x..0x%x", addr, addr + len -1));

  hw_dma_read_buffer (me, bufp + 8, 0, addr, len);

  if (hw_trace_p (me))

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

      HW_TRACE ((me, "0x%x: %02x %02x %02x %02x",

                 addr + i,

                 bufp[i+8], bufp[i+9], bufp[i+10], bufp[i+11]));

  memcpy (bufp, &leaddr, 4);

  memcpy (bufp + 4, &lelen, 4);

  hw_rv_send (me, RV_MEM_RD_CMD, bufp, len + 8);

  if (bufp != buf)

    hw_free (me, bufp);

}

/* Handle incoming DMA requests as per the RV_MEM_WR_CMD packet.

   Abort on errors.  */

static void

hw_rv_write_mem (struct hw *me, unsigned int plen)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  /* If you change this size, please adjust the mem2 testcase.  */

  unsigned8 buf[32+8];

  unsigned8 *bufp = buf;

  unsigned32 leaddr;

  unsigned32 addr;

  unsigned32 lelen;

  unsigned32 len;

  unsigned32 i;

  hw_rv_read (me, &leaddr, 4);

  hw_rv_read (me, &lelen, 4);

  len = LE2H_4 (lelen);

  addr = LE2H_4 (leaddr);

  if (len != plen - 8)

    hw_abort (me,

              "inconsistency in DMA write request packet: "

              "envelope %d+3, inner %d bytes", plen, len);

  if (addr < rv->remote_mem_address

      || addr >= rv->remote_mem_address + rv->mem_size)

    hw_abort (me, "DMA write at remote 0x%x; outside [0x%x..0x%x-1]",

              (unsigned) addr, (unsigned) rv->remote_mem_address,

              (unsigned) (rv->remote_mem_address + rv->mem_size));

  addr = addr - rv->remote_mem_address + rv->mem_address;

  if (len == 0)

    hw_abort (me, "DMA write request for 0 bytes isn't supported");

  if (len & ~rv->mem_burst_mask)

    hw_abort (me, "DMA trying to write %d bytes; not matching mask of 0x%x",

              len, rv->mem_burst_mask);

  if (len + 8 > sizeof (buf))

    bufp = hw_malloc (me, len + 8);

  hw_rv_read (me, bufp + 8, len);

  HW_TRACE ((me, "DMA W 0x%x..0x%x", addr, addr + len - 1));

  hw_dma_write_buffer (me, bufp + 8, 0, addr, len, 0);

  if (hw_trace_p (me))

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

      HW_TRACE ((me, "0x%x: %02x %02x %02x %02x",

                 addr + i,

                 bufp[i+8], bufp[i+9], bufp[i+10], bufp[i+11]));

  if (bufp != buf)

    hw_free (me, bufp);

}

static void

hw_rv_irq (struct hw *me, unsigned int len)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  unsigned32 intbitsle;

  unsigned32 intbits_ext;

  unsigned32 intval = 0;

  int i;

  if (len != 4)

    hw_abort (me, "IRQ with %d data not supported", len);

  hw_rv_read (me, &intbitsle, 4);

  intbits_ext = LE2H_4 (intbitsle);

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

    if ((intbits_ext & (1 << i)) != 0)

      intval |= rv->remote_to_local_int[i];

  if ((intbits_ext & ~(intbits_ext - 1)) != intbits_ext

      && rv->intmultiple != 0)

    intval = rv->intmultiple;

  HW_TRACE ((me, "IRQ 0x%x", intval));

  hw_port_event (me, INT_PORT, intval);

}

/* Handle incoming interrupt notifications as per the RV_IRQ_CMD

   packet.  Abort on errors.  */

static void

hw_rv_handle_incoming (struct hw *me,

                       int expected_type,

                       unsigned8 *buf,

                       unsigned int *return_len)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  unsigned8 cbuf[32];

  unsigned int len;

  unsigned int cmd;

  while (1)

    {

      hw_rv_read (me, cbuf, 3);

      if (rv->fd < 0)

        return;

      len = cbuf[0] + cbuf[1] * 256 - 3;

      cmd = cbuf[2];

      /* These come in "asynchronously"; not as a reply.  */

      switch (cmd)

        {

        case RV_IRQ_CMD:

          hw_rv_irq (me, len);

          break;

        case RV_MEM_RD_CMD:

          hw_rv_read_mem (me, len);

          break;

        case RV_MEM_WR_CMD:

          hw_rv_write_mem (me, len);

          break;

        }

      /* Something is incoming from the other side, so tighten up all

         slack at the next wait.  */

      rv->next_period = 1;

      switch (cmd)

        {

        case RV_MEM_RD_CMD:

        case RV_MEM_WR_CMD:

        case RV_IRQ_CMD:

          /* Don't try to handle more than one of these if we were'nt

             expecting a reply.  */

          if (expected_type == -1)

            return;

          continue;

        }

      /* Require a match between this supposed-reply and the command

         for the rest.  */

      if (cmd != expected_type)

        hw_abort (me, "unexpected reply, expected command %d, got %d",

                  expected_type, cmd);

      switch (cmd)

        {

        case RV_MBOX_PUT_CMD:

        case RV_MBOX_HANDLE_CMD:

        case RV_WRITE_CMD:

        case RV_READ_CMD:

          hw_rv_read (me, buf, len <= *return_len ? len : *return_len);

          *return_len = len;

          break;

        }

      break;

    }

}

/* Send a watchdog packet.  Make a note of wallclock time.  */

static void

hw_rv_send_wdog (struct hw *me)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  HW_TRACE ((me, "WD"));

  gettimeofday (&rv->last_wdog_time, NULL);

  hw_rv_send (me, RV_WATCHDOG_CMD, "", 0);

}

/* Poll the remote side: see if there's any incoming traffic; handle a

   packet if so.  Send a watchdog packet if it's time to do so.

   Beware that the Linux select call indicates traffic for a socket

   that the remote side has closed (which may be because it was

   finished; don't hork until we need to write something just because

   we're polling).  */

static void

hw_rv_poll_once (struct hw *me)

{

  hw_rv_device *rv = (hw_rv_device *) hw_data (me);

  fd_set rfds;

  fd_set efds;

  struct timeval now;

  int ret;

  struct timeval tv;

  if (rv->fd < 0)

    /* Connection has died or was never initiated.  */

    return;

  FD_ZERO (&rfds);

  FD_SET (rv->fd, &rfds);

  FD_ZERO (&efds);

  FD_SET (rv->fd, &efds);

  tv.tv_sec = 0;

  tv.tv_usec = 0;

  ret = select (rv->fd + 1, &rfds, NULL, &efds, &tv);

  gettimeofday (&now, NULL);

  if (ret < 0)

    hw_abort (me, "select failed: %d\n", errno);

  if (rv->watchdog_interval != 0

      && now.tv_sec - rv->last_wdog_time.tv_sec >= rv->watchdog_interval)

    hw_rv_send_wdog (me);

  if (FD_ISSET (rv->fd, &rfds))

    hw_rv_handle_incoming (me, -1, NULL, NULL);

}