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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [testsuite/] [gdb.base/] [m32rovly.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
 
2
/*
3
 * Ovlymgr.c -- Runtime Overlay Manager for the GDB testsuite.
4
 */
5
 
6
#include "ovlymgr.h"
7
 
8
/* Local functions and data: */
9
 
10
extern unsigned long _ovly_table[][4];
11
extern unsigned long _novlys __attribute__ ((section (".data")));
12
enum ovly_index { VMA, SIZE, LMA, MAPPED};
13
 
14
static void ovly_copy (unsigned long dst, unsigned long src, long size);
15
 
16
/* Flush the data and instruction caches at address START for SIZE bytes.
17
   Support for each new port must be added here.  */
18
/* FIXME: Might be better to have a standard libgloss function that
19
   ports provide that we can then use.  Use libgloss instead of newlib
20
   since libgloss is the one intended to handle low level system issues.
21
   I would suggest something like _flush_cache to avoid the user's namespace
22
   but not be completely obscure as other things may need this facility.  */
23
 
24
static void
25
FlushCache (void)
26
{
27
#ifdef __M32R__
28
  volatile char *mspr = (char *) 0xfffffff7;
29
  *mspr = 1;
30
#endif
31
}
32
 
33
/* OverlayLoad:
34
 * Copy the overlay into its runtime region,
35
 * and mark the overlay as "mapped".
36
 */
37
 
38
bool
39
OverlayLoad (unsigned long ovlyno)
40
{
41
  unsigned long i;
42
 
43
  if (ovlyno < 0 || ovlyno >= _novlys)
44
    exit (-1);  /* fail, bad ovly number */
45
 
46
  if (_ovly_table[ovlyno][MAPPED])
47
    return TRUE;        /* this overlay already mapped -- nothing to do! */
48
 
49
  for (i = 0; i < _novlys; i++)
50
    if (i == ovlyno)
51
      _ovly_table[i][MAPPED] = 1;       /* this one now mapped */
52
    else if (_ovly_table[i][VMA] == _ovly_table[ovlyno][VMA])
53
      _ovly_table[i][MAPPED] = 0;        /* this one now un-mapped */
54
 
55
  ovly_copy (_ovly_table[ovlyno][VMA],
56
             _ovly_table[ovlyno][LMA],
57
             _ovly_table[ovlyno][SIZE]);
58
 
59
  FlushCache ();
60
 
61
  return TRUE;
62
}
63
 
64
/* OverlayUnload:
65
 * Copy the overlay back into its "load" region.
66
 * Does NOT mark overlay as "unmapped", therefore may be called
67
 * more than once for the same mapped overlay.
68
 */
69
 
70
bool
71
OverlayUnload (unsigned long ovlyno)
72
{
73
  if (ovlyno < 0 || ovlyno >= _novlys)
74
    exit (-1);  /* fail, bad ovly number */
75
 
76
  if (!_ovly_table[ovlyno][MAPPED])
77
    exit (-1);  /* error, can't copy out a segment that's not "in" */
78
 
79
  ovly_copy (_ovly_table[ovlyno][LMA],
80
             _ovly_table[ovlyno][VMA],
81
             _ovly_table[ovlyno][SIZE]);
82
 
83
  return TRUE;
84
}
85
 
86
#ifdef __D10V__
87
#define IMAP0       (*(short *)(0xff00))
88
#define IMAP1       (*(short *)(0xff02))
89
#define DMAP        (*(short *)(0xff04))
90
 
91
static void
92
D10VTranslate (unsigned long logical,
93
               short *dmap,
94
               unsigned long **addr)
95
{
96
  unsigned long physical;
97
  unsigned long seg;
98
  unsigned long off;
99
 
100
  /* to access data, we use the following mapping
101
     0x00xxxxxx: Logical data address segment        (DMAP translated memory)
102
     0x01xxxxxx: Logical instruction address segment (IMAP translated memory)
103
     0x10xxxxxx: Physical data memory segment        (On-chip data memory)
104
     0x11xxxxxx: Physical instruction memory segment (On-chip insn memory)
105
     0x12xxxxxx: Phisical unified memory segment     (Unified memory)
106
     */
107
 
108
  /* Addresses must be correctly aligned */
109
  if (logical & (sizeof (**addr) - 1))
110
    exit (-1);
111
 
112
  /* If the address is in one of the two logical address spaces, it is
113
     first translated into a physical address */
114
  seg = (logical >> 24);
115
  off = (logical & 0xffffffL);
116
  switch (seg)
117
      {
118
      case 0x00: /* in logical data address segment */
119
        if (off <= 0x7fffL)
120
          physical = (0x10L << 24) + off;
121
        else
122
          /* Logical address out side of on-chip segment, not
123
             supported */
124
          exit (-1);
125
        break;
126
      case 0x01: /* in logical instruction address segment */
127
        {
128
          short map;
129
          if (off <= 0x1ffffL)
130
            map = IMAP0;
131
          else if (off <= 0x3ffffL)
132
            map = IMAP1;
133
          else
134
            /* Logical address outside of IMAP[01] segment, not
135
               supported */
136
            exit (-1);
137
          if (map & 0x1000L)
138
            {
139
            /* Instruction memory */
140
              physical = (0x11L << 24) | off;
141
            }
142
          else
143
            {
144
            /* Unified memory */
145
              physical = ((map & 0x7fL) << 17) + (off & 0x1ffffL);
146
              if (physical > 0xffffffL)
147
                /* Address outside of unified address segment */
148
                exit (-1);
149
              physical |= (0x12L << 24);
150
            }
151
          break;
152
        }
153
      case 0x10:
154
      case 0x11:
155
      case 0x12:
156
        physical = logical;
157
        break;
158
      default:
159
        exit (-1);      /* error */
160
      }
161
 
162
  seg = (physical >> 24);
163
  off = (physical & 0xffffffL);
164
  switch (seg)
165
    {
166
    case 0x10:  /* dst is a 15 bit offset into the on-chip memory */
167
      *dmap = 0;
168
      *addr = (long *) (0x0000 + ((short)off & 0x7fff));
169
      break;
170
    case 0x11:  /* dst is an 18-bit offset into the on-chip
171
                   instruction memory */
172
      *dmap = 0x1000L | ((off & 0x3ffffL) >> 14);
173
      *addr = (long *) (0x8000 + ((short)off & 0x3fff));
174
      break;
175
    case 0x12:  /* dst is a 24-bit offset into unified memory */
176
      *dmap = off >> 14;
177
      *addr = (long *) (0x8000 + ((short)off & 0x3fff));
178
      break;
179
    default:
180
      exit (-1);        /* error */
181
    }
182
}
183
#endif /* __D10V__ */
184
 
185
static void
186
ovly_copy (unsigned long dst, unsigned long src, long size)
187
{
188
#ifdef  __M32R__
189
  memcpy ((void *) dst, (void *) src, size);
190
  return;
191
#endif /* M32R */
192
 
193
#ifdef  __D10V__
194
  unsigned long *s, *d, tmp;
195
  short dmap_src, dmap_dst;
196
  short dmap_save;
197
 
198
  /* all section sizes should by multiples of 4 bytes */
199
  dmap_save = DMAP;
200
 
201
  D10VTranslate (src, &dmap_src, &s);
202
  D10VTranslate (dst, &dmap_dst, &d);
203
 
204
  while (size > 0)
205
    {
206
      /* NB: Transfer 4 byte (long) quantites, problems occure
207
         when only two bytes are transfered */
208
      DMAP = dmap_src;
209
      tmp = *s;
210
      DMAP = dmap_dst;
211
      *d = tmp;
212
      d++;
213
      s++;
214
      size -= sizeof (tmp);
215
      src += sizeof (tmp);
216
      dst += sizeof (tmp);
217
      if ((src & 0x3fff) == 0)
218
        D10VTranslate (src, &dmap_src, &s);
219
      if ((dst & 0x3fff) == 0)
220
        D10VTranslate (dst, &dmap_dst, &d);
221
    }
222
  DMAP = dmap_save;
223
#endif /* D10V */
224
}
225
 

powered by: WebSVN 2.1.0

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