| Line 1... |
Line 1... |
/* abstract.c -- Abstract entities
|
/* abstract.c -- Abstract entities
|
Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
|
Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
|
|
Copyright (C) 2005 György `nog' Jeney, nog@sdf.lonestar.org
|
|
|
This file is part of OpenRISC 1000 Architectural Simulator.
|
This file is part of OpenRISC 1000 Architectural Simulator.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
| Line 65... |
Line 66... |
|
|
/* Temporary variable to increase speed. */
|
/* Temporary variable to increase speed. */
|
struct dev_memarea *cur_area;
|
struct dev_memarea *cur_area;
|
|
|
/* Pointer to memory controller device descriptor. */
|
/* Pointer to memory controller device descriptor. */
|
struct dev_memarea *mc_area = (struct dev_memarea *)0;
|
struct dev_memarea *mc_area = NULL;
|
|
|
/* These are set by mmu if cache inhibit bit is set for current acces. */
|
/* These are set by mmu if cache inhibit bit is set for current acces. */
|
int data_ci, insn_ci;
|
int data_ci, insn_ci;
|
|
|
/* Virtual address of current access. */
|
/* Virtual address of current access. */
|
oraddr_t cur_vadd;
|
static oraddr_t cur_vadd;
|
|
|
|
/* Read functions */
|
|
uint32_t eval_mem_32_inv(oraddr_t, void *);
|
|
uint16_t eval_mem_16_inv(oraddr_t, void *);
|
|
uint8_t eval_mem_8_inv(oraddr_t, void *);
|
|
uint32_t eval_mem_32_inv_direct(oraddr_t, void *);
|
|
uint16_t eval_mem_16_inv_direct(oraddr_t, void *);
|
|
uint8_t eval_mem_8_inv_direct(oraddr_t, void *);
|
|
|
|
/* Write functions */
|
|
void set_mem_32_inv(oraddr_t, uint32_t, void *);
|
|
void set_mem_16_inv(oraddr_t, uint16_t, void *);
|
|
void set_mem_8_inv(oraddr_t, uint8_t, void *);
|
|
void set_mem_32_inv_direct(oraddr_t, uint32_t, void *);
|
|
void set_mem_16_inv_direct(oraddr_t, uint16_t, void *);
|
|
void set_mem_8_inv_direct(oraddr_t, uint8_t, void *);
|
|
|
/* Calculates bit mask to fit the data */
|
/* Calculates bit mask to fit the data */
|
unsigned int bit_mask (uint32_t data) {
|
static unsigned int bit_mask (uint32_t data) {
|
int i = 0;
|
int i = 0;
|
data--;
|
data--;
|
while (data >> i)
|
while (data >> i)
|
data |= 1 << i++;
|
data |= 1 << i++;
|
return data;
|
return data;
|
}
|
}
|
|
|
/* Register read and write function for a memory area.
|
/* Register read and write function for a memory area.
|
addr is inside the area, if addr & addr_mask == addr_compare
|
addr is inside the area, if addr & addr_mask == addr_compare
|
(used also by peripheral devices like 16450 UART etc.) */
|
(used also by peripheral devices like 16450 UART etc.) */
|
void register_memoryarea_mask(oraddr_t addr_mask, oraddr_t addr_compare,
|
struct dev_memarea *register_memoryarea_mask(oraddr_t addr_mask,
|
uint32_t size, unsigned granularity, unsigned mc_dev,
|
oraddr_t addr_compare,
|
uint32_t (readfunc)(oraddr_t, void *),
|
uint32_t size, unsigned mc_dev)
|
void (writefunc)(oraddr_t, uint32_t, void *),
|
|
void *dat)
|
|
{
|
{
|
struct dev_memarea **pptmp;
|
struct dev_memarea **pptmp;
|
unsigned int size_mask = bit_mask (size);
|
unsigned int size_mask = bit_mask (size);
|
int found_error = 0;
|
int found_error = 0;
|
addr_compare &= addr_mask;
|
addr_compare &= addr_mask;
|
|
|
debug(5, "addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %08"PRIx32", gran %iB\n",
|
debug(5, "addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %08"PRIx32"\n",
|
addr_mask, addr_compare, addr_compare | bit_mask (size), size,
|
addr_mask, addr_compare, addr_compare | bit_mask (size), size);
|
granularity);
|
|
/* Go to the end of the list. */
|
/* Go to the end of the list. */
|
for(pptmp = &dev_list; *pptmp; pptmp = &(*pptmp)->next)
|
for(pptmp = &dev_list; *pptmp; pptmp = &(*pptmp)->next)
|
if ((addr_compare >= (*pptmp)->addr_compare) && (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)
|
if ((addr_compare >= (*pptmp)->addr_compare) && (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)
|
|| (addr_compare + size > (*pptmp)->addr_compare) && (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)) {
|
|| (addr_compare + size > (*pptmp)->addr_compare) && (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)) {
|
if (!found_error) {
|
if (!found_error) {
|
fprintf (stderr, "ERROR: Overlapping memory area(s):\n");
|
fprintf (stderr, "ERROR: Overlapping memory area(s):\n");
|
fprintf (stderr, "\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR
|
fprintf (stderr, "\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR
|
", size %08"PRIx32", gran %iB\n",
|
", size %08"PRIx32"\n",
|
addr_mask, addr_compare, addr_compare | bit_mask (size), size,
|
addr_mask, addr_compare, addr_compare | bit_mask (size), size);
|
granularity);
|
|
}
|
}
|
found_error = 1;
|
found_error = 1;
|
fprintf (stderr, "and\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR
|
fprintf (stderr, "and\taddr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR
|
", size %08"PRIx32", gran %iB\n",
|
", size %08"PRIx32"\n",
|
(*pptmp)->addr_mask, (*pptmp)->addr_compare,
|
(*pptmp)->addr_mask, (*pptmp)->addr_compare,
|
(*pptmp)->addr_compare | (*pptmp)->size_mask,
|
(*pptmp)->addr_compare | (*pptmp)->size_mask, (*pptmp)->size);
|
(*pptmp)->size, (*pptmp)->granularity);
|
|
}
|
}
|
|
|
if (found_error)
|
if (found_error)
|
exit (-1);
|
exit (-1);
|
|
|
| Line 130... |
Line 142... |
|
|
(*pptmp)->addr_mask = addr_mask;
|
(*pptmp)->addr_mask = addr_mask;
|
(*pptmp)->addr_compare = addr_compare;
|
(*pptmp)->addr_compare = addr_compare;
|
(*pptmp)->size = size;
|
(*pptmp)->size = size;
|
(*pptmp)->size_mask = size_mask;
|
(*pptmp)->size_mask = size_mask;
|
(*pptmp)->granularity = granularity;
|
(*pptmp)->log = NULL;
|
(*pptmp)->readfunc = readfunc;
|
(*pptmp)->valid = 1;
|
(*pptmp)->writefunc = writefunc;
|
|
(*pptmp)->log = 0;
|
|
(*pptmp)->delayr = 2;
|
|
(*pptmp)->delayw = 2;
|
|
(*pptmp)->priv_dat = dat;
|
|
(*pptmp)->chip_select = -1;
|
|
(*pptmp)->next = NULL;
|
(*pptmp)->next = NULL;
|
|
|
|
return *pptmp;
|
}
|
}
|
|
|
/* Register read and write function for a memory area.
|
/* Register read and write function for a memory area.
|
Memory areas should be aligned. Memory area is rounded up to
|
Memory areas should be aligned. Memory area is rounded up to
|
fit the nearest 2^n aligment.
|
fit the nearest 2^n aligment.
|
(used also by peripheral devices like 16450 UART etc.)
|
(used also by peripheral devices like 16450 UART etc.)
|
If mc_dev is 1, this means that this device will be checked first for match
|
If mc_dev is 1, this device will be checked first for a match
|
and will be accessed in case of overlaping memory spaces.
|
and will be accessed in case of overlaping memory areas.
|
Only one device can have this set to 1 (used for memory controller) */
|
Only one device can have this set to 1 (used for memory controller) */
|
void register_memoryarea(oraddr_t addr, uint32_t size, unsigned granularity,
|
struct dev_memarea *reg_mem_area(oraddr_t addr, uint32_t size, unsigned mc_dev,
|
unsigned mc_dev,
|
struct mem_ops *ops)
|
uint32_t (readfunc)(oraddr_t, void *),
|
|
void (writefunc)(oraddr_t, uint32_t, void *),
|
|
void *dat)
|
|
{
|
{
|
unsigned int size_mask = bit_mask (size);
|
unsigned int size_mask = bit_mask (size);
|
unsigned int addr_mask = ~size_mask;
|
unsigned int addr_mask = ~size_mask;
|
register_memoryarea_mask (addr_mask, addr & addr_mask,
|
struct dev_memarea *mem;
|
size_mask + 1, granularity, mc_dev,
|
|
readfunc, writefunc, dat);
|
mem = register_memoryarea_mask(addr_mask, addr & addr_mask, size_mask + 1,
|
|
mc_dev);
|
|
|
|
memcpy(&mem->ops, ops, sizeof(struct mem_ops));
|
|
memcpy(&mem->direct_ops, ops, sizeof(struct mem_ops));
|
|
|
|
if(!ops->readfunc32) {
|
|
mem->ops.readfunc32 = eval_mem_32_inv;
|
|
mem->direct_ops.readfunc32 = eval_mem_32_inv_direct;
|
|
mem->direct_ops.read_dat32 = mem;
|
|
}
|
|
if(!ops->readfunc16) {
|
|
mem->ops.readfunc16 = eval_mem_16_inv;
|
|
mem->direct_ops.readfunc16 = eval_mem_16_inv_direct;
|
|
mem->direct_ops.read_dat16 = mem;
|
|
}
|
|
if(!ops->readfunc8) {
|
|
mem->ops.readfunc8 = eval_mem_8_inv;
|
|
mem->direct_ops.readfunc8 = eval_mem_8_inv_direct;
|
|
mem->direct_ops.read_dat8 = mem;
|
|
}
|
|
|
|
if(!ops->writefunc32) {
|
|
mem->ops.writefunc32 = set_mem_32_inv;
|
|
mem->direct_ops.writefunc32 = set_mem_32_inv_direct;
|
|
mem->direct_ops.write_dat32 = mem;
|
|
}
|
|
if(!ops->writefunc16) {
|
|
mem->ops.writefunc16 = set_mem_16_inv;
|
|
mem->direct_ops.writefunc16 = set_mem_16_inv_direct;
|
|
mem->direct_ops.write_dat16 = mem;
|
|
}
|
|
if(!ops->writefunc8) {
|
|
mem->ops.writefunc8 = set_mem_8_inv;
|
|
mem->direct_ops.writefunc8 = set_mem_8_inv_direct;
|
|
mem->direct_ops.write_dat8 = mem;
|
|
}
|
|
|
|
if(!ops->writeprog) {
|
|
mem->ops.writeprog = mem->ops.writefunc32;
|
|
mem->ops.writeprog_dat = mem->ops.write_dat32;
|
|
}
|
|
|
|
if(ops->log) {
|
|
if(!(mem->log = fopen(ops->log, "w")))
|
|
PRINTF("ERR: Unable to open %s to log memory acesses to\n", ops->log);
|
}
|
}
|
|
|
|
return mem;
|
|
}
|
|
|
/* Check if access is to registered area of memory. */
|
/* Check if access is to registered area of memory. */
|
inline struct dev_memarea *verify_memoryarea(oraddr_t addr)
|
inline struct dev_memarea *verify_memoryarea(oraddr_t addr)
|
{
|
{
|
struct dev_memarea *ptmp;
|
struct dev_memarea *ptmp;
|
| Line 183... |
Line 235... |
if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)
|
if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)
|
return cur_area = ptmp;
|
return cur_area = ptmp;
|
return cur_area = NULL;
|
return cur_area = NULL;
|
}
|
}
|
|
|
/* Finds the memory area for the address and adjust the read and write delays for it. */
|
/* Sets the valid bit (Used only by memory controllers) */
|
void adjust_rw_delay(oraddr_t memaddr, unsigned int delayr, unsigned int delayw)
|
void set_mem_valid(struct dev_memarea *mem, int valid)
|
{
|
{
|
if (verify_memoryarea(memaddr)) {
|
mem->valid = valid;
|
cur_area->delayr = delayr;
|
|
cur_area->delayw = delayw;
|
|
}
|
}
|
|
|
|
/* Adjusts the read and write delays for the memory area pointed to by mem. */
|
|
void adjust_rw_delay(struct dev_memarea *mem, int delayr, int delayw)
|
|
{
|
|
mem->ops.delayr = delayr;
|
|
mem->ops.delayw = delayw;
|
}
|
}
|
|
|
/* for cpu accesses
|
uint8_t eval_mem_8_inv(oraddr_t memaddr, void *dat)
|
*
|
|
* STATISTICS: check cpu/common/parse.c
|
|
*/
|
|
inline uint32_t evalsim_mem32(oraddr_t memaddr)
|
|
{
|
{
|
return(evalsim_mem32_atomic(memaddr, 1));
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
return 0;
|
}
|
}
|
|
|
/* for simulator accesses, the ones that cpu wouldn't do */
|
uint16_t eval_mem_16_inv(oraddr_t memaddr, void *dat)
|
inline uint32_t evalsim_mem32_void(oraddr_t memaddr)
|
|
{
|
{
|
return(evalsim_mem32_atomic(memaddr, 0));
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
return 0;
|
}
|
}
|
|
|
uint32_t evalsim_mem32_atomic(oraddr_t memaddr, int cpu_access)
|
uint32_t eval_mem_32_inv(oraddr_t memaddr, void *dat)
|
{
|
{
|
uint32_t temp = 0;
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
return 0;
|
|
}
|
|
|
if (verify_memoryarea(memaddr)) {
|
void set_mem_8_inv(oraddr_t memaddr, uint8_t val, void *dat)
|
switch(cur_area->granularity) {
|
{
|
case 4:
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
temp = cur_area->readfunc(memaddr, cur_area->priv_dat);
|
|
break;
|
|
case 1:
|
|
temp = cur_area->readfunc(memaddr, cur_area->priv_dat) << 24;
|
|
temp |= cur_area->readfunc(memaddr + 1, cur_area->priv_dat) << 16;
|
|
temp |= cur_area->readfunc(memaddr + 2, cur_area->priv_dat) << 8;
|
|
temp |= cur_area->readfunc(memaddr + 3, cur_area->priv_dat);
|
|
break;
|
|
case 2:
|
|
temp = cur_area->readfunc(memaddr, cur_area->priv_dat) << 16;
|
|
temp |= cur_area->readfunc(memaddr + 2, cur_area->priv_dat);
|
|
break;
|
|
default:
|
|
/* if you add new memory granularity be sure to check the formula
|
|
* below for the read delay and fix it if necessery
|
|
*/
|
|
PRINTF("unknown/unhandled memory granularuty\n");
|
|
exit(-1);
|
|
}
|
}
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayr * (4 / cur_area->granularity);
|
void set_mem_16_inv(oraddr_t memaddr, uint16_t val, void *dat)
|
|
{
|
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
}
|
}
|
return temp;
|
|
|
void set_mem_32_inv(oraddr_t memaddr, uint32_t val, void *dat)
|
|
{
|
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
}
|
}
|
|
|
/* for cpu accesses */
|
uint8_t eval_mem_8_inv_direct(oraddr_t memaddr, void *dat)
|
inline uint16_t evalsim_mem16(oraddr_t memaddr)
|
|
{
|
{
|
return(evalsim_mem16_atomic(memaddr, 1));
|
struct dev_memarea *mem = dat;
|
|
|
|
PRINTF("ERROR: Invalid 8-bit direct read from memory %"PRIxADDR"\n",
|
|
mem->addr_compare | memaddr);
|
|
return 0;
|
}
|
}
|
|
|
/* for simulator accesses, the ones that cpu wouldn't do */
|
uint16_t eval_mem_16_inv_direct(oraddr_t memaddr, void *dat)
|
inline uint16_t evalsim_mem16_void(oraddr_t memaddr)
|
|
{
|
{
|
return(evalsim_mem16_atomic(memaddr, 0));
|
struct dev_memarea *mem = dat;
|
}
|
|
|
PRINTF("ERROR: Invalid 16-bit direct read from memory %"PRIxADDR"\n",
|
uint16_t evalsim_mem16_atomic(oraddr_t memaddr, int cpu_access)
|
mem->addr_compare | memaddr);
|
{
|
return 0;
|
uint32_t temp = 0;
|
|
|
|
if (verify_memoryarea(memaddr)) {
|
|
switch(cur_area->granularity) {
|
|
case 1:
|
|
temp = cur_area->readfunc(memaddr, cur_area->priv_dat) << 8;
|
|
temp |= cur_area->readfunc(memaddr + 1, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayr * 2;
|
|
break;
|
|
case 2:
|
|
temp = cur_area->readfunc(memaddr, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayr;
|
|
break;
|
|
case 4:
|
|
temp = evalsim_mem32_atomic (memaddr & ~UINT32_C(3), cpu_access);
|
|
if (memaddr & 2)
|
|
temp &= 0xffff;
|
|
else
|
|
temp >>= 16;
|
|
break;
|
|
default:
|
|
/* if you add new memory granularity be sure to check the formula
|
|
* below for the read delay and fix it if necessery
|
|
*/
|
|
PRINTF("unknown/unhandled memory granularuty\n");
|
|
exit(-1);
|
|
}
|
}
|
|
|
|
uint32_t eval_mem_32_inv_direct(oraddr_t memaddr, void *dat)
|
|
{
|
|
struct dev_memarea *mem = dat;
|
|
|
|
PRINTF("ERROR: Invalid 32-bit direct read from memory %"PRIxADDR"\n",
|
|
mem->addr_compare | memaddr);
|
|
return 0;
|
}
|
}
|
return temp;
|
|
|
void set_mem_8_inv_direct(oraddr_t memaddr, uint8_t val, void *dat)
|
|
{
|
|
struct dev_memarea *mem = dat;
|
|
|
|
PRINTF("ERROR: Invalid 32-bit direct write to memory %"PRIxADDR"\n",
|
|
mem->addr_compare | memaddr);
|
}
|
}
|
|
|
/* for cpu accesses */
|
void set_mem_16_inv_direct(oraddr_t memaddr, uint16_t val, void *dat)
|
inline uint8_t evalsim_mem8(oraddr_t memaddr)
|
|
{
|
{
|
return(evalsim_mem8_atomic(memaddr, 1));
|
struct dev_memarea *mem = dat;
|
|
|
|
PRINTF("ERROR: Invalid 16-bit direct write to memory %"PRIxADDR"\n",
|
|
mem->addr_compare | memaddr);
|
}
|
}
|
|
|
/* for simulator accesses, the ones that cpu wouldn't do */
|
void set_mem_32_inv_direct(oraddr_t memaddr, uint32_t val, void *dat)
|
inline uint8_t evalsim_mem8_void(oraddr_t memaddr)
|
|
{
|
{
|
return(evalsim_mem8_atomic(memaddr, 0));
|
struct dev_memarea *mem = dat;
|
|
|
|
PRINTF("ERROR: Invalid 32-bit direct write to memory %"PRIxADDR"\n",
|
|
mem->addr_compare | memaddr);
|
}
|
}
|
|
|
uint8_t evalsim_mem8_atomic(oraddr_t memaddr, int cpu_access)
|
/* For cpu accesses
|
|
*
|
|
* NOTE: This function _is_ only called from eval_mem32 below and
|
|
* {i,d}c_simulate_read. _Don't_ call it from anywere else.
|
|
*/
|
|
inline uint32_t evalsim_mem32(oraddr_t memaddr, oraddr_t vaddr)
|
{
|
{
|
uint32_t temp = 0;
|
struct dev_memarea *mem;
|
|
|
if (verify_memoryarea(memaddr)) {
|
if((mem = verify_memoryarea(memaddr))) {
|
switch(cur_area->granularity) {
|
runtime.sim.mem_cycles += mem->ops.delayr;
|
case 1:
|
return mem->ops.readfunc32(memaddr & mem->size_mask, mem->ops.read_dat32);
|
temp = cur_area->readfunc(memaddr, cur_area->priv_dat);
|
} else {
|
if (cpu_access)
|
PRINTF("EXCEPTION: read out of memory (32-bit access to %"PRIxADDR")\n",
|
runtime.sim.mem_cycles += cur_area->delayr;
|
memaddr);
|
break;
|
except_handle(EXCEPT_BUSERR, vaddr);
|
case 2:
|
}
|
temp = evalsim_mem16_atomic (memaddr & ~ADDR_C(1), cpu_access);
|
|
if (memaddr & 1)
|
return 0;
|
temp &= 0xff;
|
}
|
else
|
|
temp >>= 8;
|
/* For cpu accesses
|
break;
|
*
|
case 4:
|
* NOTE: This function _is_ only called from eval_mem16 below and
|
temp = evalsim_mem32_atomic (memaddr & ~ADDR_C(3), cpu_access);
|
* {i,d}c_simulate_read. _Don't_ call it from anywere else.
|
temp >>= 8 * (3 - (memaddr & 3));
|
|
temp &= 0xff;
|
|
break;
|
|
default:
|
|
/* if you add new memory granularity be sure to check the formula
|
|
* below for the read delay and fix it if necessery
|
|
*/
|
*/
|
PRINTF("unknown/unhandled memory granularuty\n");
|
inline uint16_t evalsim_mem16(oraddr_t memaddr, oraddr_t vaddr)
|
exit(-1);
|
{
|
|
struct dev_memarea *mem;
|
|
|
|
if((mem = verify_memoryarea(memaddr))) {
|
|
runtime.sim.mem_cycles += mem->ops.delayr;
|
|
return mem->ops.readfunc16(memaddr & mem->size_mask, mem->ops.read_dat16);
|
|
} else {
|
|
PRINTF("EXCEPTION: read out of memory (16-bit access to %"PRIxADDR")\n",
|
|
memaddr);
|
|
except_handle(EXCEPT_BUSERR, vaddr);
|
}
|
}
|
|
|
|
return 0;
|
}
|
}
|
return temp;
|
|
|
/* For cpu accesses
|
|
*
|
|
* NOTE: This function _is_ only called from eval_mem8 below and
|
|
* {i,d}c_simulate_read. _Don't_ call it from anywere else.
|
|
*/
|
|
inline uint8_t evalsim_mem8(oraddr_t memaddr, oraddr_t vaddr)
|
|
{
|
|
struct dev_memarea *mem;
|
|
|
|
if((mem = verify_memoryarea(memaddr))) {
|
|
runtime.sim.mem_cycles += mem->ops.delayr;
|
|
return mem->ops.readfunc8(memaddr & mem->size_mask, mem->ops.read_dat8);
|
|
} else {
|
|
PRINTF("EXCEPTION: read out of memory (8-bit access to %"PRIxADDR")\n",
|
|
memaddr);
|
|
except_handle(EXCEPT_BUSERR, vaddr);
|
|
}
|
|
|
|
return 0;
|
}
|
}
|
|
|
/* Returns 32-bit values from mem array. Big endian version.
|
/* Returns 32-bit values from mem array. Big endian version.
|
*
|
*
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
*/
|
*/
|
uint32_t eval_mem32(oraddr_t memaddr,int* breakpoint)
|
uint32_t eval_mem32(oraddr_t memaddr,int* breakpoint)
|
{
|
{
|
uint32_t temp;
|
uint32_t temp;
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_32 | MPROF_READ);
|
mprofile (memaddr, MPROF_32 | MPROF_READ);
|
|
|
if (memaddr & 3) {
|
if (memaddr & 3) {
|
| Line 351... |
Line 415... |
}
|
}
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = dmmu_translate(memaddr, 0);
|
|
|
memaddr = dmmu_translate(memaddr, 0);
|
|
if (except_pending)
|
if (except_pending)
|
return 0;
|
return 0;
|
|
|
if (config.dc.enabled)
|
if (config.dc.enabled)
|
temp = dc_simulate_read(memaddr, 4);
|
temp = dc_simulate_read(phys_memaddr, memaddr, 4);
|
else {
|
else
|
temp = evalsim_mem32(memaddr);
|
temp = evalsim_mem32(phys_memaddr, memaddr);
|
if (!cur_area) {
|
|
PRINTF("EXCEPTION: read out of memory (32-bit access to %"PRIxADDR")\n",
|
|
memaddr);
|
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
temp = 0;
|
|
}
|
|
}
|
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp); /* MM170901 */
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp); /* MM170901 */
|
|
|
return temp;
|
return temp;
|
}
|
}
|
|
|
/* for simulator accesses, the ones that cpu wouldn't do
|
/* for simulator accesses, the ones that cpu wouldn't do
|
*
|
*
|
* STATISTICS OK
|
* STATISTICS OK
|
*/
|
*/
|
uint32_t eval_direct32(oraddr_t memaddr, int *breakpoint, int through_mmu,
|
uint32_t eval_direct32(oraddr_t memaddr, int *breakpoint, int through_mmu,
|
int through_dc)
|
int through_dc)
|
{
|
{
|
uint32_t temp;
|
oraddr_t phys_memaddr;
|
|
struct dev_memarea *mem;
|
|
|
if (memaddr & 3) {
|
if (memaddr & 3) {
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
if (through_mmu)
|
if (through_mmu)
|
memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
|
|
if (through_dc)
|
if (through_dc)
|
temp = dc_simulate_read(memaddr, 4);
|
return dc_simulate_read(phys_memaddr, memaddr, 4);
|
else {
|
else {
|
temp = evalsim_mem32_void(memaddr);
|
if((mem = verify_memoryarea(phys_memaddr)))
|
if (!cur_area) {
|
return mem->direct_ops.readfunc32(phys_memaddr & mem->size_mask,
|
PRINTF("EXCEPTION: read out of memory (32-bit access to %"PRIxADDR
|
mem->direct_ops.read_dat32);
|
") in eval_direct32()\n", memaddr);
|
else
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
PRINTF("ERR: 32-bit read out of memory area: %"PRIxADDR" (physical: %"
|
temp = 0;
|
PRIxADDR"\n", memaddr, phys_memaddr);
|
}
|
|
}
|
}
|
|
|
return temp;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Returns 32-bit values from mem array. Big endian version.
|
/* Returns 32-bit values from mem array. Big endian version.
|
*
|
*
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
*/
|
*/
|
uint32_t eval_insn(oraddr_t memaddr, int* breakpoint)
|
uint32_t eval_insn(oraddr_t memaddr, int* breakpoint)
|
{
|
{
|
uint32_t temp;
|
uint32_t temp;
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_32 | MPROF_FETCH);
|
mprofile (memaddr, MPROF_32 | MPROF_FETCH);
|
// memaddr = simulate_ic_mmu_fetch(memaddr);
|
// memaddr = simulate_ic_mmu_fetch(memaddr);
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
#if !(DYNAMIC_EXECUTION)
|
#if !(DYNAMIC_EXECUTION)
|
memaddr = immu_translate(memaddr);
|
phys_memaddr = immu_translate(memaddr);
|
|
|
if (except_pending)
|
if (except_pending)
|
return 0;
|
return 0;
|
#endif
|
#endif
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);
|
|
|
if (config.ic.enabled)
|
if (config.ic.enabled)
|
temp = ic_simulate_fetch(memaddr);
|
temp = ic_simulate_fetch(phys_memaddr, memaddr);
|
else {
|
else
|
temp = evalsim_mem32(memaddr);
|
temp = evalsim_mem32(phys_memaddr, memaddr);
|
if (!cur_area) {
|
|
PRINTF("EXCEPTION: read out of memory (32-bit access to %"PRIxADDR")\n",
|
|
memaddr);
|
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
temp = 0;
|
|
}
|
|
}
|
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp);
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp);
|
return temp;
|
return temp;
|
}
|
}
|
| Line 459... |
Line 508... |
uint32_t eval_insn_direct(oraddr_t memaddr, int* breakpoint, int through_mmu)
|
uint32_t eval_insn_direct(oraddr_t memaddr, int* breakpoint, int through_mmu)
|
{
|
{
|
uint32_t temp;
|
uint32_t temp;
|
int brk;
|
int brk;
|
|
|
cur_vadd = memaddr;
|
|
|
|
if(through_mmu)
|
if(through_mmu)
|
memaddr = peek_into_itlb(memaddr);
|
memaddr = peek_into_itlb(memaddr);
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadAddress, memaddr);
|
*breakpoint += CheckDebugUnit(DebugLoadAddress, memaddr);
|
| Line 483... |
Line 530... |
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
*/
|
*/
|
uint16_t eval_mem16(oraddr_t memaddr,int* breakpoint)
|
uint16_t eval_mem16(oraddr_t memaddr,int* breakpoint)
|
{
|
{
|
uint16_t temp;
|
uint16_t temp;
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_16 | MPROF_READ);
|
mprofile (memaddr, MPROF_16 | MPROF_READ);
|
|
|
if (memaddr & 1) {
|
if (memaddr & 1) {
|
| Line 495... |
Line 543... |
}
|
}
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = dmmu_translate(memaddr, 0);
|
|
|
memaddr = dmmu_translate(memaddr, 0);
|
|
if (except_pending)
|
if (except_pending)
|
return 0;
|
return 0;
|
|
|
if (config.dc.enabled)
|
if (config.dc.enabled)
|
temp = (uint16_t)dc_simulate_read(memaddr, 2);
|
temp = dc_simulate_read(phys_memaddr, memaddr, 2);
|
else {
|
else
|
temp = evalsim_mem16(memaddr);
|
temp = evalsim_mem16(phys_memaddr, memaddr);
|
if (!cur_area) {
|
|
PRINTF("EXCEPTION: read out of memory (16-bit access to %"PRIxADDR")\n",
|
|
memaddr);
|
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
temp = 0;
|
|
}
|
|
}
|
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp); /* MM170901 */
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp); /* MM170901 */
|
|
|
return temp;
|
return temp;
|
}
|
}
|
|
|
/* for simulator accesses, the ones that cpu wouldn't do
|
/* for simulator accesses, the ones that cpu wouldn't do
|
*
|
*
|
* STATISTICS OK.
|
* STATISTICS OK.
|
*/
|
*/
|
uint16_t eval_direct16(oraddr_t memaddr, int *breakpoint, int through_mmu,
|
uint16_t eval_direct16(oraddr_t memaddr, int *breakpoint, int through_mmu,
|
int through_dc)
|
int through_dc)
|
{
|
{
|
uint32_t temp;
|
oraddr_t phys_memaddr;
|
|
struct dev_memarea *mem;
|
|
|
if (memaddr & 1) {
|
if (memaddr & 1) {
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
if (through_mmu)
|
if (through_mmu)
|
memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
|
|
if (through_dc)
|
if (through_dc)
|
temp = dc_simulate_read(memaddr, 2);
|
return dc_simulate_read(phys_memaddr, memaddr, 2);
|
else {
|
else {
|
temp = evalsim_mem16_void(memaddr);
|
if((mem = verify_memoryarea(phys_memaddr)))
|
if (!cur_area) {
|
return mem->direct_ops.readfunc16(phys_memaddr & mem->size_mask,
|
PRINTF("EXCEPTION: read out of memory (16-bit access to %"PRIxADDR
|
mem->direct_ops.read_dat16);
|
") in eval_direct16()\n", memaddr);
|
else
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
PRINTF("ERR: 16-bit read out of memory area: %"PRIxADDR" (physical: %"
|
temp = 0;
|
PRIxADDR"\n", memaddr, phys_memaddr);
|
}
|
|
}
|
}
|
|
|
return temp;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Returns 8-bit values from mem array.
|
/* Returns 8-bit values from mem array.
|
*
|
*
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
* STATISTICS OK (only used for cpu_access, that is architectural access)
|
*/
|
*/
|
uint8_t eval_mem8(oraddr_t memaddr,int* breakpoint)
|
uint8_t eval_mem8(oraddr_t memaddr,int* breakpoint)
|
{
|
{
|
uint8_t temp;
|
uint8_t temp;
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_8 | MPROF_READ);
|
mprofile (memaddr, MPROF_8 | MPROF_READ);
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = dmmu_translate(memaddr, 0);
|
|
|
memaddr = dmmu_translate(memaddr, 0);
|
|
if (except_pending)
|
if (except_pending)
|
return 0;
|
return 0;
|
|
|
if (config.dc.enabled)
|
if (config.dc.enabled)
|
temp = (uint8_t)dc_simulate_read(memaddr, 1);
|
temp = dc_simulate_read(phys_memaddr, memaddr, 1);
|
else {
|
else
|
temp = evalsim_mem8(memaddr);
|
temp = evalsim_mem8(phys_memaddr, memaddr);
|
if (!cur_area) {
|
|
PRINTF("EXCEPTION: read out of memory (8-bit access to %"PRIxADDR")\n",
|
|
memaddr);
|
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
|
temp = 0;
|
|
}
|
|
}
|
|
|
|
if (config.debug.enabled)
|
if (config.debug.enabled)
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp); /* MM170901 */
|
*breakpoint += CheckDebugUnit(DebugLoadData,temp); /* MM170901 */
|
return temp;
|
return temp;
|
}
|
}
|
| Line 597... |
Line 628... |
* STATISTICS OK.
|
* STATISTICS OK.
|
*/
|
*/
|
uint8_t eval_direct8(oraddr_t memaddr, int *breakpoint, int through_mmu,
|
uint8_t eval_direct8(oraddr_t memaddr, int *breakpoint, int through_mmu,
|
int through_dc)
|
int through_dc)
|
{
|
{
|
uint8_t temp;
|
oraddr_t phys_memaddr;
|
|
struct dev_memarea *mem;
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
if (through_mmu)
|
if (through_mmu)
|
memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
|
|
if (through_dc)
|
if (through_dc)
|
temp = (unsigned char)dc_simulate_read(memaddr, 1);
|
return dc_simulate_read(phys_memaddr, memaddr, 1);
|
else {
|
else {
|
temp = evalsim_mem8_void(memaddr);
|
if((mem = verify_memoryarea(phys_memaddr)))
|
if (!cur_area) {
|
return mem->direct_ops.readfunc8(phys_memaddr & mem->size_mask,
|
PRINTF("EXCEPTION: read out of memory (8-bit access to %"PRIxADDR
|
mem->direct_ops.read_dat8);
|
") in eval_direct8()\n", memaddr);
|
else
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
PRINTF("ERR: 8-bit read out of memory area: %"PRIxADDR" (physical: %"
|
temp = 0;
|
PRIxADDR"\n", memaddr, phys_memaddr);
|
}
|
|
}
|
|
return temp;
|
|
}
|
}
|
|
|
/* for cpu accesses */
|
return 0;
|
inline void setsim_mem32(oraddr_t memaddr, uint32_t value)
|
|
{
|
|
return(setsim_mem32_atomic(memaddr, value, 1));
|
|
}
|
}
|
|
|
/* for simulator accesses, the ones that cpu wouldn't do */
|
/* For cpu accesses
|
inline void setsim_mem32_void(oraddr_t memaddr, uint32_t value)
|
*
|
{
|
* NOTE: This function _is_ only called from set_mem32 below and
|
return(setsim_mem32_atomic(memaddr, value, 0));
|
* dc_simulate_write. _Don't_ call it from anywere else.
|
}
|
|
|
|
void setsim_mem32_atomic(oraddr_t memaddr, uint32_t value, int cpu_access)
|
|
{
|
|
if (verify_memoryarea(memaddr)) {
|
|
switch(cur_area->granularity) {
|
|
case 4:
|
|
cur_area->writefunc(memaddr, value, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayw;
|
|
break;
|
|
case 1:
|
|
cur_area->writefunc(memaddr , (value >> 24) & 0xFF, cur_area->priv_dat);
|
|
cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF, cur_area->priv_dat);
|
|
cur_area->writefunc(memaddr + 2, (value >> 8) & 0xFF, cur_area->priv_dat);
|
|
cur_area->writefunc(memaddr + 3, (value ) & 0xFF, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayw * 4;
|
|
break;
|
|
case 2:
|
|
cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF, cur_area->priv_dat);
|
|
cur_area->writefunc(memaddr + 2, value & 0xFFFF, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayw * 2;
|
|
break;
|
|
default:
|
|
/* if you add new memory granularity be sure to check the formula
|
|
* below for the read delay and fix it if necessery
|
|
*/
|
*/
|
PRINTF("unknown/unhandled memory granularuty\n");
|
inline void setsim_mem32(oraddr_t memaddr, oraddr_t vaddr, uint32_t value)
|
exit(-1);
|
{
|
}
|
struct dev_memarea *mem;
|
#if DYNAMIC_EXECUTION
|
|
/* FIXME: Do this with mprotect() */
|
|
struct dyn_page *dp;
|
|
|
|
/* Since the locations 0x0-0xff are nearly always written to in an exception
|
if((mem = verify_memoryarea(memaddr))) {
|
* handler, ignore any writes to these locations. If code ends up jumping
|
cur_vadd = vaddr;
|
* out there, we'll recompile when the jump actually happens. */
|
runtime.sim.mem_cycles += mem->ops.delayw;
|
if((memaddr > 0x100) && (dp = find_dynd_page(memaddr)) && !dp->dirty)
|
mem->ops.writefunc32(memaddr & mem->size_mask, value, mem->ops.write_dat32);
|
dirtyfy_page(dp);
|
#if DYNAMIC_EXECUTION
|
|
dyn_checkwrite(memaddr);
|
#endif
|
#endif
|
} else {
|
} else {
|
PRINTF("EXCEPTION: write out of memory (32-bit access to %"PRIxADDR")\n",
|
PRINTF("EXCEPTION: write out of memory (32-bit access to %"PRIxADDR")\n",
|
memaddr);
|
memaddr);
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
except_handle(EXCEPT_BUSERR, vaddr);
|
}
|
}
|
}
|
}
|
|
|
/* for cpu accesses */
|
/* For cpu accesses
|
inline void setsim_mem16(oraddr_t memaddr, uint16_t value)
|
*
|
{
|
* NOTE: This function _is_ only called from set_mem16 below and
|
return(setsim_mem16_atomic(memaddr, value, 1));
|
* dc_simulate_write. _Don't_ call it from anywere else.
|
}
|
*/
|
|
inline void setsim_mem16(oraddr_t memaddr, oraddr_t vaddr, uint16_t value)
|
/* for simulator accesses, the ones that cpu wouldn't do */
|
|
inline void setsim_mem16_void(oraddr_t memaddr, uint16_t value)
|
|
{
|
{
|
return(setsim_mem16_atomic(memaddr, value, 0));
|
struct dev_memarea *mem;
|
}
|
|
|
|
void setsim_mem16_atomic(oraddr_t memaddr, uint16_t value, int cpu_access)
|
if((mem = verify_memoryarea(memaddr))) {
|
{
|
cur_vadd = vaddr;
|
uint32_t temp;
|
runtime.sim.mem_cycles += mem->ops.delayw;
|
if (verify_memoryarea(memaddr)) {
|
mem->ops.writefunc16(memaddr & mem->size_mask, value, mem->ops.write_dat16);
|
switch(cur_area->granularity) {
|
|
case 1:
|
|
cur_area->writefunc(memaddr, (value >> 8) & 0xFF, cur_area->priv_dat);
|
|
cur_area->writefunc(memaddr + 1, value & 0xFF, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayw * 2;
|
|
break;
|
|
case 2:
|
|
cur_area->writefunc(memaddr, value & 0xFFFF, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayw;
|
|
break;
|
|
case 4:
|
|
temp = evalsim_mem32_void(memaddr & ~ADDR_C(3));
|
|
temp &= 0xffff << ((memaddr & 2) ? 16 : 0);
|
|
temp |= (unsigned long)(value & 0xffff) << ((memaddr & 2) ? 0 : 16);
|
|
setsim_mem32_atomic(memaddr & ~ADDR_C(3), temp, cpu_access);
|
|
break;
|
|
default:
|
|
/* if you add new memory granularity be sure to check the formula
|
|
* below for the read delay and fix it if necessery
|
|
*/
|
|
PRINTF("unknown/unhandled memory granularuty\n");
|
|
exit(-1);
|
|
}
|
|
#if DYNAMIC_EXECUTION
|
#if DYNAMIC_EXECUTION
|
/* FIXME: Do this with mprotect() */
|
dyn_checkwrite(memaddr);
|
struct dyn_page *dp;
|
|
|
|
/* Since the locations 0x0-0xff are nearly always written to in an exception
|
|
* handler, ignore any writes to these locations. If code ends up jumping
|
|
* out there, we'll recompile when the jump actually happens. */
|
|
|
|
if((memaddr > 0x100) && (dp = find_dynd_page(memaddr)) && !dp->dirty)
|
|
dirtyfy_page(dp);
|
|
#endif
|
#endif
|
} else {
|
} else {
|
PRINTF("EXCEPTION: write out of memory (16-bit access to %"PRIxADDR")\n",
|
PRINTF("EXCEPTION: write out of memory (16-bit access to %"PRIxADDR")\n",
|
memaddr);
|
memaddr);
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
except_handle(EXCEPT_BUSERR, vaddr);
|
}
|
}
|
}
|
}
|
|
|
/* for cpu accesses */
|
/* For cpu accesses
|
inline void setsim_mem8(oraddr_t memaddr, uint8_t value)
|
*
|
{
|
* NOTE: This function _is_ only called from set_mem8 below and
|
return(setsim_mem8_atomic(memaddr, value, 1));
|
* dc_simulate_write. _Don't_ call it from anywere else.
|
}
|
*/
|
|
inline void setsim_mem8(oraddr_t memaddr, oraddr_t vaddr, uint8_t value)
|
/* for simulator accesses, the ones that cpu wouldn't do */
|
|
inline void setsim_mem8_void(oraddr_t memaddr, uint8_t value)
|
|
{
|
{
|
return(setsim_mem8_atomic(memaddr, value, 0));
|
struct dev_memarea *mem;
|
}
|
|
|
|
void setsim_mem8_atomic(oraddr_t memaddr, uint8_t value, int cpu_access)
|
if((mem = verify_memoryarea(memaddr))) {
|
{
|
cur_vadd = vaddr;
|
uint32_t temp;
|
runtime.sim.mem_cycles += mem->ops.delayw;
|
if (verify_memoryarea(memaddr)) {
|
mem->ops.writefunc8(memaddr & mem->size_mask, value, mem->ops.write_dat8);
|
switch (cur_area->granularity) {
|
|
case 1:
|
|
cur_area->writefunc(memaddr, value, cur_area->priv_dat);
|
|
if (cpu_access)
|
|
runtime.sim.mem_cycles += cur_area->delayw;
|
|
break;
|
|
case 2:
|
|
temp = evalsim_mem16_void (memaddr & ~ADDR_C(1));
|
|
temp &= 0xff << ((memaddr & 1) ? 8 : 0);
|
|
temp |= (unsigned short)(value & 0xff) << ((memaddr & 1) ? 0 : 8);
|
|
setsim_mem16_atomic (memaddr & ~ADDR_C(1), temp, cpu_access);
|
|
break;
|
|
case 4:
|
|
temp = evalsim_mem32_void (memaddr & ~ADDR_C(3));
|
|
temp &= ~(0xff << (8 * (3 - (memaddr & 3))));
|
|
temp |= (unsigned long)(value & 0xff) << (8 * (3 - (memaddr & 3)));
|
|
setsim_mem32_atomic (memaddr & ~ADDR_C(3), temp, cpu_access);
|
|
break;
|
|
}
|
|
#if DYNAMIC_EXECUTION
|
#if DYNAMIC_EXECUTION
|
/* FIXME: Do this with mprotect() */
|
dyn_checkwrite(memaddr);
|
struct dyn_page *dp;
|
|
|
|
/* Since the locations 0x0-0xff are nearly always written to in an exception
|
|
* handler, ignore any writes to these locations. If code ends up jumping
|
|
* out there, we'll recompile when the jump actually happens. */
|
|
|
|
if((memaddr > 0x100) && (dp = find_dynd_page(memaddr)) && !dp->dirty)
|
|
dirtyfy_page(dp);
|
|
#endif
|
#endif
|
} else {
|
} else {
|
PRINTF("EXCEPTION: write out of memory (8-bit access to %"PRIxADDR")\n",
|
PRINTF("EXCEPTION: write out of memory (8-bit access to %"PRIxADDR")\n",
|
memaddr);
|
memaddr);
|
except_handle(EXCEPT_BUSERR, cur_vadd);
|
except_handle(EXCEPT_BUSERR, vaddr);
|
}
|
}
|
}
|
}
|
|
|
/* Set mem, 32-bit. Big endian version.
|
/* Set mem, 32-bit. Big endian version.
|
*
|
*
|
| Line 798... |
Line 728... |
* wether this is cpu or architectual access is yet to
|
* wether this is cpu or architectual access is yet to
|
* be decided)
|
* be decided)
|
*/
|
*/
|
void set_mem32(oraddr_t memaddr, uint32_t value, int* breakpoint)
|
void set_mem32(oraddr_t memaddr, uint32_t value, int* breakpoint)
|
{
|
{
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_32 | MPROF_WRITE);
|
mprofile (memaddr, MPROF_32 | MPROF_WRITE);
|
|
|
if (memaddr & 3) {
|
if (memaddr & 3) {
|
except_handle (EXCEPT_ALIGN, memaddr);
|
except_handle (EXCEPT_ALIGN, memaddr);
|
return;
|
return;
|
}
|
}
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = dmmu_translate(memaddr, 1);;
|
memaddr = dmmu_translate(memaddr, 1);;
|
|
/* If we produced exception don't set anything */
|
/* If we produced exception don't set anything */
|
if (except_pending)
|
if (except_pending)
|
return;
|
return;
|
|
|
if (config.debug.enabled) {
|
if (config.debug.enabled) {
|
*breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugStoreData,value);
|
*breakpoint += CheckDebugUnit(DebugStoreData,value);
|
}
|
}
|
|
|
dc_simulate_write(memaddr, value, 4);
|
if(config.dc.enabled)
|
|
dc_simulate_write(phys_memaddr, memaddr, value, 4);
|
|
else
|
|
setsim_mem32(phys_memaddr, memaddr, value);
|
|
|
if (cur_area && cur_area->log)
|
if (cur_area && cur_area->log)
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> write %08"PRIx32"\n", memaddr,
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> write %08"PRIx32"\n", memaddr,
|
value);
|
value);
|
}
|
}
|
| Line 830... |
Line 764... |
* STATISTICS NOT OK.
|
* STATISTICS NOT OK.
|
*/
|
*/
|
void set_direct32(oraddr_t memaddr, uint32_t value,int* breakpoint,
|
void set_direct32(oraddr_t memaddr, uint32_t value,int* breakpoint,
|
int through_mmu, int through_dc)
|
int through_mmu, int through_dc)
|
{
|
{
|
|
oraddr_t phys_memaddr;
|
|
struct dev_memarea *mem;
|
|
|
if (memaddr & 3) {
|
if (memaddr & 3) {
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
return;
|
return;
|
}
|
}
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
if (through_mmu) {
|
if (through_mmu) {
|
/* 0 - no write access, we do not want a DPF exception do we ;)
|
/* 0 - no write access, we do not want a DPF exception do we ;)
|
*/
|
*/
|
memaddr = peek_into_dtlb(memaddr, 1, through_dc);
|
phys_memaddr = peek_into_dtlb(memaddr, 1, through_dc);
|
}
|
}
|
|
|
|
if(through_dc)
|
/* __PHX__ fixme: we'll get cache hit/miss delay added to cycles count,
|
dc_simulate_write(memaddr, memaddr, value, 4);
|
* and possibly also memory access times.
|
else {
|
*/
|
if((mem = verify_memoryarea(phys_memaddr)))
|
if (!through_dc)
|
mem->direct_ops.writefunc32(phys_memaddr & mem->size_mask, value,
|
PRINTF("WARNING: statistics might not be OK\n");
|
mem->direct_ops.write_dat32);
|
dc_simulate_write(memaddr, value, 4);
|
else
|
|
PRINTF("ERR: 32-bit write out of memory area: %"PRIxADDR" (physical: %"
|
|
PRIxADDR")\n", memaddr, phys_memaddr);
|
|
}
|
|
|
if (cur_area && cur_area->log)
|
if (cur_area && cur_area->log)
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %08"PRIx32"\n",
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %08"PRIx32"\n",
|
memaddr, value);
|
memaddr, value);
|
}
|
}
|
| Line 862... |
Line 801... |
|
|
/* Set mem, 16-bit. Big endian version. */
|
/* Set mem, 16-bit. Big endian version. */
|
|
|
void set_mem16(oraddr_t memaddr, uint16_t value, int* breakpoint)
|
void set_mem16(oraddr_t memaddr, uint16_t value, int* breakpoint)
|
{
|
{
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_16 | MPROF_WRITE);
|
mprofile (memaddr, MPROF_16 | MPROF_WRITE);
|
|
|
if (memaddr & 1) {
|
if (memaddr & 1) {
|
except_handle (EXCEPT_ALIGN, memaddr);
|
except_handle (EXCEPT_ALIGN, memaddr);
|
return;
|
return;
|
}
|
}
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = dmmu_translate(memaddr, 1);;
|
memaddr = dmmu_translate(memaddr, 1);;
|
|
/* If we produced exception don't set anything */
|
/* If we produced exception don't set anything */
|
if (except_pending)
|
if (except_pending)
|
return;
|
return;
|
|
|
if (config.debug.enabled) {
|
if (config.debug.enabled) {
|
*breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugStoreData,value);
|
*breakpoint += CheckDebugUnit(DebugStoreData,value);
|
}
|
}
|
|
|
dc_simulate_write(memaddr, value, 2);
|
if(config.dc.enabled)
|
|
dc_simulate_write(phys_memaddr, memaddr, value, 2);
|
|
else
|
|
setsim_mem16(phys_memaddr, memaddr, value);
|
|
|
if (cur_area && cur_area->log)
|
if (cur_area && cur_area->log)
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> write %04"PRIx16"\n", memaddr,
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> write %04"PRIx16"\n", memaddr,
|
value);
|
value);
|
}
|
}
|
| Line 894... |
Line 837... |
* STATISTICS NOT OK.
|
* STATISTICS NOT OK.
|
*/
|
*/
|
void set_direct16(oraddr_t memaddr, uint16_t value, int* breakpoint,
|
void set_direct16(oraddr_t memaddr, uint16_t value, int* breakpoint,
|
int through_mmu, int through_dc)
|
int through_mmu, int through_dc)
|
{
|
{
|
|
oraddr_t phys_memaddr;
|
|
struct dev_memarea *mem;
|
|
|
if (memaddr & 1) {
|
if (memaddr & 1) {
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
return;
|
return;
|
}
|
}
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
if (through_mmu) {
|
if (through_mmu) {
|
/* 0 - no write access, we do not want a DPF exception do we ;)
|
/* 0 - no write access, we do not want a DPF exception do we ;)
|
*/
|
*/
|
memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
}
|
}
|
|
|
/* __PHX__ fixme: we'll get cache hit/miss delay added to cycles count,
|
if(through_dc)
|
* and possibly also memory access times.
|
dc_simulate_write(memaddr, memaddr, value, 2);
|
*/
|
else {
|
if (!through_dc)
|
if((mem = verify_memoryarea(phys_memaddr)))
|
PRINTF("WARNING: statistics might not be OK\n");
|
mem->direct_ops.writefunc16(phys_memaddr & mem->size_mask, value,
|
dc_simulate_write(memaddr, value, 2);
|
mem->direct_ops.write_dat16);
|
|
else
|
|
PRINTF("ERR: 16-bit write out of memory area: %"PRIxADDR" (physical: %"
|
|
PRIxADDR"\n", memaddr, phys_memaddr);
|
|
}
|
|
|
if (cur_area && cur_area->log)
|
if (cur_area && cur_area->log)
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %04"PRIx16"\n",
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %04"PRIx16"\n",
|
memaddr, value);
|
memaddr, value);
|
}
|
}
|
|
|
/* Set mem, 8-bit. */
|
/* Set mem, 8-bit. */
|
|
|
void set_mem8(oraddr_t memaddr, uint8_t value, int* breakpoint)
|
void set_mem8(oraddr_t memaddr, uint8_t value, int* breakpoint)
|
{
|
{
|
|
oraddr_t phys_memaddr;
|
|
|
if (config.sim.mprofile)
|
if (config.sim.mprofile)
|
mprofile (memaddr, MPROF_8 | MPROF_WRITE);
|
mprofile (memaddr, MPROF_8 | MPROF_WRITE);
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
memaddr = dmmu_translate(memaddr, 1);;
|
|
|
phys_memaddr = dmmu_translate(memaddr, 1);;
|
/* If we produced exception don't set anything */
|
/* If we produced exception don't set anything */
|
if (except_pending) return;
|
if (except_pending) return;
|
|
|
if (config.debug.enabled) {
|
if (config.debug.enabled) {
|
*breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); /* 28/05/01 CZ */
|
*breakpoint += CheckDebugUnit(DebugStoreData,value);
|
*breakpoint += CheckDebugUnit(DebugStoreData,value);
|
}
|
}
|
|
|
dc_simulate_write(memaddr, value, 1);
|
if(config.dc.enabled)
|
|
dc_simulate_write(phys_memaddr, memaddr, value, 1);
|
|
else
|
|
setsim_mem8(phys_memaddr, memaddr, value);
|
|
|
if (cur_area && cur_area->log)
|
if (cur_area && cur_area->log)
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> write %02"PRIx8"\n", memaddr,
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> write %02"PRIx8"\n", memaddr,
|
value);
|
value);
|
}
|
}
|
| Line 950... |
Line 904... |
* STATISTICS NOT OK.
|
* STATISTICS NOT OK.
|
*/
|
*/
|
void set_direct8(oraddr_t memaddr, uint8_t value, int* breakpoint,
|
void set_direct8(oraddr_t memaddr, uint8_t value, int* breakpoint,
|
int through_mmu, int through_dc)
|
int through_mmu, int through_dc)
|
{
|
{
|
|
oraddr_t phys_memaddr;
|
|
struct dev_memarea *mem;
|
|
|
cur_vadd = memaddr;
|
phys_memaddr = memaddr;
|
|
|
if (through_mmu) {
|
if (through_mmu) {
|
/* 0 - no write access, we do not want a DPF exception do we ;)
|
/* 0 - no write access, we do not want a DPF exception do we ;)
|
*/
|
*/
|
memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
phys_memaddr = peek_into_dtlb(memaddr, 0, through_dc);
|
}
|
}
|
|
|
/* __PHX__ fixme: we'll get cache hit/miss delay added to cycles count,
|
if(through_dc)
|
* and possibly also memory access times.
|
dc_simulate_write(phys_memaddr, memaddr, value, 1);
|
*/
|
else {
|
if (!through_dc)
|
if((mem = verify_memoryarea(phys_memaddr)))
|
PRINTF("WARNING: statistics might not be OK\n");
|
mem->direct_ops.writefunc8(phys_memaddr & mem->size_mask, value,
|
dc_simulate_write(memaddr, value, 1);
|
mem->direct_ops.write_dat8);
|
|
else
|
|
PRINTF("ERR: 8-bit write out of memory area: %"PRIxADDR" (physical: %"
|
|
PRIxADDR"\n", memaddr, phys_memaddr);
|
|
}
|
|
|
if (cur_area && cur_area->log)
|
if (cur_area && cur_area->log)
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %02"PRIx8"\n",
|
fprintf (cur_area->log, "[%"PRIxADDR"] -> DIRECT write %02"PRIx8"\n",
|
memaddr, value);
|
memaddr, value);
|
}
|
}
|
|
|
|
|
|
/* set_program32 - same as set_direct32, but it also writes to memory that is
|
|
* non-writeable to the rest of the sim. Used to do program
|
|
* loading.
|
|
*/
|
|
void set_program32(oraddr_t memaddr, uint32_t value)
|
|
{
|
|
struct dev_memarea *mem;
|
|
|
|
if (memaddr & 3) {
|
|
PRINTF("%s:%d %s(): ERR unaligned access\n", __FILE__, __LINE__, __FUNCTION__);
|
|
return;
|
|
}
|
|
|
|
if((mem = verify_memoryarea(memaddr))) {
|
|
mem->ops.writeprog(memaddr & mem->size_mask, value, mem->ops.writeprog_dat);
|
|
} else
|
|
PRINTF("ERR: 32-bit program load out of memory area: %"PRIxADDR"\n",
|
|
memaddr);
|
|
}
|
|
|
void dumpmemory(oraddr_t from, oraddr_t to, int disasm, int nl)
|
void dumpmemory(oraddr_t from, oraddr_t to, int disasm, int nl)
|
{
|
{
|
oraddr_t i, j;
|
oraddr_t i, j;
|
struct label_entry *tmp;
|
struct label_entry *tmp;
|
int ilen = disasm ? 4 : 16;
|
int ilen = disasm ? 4 : 16;
|
| Line 1019... |
Line 999... |
if (nl)
|
if (nl)
|
PRINTF ("\n");
|
PRINTF ("\n");
|
}
|
}
|
}
|
}
|
|
|
uint32_t simmem_read_word(oraddr_t addr, void *priv_dat) {
|
|
return *(uint32_t *)(priv_dat + (addr & cur_area->size_mask));
|
|
}
|
|
|
|
void simmem_write_word(oraddr_t addr, uint32_t value, void *priv_dat) {
|
|
*(uint32_t *)(priv_dat + (addr & cur_area->size_mask)) = value;
|
|
}
|
|
|
|
uint32_t simmem_read_zero(oraddr_t addr, void *dat) {
|
|
if (config.sim.verbose)
|
|
fprintf (stderr, "WARNING: memory read from non-read memory area 0x%"
|
|
PRIxADDR".\n", addr);
|
|
return 0;
|
|
}
|
|
|
|
void simmem_write_null(oraddr_t addr, uint32_t value, void *dat) {
|
|
if (config.sim.verbose)
|
|
fprintf (stderr, "WARNING: memory write to 0x%"PRIxADDR", non-write memory area (value 0x%08"PRIx32").\n", addr, value);
|
|
}
|
|
|
|
/* Initialize memory table from a config struct */
|
|
|
|
void init_memory_table ()
|
|
{
|
|
/* If nothing was defined, use default memory block */
|
|
if (config.memory.nmemories) {
|
|
int i;
|
|
for (i = 0; i < config.memory.nmemories; i++) {
|
|
oraddr_t start = config.memory.table[i].baseaddr;
|
|
uint32_t length = config.memory.table[i].size;
|
|
char *type = config.memory.table[i].name;
|
|
int rd = config.memory.table[i].delayr;
|
|
int wd = config.memory.table[i].delayw;
|
|
int ce = config.memory.table[i].ce;
|
|
void *mem = malloc (length);
|
|
|
|
if (config.sim.verbose)
|
|
debug (1, "%"PRIxADDR" %08"PRIx32" (%"PRIi32" KB): %s (activated by CE%i; read delay = %icyc, write delay = %icyc)\n",
|
|
start, length, length >> 10, type, ce, rd, wd);
|
|
|
|
if (!mem) {
|
|
fprintf (stderr, "Failed to allocate sim memory. Aborting\n");
|
|
exit (-1);
|
|
}
|
|
|
|
register_memoryarea(start, length, 4, 0, &simmem_read_word,
|
|
&simmem_write_word, mem);
|
|
cur_area->chip_select = ce;
|
|
cur_area->valid = 1;
|
|
cur_area->delayw = wd;
|
|
cur_area->delayr = rd;
|
|
if (config.memory.table[i].log[0] != '\0') {
|
|
if ((cur_area->log = fopen (config.memory.table[i].log, "wt+")) == NULL)
|
|
fprintf (stderr, "WARNING: Cannot open '%s'.\n",
|
|
config.memory.table[i].log);
|
|
} else
|
|
cur_area->log = NULL;
|
|
}
|
|
PRINTF ("\n");
|
|
} else {
|
|
void *mem = malloc (DEFAULT_MEMORY_LEN);
|
|
if (config.sim.verbose)
|
|
fprintf (stderr, "WARNING: Memory not defined, assuming standard configuration.\n");
|
|
|
|
if (!mem) {
|
|
fprintf (stderr, "Failed to allocate sim memory. Aborting\n");
|
|
exit (-1);
|
|
}
|
|
|
|
register_memoryarea(DEFAULT_MEMORY_START, DEFAULT_MEMORY_LEN, 4, 0,
|
|
&simmem_read_word, &simmem_write_word, mem);
|
|
cur_area->chip_select = 0;
|
|
cur_area->valid = 1;
|
|
cur_area->delayw = 1;
|
|
cur_area->delayr = 1;
|
|
cur_area->log = NULL;
|
|
}
|
|
}
|
|
|
|
/* Changes read/write memory in read/write only */
|
|
|
|
void lock_memory_table ()
|
|
{
|
|
struct dev_memarea *ptmp;
|
|
|
|
/* Check list of registered devices. */
|
|
for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
|
|
if (ptmp->delayr < 0 && ptmp->readfunc == &simmem_read_word)
|
|
ptmp->readfunc = &simmem_read_zero;
|
|
if (ptmp->delayw < 0 && ptmp->writefunc == &simmem_write_word)
|
|
ptmp->writefunc = &simmem_write_null;
|
|
|
|
/* If this mem area is not for memory chip under MC control
|
|
then this area is valid all the time */
|
|
if (ptmp->readfunc != &simmem_read_word) {
|
|
ptmp->valid = 1;
|
|
ptmp->chip_select = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Closes files, etc. */
|
/* Closes files, etc. */
|
|
|
void done_memory_table ()
|
void done_memory_table (void)
|
{
|
{
|
struct dev_memarea *ptmp;
|
struct dev_memarea *ptmp;
|
|
|
/* Check list of registered devices. */
|
/* Check list of registered devices. */
|
for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
|
for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
|
| Line 1135... |
Line 1014... |
}
|
}
|
}
|
}
|
|
|
/* Displays current memory configuration */
|
/* Displays current memory configuration */
|
|
|
void memory_table_status ()
|
void memory_table_status (void)
|
{
|
{
|
struct dev_memarea *ptmp;
|
struct dev_memarea *ptmp;
|
|
|
/* Check list of registered devices. */
|
/* Check list of registered devices. */
|
for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
|
for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
|
PRINTF ("addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %"PRIx32
|
PRINTF ("addr & %"PRIxADDR" == %"PRIxADDR" to %"PRIxADDR", size %"PRIx32"\n",
|
", gran %iB\n",
|
|
ptmp->addr_mask, ptmp->addr_compare, ptmp->addr_compare | bit_mask (ptmp->size),
|
ptmp->addr_mask, ptmp->addr_compare, ptmp->addr_compare | bit_mask (ptmp->size),
|
ptmp->size, ptmp->granularity);
|
ptmp->size);
|
PRINTF ("\t");
|
PRINTF ("\t");
|
if (ptmp->delayr >= 0)
|
if (ptmp->ops.delayr >= 0)
|
PRINTF ("read delay = %i cycles, ", ptmp->delayr);
|
PRINTF ("read delay = %i cycles, ", ptmp->ops.delayr);
|
else
|
else
|
PRINTF ("reads not possible, ");
|
PRINTF ("reads not possible, ");
|
|
|
if (ptmp->delayw >= 0)
|
if (ptmp->ops.delayw >= 0)
|
PRINTF ("write delay = %i cycles", ptmp->delayw);
|
PRINTF ("write delay = %i cycles", ptmp->ops.delayw);
|
else
|
else
|
PRINTF ("writes not possible");
|
PRINTF ("writes not possible");
|
|
|
if (ptmp->log)
|
if (ptmp->log)
|
PRINTF (", (logged)\n");
|
PRINTF (", (logged)\n");
|
