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

Subversion Repositories or1k

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 1357 to Rev 1358
    ↔ Reverse comparison
  •

Rev 1357 → Rev 1358

/trunk/or1ksim/sim-config.h
378,4 → 378,67
 
/* Handle the sim commandline */
void handle_sim_command(void);
 
union param_val {
char *str_val;
int int_val;
oraddr_t addr_val;
};
 
enum param_t {
paramt_none = 0, /* No parameter */
paramt_str, /* String parameter enclosed in double quotes (") */
paramt_word, /* String parameter NOT enclosed in double quotes */
paramt_int, /* Integer parameter */
paramt_addr /* Address parameter */
};
 
struct config_section {
char *name;
void *(*sec_start)(void);
void (*sec_end)(void *);
void *dat;
struct config_param *params;
struct config_section *next;
};
 
/* Register a parameter in a section of the config file */
void reg_config_param(struct config_section *sec, const char *param,
enum param_t type,
void (*param_cb)(union param_val, void*));
 
/* Register a section in the config file */
struct config_section *reg_config_sec(const char *section,
void *(*sec_start)(void),
void (*sec_end)(void *));
 
extern struct config_section *cur_section;
#define CONFIG_ERROR(s) {fprintf (stderr, "ERROR: config.%s:%s\n", cur_section->name, s); if (runtime.sim.init) exit (1);}
 
/* FIXME: These will disapeer... */
void change_device ();
void end_device ();
extern int current_device;
 
/* FIXME: These will disapeer with the above... */
void reg_mc_sec(void);
void reg_uart_sec(void);
void reg_dma_sec(void);
void reg_memory_sec(void);
void reg_debug_sec(void);
void reg_vapi_sec(void);
void reg_ethernet_sec(void);
void reg_immu_sec(void);
void reg_dmmu_sec(void);
void reg_ic_sec(void);
void reg_dc_sec(void);
void reg_gpio_sec(void);
void reg_bpb_sec(void);
void reg_pm_sec(void);
void reg_vga_sec(void);
void reg_fb_sec(void);
void reg_kbd_sec(void);
void reg_ata_sec(void);
void reg_cuc_sec(void);
void reg_test_sec(void);
#endif
/trunk/or1ksim/debug/debug_unit.c
455,3 → 455,34
set_stall_state (result != 0);
return (result != 0);
}
 
/*--------------------------------------------------[ Debug configuration ]---*/
void debug_enabled(union param_val val, void *dat)
{
config.debug.enabled = val.int_val;
}
 
void debug_gdb_enabled(union param_val val, void *dat)
{
config.debug.gdb_enabled = val.int_val;
}
 
void debug_server_port(union param_val val, void *dat)
{
config.debug.server_port = val.int_val;
}
 
void debug_vapi_id(union param_val val, void *dat)
{
config.debug.vapi_id = val.int_val;
}
 
void reg_debug_sec(void)
{
struct config_section *sec = reg_config_sec("debug", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, debug_enabled);
reg_config_param(sec, "gdb_enabled", paramt_int, debug_gdb_enabled);
reg_config_param(sec, "server_port", paramt_int, debug_server_port);
reg_config_param(sec, "vapi_id", paramt_int, debug_server_port);
}
/trunk/or1ksim/debug/gdbcomm.c
33,6 → 33,14
#include <unistd.h>
#include <string.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
#include "arch.h"
#include "gdb.h"
#include "gdbcomm.h"
#include "vapi.h"
/trunk/or1ksim/cpu/common/labels.c
34,9 → 34,9
 
#include "port.h"
#include "config.h"
#include "sim-config.h"
 
#include "arch.h"
#include "sim-config.h"
#include "labels.h"
 
static struct label_entry *label_hash[LABELS_HASH_SIZE];
/trunk/or1ksim/cpu/common/abstract.c
33,11 → 33,11
#endif
 
#include "port.h"
#include "sim-config.h"
 
#include "arch.h"
#include "parse.h"
#include "abstract.h"
#include "sim-config.h"
#include "labels.h"
#include "execute.h"
#include "sprs.h"
/trunk/or1ksim/profiler.c
23,6 → 23,14
#include <stdio.h>
#include <string.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
#include "arch.h"
#include "profiler.h"
#include "sim-config.h"
 
/trunk/or1ksim/cache/dcache_model.c
348,3 → 348,80
mtspr(SPR_DCBLR, 0);
}
}
 
/*-----------------------------------------------------[ DC configuration ]---*/
void dc_enabled(union param_val val, void *dat)
{
config.dc.enabled = val.int_val;
setsprbits (SPR_UPR, SPR_UPR_DCP, val.int_val ? 1 : 0);
}
 
void dc_nsets(union param_val val, void *dat)
{
if (is_power2(val.int_val) && val.int_val <= MAX_DC_SETS)
config.dc.nsets = val.int_val;
else {
char tmp[200];
sprintf (tmp, "value of power of two and lower or equal than %i expected.", MAX_DC_SETS);
CONFIG_ERROR(tmp);
}
}
 
void dc_nways(union param_val val, void *dat)
{
if (val.int_val >= 1 && val.int_val <= MAX_DC_WAYS)
config.dc.nways = val.int_val;
else
CONFIG_ERROR("value 1, 2, 3 or 4 expected.");
}
 
void dc_blocksize(union param_val val, void *dat)
{
if (is_power2(val.int_val))
config.dc.blocksize = val.int_val;
else
CONFIG_ERROR("value of power of two expected.");
}
 
void dc_ustates(union param_val val, void *dat)
{
if (val.int_val >= 2 && val.int_val <= 4)
config.dc.ustates = val.int_val;
else
CONFIG_ERROR("invalid USTATE.");
}
 
void dc_load_missdelay(union param_val val, void *dat)
{
config.dc.load_missdelay = val.int_val;
}
 
void dc_load_hitdelay(union param_val val, void *dat)
{
config.dc.load_hitdelay = val.int_val;
}
 
void dc_store_missdelay(union param_val val, void *dat)
{
config.dc.store_missdelay = val.int_val;
}
 
void dc_store_hitdelay(union param_val val, void *dat)
{
config.dc.store_hitdelay = val.int_val;
}
 
void reg_dc_sec(void)
{
struct config_section *sec = reg_config_sec("dc", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, dc_enabled);
reg_config_param(sec, "nsets", paramt_int, dc_nsets);
reg_config_param(sec, "nways", paramt_int, dc_nways);
reg_config_param(sec, "blocksize", paramt_int, dc_blocksize);
reg_config_param(sec, "ustates", paramt_int, dc_ustates);
reg_config_param(sec, "load_missdelay", paramt_int, dc_load_missdelay);
reg_config_param(sec, "load_hitdelay", paramt_int, dc_load_hitdelay);
reg_config_param(sec, "store_missdelay", paramt_int, dc_store_missdelay);
reg_config_param(sec, "store_hitdelay", paramt_int, dc_store_hitdelay);
}
/trunk/or1ksim/cache/icache_model.c
214,3 → 214,68
mtspr(SPR_ICBLR, 0);
}
}
 
/*-----------------------------------------------------[ IC configuration ]---*/
void ic_enabled(union param_val val, void *dat)
{
config.ic.enabled = val.int_val;
setsprbits (SPR_UPR, SPR_UPR_ICP, val.int_val ? 1 : 0);
}
 
void ic_nsets(union param_val val, void *dat)
{
if (is_power2(val.int_val) && val.int_val <= MAX_IC_SETS)
config.ic.nsets = val.int_val;
else {
char tmp[200];
sprintf (tmp, "value of power of two and lower or equal than %i expected.", MAX_IC_SETS);
CONFIG_ERROR(tmp);
}
}
 
void ic_nways(union param_val val, void *dat)
{
if (val.int_val >= 1 && val.int_val <= MAX_IC_WAYS)
config.ic.nways = val.int_val;
else
CONFIG_ERROR("value 1, 2, 3 or 4 expected.");
}
 
void ic_blocksize(union param_val val, void *dat)
{
if (is_power2(val.int_val))
config.ic.blocksize = val.int_val;
else
CONFIG_ERROR("value of power of two expected.");
}
 
void ic_ustates(union param_val val, void *dat)
{
if (val.int_val >= 2 && val.int_val <= 4)
config.ic.ustates = val.int_val;
else
CONFIG_ERROR("invalid USTATE.");
}
 
void ic_missdelay(union param_val val, void *dat)
{
config.ic.missdelay = val.int_val;
}
 
void ic_hitdelay(union param_val val, void *dat)
{
config.ic.hitdelay = val.int_val;
}
 
void reg_ic_sec(void)
{
struct config_sections *sec = reg_config_sec("ic", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, ic_enabled);
reg_config_param(sec, "nsets", paramt_int, ic_nsets);
reg_config_param(sec, "nways", paramt_int, ic_nways);
reg_config_param(sec, "blocksize", paramt_int, ic_blocksize);
reg_config_param(sec, "ustates", paramt_int, ic_ustates);
reg_config_param(sec, "missdelay", paramt_int, ic_missdelay);
reg_config_param(sec, "hitdelay", paramt_int, ic_hitdelay);
}
/trunk/or1ksim/cuc/cuc.c
837,3 → 837,51
fclose (flog);
}
 
/*----------------------------------------------------[ CUC Configuration ]---*/
void cuc_calling_convention(union param_val val, void *dat)
{
config.cuc.calling_convention = val.int_val;
}
 
void cuc_enable_bursts(union param_val val, void *dat)
{
config.cuc.enable_bursts = val.int_val;
}
 
void cuc_no_multicycle(union param_val val, void *dat)
{
config.cuc.no_multicycle = val.int_val;
}
 
void cuc_memory_order(union param_val val, void *dat)
{
if (strcmp (val.str_val, "none") == 0)
config.cuc.memory_order = MO_NONE;
else if (strcmp (val.str_val, "weak") == 0)
config.cuc.memory_order = MO_WEAK;
else if (strcmp (val.str_val, "strong") == 0)
config.cuc.memory_order = MO_STRONG;
else if (strcmp (val.str_val, "exact") == 0) {
config.cuc.memory_order = MO_EXACT;
} else {
char tmp[200];
sprintf (tmp, "invalid memory order '%s'.\n", val.str_val);
CONFIG_ERROR(tmp);
}
}
 
void cuc_timings_fn(union param_val val, void *dat)
{
strcpy(config.cuc.timings_fn, val.str_val);
}
 
void reg_cuc_sec(void)
{
struct config_section *sec = reg_config_sec("cuc", NULL, NULL);
 
reg_config_param(sec, "calling_convention", paramt_int, cuc_calling_convention);
reg_config_param(sec, "enable_bursts", paramt_int, cuc_enable_bursts);
reg_config_param(sec, "no_multicycle", paramt_int, cuc_no_multicycle);
reg_config_param(sec, "memory_order", paramt_word, cuc_memory_order);
reg_config_param(sec, "timings_fn", paramt_str, cuc_timings_fn);
}
/trunk/or1ksim/pm/pm.c
46,3 → 46,16
if (config.sim.verbose) PRINTF("Resetting Power Management.\n");
mtspr(SPR_PMR, 0);
}
 
/*-----------------------------------------------------[ PM Configuration ]---*/
void pm_enabled(union param_val val, void *dat)
{
config.pm.enabled = val.int_val;
}
 
void reg_pm_sec(void)
{
struct config_section *sec = reg_config_sec("pm", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, pm_enabled);
}
/trunk/or1ksim/peripheral/gpio.c
302,3 → 302,48
/* Switch to values for next clock */
memcpy( &(gpio->curr), &(gpio->next), sizeof(gpio->curr) );
}
 
/*---------------------------------------------------[ GPIO configuration ]---*/
void gpio_ngpios(union param_val val, void *dat)
{
if (val.int_val >= 0 && val.int_val < MAX_GPIOS)
config.ngpios = val.int_val;
else
CONFIG_ERROR("invalid number of devices.");
}
 
void gpio_baseaddr(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.ngpios)
config.gpios[current_device].baseaddr = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void gpio_irq(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.ngpios)
config.gpios[current_device].irq = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void gpio_base_vapi_id(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.ngpios)
config.gpios[current_device].base_vapi_id = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void reg_gpio_sec(void)
{
struct config_section *sec = reg_config_sec("gpio", NULL, NULL);
 
reg_config_param(sec, "ngpios", paramt_int, gpio_ngpios);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "baseaddr", paramt_addr, gpio_baseaddr);
reg_config_param(sec, "irq", paramt_int, gpio_irq);
reg_config_param(sec, "base_vapi_id", paramt_int, gpio_base_vapi_id);
reg_config_param(sec, "enddevice", paramt_none, end_device);
}
/trunk/or1ksim/peripheral/mc.c
198,3 → 198,28
mc.tms[i]);
}
}
 
/*-----------------------------------------------------[ MC configuration }---*/
void mc_enabled(union param_val val, void *dat)
{
config.mc.enabled = val.int_val;
}
 
void mc_baseaddr(union param_val val, void *dat)
{
config.mc.baseaddr = val.addr_val;
}
 
void mc_POC(union param_val val, void *dat)
{
config.mc.POC = val.int_val;
}
 
void reg_mc_sec(void)
{
struct config_section *sec = reg_config_sec("mc", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, mc_enabled);
reg_config_param(sec, "baseaddr", paramt_addr, mc_baseaddr);
reg_config_param(sec, "POC", paramt_int, mc_POC);
}
/trunk/or1ksim/peripheral/eth.c
889,3 → 889,104
 
return NULL;
}
 
/*-----------------------------------------------[ Ethernet configuration ]---*/
void eth_nethernets (union param_val val, void *dat) {
if (val.int_val >= 0 && val.int_val < MAX_ETHERNETS)
config.nethernets = val.int_val;
else
CONFIG_ERROR("invalid number of devices.");
}
 
void eth_baseaddr (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].baseaddr = val.addr_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_dma (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].dma = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_rtx_type (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].rtx_type = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_rx_channel (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].rx_channel = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_tx_channel (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].rx_channel = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_rxfile (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.nethernets)
strcpy (config.ethernets[current_device].rxfile, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_txfile(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nethernets)
strcpy (config.ethernets[current_device].txfile, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_sockif(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nethernets)
strcpy (config.ethernets[current_device].sockif, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_irq(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].irq = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void eth_vapi_id(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].base_vapi_id = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void reg_ethernet_sec(void)
{
struct config_section *sec = reg_config_sec("ethernet", NULL, NULL);
 
reg_config_param(sec, "nethernets", paramt_int, eth_nethernets);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "irq", paramt_int, eth_irq);
reg_config_param(sec, "enddevice", paramt_int, end_device);
reg_config_param(sec, "baseaddr", paramt_int, eth_baseaddr);
reg_config_param(sec, "dma", paramt_int, eth_dma);
reg_config_param(sec, "rtx_type", paramt_int, eth_rtx_type);
reg_config_param(sec, "rx_channel", paramt_int, eth_rx_channel);
reg_config_param(sec, "tx_channel", paramt_int, eth_tx_channel);
reg_config_param(sec, "rxfile", paramt_str, eth_rxfile);
reg_config_param(sec, "txfile", paramt_str, eth_txfile);
reg_config_param(sec, "sockif", paramt_str, eth_sockif);
reg_config_param(sec, "vapi_id", paramt_int, eth_vapi_id);
}
/trunk/or1ksim/peripheral/ps2kbd.c
283,3 → 283,34
PRINTF("kbd_kresp: %lx\n", kbd_kresp);
PRINTF("kbd_buf_count: %lx\n", kbd_buf_count);
}
 
/*----------------------------------------------------[ KBD Configuration ]---*/
void kbd_enabled(union param_val val, void *dat)
{
config.kbd.enabled = val.int_val;
}
 
void kbd_baseaddr(union param_val val, void *dat)
{
config.kbd.baseaddr = val.addr_val;
}
 
void kbd_irq(union param_val val, void *dat)
{
config.kbd.irq = val.int_val;
}
 
void kbd_rxfile(union param_val val, void *dat)
{
strcpy(config.kbd.rxfile, val.str_val);
}
 
void reg_kbd_sec(void)
{
struct config_section *sec = reg_config_sec("kbd", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, kbd_enabled);
reg_config_param(sec, "baseaddr", paramt_int, kbd_baseaddr);
reg_config_param(sec, "irq", paramt_int, kbd_irq);
reg_config_param(sec, "rxfile", paramt_str, kbd_rxfile);
}
/trunk/or1ksim/peripheral/fb.c
294,3 → 294,34
SCHED_ADD(fb_job, 0, runtime.sim.cycles + config.fb.refresh_rate);
}
}
 
/*-----------------------------------------------------[ FB configuration ]---*/
void fb_enabled(union param_val val, void *dat)
{
config.fb.enabled = val.int_val;
}
 
void fb_baseaddr(union param_val val, void *dat)
{
config.fb.baseaddr = val.addr_val;
}
 
void fb_refresh_rate(union param_val val, void *dat)
{
config.fb.refresh_rate = val.int_val;
}
 
void fb_filename(union param_val val, void *dat)
{
strcpy(config.fb.filename, val.str_val);
}
 
void reg_fb_sec(void)
{
struct config_section *sec = reg_config_sec("fb", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, fb_enabled);
reg_config_param(sec, "baseaddr", paramt_addr, fb_baseaddr);
reg_config_param(sec, "refresh_rate", paramt_int, fb_refresh_rate);
reg_config_param(sec, "filename", paramt_str, fb_filename);
}
/trunk/or1ksim/peripheral/dma.c
488,3 → 488,48
{
*value = (*value & ~mask) | ((*value + 4) & mask);
}
 
/*----------------------------------------------------[ DMA configuration ]---*/
void dma_ndmas(union param_val val, void *dat)
{
if (val.int_val >= 0 && val.int_val < MAX_DMAS)
config.ndmas = val.int_val;
else
CONFIG_ERROR("invalid number of devices.");
}
 
void dma_baseaddr(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.ndmas)
config.dmas[current_device].baseaddr = val.addr_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void dma_irq(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.ndmas)
config.dmas[current_device].irq = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void dma_vapi_id(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.ndmas)
config.dmas[current_device].vapi_id = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void reg_dma_sec(void)
{
struct config_section *sec = reg_config_sec("dma", NULL, NULL);
 
reg_config_param(sec, "ndmas", paramt_int, dma_ndmas);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "enddevice", paramt_none, end_device);
reg_config_param(sec, "irq", paramt_int, dma_irq);
reg_config_param(sec, "baseaddr", paramt_addr, dma_baseaddr);
reg_config_param(sec, "vapi_id", paramt_addr, dma_vapi_id);
}
/trunk/or1ksim/peripheral/atahost.c
319,3 → 319,111
}
}
/* ========================================================================= */
 
/*----------------------------------------------------[ ATA Configuration ]---*/
void ata_natas(union param_val val, void *dat)
{
if (val.int_val >= 0 && val.int_val < MAX_ATAS)
config.natas = val.int_val;
else
CONFIG_ERROR("invalid number of devices.");
}
 
void ata_baseaddr(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].baseaddr = val.addr_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_irq(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].irq = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_type0(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_type0 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_file0(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
strcpy (config.atas[current_device].dev_file0, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_size0(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_size0 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_packet0(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_packet0 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_type1(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_type1 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_file1(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
strcpy (config.atas[current_device].dev_file1, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_size1(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_size1 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void ata_dev_packet1(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_packet1 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void reg_ata_sec(void)
{
struct config_section *sec = reg_config_sec("ata", NULL, NULL);
 
reg_config_param(sec, "natas", paramt_int, ata_natas);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "baseaddr", paramt_addr, ata_baseaddr);
reg_config_param(sec, "irq", paramt_int, ata_irq);
reg_config_param(sec, "dev_type0", paramt_int, ata_dev_type0);
reg_config_param(sec, "dev_file0", paramt_str, ata_dev_file0);
reg_config_param(sec, "dev_size0", paramt_int, ata_dev_size0);
reg_config_param(sec, "dev_packet0", paramt_int, ata_dev_packet0);
reg_config_param(sec, "dev_type1", paramt_int, ata_dev_type1);
reg_config_param(sec, "dev_file1", paramt_str, ata_dev_file1);
reg_config_param(sec, "dev_size1", paramt_int, ata_dev_size1);
reg_config_param(sec, "dev_packet1", paramt_int, ata_dev_packet1);
reg_config_param(sec, "enddevice", paramt_none, end_device);
}
/trunk/or1ksim/peripheral/vga.c
18,6 → 18,7
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
#include <stdio.h>
#include <string.h>
 
#include "config.h"
 
260,3 → 261,57
SCHED_ADD(vga_job, i, runtime.sim.cycles + config.vgas[i].refresh_rate);
}
}
 
/*----------------------------------------------------[ VGA Configuration ]---*/
void vga_nvgas(union param_val val, void *dat)
{
if (val.int_val >= 0 && val.int_val < MAX_VGAS)
config.nvgas = val.int_val;
else
CONFIG_ERROR("invalid number of devices.");
}
 
void vga_baseaddr(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nvgas)
config.vgas[current_device].baseaddr = val.addr_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void vga_irq(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nvgas)
config.vgas[current_device].irq = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void vga_refresh_rate(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nvgas)
config.vgas[current_device].refresh_rate = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void vga_filename(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nvgas)
strcpy (config.vgas[current_device].filename, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void reg_vga_sec(void)
{
struct config_section *sec = reg_config_sec("vga", NULL, NULL);
 
reg_config_param(sec, "nvgas", paramt_int, vga_nvgas);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "baseaddr", paramt_addr, vga_baseaddr);
reg_config_param(sec, "irq", paramt_int, vga_irq);
reg_config_param(sec, "refresh_rate", paramt_int, vga_refresh_rate);
reg_config_param(sec, "filename", paramt_str, vga_filename);
reg_config_param(sec, "enddevice", paramt_none, end_device);
}
/trunk/or1ksim/peripheral/16450.c
675,3 → 675,83
*/
}
}
 
/*---------------------------------------------------[ UART configuration ]---*/
void uart_nuarts(union param_val val, void *dat)
{
if (val.int_val >= 0 && val.int_val < MAX_UARTS)
config.nuarts = val.int_val;
else
CONFIG_ERROR("invalid number of devices.");
}
 
void uart_baseaddr(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].baseaddr = val.addr_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void uart_jitter(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].jitter = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void uart_irq(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].irq = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void uart_16550(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].uart16550 = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void uart_channel(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nuarts)
strcpy (config.uarts[current_device].channel, val.str_val);
else
CONFIG_ERROR("invalid device number.");
}
 
void uart_newway(union param_val val, void *dat)
{
CONFIG_ERROR(" txfile and rxfile and now obsolete.\n\tUse 'channel = \"file:rxfile,txfile\"' instead.");
exit(1);
}
 
void uart_vapi_id(union param_val val, void *dat)
{
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].vapi_id = val.int_val;
else
CONFIG_ERROR("invalid device number.");
}
 
void reg_uart_sec(void)
{
struct config_section *sec = reg_config_sec("uart", NULL, NULL);
 
reg_config_param(sec, "nuarts", paramt_int, uart_nuarts);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "enddevice", paramt_none, end_device);
reg_config_param(sec, "baseaddr", paramt_addr, uart_baseaddr);
reg_config_param(sec, "irq", paramt_int, uart_irq);
reg_config_param(sec, "16550", paramt_int, uart_16550);
reg_config_param(sec, "jitter", paramt_int, uart_jitter);
reg_config_param(sec, "channel", paramt_str, uart_channel);
reg_config_param(sec, "txfile", paramt_str, uart_newway);
reg_config_param(sec, "rxfile", paramt_str, uart_newway);
reg_config_param(sec, "vapi_id", paramt_int, uart_vapi_id);
}
/trunk/or1ksim/peripheral/test.c
45,3 → 45,22
register_memoryarea(config.test.baseaddr, 256, 4, 0, test_read32, test_write32);
}
}
 
/*---------------------------------------------------[ Test configuration ]---*/
void test_enabled(union param_val val, void *dat)
{
config.test.enabled = val.int_val;
}
 
void test_baseaddr(union param_val val, void *dat)
{
config.test.baseaddr = val.addr_val;
}
 
void reg_test_sec(void)
{
struct config_section *sec = reg_config_sec("test", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, test_enabled);
reg_config_param(sec, "baseaddr", paramt_addr, test_baseaddr);
}
/trunk/or1ksim/mmu/dmmu.c
264,3 → 264,74
}
if (start_set < end_set) PRINTF("\n");
}
 
/*---------------------------------------------------[ DMMU configuration ]---*/
void dmmu_enabled(union param_val val, void *dat)
{
setsprbits (SPR_UPR, SPR_UPR_DMP, val.int_val ? 1 : 0);
config.dmmu.enabled = val.int_val;
}
 
void dmmu_nsets(union param_val val, void *dat)
{
if (is_power2(val.int_val) && val.int_val <= 256)
config.dmmu.nsets = val.int_val;
else
CONFIG_ERROR("value of power of two and lower or equal than 256 expected.");
}
 
void dmmu_nways(union param_val val, void *dat)
{
if (val.int_val >= 1 && val.int_val <= 4)
config.dmmu.nways = val.int_val;
else
CONFIG_ERROR("value 1, 2, 3 or 4 expected.");
}
 
void dmmu_pagesize(union param_val val, void *dat)
{
if (is_power2(val.int_val))
config.dmmu.pagesize = val.int_val;
else
CONFIG_ERROR("value of power of two expected.");
}
 
void dmmu_entrysize(union param_val val, void *dat)
{
if (is_power2(val.int_val))
config.dmmu.entrysize = val.int_val;
else
CONFIG_ERROR("value of power of two expected.");
}
 
void dmmu_ustates(union param_val val, void *dat)
{
if (val.int_val >= 2 && val.int_val <= 4)
config.dmmu.ustates = val.int_val;
else
CONFIG_ERROR("invalid USTATE.");
}
 
void dmmu_missdelay(union param_val val, void *dat)
{
config.dmmu.missdelay = val.int_val;
}
 
void dmmu_hitdelay(union param_val val, void *dat)
{
config.immu.hitdelay = val.int_val;
}
 
void reg_dmmu_sec(void)
{
struct config_section *sec = reg_config_sec("dmmu", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, dmmu_enabled);
reg_config_param(sec, "nsets", paramt_int, dmmu_nsets);
reg_config_param(sec, "nways", paramt_int, dmmu_nways);
reg_config_param(sec, "pagesize", paramt_int, dmmu_pagesize);
reg_config_param(sec, "entrysize", paramt_int, dmmu_entrysize);
reg_config_param(sec, "ustates", paramt_int, dmmu_ustates);
reg_config_param(sec, "missdelay", paramt_int, dmmu_missdelay);
reg_config_param(sec, "hitdelay", paramt_int, dmmu_hitdelay);
}
/trunk/or1ksim/mmu/immu.c
241,3 → 241,74
}
if (start_set < end_set) PRINTF("\n");
}
 
/*---------------------------------------------------[ IMMU configuration ]---*/
void immu_enabled(union param_val val, void *dat)
{
setsprbits (SPR_UPR, SPR_UPR_IMP, val.int_val ? 1 : 0);
config.immu.enabled = val.int_val;
}
 
void immu_nsets(union param_val val, void *dat)
{
if (is_power2(val.int_val) && val.int_val <= 256)
config.immu.nsets = val.int_val;
else
CONFIG_ERROR("value of power of two and lower or equal than 256 expected.");
}
 
void immu_nways(union param_val val, void *dat)
{
if (val.int_val >= 1 && val.int_val <= 4)
config.immu.nways = val.int_val;
else
CONFIG_ERROR("value 1, 2, 3 or 4 expected.");
}
 
void immu_pagesize(union param_val val, void *dat)
{
if (is_power2(val.int_val))
config.immu.pagesize = val.int_val;
else
CONFIG_ERROR("value of power of two expected.");
}
 
void immu_entrysize(union param_val val, void *dat)
{
if (is_power2(val.int_val))
config.immu.entrysize = val.int_val;
else
CONFIG_ERROR("value of power of two expected.");
}
 
void immu_ustates(union param_val val, void *dat)
{
if (val.int_val >= 2 && val.int_val <= 4)
config.immu.ustates = val.int_val;
else
CONFIG_ERROR("invalid USTATE.");
}
 
void immu_missdelay(union param_val val, void *dat)
{
config.immu.missdelay = val.int_val;
}
 
void immu_hitdelay(union param_val val, void *dat)
{
config.immu.hitdelay = val.int_val;
}
 
void reg_immu_sec(void)
{
struct config_section *sec = reg_config_sec("immu", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, immu_enabled);
reg_config_param(sec, "nsets", paramt_int, immu_nsets);
reg_config_param(sec, "nways", paramt_int, immu_nways);
reg_config_param(sec, "pagesize", paramt_int, immu_pagesize);
reg_config_param(sec, "entrysize", paramt_int, immu_entrysize);
reg_config_param(sec, "ustates", paramt_int, immu_ustates);
reg_config_param(sec, "missdelay", paramt_int, immu_missdelay);
reg_config_param(sec, "hitdelay", paramt_int, immu_hitdelay);
}
/trunk/or1ksim/vapi/vapi.c
39,6 → 39,14
#include <netdb.h>
#include <netinet/tcp.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
#include "arch.h"
#include "sim-config.h"
#include "vapi.h"
#include "debug.h"
605,3 → 613,40
}
vapi_done ();
}*/
 
/*---------------------------------------------------[ VAPI configuration ]---*/
void vapi_enabled(union param_val val, void *dat)
{
config.vapi.enabled = val.int_val;
}
 
void vapi_server_port(union param_val val, void *dat)
{
config.vapi.server_port = val.int_val;
}
 
void vapi_log_enabled(union param_val val, void *dat)
{
config.vapi.log_enabled = val.int_val;
}
 
void vapi_hide_device_id(union param_val val, void *dat)
{
config.vapi.hide_device_id = val.int_val;
}
 
void vapi_log_fn(union param_val val, void *dat)
{
strcpy(config.vapi.vapi_fn, val.str_val);
}
 
void reg_vapi_sec(void)
{
struct config_section *sec = reg_config_sec("VAPI", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, vapi_enabled);
reg_config_param(sec, "server_port", paramt_int, vapi_server_port);
reg_config_param(sec, "log_enabled", paramt_int, vapi_log_enabled);
reg_config_param(sec, "hide_device_id", paramt_int, vapi_hide_device_id);
reg_config_param(sec, "vapi_log_fn", paramt_str, vapi_log_fn);
}
/trunk/or1ksim/bpb/branch_predict.c
240,3 → 240,46
btic[entry].way[minway].lru = BTIC_USTATES - 1;
}
}
 
/*----------------------------------------------------[ BPB configuration ]---*/
void bpb_enabled(union param_val val, void *dat)
{
config.bpb.enabled = val.int_val;
}
 
void bpb_btic(union param_val val, void *dat)
{
config.bpb.btic = val.int_val;
}
 
void bpb_sbp_bnf_fwd(union param_val val, void *dat)
{
config.bpb.sbp_bnf_fwd = val.int_val;
}
 
void bpb_sbp_bf_fwd(union param_val val, void *dat)
{
config.bpb.sbp_bf_fwd = val.int_val;
}
 
void bpb_missdelay(union param_val val, void *dat)
{
config.bpb.missdelay = val.int_val;
}
 
void bpb_hitdelay(union param_val val, void *dat)
{
config.bpb.hitdelay = val.int_val;
}
 
void reg_bpb_sec(void)
{
struct config_section *sec = reg_config_sec("bpb", NULL, NULL);
 
reg_config_param(sec, "enabled", paramt_int, bpb_enabled);
reg_config_param(sec, "btic", paramt_int, bpb_btic);
reg_config_param(sec, "sbp_bnf_fwd", paramt_int, bpb_sbp_bnf_fwd);
reg_config_param(sec, "sbp_bf_fwd", paramt_int, bpb_sbp_bf_fwd);
reg_config_param(sec, "missdelay", paramt_int, bpb_missdelay);
reg_config_param(sec, "hitdelay", paramt_int, bpb_hitdelay);
}
/trunk/or1ksim/toplevel.c
77,7 → 77,7
#include "cuc.h"
 
/* CVS revision number. */
const char rcsrev[] = "$Revision: 1.103 $";
const char rcsrev[] = "$Revision: 1.104 $";
 
inline void debug(int level, const char *format, ...)
{
340,6 → 340,7
{
srand(getpid());
init_defconfig();
reg_config_secs();
if (parse_args(argc, argv)) {
PRINTF("Usage: %s [options] <filename>\n", argv[0]);
PRINTF("Options:\n");
/trunk/or1ksim/sim-config.c
1,4 → 1,4
/* config.c -- Simulator configuration
/* sim-config.c -- Simulator configuration
Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
 
This file is part of OpenRISC 1000 Architectural Simulator.
46,8 → 46,9
#include "mprofiler.h"
#include "cuc.h"
 
#define WARNING(s) fprintf (stderr, "WARNING: config.%s: %s\n", sections[section].name, (s))
#define ERROR(s) {fprintf (stderr, "ERROR: config.%s:%s\n", sections[section].name, s); if (runtime.sim.init) exit (1);}
#include "debug.h"
 
#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);}
 
#if !FAST_SIM
55,12 → 56,10
#endif
struct runtime runtime;
 
int section = 0;
extern struct section {
char *name;
int flags;
} sections[];
struct config_section *cur_section;
 
struct config_section *sections = NULL;
 
void init_defconfig()
{
int i;
273,65 → 272,6
return 0;
}
 
#if !FAST_SIM
#define CNV(x) ((isspace(x) || (x) == 0) ? ' ' : (x))
 
/* Substitute for less powerful fscanf */
int fscanf_ex (FILE *f, char *fmt, void *buf, char *str)
{
char tmp[STR_SIZE];
char ch;
int i = 0;
while (*fmt) {
switch (*fmt) {
case '%':
while(*fmt != 0 && !isalpha (*fmt))
tmp[i++] = *(fmt++);
tmp[i++] = *(fmt++);
if (tmp[i - 1] == 's') {
char *cbuf = (char *)buf;
i = 0;
while (ch = (f ? fgetc (f) : *str++), isspace(ch))
if (f ? feof (f) : *str) return 1;
if (f)
ungetc (ch, f);
else
str--;
while ((*(cbuf++) = ch = (f ? fgetc (f) : *str++), CNV(ch) ) != *fmt) {
if ((f ? feof (f) : *str)) return 1;
if (++i >= STR_SIZE) {
fprintf (stderr, "ERROR: string too long.\n");
return 1;
}
}
*(--cbuf) = 0;
fmt++;
} else {
tmp[i++] = 0;
if (f)
fscanf (f, tmp, buf);
else
sscanf (str, tmp, buf);
}
break;
default:
while ((ch = (f ? fgetc (f) : *str++)) != *fmt) {
if (!isspace (ch)) {
char tmp[200];
sprintf (tmp, "unexpected char '%c' (expecting '%c')\n", ch, *fmt);
fprintf (stderr, "WARNING: config.%s: %s\n", sections[section].name, tmp);
WARNING(tmp);
}
if ((f ? feof (f) : *str)) return 1;
}
fmt++;
break;
}
}
return 0;
}
#endif /* !FAST_SIM */
 
void print_config()
{
if (config.sim.verbose) {
369,647 → 309,302
}
 
#if !FAST_SIM
/* Forward declarations of functions */
void base_include ();
void sim_clkcycle ();
void sim_exe_log_type ();
void change_device ();
void end_device ();
void uart_nuarts ();
void uart_baseaddr ();
void uart_channel ();
void uart_newway ();
void uart_jitter ();
void uart_irq ();
void uart_16550 ();
void uart_vapi_id ();
void dma_ndmas ();
void dma_baseaddr ();
void dma_irq ();
void dma_vapi_id ();
void memory_type ();
void memory_nmemories ();
void memory_ce ();
void memory_baseaddr ();
void memory_size ();
void memory_name ();
void memory_log ();
void memory_delayr ();
void memory_delayw ();
void cpu_sbuf_len ();
void eth_nethernets ();
void eth_baseaddr ();
void eth_irq ();
void eth_dma ();
void eth_rtx_type ();
void eth_rx_channel ();
void eth_tx_channel ();
void eth_rxfile ();
void eth_txfile ();
void eth_sockif ();
void eth_vapi_id ();
void gpio_ngpios ();
void gpio_baseaddr ();
void gpio_irq ();
void gpio_base_vapi_id ();
void vga_nvgas ();
void vga_baseaddr ();
void vga_irq ();
void vga_refresh_rate ();
//void vga_filename ();
void vga_bufaddr ();
void vga_paladdr ();
void vga_refresh_rate ();
void vga_filename ();
void ata_natas ();
void ata_baseaddr ();
void ata_irq ();
void ata_dev_type0 ();
void ata_dev_file0 ();
void ata_dev_size0 ();
void ata_dev_packet0 ();
void ata_dev_type1 ();
void ata_dev_file1 ();
void ata_dev_size1 ();
void ata_dev_packet1 ();
void immu_enabled ();
void immu_nsets ();
void immu_nways ();
void immu_pagesize ();
void immu_entrysize ();
void immu_ustates ();
void dmmu_enabled ();
void dmmu_nsets ();
void dmmu_nways ();
void dmmu_pagesize ();
void dmmu_entrysize ();
void dmmu_ustates ();
void ic_enabled ();
void ic_nsets ();
void ic_nways ();
void ic_blocksize ();
void ic_ustates ();
void dc_enabled ();
void dc_nsets ();
void dc_nways ();
void dc_blocksize ();
void dc_ustates ();
void cuc_memory_order ();
 
unsigned long tempL;
unsigned long tempUL;
char tempS[STR_SIZE];
 
#define CPF_SUBSECTION 1
#define CPF_SUBFIELD 2
#define CPF_GLOBAL 4 /* Not part of the substructure (group) in config */
 
struct section sections[] = {
{"base", 0}, /* 0 */
{"mc", 0},
{"uart", 0},
{"dma", 0},
{"memory", 0},
{"cpu", 0}, /* 5 */
{"sim", 0},
{"debug", 0},
{"VAPI", 0},
{"ethernet",0},
{"", 0}, /* 10 */
{"immu", 0},
{"dmmu", 0},
{"ic", 0},
{"dc", 0},
{"gpio", 0}, /* 15 */
{"bpb", 0},
{"pm", 0},
{"vga", 0},
{"fb", 0},
{"kbd", 0}, /* 20 */
{"ata", 0},
{"cuc", 0},
{"test", 0}
struct config_param {
char *name;
enum param_t type;
void (*func)(union param_val, void *dat);
struct config_param *next;
};
 
/* *INDENT-OFF* */
/* FIXME: These will be removed */
int current_device = -1;
void change_device (union param_val val, void *dat) {
current_device = val.int_val;
}
 
/* Parameter definitions */
struct config_params {
int section;
char *name;
char *type;
void (*func)();
void *addr;
int attr;
} config_params[] = {
{0, "include", "\"%s\"", base_include, (void *)(&tempS), 0},
void end_device (union param_val val, void *dat) {
current_device = -1;
}
 
{1, "enabled", "=%i", NULL, (void *)(&config.mc.enabled), 0},
{1, "baseaddr", "=0x%x", NULL, (void *)(&config.mc.baseaddr), 0},
{1, "POC", "=0x%x", NULL, (void *)(&config.mc.POC), 0},
{2, "nuarts", "=%i", uart_nuarts, (void *)(&tempL), CPF_GLOBAL},
{2, "device", "%i", change_device, (void *)(&tempL), 0},
{2, "enddevice", "", end_device, NULL, 0},
{2, "baseaddr", "=0x%x", uart_baseaddr, (void *)(&tempUL), 0},
{2, "irq", "=%i", uart_irq, (void *)(&tempL), 0},
{2, "16550", "=%i", uart_16550, (void *)(&tempL), 0},
{2, "jitter", "=%i", uart_jitter, (void *)(&tempL), 0},
{2, "channel", "=\"%s\"", uart_channel, (void *)(&tempS[0]), 0},
{2, "txfile", "=\"%s\"", uart_newway, (void *)(&tempS[0]), 0},
{2, "rxfile", "=\"%s\"", uart_newway, (void *)(&tempS[0]), 0},
{2, "vapi_id", "=0x%x", uart_vapi_id, (void *)(&tempUL), 0},
void base_include (union param_val val, void *dat) {
read_script_file (val.str_val);
cur_section = NULL;
}
 
{3, "ndmas", "=%i", dma_ndmas, (void *)(&tempL), CPF_GLOBAL},
{3, "device", "%i", change_device, (void *)(&tempL), 0},
{3, "enddevice", "", end_device, NULL, 0},
{3, "baseaddr", "=0x%x", dma_baseaddr, (void *)(&tempUL), 0},
{3, "irq", "=%i", dma_irq, (void *)(&tempL), 0},
{3, "vapi_id", "=0x%x", dma_vapi_id, (void *)(&tempUL), 0},
/*----------------------------------------------[ Simulator configuration ]---*/
void sim_debug (union param_val val, void *dat) {
config.sim.debug = val.int_val;
}
 
{4, "random_seed", "=%i", NULL, (void *)(&config.memory.random_seed), 0},
{4, "pattern", "=%i", NULL, (void *)(&config.memory.pattern), 0},
{4, "type", "=%s ", memory_type, (void *)(&tempS[0]), 0},
{4, "nmemories", "=%i", memory_nmemories,(void *)(&tempL), CPF_GLOBAL},
{4, "device", "%i", change_device, (void *)(&tempL), 0},
{4, "enddevice", "", end_device, NULL, 0},
{4, "ce", "=%i", memory_ce, (void *)(&tempL), 0},
{4, "baseaddr", "=0x%x", memory_baseaddr,(void *)(&tempUL), 0},
{4, "size", "=0x%x", memory_size, (void *)(&tempUL), 0},
{4, "name", "=\"%s\"", memory_name, (void *)(&tempS[0]), 0},
{4, "log", "=\"%s\"", memory_log, (void *)(&tempS[0]), 0},
{4, "delayr", "=%i", memory_delayr, (void *)(&tempL), 0},
{4, "delayw", "=%i", memory_delayw, (void *)(&tempL), 0},
void sim_verbose (union param_val val, void *dat) {
config.sim.verbose = val.int_val;
}
 
{5, "ver", "=0x%x", NULL, (void *)(&config.cpu.ver), 0},
{5, "rev", "=0x%x", NULL, (void *)(&config.cpu.rev), 0},
{5, "upr", "=0x%x", NULL, (void *)(&config.cpu.upr), 0},
{5, "sr", "=0x%x", NULL, (void *)(&config.cpu.sr), 0},
{5, "hazards", "=%i", NULL, (void *)(&config.cpu.hazards), 0},
{5, "superscalar", "=%i", NULL, (void *)(&config.cpu.superscalar), 0},
{5, "dependstats", "=%i", NULL, (void *)(&config.cpu.dependstats), 0},
{5, "sbuf_len", "=%i", cpu_sbuf_len, (void *)(&config.cpu.sbuf_len), 0},
{6, "debug", "=%i", NULL, (void *)(&config.sim.debug), 0},
{6, "verbose", "=%i", NULL, (void *)(&config.sim.verbose), 0},
{6, "profile", "=%i", NULL, (void *)(&config.sim.profile), 0},
{6, "prof_fn", "=\"%s\"", NULL, (void *)(&config.sim.prof_fn[0]), 0},
{6, "mprofile", "=%i", NULL, (void *)(&config.sim.mprofile), 0},
{6, "mprof_fn", "=\"%s\"", NULL, (void *)(&config.sim.mprof_fn[0]), 0},
{6, "history", "=%i", NULL, (void *)(&config.sim.history), 0},
{6, "exe_log", "=%i", NULL, (void *)(&config.sim.exe_log), 0},
{6, "exe_log_type", "=%s ", sim_exe_log_type, (void *)(&tempS[0]), 0},
{6, "exe_log_start", "=%i", NULL, (void *)(&config.sim.exe_log_start), 0},
{6, "exe_log_end", "=%i", NULL, (void *)(&config.sim.exe_log_end), 0},
{6, "exe_log_marker", "=%i", NULL, (void *)(&config.sim.exe_log_marker), 0},
{6, "exe_log_fn", "=\"%s\"", NULL, (void *)(&config.sim.exe_log_fn[0]), 0},
{6, "spr_log", "=%i", NULL, (void *)(&config.sim.spr_log), 0},
{6, "spr_log_fn", "=\"%s\"", NULL, (void *)(&config.sim.spr_log_fn[0]), 0},
{6, "clkcycle", "=%s ", sim_clkcycle, (void *)(&tempS[0]), 0},
{6, "stdout", "=\"%s\"", NULL, (void *)(&config.sim.fstdout[0]), 0},
void sim_profile (union param_val val, void *dat) {
config.sim.profile = val.int_val;
}
 
{7, "enabled", "=%i", NULL, (void *)(&config.debug.enabled), 0},
{7, "gdb_enabled", "=%i", NULL, (void *)(&config.debug.gdb_enabled), 0},
{7, "server_port", "=%i", NULL, (void *)(&config.debug.server_port), 0},
{7, "vapi_id", "=0x%x", NULL, (void *)(&config.debug.vapi_id), 0},
{8, "enabled", "=%i", NULL, (void *)(&config.vapi.enabled), 0},
{8, "server_port", "=%i", NULL, (void *)(&config.vapi.server_port), 0},
{8, "log_enabled", "=%i", NULL, (void *)(&config.vapi.log_enabled), 0},
{8, "hide_device_id", "=%i", NULL, (void *)(&config.vapi.hide_device_id), 0},
{8, "vapi_log_fn", "=\"%s\"", NULL, (void *)(&config.vapi.vapi_fn[0]), 0},
{9, "nethernets", "=%i", eth_nethernets,(void *)(&tempL), CPF_GLOBAL},
{9, "device", "%i", change_device, (void *)(&tempL), 0},
{9, "irq", "=%i", eth_irq, (void *)(&tempUL), 15},
{9, "enddevice", "", end_device, NULL, 0},
{9, "baseaddr", "=0x%x", eth_baseaddr, (void *)(&tempUL), 0},
{9, "dma", "=%i", eth_dma, (void *)(&tempL), 0},
{9, "rtx_type", "=%i", eth_rtx_type, (void *)(&tempUL), 0},
{9, "rx_channel", "=%i", eth_rx_channel,(void *)(&tempL), 0},
{9, "tx_channel", "=%i", eth_tx_channel,(void *)(&tempL), 0},
{9, "rxfile", "=\"%s\"", eth_rxfile, (void *)(&tempS[0]), 0},
{9, "txfile", "=\"%s\"", eth_txfile, (void *)(&tempS[0]), 0},
{9, "sockif", "=\"%s\"", eth_sockif, (void *)(&tempS[0]), 0},
{9, "vapi_id", "=0x%x", eth_vapi_id, (void *)(&tempUL), 0},
{11, "enabled", "=%i", immu_enabled, (void *)(&tempL), 0},
{11, "nsets", "=%i", immu_nsets, (void *)(&tempL), 0},
{11, "nways", "=%i", immu_nways, (void *)(&tempL), 0},
{11, "pagesize", "=%i", immu_pagesize, (void *)(&tempL), 0},
{11, "entrysize", "=%i", immu_entrysize,(void *)(&tempL), 0},
{11, "ustates", "=%i", immu_ustates, (void *)(&tempL), 0},
{11, "missdelay", "=%i", NULL, (void *)(&config.immu.missdelay), 0},
{11, "hitdelay", "=%i", NULL, (void *)(&config.immu.hitdelay), 0},
{12, "enabled", "=%i", dmmu_enabled, (void *)(&tempL), 0},
{12, "nsets", "=%i", dmmu_nsets, (void *)(&tempL), 0},
{12, "nways", "=%i", dmmu_nways, (void *)(&tempL), 0},
{12, "pagesize", "=%i", dmmu_pagesize, (void *)(&tempL), 0},
{12, "entrysize", "=%i", dmmu_entrysize,(void *)(&tempL), 0},
{12, "ustates", "=%i", dmmu_ustates, (void *)(&tempL), 0},
{12, "missdelay", "=%i", NULL, (void *)(&config.dmmu.missdelay), 0},
{12, "hitdelay", "=%i", NULL, (void *)(&config.dmmu.hitdelay), 0},
void sim_prof_fn (union param_val val, void *dat) {
strcpy(config.sim.prof_fn, val.str_val);
}
 
{13, "enabled", "=%i", ic_enabled, (void *)(&tempL), 0},
{13, "nsets", "=%i", ic_nsets, (void *)(&tempL), 0},
{13, "nways", "=%i", ic_nways, (void *)(&tempL), 0},
{13, "blocksize", "=%i", ic_blocksize, (void *)(&tempL), 0},
{13, "ustates", "=%i", ic_ustates, (void *)(&tempL), 0},
{13, "missdelay", "=%i", NULL, (void *)(&config.ic.missdelay), 0},
{13, "hitdelay", "=%i", NULL, (void *)(&config.ic.hitdelay), 0},
{14, "enabled", "=%i", dc_enabled, (void *)(&tempL), 0},
{14, "nsets", "=%i", dc_nsets, (void *)(&tempL), 0},
{14, "nways", "=%i", dc_nways, (void *)(&tempL), 0},
{14, "blocksize", "=%i", dc_blocksize, (void *)(&tempL), 0},
{14, "ustates", "=%i", dc_ustates, (void *)(&tempL), 0},
{14, "load_missdelay", "=%i", NULL, (void *)(&config.dc.load_missdelay), 0},
{14, "load_hitdelay", "=%i", NULL, (void *)(&config.dc.load_hitdelay), 0},
{14, "store_missdelay", "=%i", NULL, (void *)(&config.dc.store_missdelay), 0},
{14, "store_hitdelay", "=%i", NULL, (void *)(&config.dc.store_hitdelay), 0},
{15, "ngpios", "=%i", gpio_ngpios, (void *)(&tempL), CPF_GLOBAL},
{15, "device", "%i", change_device, (void *)(&tempL), 0},
{15, "baseaddr", "=0x%x", gpio_baseaddr, (void *)(&tempUL), 0},
{15, "irq", "=%i", gpio_irq, (void *)(&tempL), 0},
{15, "base_vapi_id", "=0x%x", gpio_base_vapi_id, (void *)(&tempUL), 0},
{15, "enddevice", "", end_device, NULL, 0},
 
{16, "enabled", "=%i", NULL, (void *)(&config.bpb.enabled), 0},
{16, "btic", "=%i", NULL, (void *)(&config.bpb.btic), 0},
{16, "sbp_bnf_fwd", "=%i", NULL, (void *)(&config.bpb.sbp_bnf_fwd), 0},
{16, "sbp_bf_fwd", "=%i", NULL, (void *)(&config.bpb.sbp_bf_fwd), 0},
{16, "missdelay", "=%i", NULL, (void *)(&config.bpb.missdelay), 0},
{16, "hitdelay", "=%i", NULL, (void *)(&config.bpb.hitdelay), 0},
 
{17, "enabled", "=%i", NULL, (void *)(&config.pm.enabled), 0},
 
{18, "nvgas", "=%i", vga_nvgas, (void *)(&tempL), CPF_GLOBAL},
{18, "device", "%i", change_device, (void *)(&tempL), 0},
{18, "baseaddr", "=0x%x", vga_baseaddr, (void *)(&tempUL), 0},
{18, "irq", "=%i", vga_irq, (void *)(&tempL), 0},
{18, "refresh_rate", "=%i", vga_refresh_rate, (void *)(&tempUL), 0},
{18, "filename", "=\"%s\"", vga_filename, (void *)(&tempS[0]), 0},
{18, "enddevice", "", end_device, NULL, 0},
 
{19, "enabled", "=%i", NULL, (void *)(&config.fb.enabled), 0},
{19, "baseaddr", "=0x%x", NULL, (void *)(&config.fb.baseaddr), 0},
{19, "refresh_rate", "=%i", NULL, (void *)(&config.fb.refresh_rate), 0},
{19, "filename", "=\"%s\"", NULL, (void *)(&config.fb.filename), 0},
 
{20, "enabled", "=%i", NULL, (void *)(&config.kbd.enabled), 0},
{20, "baseaddr", "=0x%x", NULL, (void *)(&config.kbd.baseaddr), 0},
{20, "irq", "=%i", NULL, (void *)(&config.kbd.irq), 0},
{20, "rxfile", "=\"%s\"", NULL, (void *)(&config.kbd.rxfile), 0},
 
{21, "natas", "=%i", ata_natas, (void *)(&tempL ), CPF_GLOBAL},
{21, "device", "%i", change_device, (void *)(&tempL ), 0},
{21, "baseaddr", "=0x%x", ata_baseaddr, (void *)(&tempUL), 0},
{21, "irq", "=%i", ata_irq, (void *)(&tempL ), 0},
{21, "dev_type0", "=%i", ata_dev_type0, (void *)(&tempL ), 0},
{21, "dev_file0", "=\"%s\"", ata_dev_file0, (void *)(&tempS ), 0},
{21, "dev_size0", "=%i", ata_dev_size0, (void *)(&tempUL), 0},
{21, "dev_packet0", "=%i", ata_dev_packet0, (void *)(&tempL ), 0},
{21, "dev_type1", "=%i", ata_dev_type1, (void *)(&tempL ), 0},
{21, "dev_file1", "=\"%s\"", ata_dev_file1, (void *)(&tempS ), 0},
{21, "dev_size1", "=%i", ata_dev_size1, (void *)(&tempUL), 0},
{21, "dev_packet1", "=%i", ata_dev_packet1, (void *)(&tempL ), 0},
{21, "enddevice", "", end_device, NULL, 0},
 
{22, "calling_convention","=%i", NULL, (void *)&config.cuc.calling_convention, 0},
{22, "enable_bursts", "=%i", NULL, (void *)&config.cuc.enable_bursts, 0},
{22, "no_multicycle", "=%i", NULL, (void *)&config.cuc.no_multicycle, 0},
{22, "memory_order", "=%s ", cuc_memory_order, (void *)&tempS, 0},
{22, "timings_fn", "=\"%s\"", NULL, (void *)config.cuc.timings_fn},
 
{23, "enabled", "=%i", NULL, (void *)(&config.test.enabled), 0},
{23, "baseaddr", "=0x%x", NULL, (void *)(&config.test.baseaddr), 0}
};
 
/* *INDENT-ON* */
 
int current_device = -1;
void change_device () {
current_device = tempL;
void sim_mprofile (union param_val val, void *dat) {
config.sim.mprofile = val.int_val;
}
 
void end_device () {
current_device = -1;
void sim_mprof_fn (union param_val val, void *dat) {
strcpy(config.sim.mprof_fn, val.str_val);
}
 
void base_include () {
read_script_file (tempS);
section = 0;
void sim_history (union param_val val, void *dat) {
config.sim.history = val.int_val;
}
 
void sim_clkcycle () {
int len = strlen (tempS);
int pos = len - 1;
long time;
if (len < 2) goto err;
if (tempS[pos--] != 's') goto err;
switch (tempS[pos--]) {
case 'p': time = 1; break;
case 'n': time = 1000; break;
case 'u': time = 1000000; break;
case 'm': time = 1000000000; break;
default:
goto err;
}
tempS[pos + 1] = 0;
config.sim.clkcycle_ps = time * atol (tempS);
return;
err:
ERROR("invalid time format.");
void sim_exe_log (union param_val val, void *dat) {
config.sim.exe_log = val.int_val;
}
 
void sim_exe_log_type () {
if (strcmp (tempS, "default") == 0)
void sim_exe_log_type (union param_val val, void *dat) {
if (strcmp (val.str_val, "default") == 0)
config.sim.exe_log_type = EXE_LOG_HARDWARE;
else if (strcmp (tempS, "hardware") == 0)
else if (strcmp (val.str_val, "hardware") == 0)
config.sim.exe_log_type = EXE_LOG_HARDWARE;
else if (strcmp (tempS, "simple") == 0)
else if (strcmp (val.str_val, "simple") == 0)
config.sim.exe_log_type = EXE_LOG_SIMPLE;
else if (strcmp (tempS, "software") == 0) {
else if (strcmp (val.str_val, "software") == 0) {
config.sim.exe_log_type = EXE_LOG_SOFTWARE;
} else {
char tmp[200];
sprintf (tmp, "invalid execute log type '%s'.\n", tempS);
ERROR(tmp);
sprintf (tmp, "invalid execute log type '%s'.\n", val.str_val);
CONFIG_ERROR(tmp);
}
}
 
void uart_nuarts () {
if (tempL >= 0 && tempL < MAX_UARTS)
config.nuarts = tempL;
else
ERROR("invalid number of devices.");
void sim_exe_log_start (union param_val val, void *dat) {
config.sim.exe_log_start = val.int_val;
}
 
void uart_baseaddr () {
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].baseaddr = tempUL;
else
ERROR("invalid device number.");
void sim_exe_log_end (union param_val val, void *dat) {
config.sim.exe_log_end = val.int_val;
}
 
void uart_jitter () {
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].jitter = tempL;
else
ERROR("invalid device number.");
void sim_exe_log_marker (union param_val val, void *dat) {
config.sim.exe_log_marker = val.int_val;
}
 
void uart_irq () {
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].irq = tempL;
else
ERROR("invalid device number.");
void sim_exe_log_fn (union param_val val, void *dat) {
strcpy(config.sim.exe_log_fn, val.str_val);
}
 
void uart_16550 () {
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].uart16550 = tempL;
else
ERROR("invalid device number.");
void sim_clkcycle (union param_val val, void *dat) {
int len = strlen (val.str_val);
int pos = len - 1;
long time;
if (len < 2) goto err;
if (val.str_val[pos--] != 's') goto err;
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:
goto err;
}
val.str_val[pos + 1] = 0;
config.sim.clkcycle_ps = time * atol (val.str_val);
return;
err:
CONFIG_ERROR("invalid time format.");
}
 
void uart_channel () {
if (current_device >= 0 && current_device < config.nuarts)
strcpy (config.uarts[current_device].channel, tempS);
else
ERROR("invalid device number.");
void sim_stdout (union param_val val, void *dat) {
strcpy(config.sim.fstdout, val.str_val);
}
 
void uart_newway () {
ERROR(" txfile and rxfile and now obsolete.\n\tUse 'channel = \"file:rxfile,txfile\"' instead.");
exit(1);
void sim_spr_log (union param_val val, void *dat) {
config.sim.spr_log = val.int_val;
}
 
void uart_vapi_id () {
if (current_device >= 0 && current_device < config.nuarts)
config.uarts[current_device].vapi_id = tempUL;
else
ERROR("invalid device number.");
void sim_spr_log_fn (union param_val val, void *dat) {
strcpy(config.sim.spr_log_fn, val.str_val);
}
 
void dma_ndmas () {
if (tempL >= 0 && tempL < MAX_DMAS)
config.ndmas = tempL;
else
ERROR("invalid number of devices.");
}
void reg_sim_sec (void) {
struct config_section *sec = reg_config_sec("sim", NULL, NULL);
 
void dma_baseaddr () {
if (current_device >= 0 && current_device < config.ndmas)
config.dmas[current_device].baseaddr = tempUL;
else
ERROR("invalid device number.");
reg_config_param(sec, "debug", paramt_int, sim_debug);
reg_config_param(sec, "verbose", paramt_int, sim_verbose);
reg_config_param(sec, "profile", paramt_int, sim_profile);
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_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_int, sim_exe_log_start);
reg_config_param(sec, "exe_log_end", paramt_int, sim_exe_log_end);
reg_config_param(sec, "exe_log_marker", paramt_int, sim_exe_log_marker);
reg_config_param(sec, "exe_log_fn", paramt_str, sim_exe_log_fn);
reg_config_param(sec, "spr_log", paramt_int, sim_spr_log);
reg_config_param(sec, "spr_log_fn", paramt_str, sim_spr_log_fn);
reg_config_param(sec, "clkcycle", paramt_word, sim_clkcycle);
reg_config_param(sec, "stdout", paramt_str, sim_stdout);
}
 
void dma_irq () {
if (current_device >= 0 && current_device < config.ndmas)
config.dmas[current_device].irq = tempL;
else
ERROR("invalid device number.");
/*-------------------------------------------------[ Memory configuration ]---*/
void memory_random_seed(union param_val val, void *dat) {
config.memory.random_seed = val.int_val;
}
 
void dma_vapi_id () {
if (current_device >= 0 && current_device < config.ndmas)
config.dmas[current_device].vapi_id = tempUL;
else
ERROR("invalid device number.");
void memory_pattern(union param_val val, void *dat) {
config.memory.pattern = val.int_val;
}
 
void memory_nmemories () {
if (tempL >= 0 && tempL < MAX_MEMORIES)
config.memory.nmemories = tempL;
void memory_nmemories (union param_val val, void *dat) {
if (val.int_val >= 0 && val.int_val < MAX_MEMORIES)
config.memory.nmemories = val.int_val;
else
ERROR("invalid number of devices.");
CONFIG_ERROR("invalid number of devices.");
}
 
void memory_type () {
if (strcmp (tempS, "unknown") == 0)
void memory_type (union param_val val, void *dat) {
if (strcmp (val.str_val, "unknown") == 0)
config.memory.type = MT_UNKNOWN;
else if (strcmp (tempS, "random") == 0)
else if (strcmp (val.str_val, "random") == 0)
config.memory.type = MT_RANDOM;
else if (strcmp (tempS, "pattern") == 0)
else if (strcmp (val.str_val, "pattern") == 0)
config.memory.type = MT_PATTERN;
else if (strcmp (tempS, "zero") == 0) {
else if (strcmp (val.str_val, "zero") == 0) {
config.memory.type = MT_PATTERN;
config.memory.pattern = 0;
} else {
char tmp[200];
sprintf (tmp, "invalid memory type '%s'.\n", tempS);
ERROR(tmp);
sprintf (tmp, "invalid memory type '%s'.\n", val.str_val);
CONFIG_ERROR(tmp);
}
}
 
void memory_ce () {
void memory_ce (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
config.memory.table[current_device].ce = tempL;
config.memory.table[current_device].ce = val.int_val;
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void memory_baseaddr () {
void memory_baseaddr (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
config.memory.table[current_device].baseaddr = tempUL;
config.memory.table[current_device].baseaddr = val.addr_val;
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void memory_size () {
void memory_size (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
config.memory.table[current_device].size = tempUL;
config.memory.table[current_device].size = val.int_val;
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void memory_name () {
void memory_name (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
strcpy (config.memory.table[current_device].name, tempS);
strcpy (config.memory.table[current_device].name, val.str_val);
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void memory_log () {
void memory_log (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
strcpy (config.memory.table[current_device].log, tempS);
strcpy (config.memory.table[current_device].log, val.str_val);
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void memory_delayr () {
void memory_delayr (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
config.memory.table[current_device].delayr = tempL;
config.memory.table[current_device].delayr = val.int_val;
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void memory_delayw () {
void memory_delayw (union param_val val, void *dat) {
if (current_device >= 0 && current_device < config.memory.nmemories)
config.memory.table[current_device].delayw = tempL;
config.memory.table[current_device].delayw = val.int_val;
else
ERROR("invalid device number.");
CONFIG_ERROR("invalid device number.");
}
 
void cpu_sbuf_len () {
if (config.cpu.sbuf_len >= MAX_SBUF_LEN) {
config.cpu.sbuf_len = MAX_SBUF_LEN - 1;
WARNING("sbuf_len too large; truncated.");
} else if (config.cpu.sbuf_len < 0) {
config.cpu.sbuf_len = 0;
WARNING("sbuf_len negative; disabled.");
}
}
void reg_memory_sec(void) {
struct config_section *sec = reg_config_sec("memory", NULL, NULL);
 
void eth_nethernets () {
if (tempL >= 0 && tempL < MAX_ETHERNETS)
config.nethernets = tempL;
else
ERROR("invalid number of devices.");
reg_config_param(sec, "random_seed", paramt_int, memory_random_seed);
reg_config_param(sec, "pattern", paramt_int, memory_pattern);
reg_config_param(sec, "type", paramt_word, memory_type);
reg_config_param(sec, "nmemories", paramt_int, memory_nmemories);
reg_config_param(sec, "device", paramt_int, change_device);
reg_config_param(sec, "enddevice", paramt_none, end_device);
reg_config_param(sec, "ce", paramt_int, memory_ce);
reg_config_param(sec, "baseaddr", paramt_addr, memory_baseaddr);
reg_config_param(sec, "size", paramt_int, memory_size);
reg_config_param(sec, "name", paramt_str, memory_name);
reg_config_param(sec, "log", paramt_str, memory_log);
reg_config_param(sec, "delayr", paramt_int, memory_delayr);
reg_config_param(sec, "delayw", paramt_int, memory_delayw);
}
 
void eth_baseaddr () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].baseaddr = tempUL;
else
ERROR("invalid device number.");
/*----------------------------------------------------[ CPU configuration ]---*/
void cpu_ver (union param_val val, void *dat) {
config.cpu.ver = val.int_val;
}
 
void eth_dma () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].dma = tempL;
else
ERROR("invalid device number.");
void cpu_rev (union param_val val, void *dat) {
config.cpu.rev = val.int_val;
}
 
void eth_rtx_type () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].rtx_type = tempUL;
else
ERROR("invalid device number.");
void cpu_upr (union param_val val, void *dat) {
config.cpu.upr = val.int_val;
}
 
void eth_rx_channel () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].rx_channel = tempL;
else
ERROR("invalid device number.");
void cpu_sr (union param_val val, void *dat) {
config.cpu.sr = val.int_val;
}
 
void eth_tx_channel () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].rx_channel = tempL;
else
ERROR("invalid device number.");
void cpu_hazards (union param_val val, void *dat) {
config.cpu.hazards = val.int_val;
}
 
void eth_rxfile () {
if (current_device >= 0 && current_device < config.nethernets)
strcpy (config.ethernets[current_device].rxfile, tempS);
else
ERROR("invalid device number.");
void cpu_superscalar (union param_val val, void *dat) {
config.cpu.superscalar = val.int_val;
}
 
void eth_txfile () {
if (current_device >= 0 && current_device < config.nethernets)
strcpy (config.ethernets[current_device].txfile, tempS);
else
ERROR("invalid device number.");
void cpu_dependstats (union param_val val, void *dat) {
config.cpu.dependstats = val.int_val;
}
 
void eth_sockif () {
if (current_device >= 0 && current_device < config.nethernets)
strcpy (config.ethernets[current_device].sockif, tempS);
else
ERROR("invalid device number.");
void cpu_sbuf_len (union param_val val, void *dat) {
if (val.int_val >= MAX_SBUF_LEN) {
config.cpu.sbuf_len = MAX_SBUF_LEN - 1;
WARNING("sbuf_len too large; truncated.");
} else if (val.int_val < 0) {
config.cpu.sbuf_len = 0;
WARNING("sbuf_len negative; disabled.");
} else
config.cpu.sbuf_len = val.int_val;
}
 
void eth_irq () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].irq = tempUL;
else
ERROR("invalid device number.");
}
void reg_cpu_sec(void)
{
struct config_section *sec = reg_config_sec("cpu", NULL, NULL);
 
void eth_vapi_id () {
if (current_device >= 0 && current_device < config.nethernets)
config.ethernets[current_device].base_vapi_id = tempUL;
else
ERROR("invalid device number.");
reg_config_param(sec, "ver", paramt_int, cpu_ver);
reg_config_param(sec, "rev", paramt_int, cpu_rev);
reg_config_param(sec, "upr", paramt_int, cpu_upr);
reg_config_param(sec, "sr", paramt_int, cpu_sr);
reg_config_param(sec, "hazards", paramt_int, cpu_hazards);
reg_config_param(sec, "superscalar", paramt_int, cpu_superscalar);
reg_config_param(sec, "dependstats", paramt_int, cpu_dependstats);
reg_config_param(sec, "sbuf_len", paramt_int, cpu_sbuf_len);
}
 
void gpio_ngpios () {
if (tempL >= 0 && tempL < MAX_GPIOS)
config.ngpios = tempL;
else
ERROR("invalid number of devices.");
}
 
void gpio_baseaddr () {
if (current_device >= 0 && current_device < config.ngpios)
config.gpios[current_device].baseaddr = tempUL;
else
ERROR("invalid device number.");
}
 
void gpio_irq () {
if (current_device >= 0 && current_device < config.ngpios)
config.gpios[current_device].irq = tempL;
else
ERROR("invalid device number.");
}
 
void gpio_base_vapi_id () {
if (current_device >= 0 && current_device < config.ngpios)
config.gpios[current_device].base_vapi_id = tempUL;
else
ERROR("invalid device number.");
}
 
int is_power2 (int x) {
while (!(x & 1))
x >>= 1;
1016,287 → 611,126
return x == 1;
}
 
void immu_enabled () {
setsprbits (SPR_UPR, SPR_UPR_IMP, tempL & 1);
config.immu.enabled = tempL;
}
void reg_config_secs(void)
{
reg_config_param(reg_config_sec("base", NULL, NULL), "include", paramt_str,
base_include);
 
void dmmu_enabled () {
setsprbits (SPR_UPR, SPR_UPR_DMP, tempL & 1);
config.dmmu.enabled = tempL;
reg_sim_sec();
reg_cpu_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();
reg_test_sec();
}
 
void immu_nsets () {
if (is_power2(tempL) && tempL <= 256)
config.immu.nsets = tempL;
else
ERROR("value of power of two and lower or equal than 256 expected.");
}
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));
 
void dmmu_nsets () {
if (is_power2(tempL) && tempL <= 256)
config.dmmu.nsets = tempL;
else
ERROR("value of power of two and lower or equal than 256 expected.");
}
if(!new) {
fprintf(stderr, "Out-of-memory\n");
exit(1);
}
 
void immu_nways () {
if (tempL >= 1 && tempL <= 4)
config.immu.nways = tempL;
else
ERROR("value 1, 2, 3 or 4 expected.");
}
if(!(new->name = strdup(param))) {
fprintf(stderr, "Out-of-memory\n");
exit(1);
}
 
void dmmu_nways () {
if (tempL >= 1 && tempL <= 4)
config.dmmu.nways = tempL;
else
ERROR("value 1, 2, 3 or 4 expected.");
}
new->func = param_cb;
new->type = type;
 
void immu_pagesize () {
if (is_power2(tempL))
config.immu.pagesize = tempL;
else
ERROR("value of power of two expected.");
new->next = sec->params;
sec->params = new;
}
 
void dmmu_pagesize () {
if (is_power2(tempL))
config.dmmu.pagesize = tempL;
else
ERROR("value of power of two expected.");
}
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));
 
void immu_entrysize () {
if (is_power2(tempL))
config.immu.entrysize = tempL;
else
ERROR("value of power of two expected.");
}
if(!new) {
fprintf(stderr, "Out-of-memory\n");
exit(1);
}
 
void dmmu_entrysize () {
if (is_power2(tempL))
config.dmmu.entrysize = tempL;
else
ERROR("value of power of two expected.");
}
 
void immu_ustates () {
if (tempL >= 2 && tempL <= 4)
config.immu.ustates = tempL;
else
ERROR("invalid USTATE.");
}
 
void dmmu_ustates () {
if (tempL >= 2 && tempL <= 4)
config.dmmu.ustates = tempL;
else
ERROR("invalid USTATE.");
}
 
void ic_enabled () {
config.ic.enabled = tempL;
setsprbits (SPR_UPR, SPR_UPR_ICP, tempL & 1);
}
 
void ic_nsets () {
if (is_power2(tempL) && tempL <= MAX_IC_SETS)
config.ic.nsets = tempL;
else {
char tmp[200];
sprintf (tmp, "value of power of two and lower or equal than %i expected.", MAX_IC_SETS);
ERROR(tmp);
if(!(new->name = strdup(section))) {
fprintf(stderr, "Out-of-memory\n");
exit(1);
}
}
 
void ic_nways () {
if (tempL >= 1 && tempL <= MAX_IC_WAYS)
config.ic.nways = tempL;
else
ERROR("value 1, 2, 3 or 4 expected.");
}
new->next = sections;
new->sec_start = sec_start;
new->sec_end = sec_end;
new->params = NULL;
 
void ic_blocksize () {
if (is_power2(tempL))
config.ic.blocksize = tempL;
else
ERROR("value of power of two expected.");
}
sections = new;
 
void ic_ustates () {
if (tempL >= 2 && tempL <= 4)
config.ic.ustates = tempL;
else
ERROR("invalid USTATE.");
return new;
}
 
void dc_enabled () {
config.dc.enabled = tempL;
setsprbits (SPR_UPR, SPR_UPR_DCP, tempL & 1);
}
static void switch_param(char *param, struct config_param *cur_param)
{
char *end_p;
union param_val val;
 
void dc_nsets () {
if (is_power2(tempL) && tempL <= MAX_DC_SETS)
config.dc.nsets = tempL;
else {
char tmp[200];
sprintf (tmp, "value of power of two and lower or equal than %i expected.", MAX_DC_SETS);
ERROR(tmp);
/* Skip over an = sign if it exists */
if(*param == '=') {
param++;
while(*param && isspace(*param)) param++;
}
}
 
void dc_nways () {
if (tempL >= 1 && tempL <= MAX_IC_WAYS)
config.dc.nways = tempL;
else
ERROR("value 1, 2, 3 or 4 expected.");
}
switch (cur_param->type) {
case paramt_int:
val.int_val = strtol(param, NULL, 0);
case paramt_addr:
val.addr_val = strtoul(param, NULL, 0);
break;
case paramt_str:
if(*param != '"') {
CONFIG_ERROR("String value expected\n");
return;
}
 
void dc_blocksize () {
if (is_power2(tempL))
config.dc.blocksize = tempL;
else
ERROR("value of power of two expected.");
}
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;
}
 
void dc_ustates () {
if (tempL >= 2 && tempL <= 4)
config.dc.ustates = tempL;
else
ERROR("invalid USTATE.");
cur_param->func(val, cur_section->dat);
}
 
void vga_nvgas () {
if (tempL >= 0 && tempL < MAX_VGAS)
config.nvgas = tempL;
else
ERROR("invalid number of devices.");
}
 
void vga_baseaddr () {
if (current_device >= 0 && current_device < config.nvgas)
config.vgas[current_device].baseaddr = tempUL;
else
ERROR("invalid device number.");
}
 
void vga_irq () {
if (current_device >= 0 && current_device < config.nvgas)
config.vgas[current_device].irq = tempL;
else
ERROR("invalid device number.");
}
 
void vga_refresh_rate () {
if (current_device >= 0 && current_device < config.nvgas)
config.vgas[current_device].refresh_rate = tempUL;
else
ERROR("invalid device number.");
}
 
void vga_filename () {
if (current_device >= 0 && current_device < config.nvgas)
strcpy (config.vgas[current_device].filename, tempS);
else
ERROR("invalid device number.");
}
 
 
void ata_natas () {
if (tempL >= 0 && tempL < MAX_ATAS)
config.natas = tempL;
else
ERROR("invalid number of devices.");
}
 
void ata_baseaddr () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].baseaddr = tempUL;
else
ERROR("invalid device number.");
}
 
void ata_irq () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].irq = tempL;
else
ERROR("invalid device number.");
}
 
void ata_dev_type0 () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_type0 = tempL;
else
ERROR("invalid device number.");
}
 
void ata_dev_file0 () {
if (current_device >= 0 && current_device < config.natas)
strcpy (config.atas[current_device].dev_file0, tempS);
else
ERROR("invalid device number.");
}
 
void ata_dev_size0 () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_size0 = tempUL;
else
ERROR("invalid device number.");
}
 
void ata_dev_packet0 () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_packet0 = tempL;
else
ERROR("invalid device number.");
}
 
void ata_dev_type1 () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_type1 = tempL;
else
ERROR("invalid device number.");
}
 
void ata_dev_file1 () {
if (current_device >= 0 && current_device < config.natas)
strcpy (config.atas[current_device].dev_file1, tempS);
else
ERROR("invalid device number.");
}
 
void ata_dev_size1 () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_size1 = tempUL;
else
ERROR("invalid device number.");
}
 
void ata_dev_packet1 () {
if (current_device >= 0 && current_device < config.natas)
config.atas[current_device].dev_packet1 = tempL;
else
ERROR("invalid device number.");
}
 
void cuc_memory_order () {
if (strcmp (tempS, "none") == 0)
config.cuc.memory_order = MO_NONE;
else if (strcmp (tempS, "weak") == 0)
config.cuc.memory_order = MO_WEAK;
else if (strcmp (tempS, "strong") == 0)
config.cuc.memory_order = MO_STRONG;
else if (strcmp (tempS, "exact") == 0) {
config.cuc.memory_order = MO_EXACT;
} else {
char tmp[200];
sprintf (tmp, "invalid memory order '%s'.\n", tempS);
ERROR(tmp);
}
}
 
/* Read environment from a script file. Does not fail - assumes default configuration instead.
The syntax of script file is:
param = value
1320,7 → 754,7
char *home = getenv("HOME");
char ctmp[STR_SIZE];
int local = 1;
section = 0;
cur_section = NULL;
sprintf(ctmp, "%s/.or1k/%s", home, filename);
if ((f = fopen (filename, "rt")) != NULL
1332,28 → 766,32
while (!feof(f)) {
char param[STR_SIZE];
if (fscanf(f, "%s ", param) != 1) break;
/* Is this a sections? */
/* Is this a section? */
if (strcmp (param, "section") == 0) {
int i;
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);
}
for (i = 1; i < sizeof(sections) / sizeof(struct section); i++)
if (strcmp (sections[i].name, param) == 0) {
section = i;
for (cur = sections; cur; cur = cur->next)
if (strcmp (cur->name, param) == 0) {
cur_section = cur;
break;
}
if (!section) {
char tmp[200];
sprintf (tmp, "Unknown section: %s; ignoring.", param);
WARNING(tmp);
if (!cur) {
fprintf (stderr, "WARNING: config: Unknown section: %s; ignoring.", 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) {
section = 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 != '/') {
1365,13 → 803,13
}
}
} else {
int i, found = -1;
for (i = 0; i < sizeof(config_params)/sizeof(struct config_params); i++)
if (config_params[i].section == section && strcmp (config_params[i].name, param) == 0) {
found = i;
struct config_param *cur_param;
char *cur_p;
for (cur_param = cur_section->params; cur_param; cur_param = cur_param->next)
if (strcmp (cur_param->name, param) == 0) {
break;
}
if (found < 0) {
if (!cur_param) {
char tmp[200];
sprintf (tmp, "Invalid parameter: %s; ignoring.\n", param);
WARNING(tmp);
1379,14 → 817,15
continue;
}
 
if(cur_param->type == paramt_none)
continue;
 
/* Parse parameter value */
{
if (config_params[found].type[0])
if(fscanf_ex (f, config_params[found].type, config_params[found].addr, 0))
exit (1);
}
if (config_params[found].func)
config_params[found].func();
cur_p = fgets (param, STR_SIZE, f);
 
while(*cur_p && isspace(*cur_p)) cur_p++;
 
switch_param(cur_p, cur_param);
}
}
fclose (f);
1399,41 → 838,38
/* Utility for execution of set sim command. */
static int set_config (int argc, char **argv)
{
int i;
struct config_section *cur;
struct config_param *cur_param;
 
if (argc < 2) return 1;
 
PRINTF ("sec:%s\n", argv[1]);
section = 0;
for (i = 1; i < sizeof(sections) / sizeof(struct section); i++)
if (strcmp (sections[i].name, argv[1]) == 0) {
section = i;
cur_section = NULL;
for (cur = sections; cur; cur = cur->next)
if (strcmp (cur->name, argv[1]) == 0) {
cur_section = cur;
break;
}
 
if (!section) return 1;
if (!cur_section) return 1;
 
if (argc < 3) return 2;
PRINTF ("item:%s\n", argv[2]);
{
int found = -1;
for (i = 0; i < sizeof(config_params)/sizeof(struct config_params); i++)
if (config_params[i].section == section && strcmp (config_params[i].name, argv[2]) == 0) {
found = i;
for (cur_param = cur->params; cur_param; cur_param = cur_param->next)
if (strcmp (cur_param->name, argv[2]) == 0) {
break;
}
if (found < 0) return 2;
if (!cur_param) return 2;
/* Parse parameter value */
if (config_params[found].type[0]) {
if (cur_param->type) {
if (argc < 4) return 3;
if (fscanf_ex (0, config_params[found].type, config_params[found].addr, argv[3]))
return 3;
PRINTF ("params:%s\n", argv[3]);
}
if (config_params[found].func)
config_params[found].func();
 
switch_param(argv[3], cur_param);
}
return 0;
}
1441,20 → 877,20
/* Executes set sim command, displays error. */
void set_config_command(int argc, char **argv)
{
int i;
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 (i = 1; i < sizeof(sections) / sizeof(struct section); i++)
PRINTF ("%s ", sections[i].name);
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 (i = 0; i < sizeof(config_params)/sizeof(struct config_params); i++)
if (config_params[i].section == section)
PRINTF ("%s ", config_params[i].name);
for (cur_param = cur_section->params; cur_param; cur_param = cur_param->next)
PRINTF ("%s ", cur_param->name);
PRINTF ("\n");
break;
case 3:
/trunk/or1ksim/support/sched.c
28,7 → 28,6
#include <limits.h>
 
#include "config.h"
#include "sim-config.h"
#include "sched.h"
 
struct scheduler_struct scheduler;
/trunk/or1ksim/support/dumpverilog.c
31,8 → 31,8
#endif
 
#include "port.h"
#include "arch.h"
#include "sim-config.h"
#include "arch.h"
#include "parse.h"
#include "abstract.h"
#include "opcode/or32.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.