Subversion Repositories openrisc

/* lib-upcalls.c. Test of Or1ksim library upcall interface.
 
   Copyright (C) 1999-2006 OpenCores
   Copyright (C) 2010 Embecosm Limited
 
   Contributors various OpenCores participants
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of OpenRISC 1000 Architectural Simulator.
 
   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 code is commented throughout for use with Doxygen.
   --------------------------------------------------------------------------*/
 
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "or1ksim.h"
 
 
/*! Memory mapped register memory */
static unsigned char *regv;
 
/*! Number of bytes of register memory */
static int  regc;
 
/*! Number of times each upcall has been called */
static int  upcall_count;
 
 
/* --------------------------------------------------------------------------*/
/*!Read upcall
 
   Upcall from Or1ksim to read a word from an external peripheral. Read the
   specified bytes from the peripheral if available.
 
   We only ever expect to get 4 byte reads here (modeling Wishbone).
 
   @note We receive the full address, since there is a single upcall routine,
         and this allows us to decode between potentially multiple devices.
 
   @todo We assume that the register memory size is a power of 2, making
         address shortening a simple modulo exercise. We should use a more
         generic solution.
 
   @note The mask is a byte mask. Since this is testing, we warn if any byte
         is not either 0xff or 0x00.
 
   @param[in]  class_ptr  A handle pass back from the initalization. Intended
                          for C++ callers, not used here.
   @param[in]  addr       Address to read from.
   @param[in]  mask       Byte mask for the read.
   @param[out] rdata      Buffer for the data read.
   @param[in]  data_len   Number of bytes in mask and rdata.
 
   @return  Zero on success, non-zero on failure.                            */
/* --------------------------------------------------------------------------*/
static int
read_upcall (void              *class_ptr,
	     unsigned long int  addr,
	     unsigned char      mask[],
	     unsigned char      rdata[],
	     int                data_len)
{
  unsigned long int  devaddr = addr % regc;
 
  upcall_count--;			/* One less upcall to do */
 
  if (4 != data_len)
    {
      printf ("Warning: 4-byte reads only supported for this device.\n");
      return  -1;
    }
 
  if (devaddr > regc - data_len)
    {
      printf ("Warning: read from 0x%08lx out of range: zero result.\n",
	      devaddr);
      return  -1;
    }
 
  /* Read the data */
  int  i;
 
  for (i = 0; i < 4; i++)
    {
      switch (mask[i])
	{
	case 0x00: rdata[i] = 0;                 break;
	case 0xff: rdata[i] = regv[devaddr + i]; break;
 
	default:
	  printf ("Warning: invalid mask byte %d for read 0x%02x: "
		  "treated as 0xff.\n", i, mask[i]);
	  rdata[i] = regv[devaddr + i];
	  break;
	}
    }
 
  /* printf ("Read from 0x%08lx: vector [%02x %02x %02x %02x ], " */
  /* 	  "mask [%02x %02x %02x %02x ].\n", devaddr, rdata[0], rdata[1], */
  /* 	  rdata[2], rdata[3], mask[0], mask[1], mask[2], mask[3]); */
 
  return  0;			/* Success */
 
}	/* read_upcall () */
 
 
/* --------------------------------------------------------------------------*/
/*!Write upcall
 
   Upcall from Or1ksim to write a word to an external peripheral. Read the
   specified bytes from the peripheral if available.
 
   We only ever expect to get 4 byte reads here (modeling Wishbone).
 
   @note We receive the full address, since there is a single upcall routine,
         and this allows us to decode between potentially multiple devices.
 
   @todo We assume that the register memory size is a power of 2, making
         address shortening a simple modulo exercise. We should use a more
         generic solution.
 
   @note The mask is a byte mask. Since this is testing, we warn if any byte
         is not either 0xff or 0x00.
 
   @param[in] class_ptr  A handle pass back from the initalization. Intended
                         for C++ callers, not used here.
   @param[in] addr       Address to write to.
   @param[in] mask       Byte mask for the write.
   @param[in] wdata      The data to write.
   @param[in] data_len   Number of bytes in mask and rdata.
 
   @return  Zero on success, non-zero on failure.                            */
/* --------------------------------------------------------------------------*/
static int
write_upcall (void              *class_ptr,
	      unsigned long int  addr,
	      unsigned char      mask[],
	      unsigned char      wdata[],
	      int                data_len)
{
  unsigned long int  devaddr  = addr % regc;
 
  upcall_count--;			/* One less upcall to do */
 
  if (4 != data_len)
    {
      printf ("Warning: 4-byte writes only supported for this device.\n");
      return  -1;
    }
 
  if (devaddr > regc - data_len)
    {
      printf ("Warning: write to 0x%08lx out of range: ignored.\n",
	      devaddr);
      return  -1;
    }
 
  /* printf ("Write to 0x%08lx: vector [%02x %02x %02x %02x ], " */
  /* 	  "mask [%02x %02x %02x %02x ].\n", devaddr, wdata[0], wdata[1], */
  /* 	  wdata[2], wdata[3], mask[0], mask[1], mask[2], mask[3]); */
 
  /* Write the data */
  int  i;
 
  for (i = 0; i < 4; i++)
    {
      switch (mask[i])
	{
	case 0x00:                               break;
	case 0xff: regv[devaddr + i] = wdata[i]; break;
 
	default:
	  printf ("Warning: invalid mask byte %d for write 0x%02x: "
		  "treated as 0xff.\n", i, mask[i]);
	  regv[devaddr + i] = wdata[i];
	  break;
	}
    }
 
  return  0;			/* Success */
 
}	/* write_upcall () */
 
 
/* --------------------------------------------------------------------------*/
/*!Main program
 
   Build an or1ksim program using the library which loads a program and config
   from the command line which will drive upcalls.
 
   lib-upcalls <config-file> <image> <upcall_count> <reg_bytes> [<reg_file>]
 
   A register memory of <reg_bytes> bytes is initalized from <reg_file> if
   present, or zeroed if not. <image> is run continuously, making upcalls,
   which are satisfied using the register memory. The program exits
   successfully when <upcall_count> upcalls have been made.
 
   @param[in] argc  Number of elements in argv
   @param[in] argv  Vector of program name and arguments
 
   @return  Return code for the program.                                     */
/* --------------------------------------------------------------------------*/
int
main (int   argc,
      char *argv[])
{
  char *reg_file;
 
  /* Parse args */
  switch (argc)
    {
    case 5:
      reg_file = NULL;
      break;
 
    case 6:
      reg_file = argv[5];
      break;
 
    default:
      printf ("usage: lib-upcalls <config-file> <image> "
	      "<upcall_count> <reg_bytes> [<reg_file>]\n");
      return  1;
    }
 
  upcall_count = atoi (argv[3]);
 
  if (upcall_count <= 0)
    {
      printf ("ERROR: Upcall count must be positive\n");
      return  1;
    }
 
  regc = atoi (argv[4]);
 
  if (regc < 0)
    {
      printf ("ERROR: Register memory size must be positive\n");
      return  1;
    }
 
  /* Read the register file if provided. */
  regv = malloc (regc * sizeof (unsigned char));
 
  if (NULL == regv)
    {
      printf ("ERROR: Failed to allocate register memory\n");
      return  1;
    }
 
  int  next_free_byte = 0;
 
  if (NULL != reg_file)
    {
      FILE *fd = fopen (reg_file, "r");
 
      if (NULL == fd)
	{
	  printf ("ERROR: Failed to open register file: %s\n",
		  strerror (errno));
	  free (regv);
	  return  1;
	}
 
      for (; next_free_byte < regc; next_free_byte++)
	{
	  unsigned char  byte;
 
	  if (1 == fscanf (fd, "%2hhx ", &byte))
	    {
	      regv[next_free_byte] = byte;
	    }
	  else
	    {
	      break;
	    }
	}
 
      /* Should have read the whole file successfully. */
      if (ferror (fd))
	{
	  printf ("ERROR: Reading register file: %s\n", strerror (errno));
	  free (regv);
	  return  1;
	}
 
      if (!feof (fd))
	{
	  printf ("Warning: additional register file data ignored.\n");
	}
 
      if (0 != fclose (fd))
	{
	  printf ("ERROR: Failed to close register file: %s\n",
		  strerror (errno));
	  free (regv);
	  return  1;
	}
    }
 
  /* Fill in any remaining bytes with zero */
  if (next_free_byte < regc)
    {
      (void)memset (&(regv[next_free_byte]), 0, regc - next_free_byte);
    }
 
  /* Initialize the program. Put the initialization message afterwards, or it
     will get swamped by the Or1ksim header. */
  if (0 == or1ksim_init (argv[1], argv[2], NULL, &read_upcall, &write_upcall))
    {
      printf ("Initalization succeeded.\n");
    }
  else
    {
      printf ("Initalization failed.\n");
      return  1;
    }
 
  /* Run repeatedly for 1 millisecond until we hit a breakpoint or all upcalls
     are done. */
  do
    {
      switch (or1ksim_run (1.0e-3))
	{
	case OR1KSIM_RC_OK:
	  break;
 
	case OR1KSIM_RC_BRKPT:
	  printf ("Test completed successfully: hit breakpoint.\n");
	  return  0;
 
	default:
	  printf ("ERROR: run failed\n");
	  return  1;
	}
    }
  while (upcall_count > 0);
 
  /* A little longer to allow response to last upcall to be handled. */
  switch (or1ksim_run (1.0e-3))
    {
    case OR1KSIM_RC_OK:
      printf ("Test completed successfully: All upcalls processed.\n");
      return  0;
 
    case OR1KSIM_RC_BRKPT:
      printf ("Test completed successfully: hit breakpoint.\n");
      return  0;
 
    default:
      printf ("ERROR: run failed\n");
      return  1;
    }
}	/* main () */