Subversion Repositories openrisc

/* lib-jtag.c. Basic test of Or1ksim library JTAG 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"

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

/*!Dump a JTAG register

   Prefix with the supplied string and add a newline afterwards.

   @param[in] prefix     Prefix string to print out

   @param[in] jreg       The JTAG register

   @param[in] num_bytes  The number of bytes in the register                 */

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

static void

dump_jreg (const char    *prefix,

           unsigned char *jreg,

           int            num_bytes)

{

  int  i;

  printf ("%s: ", prefix);

  /* Dump each byte in turn */

  for (i = num_bytes - 1; i >=0; i--)

    {

      printf ("%02x", jreg[i]);

    }

  printf ("\n");

}       /* dump_jreg () */

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

/*!Convert a hex char into its value.

   @param[in] c  The char to convert

   @return  The value represented by the char, or -1 if it's not a valid

            char.                                                            */

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

static int

hexch2val (char  c)

{

  switch (c)

    {

    case '0': return  0;

    case '1': return  1;

    case '2': return  2;

    case '3': return  3;

    case '4': return  4;

    case '5': return  5;

    case '6': return  6;

    case '7': return  7;

    case '8': return  8;

    case '9': return  9;

    case 'a': case 'A': return 10;

    case 'b': case 'B': return 11;

    case 'c': case 'C': return 12;

    case 'd': case 'D': return 13;

    case 'e': case 'E': return 14;

    case 'f': case 'F': return 15;

    default:

      return  -1;

    }

}       /* hexch2val () */

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

/*!Shift a JTAG register.

   Almost all this code is common between the instruction and data

   registers. All that varies is the library function called and the error

   message if anything goes wrong. So we common things up here.

   @param[in] type       'D' if this is a data register, 'I' if an instruction

                         register.

   @param[in] next_jreg  Offset into argv of the next JTAG register hex

                         string.

   @param[in] argc       argc from the main program (for checking next_jref).

   @param[in] argv       argv from the main program.

   @return  1 (TRUE) on success, 0 (FALSE) on failure.                       */

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

static int

process_jreg (const char  type,

              int         next_jreg,

              int         argc,

              char       *argv[])

{

  const char *long_name = ('D' == type) ? "data" : "instruction";

  /* Do we have the arg? */

  if (next_jreg > argc)

    {

      printf ("ERROR: no %s register found.\n", long_name);

      return  0;

    }

  /* Is the reg an exact number of bytes? */

  char *hex_str   = argv[next_jreg];

  int   num_chars = strlen (hex_str);

  if (0 != (num_chars % 2))

    {

      printf ("ERROR: %s register not exact number of bytes.\n", long_name);

      return  0;

    }

  /* Allocate space */

  int            num_bytes = num_chars / 2;

  unsigned char *jreg      = malloc (num_bytes);

  if (NULL == jreg)

    {

      printf ("ERROR: malloc for %s register failed.\n", long_name);

      return  0;

    }

  /* Initialize the register. The hex presentation is MS byte of the string on

     the left (i.e. at offset 0), but the internal representation is LS byte

     at the lowest address. */

  int  i;

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

    {

      int  byte_off = num_bytes - i - 1;

      int  ch_off   = i * 2;

      int  j;

      /* Each nybble in turn */

      for (j = 0; j < 2; j++)

        {

          char  c     = hex_str[ch_off + j];

          int   c_val = hexch2val (c);

          if (c_val < 0)

            {

              printf ("ERROR: %c not valid hex digit.\n", c);

              free (jreg);

              return  0;

            }

          jreg[byte_off] <<= 4;

          jreg[byte_off]  |= c_val;

        }

    }

  /* Note what we are doing */

  dump_jreg ("  shifting in", jreg, num_bytes);

  double  t;

  if ('D' == type)

    {

      t = or1ksim_jtag_shift_dr (jreg);

    }

  else

    {

      t = or1ksim_jtag_shift_ir (jreg);

    }

  dump_jreg ("  shifted out", jreg, num_bytes);

  printf ("  time taken %.12fs\n", t);

  free (jreg);

  return  1;                    /* Completed successfully */

}       /* process_jreg () */

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

/*!Main program

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

   from the command line which will drive JTAG.

   lib-jtag <config-file> <image> <jtype> [<reg>] [<jtype> [<reg>]] ...

   - config-file  An Or1ksim configuration file.

   - image        A OpenRISC binary image to load into Or1ksim

   - jtype        One of 'R' (JTAG reset), 'I' (JTAG instruction register) or

                  'D' (JTAG data register).

   - reg          If jtype is 'D' or 'I', a JTAG register specified in

                  hex. Must be an even number of digits (i.e. exact number of

                  bytes), and use leading zeros if null bytes are needed at

                  the MS end.

   The target program is run in bursts of 1ms execution, and the type of

   return (OK, hit breakpoint) noted. Between each burst of execution, the

   next register is submitted to the corresponding Or1ksim JTAG interface

   function, and the resulting register (for 'I' and 'D') noted.

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

{

  /* Check we have minimum number of args. */

  if (argc < 4)

    {

      printf ("usage: lib-jtag <config-file> <image> <jtype> <reg> [<jtype> "

              "<reg>] ...\n");

      return  1;

    }

  /* 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, NULL, NULL))

    {

      printf ("Initalization succeeded.\n");

    }

  else

    {

      printf ("Initalization failed.\n");

      return  1;

    }

  /* Run repeatedly for 1 millisecond until we have processed all JTAG

     registers */

  int  next_jreg = 3;                   /* Offset to next JTAG register */

  do

    {

      switch (or1ksim_run (1.0e-3))

        {

        case OR1KSIM_RC_OK:

          printf ("Execution step completed OK.\n");

          break;

        case OR1KSIM_RC_BRKPT:

          printf ("Execution step completed with breakpoint.\n");

          break;

        default:

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

          return  1;

        }

      /* Process the next arg appropriately. */

      switch (argv[next_jreg++][0])

        {

        case 'R':

          printf ("Resetting JTAG.\n");

          or1ksim_jtag_reset ();

          break;

        case 'I':

          printf ("Shifting instruction register.\n");

          if (!process_jreg ('I', next_jreg++, argc, argv))

            {

              return  1;                /* Something went wrong */

            }

          break;

        case 'D':

          printf ("Shifting data register.\n");

          if (!process_jreg ('D', next_jreg++, argc, argv))

            {

              return  1;                /* Something went wrong */

            }

          break;

        default:

          printf ("ERROR: unknown JTAG request type.\n");

          return  1;

        }

    }

  while (next_jreg < argc);

  /* A little longer to allow response to last upcall to be handled. */

  switch (or1ksim_run (1.0e-3))

    {

    case OR1KSIM_RC_OK:

      printf ("Execution step completed OK.\n");

      break;

    case OR1KSIM_RC_BRKPT:

      printf ("Execution step completed with breakpoint.\n");

      break;

    default:

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

      return  1;

    }

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

  return  0;

}       /* main () */