URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc1/] [or1ksim/] [sim-config.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* sim-config.c -- Simulator configuration
 
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
   Copyright (C) 2008 Embecosm Limited
 
   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 program is commented throughout in a fashion suitable for processing
   with Doxygen. */
 
/* Simulator configuration. Eventually this one will be a lot bigger. Updated
   to use argtable2 for argument parsing. */
 
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
 
/* Package includes */
#include "sim-config.h"
#include "vapi.h"
#include "cuc.h"
#include "cpu-config.h"
#include "memory.h"
#include "dmmu.h"
#include "immu.h"
#include "dcache-model.h"
#include "icache-model.h"
#include "pic.h"
#include "pm.h"
#include "branch-predict.h"
#include "debug-unit.h"
#include "mc.h"
#include "16450.h"
#include "dma.h"
#include "eth.h"
#include "gpio.h"
#include "vga.h"
#include "fb.h"
#include "ps2kbd.h"
#include "atahost.h"
#include "generic.h"
#include "execute.h"
#include "spr-defs.h"
#include "debug.h"
#include "misc.h"
#include "argtable2.h"
 
 
DEFAULT_DEBUG_CHANNEL (config);
 
#define WARNING(s) fprintf (stderr, "Warning: config.%s: %s\n", cur_section->name, (s))
#define MERROR(s) {fprintf (stderr, "ERROR: %s\n", s); if (runtime.sim.init) exit (1);}
 
struct config config;
struct runtime runtime;
 
struct config_section *cur_section;
 
struct config_section *sections = NULL;
 
/* Forward declarations */
static void read_script_file (const char *filename);
 
 
 
/*---------------------------------------------------------------------------*/
/*!Set default configuration parameters for fixed components
 
   These values are held in the global config variable. Parameter orders
   match the order in the corresponding section registration function and
   documentation.
 
   Also set some starting values for runtime elements.                       */
/*---------------------------------------------------------------------------*/
void
init_defconfig ()
{
  int  set_bits;                /* Temporaries for computing bit fields */
  int  way_bits;
 
  memset (&config, 0, sizeof (config));
 
  /* External linkage disabled here. */
  config.ext.class_ptr = NULL;
  config.ext.read_up   = NULL;
  config.ext.write_up  = NULL;
 
  /* Sim */
  config.sim.verbose        = 0;
  config.sim.debug          = 0;
  config.sim.profile        = 0;
  config.sim.prof_fn        = strdup ("sim.profile");
  config.sim.mprofile       = 0;
  config.sim.mprof_fn       = strdup ("sim.mprofile");
  config.sim.history        = 0;
  config.sim.exe_log        = 0;
  config.sim.exe_log_type   = EXE_LOG_HARDWARE;
  config.sim.exe_log_start  = 0;
  config.sim.exe_log_end    = 0;
  config.sim.exe_log_marker = 0;
  config.sim.exe_log_fn     = strdup ("executed.log");
  config.sim.clkcycle_ps    = 4000;     /* 4000 for 4ns (250MHz) */
 
  /* VAPI */
  config.vapi.enabled        = 0;
  config.vapi.server_port    = 50000;
  config.vapi.log_enabled    = 0;
  config.vapi.hide_device_id = 0;
  config.vapi.vapi_fn        = strdup ("vapi.log");
 
  /* CUC */
  config.cuc.calling_convention = 1;
  config.cuc.enable_bursts      = 1;
  config.cuc.no_multicycle      = 1;
  config.cuc.memory_order       = MO_STRONG;
  config.cuc.timings_fn         = strdup ("virtex.tim");
 
  /* CPU */
  cpu_state.sprs[SPR_VR]      = 0;
  cpu_state.sprs[SPR_UPR]     = SPR_UPR_UP | SPR_UPR_TTP;
  cpu_state.sprs[SPR_SR]      = SPR_SR_FO  | SPR_SR_SM;
  cpu_state.sprs[SPR_CPUCFGR] = SPR_CPUCFGR_OB32S;
  config.cpu.superscalar      = 0;
  config.cpu.hazards          = 0;
  config.cpu.dependstats      = 0;
  config.cpu.sbuf_len         = 0;
 
  /* Data cache (IC is set dynamically). Also set relevant SPR bits */
  config.dc.enabled         = 0;
  config.dc.nsets           = 1;
  config.dc.nways           = 1;
  config.dc.blocksize       = 1;
  config.dc.ustates         = 2;
  config.dc.load_hitdelay   = 2;
  config.dc.load_missdelay  = 2;
  config.dc.store_hitdelay  = 0;
  config.dc.store_missdelay = 0;
 
  if (config.dc.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_DCP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DCP;
    }
 
  set_bits = log2_int (config.dc.nsets);
  cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCS;
  cpu_state.sprs[SPR_DCCFGR] |= set_bits << SPR_DCCFGR_NCS_OFF;
 
  way_bits = log2_int (config.dc.nways);
  cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCW;
  cpu_state.sprs[SPR_DCCFGR] |= way_bits << SPR_DCCFGR_NCW_OFF;
 
  if (MIN_DC_BLOCK_SIZE == config.dc.blocksize)
    {
      cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_CBS;
    }
  else
    {
      cpu_state.sprs[SPR_DCCFGR] |= SPR_DCCFGR_CBS;
    }
 
  /* Power management */
  config.pm.enabled = 0;
 
  if (config.pm.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_PMP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PMP;
    }
 
  /* Programmable Interrupt Controller */
  config.pic.enabled      = 0;
  config.pic.edge_trigger = 1;
 
  if (config.pic.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_PICP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PICP;
    }
 
  /* Branch Prediction */
  config.bpb.enabled     = 0;
  config.bpb.btic        = 0;
  config.bpb.sbp_bnf_fwd = 0;
  config.bpb.sbp_bf_fwd  = 0;
  config.bpb.missdelay   = 0;
  config.bpb.hitdelay    = 0;
 
  /* Debug */
  config.debug.enabled     = 0;
  config.debug.gdb_enabled = 0;
  config.debug.server_port = 51000;
  config.debug.vapi_id     = 0;
 
  cpu_state.sprs[SPR_DCFGR] = SPR_DCFGR_WPCI |
                              MATCHPOINTS_TO_NDP (MAX_MATCHPOINTS);
 
  if (config.debug.enabled)
    {
      cpu_state.sprs[SPR_UPR] |= SPR_UPR_DUP;
    }
  else
    {
      cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DUP;
    }
 
  /* Configure runtime */
  memset (&runtime, 0, sizeof (runtime));
 
  /* Sim */
  runtime.sim.fexe_log              = NULL;
  runtime.sim.iprompt               = 0;
  runtime.sim.fprof                 = NULL;
  runtime.sim.fmprof                = NULL;
  runtime.sim.init                  = 1;
  runtime.sim.fout                  = stdout;
 
  /* VAPI */
  runtime.vapi.vapi_file = NULL;
  runtime.vapi.enabled   = 0;
 
}       /* init_defconfig() */
 
 
/*---------------------------------------------------------------------------*/
/*! Parse the arguments for the standalone simulator
 
    Updated by Jeremy Bennett to use argtable2.
 
    @param[in] argc  Number of command args
    @param[in] argv  Vector of the command args
 
    @return  0 on success, 1 on failure                                      */
/*---------------------------------------------------------------------------*/
int
parse_args (int argc, char *argv[])
{
  struct arg_lit *vercop;
  struct arg_lit *help;
  struct arg_file *cfg_file;
  struct arg_lit *nosrv;
  struct arg_int *srv;
  struct arg_str *dbg;
  struct arg_lit *command;
  struct arg_lit *profile;
  struct arg_lit *mprofile;
  struct arg_file *load_file;
  struct arg_end *end;
 
  void *argtab[11];
  int nerrors;
 
  /* Specify each argument, with fall back values */
  vercop = arg_lit0 ("v", "version", "version and copyright notice");
  help = arg_lit0 ("h", "help", "print this help message");
  cfg_file = arg_file0 ("f", "file", "<file>",
                        "config file (default \"sim.cfg\")");
  cfg_file->filename[0] = "sim.cfg";
  nosrv = arg_lit0 (NULL, "nosrv", "do not launch JTAG proxy server");
  srv = arg_int0 (NULL, "srv", "<n>", "port number (default random)");
  srv->ival[0] = rand () % (65536 - 49152) + 49152;
  srv->hdr.flag |= ARG_HASOPTVALUE;
  dbg = arg_str0 ("d", "debug-config", "<str>", "Debug config string");
  command = arg_lit0 ("i", "interactive", "launch interactive prompt");
  profile = arg_lit0 (NULL, "enable-profile", "enable profiling");
  mprofile = arg_lit0 (NULL, "enable-mprofile", "enable memory profiling");
  load_file = arg_file0 (NULL, NULL, "<file>", "OR32 executable");
  end = arg_end (20);
 
  /* Set up the argument table */
  argtab[0] = vercop;
  argtab[1] = help;
  argtab[2] = cfg_file;
  argtab[3] = nosrv;
  argtab[4] = srv;
  argtab[5] = dbg, argtab[6] = command;
  argtab[7] = profile;
  argtab[8] = mprofile;
  argtab[9] = load_file;
  argtab[10] = end;
 
  /* Parse */
  nerrors = arg_parse (argc, argv, argtab);
 
  /* Special case here is if help or version is specified, we ignore any other
     errors and just print the help or version information and then give up. */
  if (vercop->count > 0)
    {
      PRINTF ("OpenRISC 1000 Architectural Simulator, version %s\n",
              PACKAGE_VERSION);
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  if (help->count > 0)
    {
      printf ("Usage:\n  %s ", argv[0]);
      arg_print_syntax (stdout, argtab, "\n\n");
      arg_print_glossary (stdout, argtab, "  %-25s %s\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  /* Deal with any errors */
  if (0 != nerrors)
    {
      arg_print_errors (stderr, end, "or1ksim");
      printf ("\nUsage:\n  %s ", argv[0]);
      arg_print_syntaxv (stderr, argtab, "\n");
 
      arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
      return 1;
    }
 
  /* Process config file next, so any other command args will override */
  if (0 == cfg_file->count)
    {
      fprintf (stderr,
               "WARNING: No config file given, default configuration used\n");
    }
 
  read_script_file (cfg_file->filename[0]);
 
 
  /* Remote debug server */
  if (nosrv->count > 0)
    {
      if (srv->count > 0)
        {
          fprintf (stderr,
                   "%s: cannot specify --nosrv with --srv. Ignoring --nosrv\n",
                   argv[0]);
        }
      else
        {
          config.debug.enabled = 0;
          config.debug.gdb_enabled = 0;
        }
    }
 
  if (srv->count > 0)
    {
      config.debug.enabled = 1;
      config.debug.gdb_enabled = 1;
      config.debug.server_port = srv->ival[0];
    }
 
  /* Runtime debug messages */
  if (dbg->count > 0)
    {
      parse_dbchs (dbg->sval[0]);
    }
 
  /* Interactive operation */
  runtime.sim.iprompt = command->count;
 
  /* Profiling requests */
  config.sim.profile = profile->count;
  config.sim.mprofile = mprofile->count;
 
  /* Executable file */
  if (load_file->count > 0)
    {
      runtime.sim.filename = strdup (load_file->filename[0]);
    }
  else
    {
      runtime.sim.filename = NULL;
    }
 
  arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));
  return 0;                      /* Success */
 
}       /* parse_args() */
 
 
/*---------------------------------------------------------------------------*/
/*!Print the current configuration                                           */
/*---------------------------------------------------------------------------*/
void
print_config ()
{
  if (config.sim.verbose)
    {
      char temp[20];
      PRINTF ("Verbose on, ");
      if (config.sim.debug)
        PRINTF ("simdebug on, ");
      else
        PRINTF ("simdebug off, ");
      if (runtime.sim.iprompt)
        PRINTF ("interactive prompt on\n");
      else
        PRINTF ("interactive prompt off\n");
 
      PRINTF ("Machine initialization...\n");
      generate_time_pretty (temp, config.sim.clkcycle_ps);
      PRINTF ("Clock cycle: %s\n", temp);
      if (cpu_state.sprs[SPR_UPR] & SPR_UPR_DCP)
        PRINTF ("Data cache present.\n");
      else
        PRINTF ("No data cache.\n");
      if (cpu_state.sprs[SPR_UPR] & SPR_UPR_ICP)
        PRINTF ("Insn cache tag present.\n");
      else
        PRINTF ("No instruction cache.\n");
      if (config.bpb.enabled)
        PRINTF ("BPB simulation on.\n");
      else
        PRINTF ("BPB simulation off.\n");
      if (config.bpb.btic)
        PRINTF ("BTIC simulation on.\n");
      else
        PRINTF ("BTIC simulation off.\n");
    }
}
 
struct config_param
{
  char *name;
  enum param_t type;
  void (*func) (union param_val, void *dat);
  struct config_param *next;
};
 
void
base_include (union param_val val, void *dat)
{
  read_script_file (val.str_val);
  cur_section = NULL;
}
 
/*---------------------------------------------[ Simulator configuration ]---*/
 
 
void
sim_verbose (union param_val val, void *dat)
{
  config.sim.verbose = val.int_val;
}
 
 
/*---------------------------------------------------------------------------*/
/*!Set the simulator debug message level
 
   Value must be in the range 0 (no messages) to 9. Values outside this range
   are converted to the nearer end of the range with a warning.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
void
sim_debug (union param_val  val,
           void            *dat)
{
  if (val.int_val < 0)
    {
      WARNING ("Debug value negative: 0 used instead");
      config.sim.debug = 0;
    }
  else if (val.int_val > 9)
    {
      WARNING ("Debug value too large: 9 used instead");
      config.sim.debug = 9;
    }
  else
    {
      config.sim.debug = val.int_val;
    }
}       /* sim_debug() */
 
 
void
sim_profile (union param_val val, void *dat)
{
  config.sim.profile = val.int_val;
}
 
void
sim_prof_fn (union param_val val, void *dat)
{
  if (NULL != config.sim.prof_fn)
    {
      free (config.sim.prof_fn);
    }
 
  config.sim.prof_fn = strdup(val.str_val);
}
 
void
sim_mprofile (union param_val val, void *dat)
{
  config.sim.mprofile = val.int_val;
}
 
void
sim_mprof_fn (union param_val val, void *dat)
{
  if (NULL != config.sim.mprof_fn)
    {
      free (config.sim.mprof_fn);
    }
 
  config.sim.mprof_fn = strdup (val.str_val);
}
 
void
sim_history (union param_val val, void *dat)
{
  config.sim.history = val.int_val;
}
 
void
sim_exe_log (union param_val val, void *dat)
{
  config.sim.exe_log = val.int_val;
}
 
/*---------------------------------------------------------------------------*/
/*!Set the execution log type
 
   Value must be one of default, hardware, simple or software. Invalid values
   are ignored with a warning.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
void
sim_exe_log_type (union param_val  val,
                  void            *dat)
{
  if (strcasecmp (val.str_val, "default") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_HARDWARE;
    }
  else if (strcasecmp (val.str_val, "hardware") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_HARDWARE;
    }
  else if (strcasecmp (val.str_val, "simple") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_SIMPLE;
    }
  else if (strcasecmp (val.str_val, "software") == 0)
    {
      config.sim.exe_log_type = EXE_LOG_SOFTWARE;
    }
  else
    {
      WARNING ("Execution log type invalid. Ignored");
    }
}       /* sim_exe_log_type() */
 
 
void
sim_exe_log_start (union param_val val, void *dat)
{
  config.sim.exe_log_start = val.longlong_val;
}
 
void
sim_exe_log_end (union param_val val, void *dat)
{
  config.sim.exe_log_end = val.longlong_val;
}
 
void
sim_exe_log_marker (union param_val val, void *dat)
{
  config.sim.exe_log_marker = val.int_val;
}
 
void
sim_exe_log_fn (union param_val val, void *dat)
{
  if (NULL != config.sim.exe_log_fn)
    {
      free (config.sim.exe_log_fn);
    }
 
  config.sim.exe_log_fn = strdup (val.str_val);
}
 
/*---------------------------------------------------------------------------*/
/*!Set the clock cycle time.
 
   Value must be an integer followed by one of ps, ns, us or ms.
 
   If a valid time is not presented, the value is unchanged.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure (not used here)                 */
/*---------------------------------------------------------------------------*/
void
sim_clkcycle (union param_val  val,
              void            *dat)
{
  int len = strlen (val.str_val);
  int pos = len - 1;
  long time;
  if (len < 2)
    {
      WARNING ("Clock cycle time invalid: unchanged\n");
      return;
    }
 
  if (val.str_val[pos--] != 's')
    {
      WARNING ("Clock cycle time invalid: unchanged\n");
      return;
    }
 
  switch (val.str_val[pos--])
    {
    case 'p':
      time = 1;
      break;
    case 'n':
      time = 1000;
      break;
    case 'u':
      time = 1000000;
      break;
    case 'm':
      time = 1000000000;
      break;
    default:
      WARNING ("Clock cycle time invalid: unchanged\n");
      return;
    }
 
  val.str_val[pos + 1] = 0;
  time = time * atol (val.str_val);
 
  if (0 == time)
    {
      WARNING ("Clock cycle time of zero invalid: unchanged\n");
      return;
    }
 
  config.sim.clkcycle_ps = time;
 
}       /* sim_clkcycle() */
 
 
/*---------------------------------------------------------------------------*/
/*!Register the functions to handle a section sim
 
   This section does not allocate dynamically a data structure holding its
   config information. It's all in the global config.sim data
   structure. Therefore it does not need a start and end function to
   initialize default values (although it might be clearer to do so). The
   default values are set in init_defconfig().
 
   New preferred parameter names are introduced (_file for filenames), but
   the legacy names (_fn) are also present for backwards compatibility       */
/*---------------------------------------------------------------------------*/
static void
reg_sim_sec ()
{
  struct config_section *sec = reg_config_sec ("sim", NULL, NULL);
 
  reg_config_param (sec, "verbose",        paramt_int,      sim_verbose);
  reg_config_param (sec, "debug",          paramt_int,      sim_debug);
  reg_config_param (sec, "profile",        paramt_int,      sim_profile);
  reg_config_param (sec, "prof_file",      paramt_str,      sim_prof_fn);
  reg_config_param (sec, "prof_fn",        paramt_str,      sim_prof_fn);
  reg_config_param (sec, "mprofile",       paramt_int,      sim_mprofile);
  reg_config_param (sec, "mprof_file",     paramt_str,      sim_mprof_fn);
  reg_config_param (sec, "mprof_fn",       paramt_str,      sim_mprof_fn);
  reg_config_param (sec, "history",        paramt_int,      sim_history);
  reg_config_param (sec, "exe_log",        paramt_int,      sim_exe_log);
  reg_config_param (sec, "exe_log_type",   paramt_word,     sim_exe_log_type);
  reg_config_param (sec, "exe_log_start",  paramt_longlong, sim_exe_log_start);
  reg_config_param (sec, "exe_log_end",    paramt_longlong, sim_exe_log_end);
  reg_config_param (sec, "exe_log_marker", paramt_int,      sim_exe_log_marker);
  reg_config_param (sec, "exe_log_file",   paramt_str,      sim_exe_log_fn);
  reg_config_param (sec, "exe_log_fn",     paramt_str,      sim_exe_log_fn);
  reg_config_param (sec, "clkcycle",       paramt_word,     sim_clkcycle);
 
}       /* reg_sim_sec() */
 
 
void
reg_config_secs (void)
{
  reg_config_param (reg_config_sec ("base", NULL, NULL), "include",
                    paramt_str, base_include);
 
  reg_generic_sec ();           /* JPB */
  reg_sim_sec ();
  reg_cpu_sec ();
  reg_pic_sec ();
  reg_memory_sec ();
  reg_mc_sec ();
  reg_uart_sec ();
  reg_dma_sec ();
  reg_debug_sec ();
  reg_vapi_sec ();
  reg_ethernet_sec ();
  reg_immu_sec ();
  reg_dmmu_sec ();
  reg_ic_sec ();
  reg_dc_sec ();
  reg_gpio_sec ();
  reg_bpb_sec ();
  reg_pm_sec ();
  reg_vga_sec ();
  reg_fb_sec ();
  reg_kbd_sec ();
  reg_ata_sec ();
  reg_cuc_sec ();
}
 
/* Returns a user friendly string of type */
static char *
get_paramt_str (enum param_t type)
{
  switch (type)
    {
    case paramt_int:
      return "integer";
    case paramt_longlong:
      return "longlong";
    case paramt_addr:
      return "address";
    case paramt_str:
      return "string";
    case paramt_word:
      return "word";
    case paramt_none:
      return "none";
    }
  return "";
}
 
void
reg_config_param (struct config_section *sec, const char *param,
                  enum param_t type,
                  void (*param_cb) (union param_val, void *))
{
  struct config_param *new = malloc (sizeof (struct config_param));
 
  TRACE ("Registering config param `%s' to section `%s', type %s\n", param,
         sec->name, get_paramt_str (type));
 
  if (!new)
    {
      fprintf (stderr, "Out-of-memory\n");
      exit (1);
    }
 
  if (!(new->name = strdup (param)))
    {
      fprintf (stderr, "Out-of-memory\n");
      exit (1);
    }
 
  new->func = param_cb;
  new->type = type;
 
  new->next = sec->params;
  sec->params = new;
}
 
struct config_section *
reg_config_sec (const char *section,
                void *(*sec_start) (void), void (*sec_end) (void *))
{
  struct config_section *new = malloc (sizeof (struct config_section));
 
  TRACE ("Registering config section `%s'\n", section);
 
  if (!new)
    {
      fprintf (stderr, "Out-of-memory\n");
      exit (1);
    }
 
  if (!(new->name = strdup (section)))
    {
      fprintf (stderr, "Out-of-memory\n");
      exit (1);
    }
 
  new->next = sections;
  new->sec_start = sec_start;
  new->sec_end = sec_end;
  new->params = NULL;
 
  sections = new;
 
  return new;
}
 
static void
switch_param (char *param, struct config_param *cur_param)
{
  char *end_p;
  union param_val val;
 
  /* Skip over an = sign if it exists */
  if (*param == '=')
    {
      param++;
      while (*param && isspace (*param))
        param++;
    }
 
  switch (cur_param->type)
    {
    case paramt_int:
      val.int_val = strtol (param, NULL, 0);
      break;
    case paramt_longlong:
      val.longlong_val = strtoll (param, NULL, 0);
      break;
    case paramt_addr:
      val.addr_val = strtoul (param, NULL, 0);
      break;
    case paramt_str:
      if (*param != '"')
        {
          CONFIG_ERROR ("String value expected\n");
          return;
        }
 
      param++;
      end_p = param;
      while (*end_p && (*end_p != '"'))
        end_p++;
      *end_p = '\0';
      val.str_val = param;
      break;
    case paramt_word:
      end_p = param;
      while (*end_p && !isspace (*end_p))
        end_p++;
      *end_p = '\0';
      val.str_val = param;
      break;
    case paramt_none:
      break;
    }
 
  cur_param->func (val, cur_section->dat);
}
 
/* Read environment from a script file. Does not fail - assumes default configuration instead.
   The syntax of script file is:
   param = value
   section x
     data
     param = value
   end
 
   Example:
   section mc
     memory_table_file = sim.mem
     enable = 1
     POC = 0x47892344
   end
 
 */
 
static void
read_script_file (const char *filename)
{
  FILE *f;
  char *home = getenv ("HOME");
  char ctmp[STR_SIZE];
  int local = 1;
  cur_section = NULL;
 
  sprintf (ctmp, "%s/.or1k/%s", home, filename);
  if ((f = fopen (filename, "rt")) || (home && (f = fopen (ctmp, "rt"))))
    {
      if (config.sim.verbose)
        PRINTF ("Reading script file from '%s'...\n",
                local ? filename : ctmp);
 
      while (!feof (f))
        {
          char param[STR_SIZE];
          if (fscanf (f, "%s ", param) != 1)
            break;
          /* Is this a section? */
          if (strcmp (param, "section") == 0)
            {
              struct config_section *cur;
              cur_section = NULL;
              if (fscanf (f, "%s\n", param) != 1)
                {
                  fprintf (stderr, "%s: ERROR: Section name required.\n",
                           local ? filename : ctmp);
                  exit (1);
                }
              TRACE ("Came across section `%s'\n", param);
              for (cur = sections; cur; cur = cur->next)
                if (strcmp (cur->name, param) == 0)
                  {
                    cur_section = cur;
                    break;
                  }
              if (!cur)
                {
                  fprintf (stderr,
                           "WARNING: config: Unknown section: %s; ignoring.\n",
                           param);
                  /* just skip section */
                  while (fscanf (f, "%s\n", param) == 1
                         && strcmp (param, "end"));
                }
              else
                {
                  cur->dat = NULL;
                  if (cur->sec_start)
                    cur->dat = cur->sec_start ();
                }
            }
          else if (strcmp (param, "end") == 0)
            {
              if (cur_section->sec_end)
                cur_section->sec_end (cur_section->dat);
              cur_section = NULL;
            }
          else if (strncmp (param, "/*", 2) == 0)
            {
              char c0 = 0, c1 = 0;
              while (c0 != '*' || c1 != '/')
                {
                  c0 = c1;
                  c1 = fgetc (f);
                  if (feof (f))
                    {
                      fprintf (stderr, "%s: ERROR: Comment reached EOF.\n",
                               local ? filename : ctmp);
                      exit (1);
                    }
                }
            }
          else
            {
              struct config_param *cur_param;
              char *cur_p;
              TRACE ("Came across parameter `%s' in section `%s'\n", param,
                     cur_section->name);
              for (cur_param = cur_section->params; cur_param;
                   cur_param = cur_param->next)
                if (strcmp (cur_param->name, param) == 0)
                  {
                    break;
                  }
              if (!cur_param)
                {
                  char tmp[200];
                  sprintf (tmp, "Invalid parameter: %s; ignoring.\n", param);
                  WARNING (tmp);
                  while (fgetc (f) != '\n' || feof (f));
                  continue;
                }
 
              if (cur_param->type == paramt_none)
                continue;
 
              /* Parse parameter value */
              cur_p = fgets (param, STR_SIZE, f);
 
              while (*cur_p && isspace (*cur_p))
                cur_p++;
 
              switch_param (cur_p, cur_param);
            }
        }
      fclose (f);
    }
  else if (config.sim.verbose)
    fprintf (stderr,
             "WARNING: Cannot read script file from '%s',\nneither '%s'.\n",
             filename, ctmp);
}
 
/* Utility for execution of set sim command.  */
static int
set_config (int argc, char **argv)
{
  struct config_section *cur;
  struct config_param *cur_param;
 
  if (argc < 2)
    return 1;
 
  PRINTF ("sec:%s\n", argv[1]);
  cur_section = NULL;
  for (cur = sections; cur; cur = cur->next)
    if (strcmp (cur->name, argv[1]) == 0)
      {
        cur_section = cur;
        break;
      }
 
  if (!cur_section)
    return 1;
 
  if (argc < 3)
    return 2;
 
  PRINTF ("item:%s\n", argv[2]);
  {
    for (cur_param = cur->params; cur_param; cur_param = cur_param->next)
      if (strcmp (cur_param->name, argv[2]) == 0)
        {
          break;
        }
    if (!cur_param)
      return 2;
 
    /* Parse parameter value */
    if (cur_param->type)
      {
        if (argc < 4)
          return 3;
        PRINTF ("params:%s\n", argv[3]);
      }
 
    switch_param (argv[3], cur_param);
  }
  return 0;
}
 
/* Executes set sim command, displays error.  */
void
set_config_command (int argc, char **argv)
{
  struct config_section *cur;
  struct config_param *cur_param;
 
  switch (set_config (argc, argv))
    {
    case 1:
      PRINTF
        ("Invalid or missing section name.  One of valid sections must be specified:\n");
      for (cur = sections; cur; cur = cur->next)
        PRINTF ("%s ", cur->name);
      PRINTF ("\n");
      break;
    case 2:
      PRINTF
        ("Invalid or missing item name.  One of valid items must be specified:\n");
      for (cur_param = cur_section->params; cur_param;
           cur_param = cur_param->next)
        PRINTF ("%s ", cur_param->name);
      PRINTF ("\n");
      break;
    case 3:
      PRINTF ("Invalid parameters specified.\n");
      break;
    }
}

Line No.	Rev	Author	Line
1	1358	nogj	`/* sim-config.c -- Simulator configuration`
2	1743	jeremybenn
3	645	markom	`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
4	1743	jeremybenn	`Copyright (C) 2008 Embecosm Limited`
5
6			`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
7
8			`This file is part of OpenRISC 1000 Architectural Simulator.`
9
10			`This program is free software; you can redistribute it and/or modify it`
11			`under the terms of the GNU General Public License as published by the Free`
12			`Software Foundation; either version 3 of the License, or (at your option)`
13			`any later version.`
14
15			`This program is distributed in the hope that it will be useful, but WITHOUT`
16			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
17			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for`
18			`more details.`
19
20			`You should have received a copy of the GNU General Public License along`
21			`with this program. If not, see <http://www.gnu.org/licenses/>. */`
22	645	markom
23	1748	jeremybenn	`/* This program is commented throughout in a fashion suitable for processing`
24			`with Doxygen. */`
25	645	markom
26	1748	jeremybenn	`/* Simulator configuration. Eventually this one will be a lot bigger. Updated`
27			`to use argtable2 for argument parsing. */`
28	645	markom
29	1308	phoenix
30	1748	jeremybenn	`/* Autoconf and/or portability configuration */`
31	1350	nogj	`#include "config.h"`
32	1748	jeremybenn	`#include "port.h"`
33	1350	nogj
34	1748	jeremybenn	`/* System includes */`
35			`#include <stdlib.h>`
36	1350	nogj
37	1748	jeremybenn	`/* Package includes */`
38	645	markom	`#include "sim-config.h"`
39	1748	jeremybenn	`#include "vapi.h"`
40			`#include "cuc.h"`
41			`#include "cpu-config.h"`
42			`#include "memory.h"`
43			`#include "dmmu.h"`
44			`#include "immu.h"`
45			`#include "dcache-model.h"`
46			`#include "icache-model.h"`
47			`#include "pic.h"`
48			`#include "pm.h"`
49			`#include "branch-predict.h"`
50			`#include "debug-unit.h"`
51			`#include "mc.h"`
52			`#include "16450.h"`
53			`#include "dma.h"`
54			`#include "eth.h"`
55			`#include "gpio.h"`
56			`#include "vga.h"`
57			`#include "fb.h"`
58			`#include "ps2kbd.h"`
59			`#include "atahost.h"`
60			`#include "generic.h"`
61	1432	nogj	`#include "execute.h"`
62	1748	jeremybenn	`#include "spr-defs.h"`
63			`#include "debug.h"`
64			`#include "misc.h"`
65			`#include "argtable2.h"`
66	645	markom
67
68	1748	jeremybenn	`DEFAULT_DEBUG_CHANNEL (config);`
69	1358	nogj
70	1748	jeremybenn	`#define WARNING(s) fprintf (stderr, "Warning: config.%s: %s\n", cur_section->name, (s))`
71	645	markom	`#define MERROR(s) {fprintf (stderr, "ERROR: %s\n", s); if (runtime.sim.init) exit (1);}`
72
73			`struct config config;`
74			`struct runtime runtime;`
75
76	1358	nogj	`struct config_section *cur_section;`
77	645	markom
78	1358	nogj	`struct config_section *sections = NULL;`
79
80	1748	jeremybenn	`/* Forward declarations */`
81			`static void read_script_file (const char *filename);`
82	1557	nogj
83	1748	jeremybenn
84
85			`/---------------------------------------------------------------------------/`
86			`/*!Set default configuration parameters for fixed components`
87
88			`These values are held in the global config variable. Parameter orders`
89			`match the order in the corresponding section registration function and`
90			`documentation.`
91
92			`Also set some starting values for runtime elements. */`
93			`/---------------------------------------------------------------------------/`
94			`void`
95			`init_defconfig ()`
96	645	markom	`{`
97	1748	jeremybenn	`int set_bits; /* Temporaries for computing bit fields */`
98			`int way_bits;`
99
100			`memset (&config, 0, sizeof (config));`
101
102			`/* External linkage disabled here. */`
103			`config.ext.class_ptr = NULL;`
104			`config.ext.read_up = NULL;`
105			`config.ext.write_up = NULL;`
106
107	645	markom	`/* Sim */`
108	1748	jeremybenn	`config.sim.verbose = 0;`
109			`config.sim.debug = 0;`
110			`config.sim.profile = 0;`
111			`config.sim.prof_fn = strdup ("sim.profile");`
112			`config.sim.mprofile = 0;`
113			`config.sim.mprof_fn = strdup ("sim.mprofile");`
114			`config.sim.history = 0;`
115			`config.sim.exe_log = 0;`
116			`config.sim.exe_log_type = EXE_LOG_HARDWARE;`
117			`config.sim.exe_log_start = 0;`
118			`config.sim.exe_log_end = 0;`
119	672	markom	`config.sim.exe_log_marker = 0;`
120	1748	jeremybenn	`config.sim.exe_log_fn = strdup ("executed.log");`
121			`config.sim.clkcycle_ps = 4000; /* 4000 for 4ns (250MHz) */`
122	645	markom
123	1748	jeremybenn	`/* VAPI */`
124			`config.vapi.enabled = 0;`
125			`config.vapi.server_port = 50000;`
126			`config.vapi.log_enabled = 0;`
127			`config.vapi.hide_device_id = 0;`
128			`config.vapi.vapi_fn = strdup ("vapi.log");`
129	876	rherveille
130	1748	jeremybenn	`/* CUC */`
131			`config.cuc.calling_convention = 1;`
132			`config.cuc.enable_bursts = 1;`
133			`config.cuc.no_multicycle = 1;`
134			`config.cuc.memory_order = MO_STRONG;`
135			`config.cuc.timings_fn = strdup ("virtex.tim");`
136
137	645	markom	`/* CPU */`
138	1748	jeremybenn	`cpu_state.sprs[SPR_VR] = 0;`
139			`cpu_state.sprs[SPR_UPR] = SPR_UPR_UP \| SPR_UPR_TTP;`
140			`cpu_state.sprs[SPR_SR] = SPR_SR_FO \| SPR_SR_SM;`
141			`cpu_state.sprs[SPR_CPUCFGR] = SPR_CPUCFGR_OB32S;`
142			`config.cpu.superscalar = 0;`
143			`config.cpu.hazards = 0;`
144			`config.cpu.dependstats = 0;`
145			`config.cpu.sbuf_len = 0;`
146	645	markom
147	1748	jeremybenn	`/* Data cache (IC is set dynamically). Also set relevant SPR bits */`
148			`config.dc.enabled = 0;`
149			`config.dc.nsets = 1;`
150			`config.dc.nways = 1;`
151			`config.dc.blocksize = 1;`
152			`config.dc.ustates = 2;`
153			`config.dc.load_hitdelay = 2;`
154			`config.dc.load_missdelay = 2;`
155			`config.dc.store_hitdelay = 0;`
156			`config.dc.store_missdelay = 0;`
157
158			`if (config.dc.enabled)`
159			`{`
160			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_DCP;`
161			`}`
162			`else`
163			`{`
164			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DCP;`
165			`}`
166
167			`set_bits = log2_int (config.dc.nsets);`
168			`cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCS;`
169			`cpu_state.sprs[SPR_DCCFGR] \|= set_bits << SPR_DCCFGR_NCS_OFF;`
170
171			`way_bits = log2_int (config.dc.nways);`
172			`cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_NCW;`
173			`cpu_state.sprs[SPR_DCCFGR] \|= way_bits << SPR_DCCFGR_NCW_OFF;`
174
175			`if (MIN_DC_BLOCK_SIZE == config.dc.blocksize)`
176			`{`
177			`cpu_state.sprs[SPR_DCCFGR] &= ~SPR_DCCFGR_CBS;`
178			`}`
179			`else`
180			`{`
181			`cpu_state.sprs[SPR_DCCFGR] \|= SPR_DCCFGR_CBS;`
182			`}`
183
184			`/* Power management */`
185			`config.pm.enabled = 0;`
186
187			`if (config.pm.enabled)`
188			`{`
189			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_PMP;`
190			`}`
191			`else`
192			`{`
193			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PMP;`
194			`}`
195
196			`/* Programmable Interrupt Controller */`
197			`config.pic.enabled = 0;`
198			`config.pic.edge_trigger = 1;`
199
200			`if (config.pic.enabled)`
201			`{`
202			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_PICP;`
203			`}`
204			`else`
205			`{`
206			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_PICP;`
207			`}`
208
209			`/* Branch Prediction */`
210			`config.bpb.enabled = 0;`
211			`config.bpb.btic = 0;`
212			`config.bpb.sbp_bnf_fwd = 0;`
213			`config.bpb.sbp_bf_fwd = 0;`
214			`config.bpb.missdelay = 0;`
215			`config.bpb.hitdelay = 0;`
216
217	645	markom	`/* Debug */`
218	1743	jeremybenn	`config.debug.enabled = 0;`
219	645	markom	`config.debug.gdb_enabled = 0;`
220	1748	jeremybenn	`config.debug.server_port = 51000;`
221			`config.debug.vapi_id = 0;`
222	1743	jeremybenn
223	1748	jeremybenn	`cpu_state.sprs[SPR_DCFGR] = SPR_DCFGR_WPCI \|`
224			`MATCHPOINTS_TO_NDP (MAX_MATCHPOINTS);`
225	897	markom
226	1748	jeremybenn	`if (config.debug.enabled)`
227			`{`
228			`cpu_state.sprs[SPR_UPR] \|= SPR_UPR_DUP;`
229			`}`
230			`else`
231			`{`
232			`cpu_state.sprs[SPR_UPR] &= ~SPR_UPR_DUP;`
233			`}`
234	970	simons
235	645	markom	`/* Configure runtime */`
236	1748	jeremybenn	`memset (&runtime, 0, sizeof (runtime));`
237
238	645	markom	`/* Sim */`
239	1748	jeremybenn	`runtime.sim.fexe_log = NULL;`
240			`runtime.sim.iprompt = 0;`
241			`runtime.sim.fprof = NULL;`
242			`runtime.sim.fmprof = NULL;`
243			`runtime.sim.init = 1;`
244			`runtime.sim.fout = stdout;`
245	645	markom
246			`/* VAPI */`
247			`runtime.vapi.vapi_file = NULL;`
248	1748	jeremybenn	`runtime.vapi.enabled = 0;`
249	645	markom
250	1748	jeremybenn	`} /* init_defconfig() */`
251
252
253			`/---------------------------------------------------------------------------/`
254			`/*! Parse the arguments for the standalone simulator`
255
256			`Updated by Jeremy Bennett to use argtable2.`
257
258			`@param[in] argc Number of command args`
259			`@param[in] argv Vector of the command args`
260
261			`@return 0 on success, 1 on failure */`
262			`/---------------------------------------------------------------------------/`
263			`int`
264			`parse_args (int argc, char *argv[])`
265	1557	nogj	`{`
266	1748	jeremybenn	`struct arg_lit *vercop;`
267			`struct arg_lit *help;`
268			`struct arg_file *cfg_file;`
269			`struct arg_lit *nosrv;`
270			`struct arg_int *srv;`
271			`struct arg_str *dbg;`
272			`struct arg_lit *command;`
273			`struct arg_lit *profile;`
274			`struct arg_lit *mprofile;`
275			`struct arg_file *load_file;`
276			`struct arg_end *end;`
277	1557	nogj
278	1748	jeremybenn	`void *argtab[11];`
279			`int nerrors;`
280
281			`/* Specify each argument, with fall back values */`
282			`vercop = arg_lit0 ("v", "version", "version and copyright notice");`
283			`help = arg_lit0 ("h", "help", "print this help message");`
284			`cfg_file = arg_file0 ("f", "file", "<file>",`
285			`"config file (default \"sim.cfg\")");`
286			`cfg_file->filename[0] = "sim.cfg";`
287			`nosrv = arg_lit0 (NULL, "nosrv", "do not launch JTAG proxy server");`
288			`srv = arg_int0 (NULL, "srv", "<n>", "port number (default random)");`
289			`srv->ival[0] = rand () % (65536 - 49152) + 49152;`
290			`srv->hdr.flag \|= ARG_HASOPTVALUE;`
291			`dbg = arg_str0 ("d", "debug-config", "<str>", "Debug config string");`
292			`command = arg_lit0 ("i", "interactive", "launch interactive prompt");`
293			`profile = arg_lit0 (NULL, "enable-profile", "enable profiling");`
294			`mprofile = arg_lit0 (NULL, "enable-mprofile", "enable memory profiling");`
295			`load_file = arg_file0 (NULL, NULL, "<file>", "OR32 executable");`
296			`end = arg_end (20);`
297
298			`/* Set up the argument table */`
299			`argtab[0] = vercop;`
300			`argtab[1] = help;`
301			`argtab[2] = cfg_file;`
302			`argtab[3] = nosrv;`
303			`argtab[4] = srv;`
304			`argtab[5] = dbg, argtab[6] = command;`
305			`argtab[7] = profile;`
306			`argtab[8] = mprofile;`
307			`argtab[9] = load_file;`
308			`argtab[10] = end;`
309
310			`/* Parse */`
311			`nerrors = arg_parse (argc, argv, argtab);`
312
313			`/* Special case here is if help or version is specified, we ignore any other`
314			`errors and just print the help or version information and then give up. */`
315			`if (vercop->count > 0)`
316			`{`
317			`PRINTF ("OpenRISC 1000 Architectural Simulator, version %s\n",`
318			`PACKAGE_VERSION);`
319
320			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
321			`return 1;`
322			`}`
323
324			`if (help->count > 0)`
325			`{`
326			`printf ("Usage:\n %s ", argv[0]);`
327			`arg_print_syntax (stdout, argtab, "\n\n");`
328			`arg_print_glossary (stdout, argtab, " %-25s %s\n");`
329
330			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
331			`return 1;`
332			`}`
333
334			`/* Deal with any errors */`
335			`if (0 != nerrors)`
336			`{`
337			`arg_print_errors (stderr, end, "or1ksim");`
338			`printf ("\nUsage:\n %s ", argv[0]);`
339			`arg_print_syntaxv (stderr, argtab, "\n");`
340
341			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
342			`return 1;`
343			`}`
344
345			`/* Process config file next, so any other command args will override */`
346			`if (0 == cfg_file->count)`
347			`{`
348			`fprintf (stderr,`
349			`"WARNING: No config file given, default configuration used\n");`
350			`}`
351
352			`read_script_file (cfg_file->filename[0]);`
353
354
355			`/* Remote debug server */`
356			`if (nosrv->count > 0)`
357			`{`
358			`if (srv->count > 0)`
359			`{`
360			`fprintf (stderr,`
361			`"%s: cannot specify --nosrv with --srv. Ignoring --nosrv\n",`
362			`argv[0]);`
363			`}`
364			`else`
365			`{`
366			`config.debug.enabled = 0;`
367			`config.debug.gdb_enabled = 0;`
368			`}`
369			`}`
370
371			`if (srv->count > 0)`
372			`{`
373	645	markom	`config.debug.enabled = 1;`
374	1205	phoenix	`config.debug.gdb_enabled = 1;`
375	1748	jeremybenn	`config.debug.server_port = srv->ival[0];`
376	645	markom	`}`
377
378	1748	jeremybenn	`/* Runtime debug messages */`
379			`if (dbg->count > 0)`
380			`{`
381			`parse_dbchs (dbg->sval[0]);`
382			`}`
383
384			`/* Interactive operation */`
385			`runtime.sim.iprompt = command->count;`
386
387			`/* Profiling requests */`
388			`config.sim.profile = profile->count;`
389			`config.sim.mprofile = mprofile->count;`
390
391			`/* Executable file */`
392			`if (load_file->count > 0)`
393			`{`
394			`runtime.sim.filename = strdup (load_file->filename[0]);`
395			`}`
396			`else`
397			`{`
398			`runtime.sim.filename = NULL;`
399			`}`
400
401			`arg_freetable (argtab, sizeof (argtab) / sizeof (argtab[0]));`
402			`return 0; /* Success */`
403
404			`} /* parse_args() */`
405
406
407			`/---------------------------------------------------------------------------/`
408			`/!Print the current configuration /`
409			`/---------------------------------------------------------------------------/`
410			`void`
411			`print_config ()`
412	645	markom	`{`
413	1748	jeremybenn	`if (config.sim.verbose)`
414			`{`
415			`char temp[20];`
416			`PRINTF ("Verbose on, ");`
417			`if (config.sim.debug)`
418			`PRINTF ("simdebug on, ");`
419			`else`
420			`PRINTF ("simdebug off, ");`
421			`if (runtime.sim.iprompt)`
422			`PRINTF ("interactive prompt on\n");`
423			`else`
424			`PRINTF ("interactive prompt off\n");`
425
426			`PRINTF ("Machine initialization...\n");`
427			`generate_time_pretty (temp, config.sim.clkcycle_ps);`
428			`PRINTF ("Clock cycle: %s\n", temp);`
429			`if (cpu_state.sprs[SPR_UPR] & SPR_UPR_DCP)`
430			`PRINTF ("Data cache present.\n");`
431			`else`
432			`PRINTF ("No data cache.\n");`
433			`if (cpu_state.sprs[SPR_UPR] & SPR_UPR_ICP)`
434			`PRINTF ("Insn cache tag present.\n");`
435			`else`
436			`PRINTF ("No instruction cache.\n");`
437			`if (config.bpb.enabled)`
438			`PRINTF ("BPB simulation on.\n");`
439			`else`
440			`PRINTF ("BPB simulation off.\n");`
441			`if (config.bpb.btic)`
442			`PRINTF ("BTIC simulation on.\n");`
443			`else`
444			`PRINTF ("BTIC simulation off.\n");`
445			`}`
446	645	markom	`}`
447
448	1748	jeremybenn	`struct config_param`
449			`{`
450	1358	nogj	`char *name;`
451			`enum param_t type;`
452	1748	jeremybenn	`void (func) (union param_val, void dat);`
453	1358	nogj	`struct config_param *next;`
454	645	markom	`};`
455
456	1748	jeremybenn	`void`
457			`base_include (union param_val val, void *dat)`
458			`{`
459	1358	nogj	`read_script_file (val.str_val);`
460			`cur_section = NULL;`
461			`}`
462	645	markom
463	1748	jeremybenn	`/---------------------------------------------[ Simulator configuration ]---/`
464	645	markom
465	1748	jeremybenn
466			`void`
467			`sim_verbose (union param_val val, void *dat)`
468			`{`
469	1358	nogj	`config.sim.verbose = val.int_val;`
470			`}`
471	645	markom
472	1748	jeremybenn
473			`/---------------------------------------------------------------------------/`
474			`/*!Set the simulator debug message level`
475
476			`Value must be in the range 0 (no messages) to 9. Values outside this range`
477			`are converted to the nearer end of the range with a warning.`
478
479			`@param[in] val The value to use`
480			`@param[in] dat The config data structure (not used here) */`
481			`/---------------------------------------------------------------------------/`
482			`void`
483			`sim_debug (union param_val val,`
484			`void *dat)`
485			`{`
486			`if (val.int_val < 0)`
487			`{`
488			`WARNING ("Debug value negative: 0 used instead");`
489			`config.sim.debug = 0;`
490			`}`
491			`else if (val.int_val > 9)`
492			`{`
493			`WARNING ("Debug value too large: 9 used instead");`
494			`config.sim.debug = 9;`
495			`}`
496			`else`
497			`{`
498			`config.sim.debug = val.int_val;`
499			`}`
500			`} /* sim_debug() */`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc1/] [or1ksim/] [sim-config.c] - Blame information for rev 1765