Subversion Repositories openrisc_2011-10-31

/* lib-inttest-level.c. Test of Or1ksim library level triggered interrupt funcs.

   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 <stddef.h>

#include <stdlib.h>

#include <stdio.h>

#include "or1ksim.h"

/*! Number of interrupts in PIC */

#define  NUM_INTS  32

/*! Vector of interrupts to be raised */

static int *raisev;

/*! Count of interrupts to be raised */

static int  raisec = 0;

/*! Next interrupt to be raised */

static int  next_raise = 0;

/*! Vector of interrupts to be cleared */

static int *clearv;

/*! Count of interrupts to be cleared */

static int  clearc = 0;

/*! Next interrupt to be cleared */

static int  next_clear = 0;

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

/*!Read upcall

   Upcall from Or1ksim to read a word from an external peripheral. If called

   this will raise the next interrupt.

   @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. Ignored here.

   @param[in]  mask       Byte mask for the read. Ignored here.

   @param[out] rdata      Buffer for the data read. Ignored here.

   @param[in]  data_len   Number of bytes in mask and rdata.

   @return  Zero on success, non-zero on failure. Always zero here.          */

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

static int

read_upcall (void              *class_ptr,

             unsigned long int  addr,

             unsigned char      mask[],

             unsigned char      rdata[],

             int                data_len)

{

  /* Raise an interrupt if there is one left to raise. */

  if ((NULL != raisev) && (next_raise < raisec))

    {

      printf ("Raising interrupt %d\n", raisev[next_raise]);

      or1ksim_interrupt_set (raisev[next_raise++]);

    }

  return  0;                     /* Success */

}       /* read_upcall () */

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

/*!Write upcall

   Upcall from Or1ksim to write a word to an external peripheral. If called

   this will clear the next interrupt.

   @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. Ignored here.

   @param[in] mask       Byte mask for the write. Ignored here.

   @param[in] wdata      The data to write. Ignored here.

   @param[in] data_len   Number of bytes in mask and rdata.

   @return  Zero on success, non-zero on failure. Always zero here.          */

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

static int

write_upcall (void              *class_ptr,

              unsigned long int  addr,

              unsigned char      mask[],

              unsigned char      wdata[],

              int                data_len)

{

  /* Clear an interrupt if there is one left to clear. */

  if ((NULL != clearv) && (next_clear < clearc))

    {

      printf ("Clearing interrupt %d\n", clearv[next_clear]);

      or1ksim_interrupt_clear (clearv[next_clear++]);

    }

  return  0;                     /* Success */

}       /* write_upcall () */

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

/*!Main program

   Build an or1ksim program using the library which loads a program and config

   from the command line, and then drives interrupts. Usage:

   lib-inttest-level <config-file> <image> +|-<int #> +|-<int #> ...

   <image> is run continuously. It requests that an interrupt be raised by a

   read upcall and cleared by a write upcall. The sequence of interrupts is

   specified to be raised (if preceded by '+') or cleared (if preceded by

   '-'). This allows the program to test the effect of clearing the wrong

   interrupt.

   @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[])

{

  /* Parse args */

  if (argc < 4)

    {

      fprintf (stderr,

               "usage: lib-inttest-level <config-file> <image> "

               "+|-<int #> +|-<int #> ...\n");

      return  1;

    }

  /* Get all the interrupts sorted out. Count them, then place them in a

     vector. */

  int  i;

  for (i = 3; i < argc; i++)

    {

      int  inum;

      switch (argv[i][0])

        {

        case '+':

          inum = atoi (&(argv[i][1]));

          if ((0 <= inum) && (inum < NUM_INTS))

            {

              raisec++;

            }

          else

            {

              printf ("Warning: Invalid interrupt # %d to raise.\n", inum);

            }

          break;

        case '-':

          inum = atoi (&(argv[i][1]));

          if ((0 <= inum) && (inum < NUM_INTS))

            {

              clearc++;

            }

          else

            {

              printf ("Warning: Invalid interrupt # %d to clear.\n", inum);

            }

          break;

        default:

          printf ("Warning: No raise/clear specified - ignored\n");

          break;

        }

    }

  if ((0 == raisec) && (0 == clearc))

    {

      printf ("ERROR: No interrupts specified.\n");

      return  1;

    }

  /* Allocate space and populate the vectors. */

  raisev = (raisec > 0) ? calloc (raisec, sizeof (int)) : NULL;

  clearv = (clearc > 0) ? calloc (clearc, sizeof (int)) : NULL;

  raisec = 0;

  clearc = 0;

  for (i = 3; i < argc; i++)

    {

      int  inum;

      switch (argv[i][0])

        {

        case '+':

          inum = atoi (&(argv[i][1]));

          if ((0 <= inum) && (inum < NUM_INTS))

            {

              raisev[raisec++] = inum;

            }

          break;

        case '-':

          inum = atoi (&(argv[i][1]));

          if ((0 <= inum) && (inum < NUM_INTS))

            {

              clearv[clearc++] = inum;

            }

          break;

        default:

          printf ("Warning: No raise/clear specified - ignored\n");

          break;

        }

    }

  /* Start the counts */

  next_raise = 0;

  next_clear = 0;

  /* 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");

      free (raisev);

      free (clearv);

      return  1;

    }

  /* Run in bursts of 1ms until all interrupts have been set and cleared. */

  do

    {

      if (OR1KSIM_RC_OK != or1ksim_run (1.0e-3))

        {

          printf ("ERROR: run failed\n");

          free (raisev);

          free (clearv);

          return  1;

        }

    }

  while ((next_raise < raisec) || (next_clear < clearc));

  /* One more burst to allow the device driver time to complete. */

  if (OR1KSIM_RC_OK != or1ksim_run (1.0e-3))

    {

      printf ("ERROR: run failed\n");

      free (raisev);

      free (clearv);

      return  1;

    }

  /* All interrupts should have been handled. */

  free (raisev);

  free (clearv);

  printf ("Test completed successfully.\n");

  return  0;

}       /* main () */