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

Subversion Repositories or1k

[/] [or1k/] [tags/] [nog_patch_42/] [or1ksim/] [cpu/] [common/] [abstract.c] - Blame information for rev 297

Go to most recent revision | Details | Compare with Previous | View Log


/* abstract.c -- Abstract entities
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
/* Abstract memory and routines that go with this. I need to
add all sorts of other abstract entities. Currently we have
only memory. */
 
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
#include "config.h"
#include "sim-config.h"
 
#include "parse.h"
#include "abstract.h"
#include "labels.h"
#include "arch.h"
#include "trace.h"
#include "execute.h"
#include "sprs.h"
#include "stats.h"
#include "except.h"
#include "debug_unit.h"
#include "opcode/or32.h"
 
extern unsigned long reg[];
extern char *disassembled;
 
/* This is an abstract+physical memory array rather than only physical
   memory array */
static struct mem_entry *simmem;
 
/* Pointer to memory area descriptions that are assigned to individual
   peripheral devices. */
struct dev_memarea *dev_list;
 
/* Temporary variable to increase speed.  */
struct dev_memarea *cur_area;
 
void dumpmemory(unsigned int from, unsigned int to, int disasm)
{
  unsigned int i, j;
  struct label_entry *tmp;
  int breakpoint = 0;
  int ilen = disasm ? 4 : 16;
 
  for(i = from; i < to; i += ilen) {
    printf("%.8x: ", i);
    for (j = 0; j < ilen;) {
      int data = -1;
      if (!disasm) {
        tmp = NULL;
        if (verify_memoryarea(i+j)) {
          struct label_entry *entry;
          entry = get_label(i + j);
          if (entry)
            printf("(%s)", entry->name);
          printf("%02x ", data = evalsim_mem8(i+j));
        } else printf("XX ");
        j++;
      } else {
        int breakpoint;
        unsigned int _insn = eval_mem32(i, &breakpoint);
        int index = insn_decode (_insn);
        int len = insn_len (index);
 
        tmp = NULL;
        if (verify_memoryarea(i+j)) {
          struct label_entry *entry;
          entry = get_label(i + j);
          if (entry)
            printf("(%s)", entry->name);
 
          printf(": %08x ", (unsigned long)_insn);
          if (index >= 0) {
            disassemble_insn (_insn);
            printf(" %s", disassembled);
          } else
            printf("<invalid>");
        } else printf("XXXXXXXX");
        j += len;
      }
    }
    printf ("\n");
  }
}
 
/* Calls IMMU translation routines before simulating insn
cache for virtually indexed insn cache or after simulating insn cache
for physically indexed insn cache. It returns physical address. */
 
unsigned long simulate_ic_mmu_fetch(unsigned long virtaddr)
{
  if (config.ic.tagtype == NONE)
    return virtaddr;
  else
    if (config.ic.tagtype == VIRTUAL) {
      ic_simulate_fetch(virtaddr);
      return immu_translate(virtaddr);
    }
    else if (config.dc.tagtype == PHYSICAL) {
      unsigned long phyaddr = immu_translate(virtaddr);
      ic_simulate_fetch(phyaddr);
      return phyaddr;
    }
    else {
      printf("INTERNAL ERROR: Unknown insn cache type.\n");
      cont_run = 0;
    }
 
  return -1;
}
 
/* Calls DMMU translation routines (load cycles) before simulating data
   cache for virtually indexed data cache or after simulating data cache
   for physically indexed data cache. It returns physical address. */
 
unsigned long simulate_dc_mmu_load(unsigned long virtaddr)
{
  if (config.dc.tagtype == NONE)
    return virtaddr;
  else
  if (config.ic.tagtype == VIRTUAL) {
    ic_simulate_fetch(virtaddr);
    return immu_translate(virtaddr);
  }
  else if (config.dc.tagtype == PHYSICAL) {
    unsigned long phyaddr = immu_translate(virtaddr);
    ic_simulate_fetch(phyaddr);
    return phyaddr;
  }
  else {
    printf("INTERNAL ERROR: Unknown insn cache type.\n");
    cont_run = 0;
  }
 
  return -1;
}
 
/* Calls DMMU translation routines (store cycles) before simulating data
cache for virtually indexed data cache or after simulating data cache
for physically indexed data cache. It returns physical address. */
 
unsigned long simulate_dc_mmu_store(unsigned long virtaddr)
{
  if (config.dc.tagtype == NONE)
    return virtaddr;
  else
  if (config.dc.tagtype == VIRTUAL) {
    dc_simulate_write(virtaddr);
    return dmmu_translate(virtaddr);
  }
  else if (config.dc.tagtype == PHYSICAL) {
    unsigned long phyaddr = dmmu_translate(virtaddr);
    dc_simulate_write(phyaddr);
    return phyaddr;
  }
  else {
    printf("INTERNAL ERROR: Unknown data cache type.\n");
    cont_run = 0;
  }
 
  return -1;
}
 
/* Calculates bit mask to fit the data */
unsigned long bit_mask (unsigned long data) {
  int i = 0;
  data--;
  while ((data << i) & 1)
    data |= 1 << i++;
  return data;
}
 
/* Register read and write function for a memory area.
   addr is inside the area, if addr & addr_mask == addr_compare
   (used also by peripheral devices like 16450 UART etc.) */
void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,
                         unsigned long size, unsigned granularity,
                         unsigned long (readfunc)(unsigned long),
                         void (writefunc)(unsigned long, unsigned long))
{
  struct dev_memarea **pptmp;
  unsigned long size_mask = bit_mask (size);
  int found_error = 0;
  addr_compare &= addr_mask;
 
  /* Go to the end of the list. */
  for(pptmp = &dev_list; *pptmp; pptmp = &(*pptmp)->next)
    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)) {
      if (!found_error) {
        fprintf (stderr, "ERROR: Overlapping memory area(s):\n");
        fprintf (stderr, "\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare | bit_mask (size), size, granularity);
      }
      found_error = 1;
      printf ("and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (*pptmp)->addr_mask, (*pptmp)->addr_compare,
        (*pptmp)->addr_compare | (*pptmp)->size_mask, (*pptmp)->size, (*pptmp)->granularity);
    }
 
  if (found_error)
    exit (-1);
 
  cur_area = *pptmp = (struct dev_memarea *)malloc(sizeof(struct dev_memarea));
  (*pptmp)->addr_mask = addr_mask;
  (*pptmp)->addr_compare = addr_compare;
  (*pptmp)->size = size;
  (*pptmp)->size_mask = size_mask;
  (*pptmp)->granularity = granularity;
  (*pptmp)->readfunc = readfunc;
  (*pptmp)->writefunc = writefunc;
  (*pptmp)->next = NULL;
}
 
/* Register read and write function for a memory area.
   Memory areas should be aligned. Memory area is rounded up to
   fit the nearest 2^n aligment.
   (used also by peripheral devices like 16450 UART etc.) */
void register_memoryarea(unsigned long addr,
                         unsigned long size, unsigned granularity,
                         unsigned long (readfunc)(unsigned long),
                         void (writefunc)(unsigned long, unsigned long))
{
  unsigned long size_mask = bit_mask (size);
  unsigned long addr_mask = ~size_mask;
  register_memoryarea_mask (addr_mask, addr & addr_mask,
                      size_mask + 1, granularity,
                      readfunc, writefunc);
}
 
 
/* Check if access is to registered area of memory. */
struct dev_memarea *verify_memoryarea(unsigned long addr)
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next)
    if ((addr & ptmp->addr_mask) == ptmp->addr_compare)
      return cur_area = ptmp;
  return cur_area = NULL;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)
{
 
  unsigned long temp;
  struct dev_memarea *dev;
 
  slp_checkaccess(memaddr, SLP_MEMREAD);
  memaddr = simulate_dc_mmu_load(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  temp = evalsim_mem32(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
unsigned long evalsim_mem32(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr) << 24;
      temp |= cur_area->readfunc(memaddr + 1) << 16;
      temp |= cur_area->readfunc(memaddr + 2) << 8;
      temp |= cur_area->readfunc(memaddr + 3);
      break;
    case 2:
      temp = cur_area->readfunc(memaddr) << 16;
      temp |= cur_area->readfunc(memaddr + 2);
      break;
    case 4:
      temp = cur_area->readfunc(memaddr);
      break;
    }
  } else {
    printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);
    cont_run = 0;
    temp = 0;
  }
  return temp;
}
 
/* Returns 16-bit values from mem array. Big endian version. */
 
unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)
{
  unsigned short temp;
  memaddr = simulate_dc_mmu_load(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
 
  temp = evalsim_mem16(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
unsigned short evalsim_mem16(unsigned long memaddr)
{
  unsigned short temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr) << 8;
      temp |= cur_area->readfunc(memaddr + 1);
      break;
    case 2:
      temp = cur_area->readfunc(memaddr);
      break;
    case 4:
      printf("EXCEPTION: read 16-bit value from 32-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);
      cont_run = 0;
      break;
    }
  } else {
    printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);
    cont_run = 0;
    temp = 0;
  }
  return temp;
}
 
 
/* Returns 8-bit values from mem array. */
 
unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)
{
  unsigned char temp;
  memaddr = simulate_dc_mmu_load(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);  /* 28/05/01 CZ */
 
  temp = evalsim_mem8(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
unsigned char evalsim_mem8(unsigned long memaddr)
{
  unsigned char temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr);
      break;
    case 2:
    case 4:
      printf("EXCEPTION: read 8-bit value from %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);
      cont_run = 0;
      break;
    }
  } else {
    printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);
    cont_run = 0;
    temp = 0;
  }
  return temp;
}
 
/* Set mem, 32-bit. Big endian version. */
 
void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)
{
  slp_checkaccess(memaddr, SLP_MEMWRITE);
  memaddr = simulate_dc_mmu_store(memaddr);
 
  if (DEBUG_ENABLED) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  setsim_mem32(memaddr, value);
}
 
void setsim_mem32(unsigned long memaddr, unsigned long value)
{
  struct dev_memarea *dev;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr    , (value >> 24) & 0xFF);
      cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);
      cur_area->writefunc(memaddr + 2, (value >>  8) & 0xFF);
      cur_area->writefunc(memaddr + 3, (value      ) & 0xFF);
      break;
    case 2:
      cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);
      cur_area->writefunc(memaddr + 2, value & 0xFFFF);
      break;
    case 4:
      cur_area->writefunc(memaddr, value);
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);
    cont_run = 0;
  }
}
 
/* Set mem, 16-bit. Big endian version. */
 
void set_mem16(unsigned long memaddr, unsigned short value,int* breakpoint)
{
  memaddr = simulate_dc_mmu_store(memaddr);
 
  if (DEBUG_ENABLED) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  setsim_mem16(memaddr, value);
}
 
void setsim_mem16(unsigned long memaddr, unsigned short value)
{
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr, (value >> 8) & 0xFF);
      cur_area->writefunc(memaddr + 1, value & 0xFF);
      break;
    case 2:
      cur_area->writefunc(memaddr, value & 0xFFFF);
      break;
    case 4:
      printf("EXCEPTION: write 16-bit value to 32-bit region (address 0x%08lX)\n", memaddr);
      cont_run = 0;
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);
    cont_run = 0;
  }
}
 
/* Set mem, 8-bit. */
 
void set_mem8(unsigned long memaddr, unsigned char value,int* breakpoint)
{
  memaddr = simulate_dc_mmu_store(memaddr);
 
  if (DEBUG_ENABLED) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  setsim_mem8(memaddr, value);
}
 
void setsim_mem8(unsigned long memaddr, unsigned char value)
{
  if (verify_memoryarea(memaddr)) {
    if (cur_area->granularity == 1)
      cur_area->writefunc(memaddr, value);
    else {
      printf("EXCEPTION: write 8-bit value to %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);
      cont_run = 0;
    }
  } else {
    printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);
    cont_run = 0;
  }
}
 
unsigned long simmem_read_byte(unsigned long addr) {
  return simmem[cur_area->misc + (addr & cur_area->size_mask)].data;
}
 
void simmem_write_byte(unsigned long addr, unsigned long value) {
  simmem[cur_area->misc + (addr & cur_area->size_mask)].data = (unsigned char)value;
}
 
/* Initialize memory table from a file. Syntax:
   start_address1 length1 type1 [ce1 [delayr1 [delayw1]]]
   start_address2 length2 type2 [ce2 [delayr2 [delayw2]]]
   start_address3 length3 type3 [ce3 [delayr3 [delayw3]]]
 
   Example:
   00000100 00001F00 flash 3 100
   80000000 00010000 RAM
  */
void sim_read_memory_table (char *filename)
{
  FILE *f;
  unsigned long memory_needed = 0;
  char *home = getenv("HOME");
  char ctmp[256];
  int local = 1;
  int gce = 0;
  sprintf(ctmp, "%s/.or1k/%s", home, filename);
  if ((f = fopen (filename, "rt")) != NULL
      || home != NULL && !(local = 0) && (f = fopen (ctmp, "rt")) != NULL) {
    unsigned long start, length;
    char type[100];
    int nparam;
    int rd, wd, ce;
    printf ("Reading memory table from '%s':\n", local ? filename : ctmp);
    while ((nparam = fscanf (f, "%08x %08x %s %i %i %i\n", &start, &length, &type, &ce, &rd, &wd)) >= 3 && nparam <= 6) {
      if (nparam < 4)
        ce = gce + 1;
      if (nparam < 5)
        rd = 1;
      if (nparam < 6)
        wd = 1;
 
      gce = ce;
      printf ("%08X %08X (%i KB): %s (activated by CE%i; read delay = %icyc, write delay = %icyc)\n", start, length, length >> 10, type, ce, rd, wd);
      register_memoryarea(start, length, 1, &simmem_read_byte, &simmem_write_byte);
      cur_area->misc = memory_needed;
      memory_needed += cur_area->size;
    }
    fclose (f);
    printf ("\n");
  } else {
    fprintf (stderr, "Cannot read memory table from '%s',\nneither '%s', assuming standard configuration.\n", filename, ctmp);
    register_memoryarea(DEFAULT_MEMORY_START, DEFAULT_MEMORY_LEN, 1, &simmem_read_byte, &simmem_write_byte);
    memory_needed += cur_area->size;
  }
 
  simmem = (struct mem_entry *) malloc (sizeof (struct mem_entry) * memory_needed);
  if (!simmem) {
    fprintf (stderr, "Failed to allocate sim memory. Aborting\n");
    exit (-1);
  }
}

Line No.	Rev	Author	Line
1	2	cvs	`/* abstract.c -- Abstract entities`
2			`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
3
4			`This file is part of OpenRISC 1000 Architectural Simulator.`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2 of the License, or`
9			`(at your option) any later version.`
10
11			`This program is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
19
20	66	lampret	`/* Abstract memory and routines that go with this. I need to`
21	2	cvs	`add all sorts of other abstract entities. Currently we have`
22			`only memory. */`
23
24	221	markom	`#include <stdlib.h>`
25	2	cvs	`#include <stdio.h>`
26			`#include <ctype.h>`
27			`#include <string.h>`
28
29	6	lampret	`#include "config.h"`
30	7	jrydberg	`#include "sim-config.h"`
31	6	lampret
32	2	cvs	`#include "parse.h"`
33			`#include "abstract.h"`
34	261	markom	`#include "labels.h"`
35	2	cvs	`#include "arch.h"`
36			`#include "trace.h"`
37			`#include "execute.h"`
38	32	lampret	`#include "sprs.h"`
39	35	lampret	`#include "stats.h"`
40	32	lampret	`#include "except.h"`
41	123	markom	`#include "debug_unit.h"`
42	134	markom	`#include "opcode/or32.h"`
43	2	cvs
44			`extern unsigned long reg[];`
45	138	markom	`extern char *disassembled;`
46	2	cvs
47	28	lampret	`/* This is an abstract+physical memory array rather than only physical`
48			`memory array */`
49	221	markom	`static struct mem_entry *simmem;`
50	2	cvs
51	30	lampret	`/* Pointer to memory area descriptions that are assigned to individual`
52			`peripheral devices. */`
53			`struct dev_memarea *dev_list;`
54
55	221	markom	`/* Temporary variable to increase speed. */`
56			`struct dev_memarea *cur_area;`
57
58	167	markom	`void dumpmemory(unsigned int from, unsigned int to, int disasm)`
59	2	cvs	`{`
60	239	markom	`unsigned int i, j;`
61			`struct label_entry *tmp;`
62			`int breakpoint = 0;`
63			`int ilen = disasm ? 4 : 16;`
64	221	markom
65	239	markom	`for(i = from; i < to; i += ilen) {`
66	269	markom	`printf("%.8x: ", i);`
67	239	markom	`for (j = 0; j < ilen;) {`
68			`int data = -1;`
69			`if (!disasm) {`
70			`tmp = NULL;`
71			`if (verify_memoryarea(i+j)) {`
72	261	markom	`struct label_entry *entry;`
73			`entry = get_label(i + j);`
74			`if (entry)`
75			`printf("(%s)", entry->name);`
76			`printf("%02x ", data = evalsim_mem8(i+j));`
77	239	markom	`} else printf("XX ");`
78	261	markom	`j++;`
79	239	markom	`} else {`
80			`int breakpoint;`
81			`unsigned int _insn = eval_mem32(i, &breakpoint);`
82			`int index = insn_decode (_insn);`
83			`int len = insn_len (index);`
84
85			`tmp = NULL;`
86			`if (verify_memoryarea(i+j)) {`
87	261	markom	`struct label_entry *entry;`
88			`entry = get_label(i + j);`
89			`if (entry)`
90			`printf("(%s)", entry->name);`
91	221	markom
92	261	markom	`printf(": %08x ", (unsigned long)_insn);`
93	239	markom	`if (index >= 0) {`
94			`disassemble_insn (_insn);`
95			`printf(" %s", disassembled);`
96			`} else`
97			`printf("<invalid>");`
98			`} else printf("XXXXXXXX");`
99			`j += len;`
100	269	markom	`}`
101	239	markom	`}`
102	269	markom	`printf ("\n");`
103	239	markom	`}`
104	2	cvs	`}`
105
106	77	lampret	`/* Calls IMMU translation routines before simulating insn`
107			`cache for virtually indexed insn cache or after simulating insn cache`
108			`for physically indexed insn cache. It returns physical address. */`
109
110			`unsigned long simulate_ic_mmu_fetch(unsigned long virtaddr)`
111			`{`
112	239	markom	`if (config.ic.tagtype == NONE)`
113			`return virtaddr;`
114			`else`
115			`if (config.ic.tagtype == VIRTUAL) {`
116			`ic_simulate_fetch(virtaddr);`
117			`return immu_translate(virtaddr);`
118			`}`
119			`else if (config.dc.tagtype == PHYSICAL) {`
120			`unsigned long phyaddr = immu_translate(virtaddr);`
121			`ic_simulate_fetch(phyaddr);`
122			`return phyaddr;`
123			`}`
124			`else {`
125			`printf("INTERNAL ERROR: Unknown insn cache type.\n");`
126			`cont_run = 0;`
127			`}`
128	221	markom
129	239	markom	`return -1;`
130	77	lampret	`}`
131
132			`/* Calls DMMU translation routines (load cycles) before simulating data`
133	239	markom	`cache for virtually indexed data cache or after simulating data cache`
134			`for physically indexed data cache. It returns physical address. */`
135	6	lampret
136			`unsigned long simulate_dc_mmu_load(unsigned long virtaddr)`
137			`{`
138	239	markom	`if (config.dc.tagtype == NONE)`
139			`return virtaddr;`
140			`else`
141			`if (config.ic.tagtype == VIRTUAL) {`
142			`ic_simulate_fetch(virtaddr);`
143			`return immu_translate(virtaddr);`
144			`}`
145			`else if (config.dc.tagtype == PHYSICAL) {`
146			`unsigned long phyaddr = immu_translate(virtaddr);`
147			`ic_simulate_fetch(phyaddr);`
148			`return phyaddr;`
149			`}`
150			`else {`
151			`printf("INTERNAL ERROR: Unknown insn cache type.\n");`
152			`cont_run = 0;`
153			`}`
154	221	markom
155	239	markom	`return -1;`
156	6	lampret	`}`
157
158	77	lampret	`/* Calls DMMU translation routines (store cycles) before simulating data`
159	6	lampret	`cache for virtually indexed data cache or after simulating data cache`
160			`for physically indexed data cache. It returns physical address. */`
161
162			`unsigned long simulate_dc_mmu_store(unsigned long virtaddr)`
163			`{`
164	239	markom	`if (config.dc.tagtype == NONE)`
165			`return virtaddr;`
166			`else`
167			`if (config.dc.tagtype == VIRTUAL) {`
168			`dc_simulate_write(virtaddr);`
169			`return dmmu_translate(virtaddr);`
170			`}`
171			`else if (config.dc.tagtype == PHYSICAL) {`
172			`unsigned long phyaddr = dmmu_translate(virtaddr);`
173			`dc_simulate_write(phyaddr);`
174			`return phyaddr;`
175			`}`
176			`else {`
177			`printf("INTERNAL ERROR: Unknown data cache type.\n");`
178			`cont_run = 0;`
179			`}`
180	221	markom
181	239	markom	`return -1;`
182	6	lampret	`}`
183
184	261	markom	`/* Calculates bit mask to fit the data */`
185			`unsigned long bit_mask (unsigned long data) {`
186			`int i = 0;`
187			`data--;`
188			`while ((data << i) & 1)`
189			`data \|= 1 << i++;`
190			`return data;`
191			`}`
192
193			`/* Register read and write function for a memory area.`
194			`addr is inside the area, if addr & addr_mask == addr_compare`
195			`(used also by peripheral devices like 16450 UART etc.) */`
196			`void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,`
197			`unsigned long size, unsigned granularity,`
198	239	markom	`unsigned long (readfunc)(unsigned long),`
199	261	markom	`void (writefunc)(unsigned long, unsigned long))`
200	30	lampret	`{`
201	239	markom	`struct dev_memarea **pptmp;`
202	261	markom	`unsigned long size_mask = bit_mask (size);`
203			`int found_error = 0;`
204			`addr_compare &= addr_mask;`
205	221	markom
206	239	markom	`/* Go to the end of the list. */`
207	261	markom	`for(pptmp = &dev_list; pptmp; pptmp = &(pptmp)->next)`
208			`if ((addr_compare >= (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)`
209			`\|\| (addr_compare + size > (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)) {`
210	262	markom	`if (!found_error) {`
211	261	markom	`fprintf (stderr, "ERROR: Overlapping memory area(s):\n");`
212	262	markom	`fprintf (stderr, "\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare \| bit_mask (size), size, granularity);`
213			`}`
214	261	markom	`found_error = 1;`
215	262	markom	`printf ("and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (pptmp)->addr_mask, (pptmp)->addr_compare,`
216	261	markom	`(pptmp)->addr_compare \| (pptmp)->size_mask, (pptmp)->size, (pptmp)->granularity);`
217			`}`
218
219			`if (found_error)`
220			`exit (-1);`
221
222	239	markom	`cur_area = pptmp = (struct dev_memarea )malloc(sizeof(struct dev_memarea));`
223	261	markom	`(*pptmp)->addr_mask = addr_mask;`
224			`(*pptmp)->addr_compare = addr_compare;`
225	239	markom	`(*pptmp)->size = size;`
226	261	markom	`(*pptmp)->size_mask = size_mask;`
227	239	markom	`(*pptmp)->granularity = granularity;`
228			`(*pptmp)->readfunc = readfunc;`
229			`(*pptmp)->writefunc = writefunc;`
230			`(*pptmp)->next = NULL;`
231	261	markom	`}`
232	221	markom
233	261	markom	`/* Register read and write function for a memory area.`
234			`Memory areas should be aligned. Memory area is rounded up to`
235			`fit the nearest 2^n aligment.`
236			`(used also by peripheral devices like 16450 UART etc.) */`
237			`void register_memoryarea(unsigned long addr,`
238			`unsigned long size, unsigned granularity,`
239			`unsigned long (readfunc)(unsigned long),`
240			`void (writefunc)(unsigned long, unsigned long))`
241			`{`
242			`unsigned long size_mask = bit_mask (size);`
243			`unsigned long addr_mask = ~size_mask;`
244			`register_memoryarea_mask (addr_mask, addr & addr_mask,`
245			`size_mask + 1, granularity,`
246			`readfunc, writefunc);`
247	30	lampret	`}`
248
249	261	markom
250	30	lampret	`/* Check if access is to registered area of memory. */`
251			`struct dev_memarea *verify_memoryarea(unsigned long addr)`
252			`{`
253	239	markom	`struct dev_memarea *ptmp;`
254	221	markom
255	239	markom	`/* Check list of registered devices. */`
256			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
257	261	markom	`if ((addr & ptmp->addr_mask) == ptmp->addr_compare)`
258	239	markom	`return cur_area = ptmp;`
259			`return cur_area = NULL;`
260	30	lampret	`}`
261
262	2	cvs	`/* Returns 32-bit values from mem array. Big endian version. */`
263	123	markom	`unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)`
264	2	cvs	`{`
265	6	lampret
266	239	markom	`unsigned long temp;`
267			`struct dev_memarea *dev;`
268	123	markom
269	239	markom	`slp_checkaccess(memaddr, SLP_MEMREAD);`
270			`memaddr = simulate_dc_mmu_load(memaddr);`
271	270	markom	`if (DEBUG_ENABLED)`
272			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
273	239	markom	`temp = evalsim_mem32(memaddr);`
274	270	markom	`if (DEBUG_ENABLED)`
275			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
276	239	markom	`return temp;`
277	66	lampret	`}`
278
279	221	markom	`unsigned long evalsim_mem32(unsigned long memaddr)`
280	66	lampret	`{`
281	239	markom	`unsigned long temp;`
282	221	markom
283	239	markom	`if (verify_memoryarea(memaddr)) {`
284			`switch(cur_area->granularity) {`
285			`case 1:`
286			`temp = cur_area->readfunc(memaddr) << 24;`
287			`temp \|= cur_area->readfunc(memaddr + 1) << 16;`
288			`temp \|= cur_area->readfunc(memaddr + 2) << 8;`
289			`temp \|= cur_area->readfunc(memaddr + 3);`
290			`break;`
291			`case 2:`
292			`temp = cur_area->readfunc(memaddr) << 16;`
293			`temp \|= cur_area->readfunc(memaddr + 2);`
294			`break;`
295			`case 4:`
296			`temp = cur_area->readfunc(memaddr);`
297			`break;`
298			`}`
299			`} else {`
300			`printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
301			`cont_run = 0;`
302			`temp = 0;`
303			`}`
304			`return temp;`
305	2	cvs	`}`
306
307			`/* Returns 16-bit values from mem array. Big endian version. */`
308
309	123	markom	`unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)`
310	2	cvs	`{`
311	239	markom	`unsigned short temp;`
312			`memaddr = simulate_dc_mmu_load(memaddr);`
313	270	markom	`if (DEBUG_ENABLED)`
314			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
315	66	lampret
316	239	markom	`temp = evalsim_mem16(memaddr);`
317	270	markom	`if (DEBUG_ENABLED)`
318			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
319	239	markom	`return temp;`
320	66	lampret	`}`
321
322	221	markom	`unsigned short evalsim_mem16(unsigned long memaddr)`
323	66	lampret	`{`
324	239	markom	`unsigned short temp;`
325	221	markom
326	239	markom	`if (verify_memoryarea(memaddr)) {`
327			`switch(cur_area->granularity) {`
328			`case 1:`
329			`temp = cur_area->readfunc(memaddr) << 8;`
330			`temp \|= cur_area->readfunc(memaddr + 1);`
331			`break;`
332			`case 2:`
333			`temp = cur_area->readfunc(memaddr);`
334			`break;`
335			`case 4:`
336			`printf("EXCEPTION: read 16-bit value from 32-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);`
337			`cont_run = 0;`
338			`break;`
339			`}`
340			`} else {`
341			`printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
342			`cont_run = 0;`
343			`temp = 0;`
344			`}`
345			`return temp;`
346	2	cvs	`}`
347
348
349	6	lampret	`/* Returns 8-bit values from mem array. */`
350	2	cvs
351	123	markom	`unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)`
352	221	markom	`{`
353	239	markom	`unsigned char temp;`
354			`memaddr = simulate_dc_mmu_load(memaddr);`
355	270	markom	`if (DEBUG_ENABLED)`
356			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
357	6	lampret
358	239	markom	`temp = evalsim_mem8(memaddr);`
359	270	markom	`if (DEBUG_ENABLED)`
360			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
361	239	markom	`return temp;`
362	66	lampret	`}`
363
364	221	markom	`unsigned char evalsim_mem8(unsigned long memaddr)`
365			`{`
366	239	markom	`unsigned char temp;`
367	123	markom
368	239	markom	`if (verify_memoryarea(memaddr)) {`
369			`switch(cur_area->granularity) {`
370			`case 1:`
371			`temp = cur_area->readfunc(memaddr);`
372			`break;`
373			`case 2:`
374			`case 4:`
375			`printf("EXCEPTION: read 8-bit value from %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);`
376			`cont_run = 0;`
377			`break;`
378			`}`
379			`} else {`
380			`printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);`
381			`cont_run = 0;`
382			`temp = 0;`
383			`}`
384			`return temp;`
385	2	cvs	`}`
386
387			`/* Set mem, 32-bit. Big endian version. */`
388
389	123	markom	`void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)`
390	2	cvs	`{`
391	239	markom	`slp_checkaccess(memaddr, SLP_MEMWRITE);`
392			`memaddr = simulate_dc_mmu_store(memaddr);`
393	221	markom
394	270	markom	`if (DEBUG_ENABLED) {`
395			`breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); / 28/05/01 CZ */`
396			`*breakpoint += CheckDebugUnit(DebugStoreData,value);`
397			`}`
398	123	markom
399	239	markom	`setsim_mem32(memaddr, value);`
400	66	lampret	`}`
401
402			`void setsim_mem32(unsigned long memaddr, unsigned long value)`
403			`{`
404	239	markom	`struct dev_memarea *dev;`
405	66	lampret
406	239	markom	`if (verify_memoryarea(memaddr)) {`
407			`switch(cur_area->granularity) {`
408			`case 1:`
409	251	erez	`cur_area->writefunc(memaddr , (value >> 24) & 0xFF);`
410	239	markom	`cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);`
411	251	erez	`cur_area->writefunc(memaddr + 2, (value >> 8) & 0xFF);`
412			`cur_area->writefunc(memaddr + 3, (value ) & 0xFF);`
413	239	markom	`break;`
414			`case 2:`
415			`cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);`
416			`cur_area->writefunc(memaddr + 2, value & 0xFFFF);`
417			`break;`
418			`case 4:`
419			`cur_area->writefunc(memaddr, value);`
420			`break;`
421	242	markom	`}`
422	239	markom	`} else {`
423			`printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);`
424			`cont_run = 0;`
425			`}`
426	2	cvs	`}`
427
428			`/* Set mem, 16-bit. Big endian version. */`
429
430	123	markom	`void set_mem16(unsigned long memaddr, unsigned short value,int* breakpoint)`
431	2	cvs	`{`
432	239	markom	`memaddr = simulate_dc_mmu_store(memaddr);`
433	221	markom
434	270	markom	`if (DEBUG_ENABLED) {`
435			`breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); / 28/05/01 CZ */`
436			`*breakpoint += CheckDebugUnit(DebugStoreData,value);`
437			`}`
438	123	markom
439	239	markom	`setsim_mem16(memaddr, value);`
440	66	lampret	`}`
441
442			`void setsim_mem16(unsigned long memaddr, unsigned short value)`
443			`{`
444	239	markom	`if (verify_memoryarea(memaddr)) {`
445			`switch(cur_area->granularity) {`
446			`case 1:`
447			`cur_area->writefunc(memaddr, (value >> 8) & 0xFF);`
448			`cur_area->writefunc(memaddr + 1, value & 0xFF);`
449			`break;`
450			`case 2:`
451	251	erez	`cur_area->writefunc(memaddr, value & 0xFFFF);`
452	239	markom	`break;`
453			`case 4:`
454			`printf("EXCEPTION: write 16-bit value to 32-bit region (address 0x%08lX)\n", memaddr);`
455			`cont_run = 0;`
456			`break;`
457			`}`
458			`} else {`
459			`printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);`
460			`cont_run = 0;`
461			`}`
462	2	cvs	`}`
463
464	6	lampret	`/* Set mem, 8-bit. */`
465	2	cvs
466	123	markom	`void set_mem8(unsigned long memaddr, unsigned char value,int* breakpoint)`
467	2	cvs	`{`
468	239	markom	`memaddr = simulate_dc_mmu_store(memaddr);`
469	221	markom
470	270	markom	`if (DEBUG_ENABLED) {`
471			`breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); / 28/05/01 CZ */`
472			`*breakpoint += CheckDebugUnit(DebugStoreData,value);`
473			`}`
474	123	markom
475	239	markom	`setsim_mem8(memaddr, value);`
476	66	lampret	`}`
477
478			`void setsim_mem8(unsigned long memaddr, unsigned char value)`
479			`{`
480	239	markom	`if (verify_memoryarea(memaddr)) {`
481			`if (cur_area->granularity == 1)`
482			`cur_area->writefunc(memaddr, value);`
483			`else {`
484			`printf("EXCEPTION: write 8-bit value to %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);`
485			`cont_run = 0;`
486			`}`
487			`} else {`
488			`printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);`
489			`cont_run = 0;`
490			`}`
491	2	cvs	`}`
492	30	lampret
493	235	erez	`unsigned long simmem_read_byte(unsigned long addr) {`
494	297	markom	`return simmem[cur_area->misc + (addr & cur_area->size_mask)].data;`
495	221	markom	`}`
496
497	235	erez	`void simmem_write_byte(unsigned long addr, unsigned long value) {`
498	297	markom	`simmem[cur_area->misc + (addr & cur_area->size_mask)].data = (unsigned char)value;`
499	221	markom	`}`
500

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [nog_patch_42/] [or1ksim/] [cpu/] [common/] [abstract.c] - Blame information for rev 297