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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [sh3-rom.c] - Blame information for rev 578

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

Line No. Rev Author Line
1 578 markom
/* Remote target glue for the Hitachi SH-3 ROM monitor.
2
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include "defs.h"
23
#include "gdbcore.h"
24
#include "target.h"
25
#include "monitor.h"
26
#include "serial.h"
27
#include "srec.h"
28
#include "arch-utils.h"
29
#include "regcache.h"
30
 
31
static serial_t parallel;
32
static int parallel_in_use;
33
 
34
static void sh3_open (char *args, int from_tty);
35
 
36
static void
37
sh3_supply_register (char *regname, int regnamelen, char *val, int vallen)
38
{
39
  int numregs;
40
  int regno;
41
 
42
  numregs = 1;
43
  regno = -1;
44
 
45
  if (regnamelen == 2)
46
    {
47
      switch (regname[0])
48
        {
49
        case 'S':
50
          if (regname[1] == 'R')
51
            regno = SR_REGNUM;
52
          break;
53
        case 'P':
54
          if (regname[1] == 'C')
55
            regno = PC_REGNUM;
56
          else if (regname[1] == 'R')
57
            regno = PR_REGNUM;
58
          break;
59
        }
60
    }
61
  else if (regnamelen == 3)
62
    {
63
      switch (regname[0])
64
        {
65
        case 'G':
66
        case 'V':
67
          if (regname[1] == 'B' && regname[2] == 'R')
68
            {
69
              if (regname[0] == 'G')
70
                regno = VBR_REGNUM;
71
              else
72
                regno = GBR_REGNUM;
73
            }
74
          break;
75
        case 'S':
76
          if (regname[1] == 'S' && regname[2] == 'R')
77
            regno = gdbarch_tdep (current_gdbarch)->SSR_REGNUM;
78
          else if (regname[1] == 'P' && regname[2] == 'C')
79
            regno = gdbarch_tdep (current_gdbarch)->SPC_REGNUM;
80
          break;
81
        }
82
    }
83
  else if (regnamelen == 4)
84
    {
85
      switch (regname[0])
86
        {
87
        case 'M':
88
          if (regname[1] == 'A' && regname[2] == 'C')
89
            {
90
              if (regname[3] == 'H')
91
                regno = MACH_REGNUM;
92
              else if (regname[3] == 'L')
93
                regno = MACL_REGNUM;
94
            }
95
          break;
96
        case 'R':
97
          if (regname[1] == '0' && regname[2] == '-' && regname[3] == '7')
98
            {
99
              regno = R0_REGNUM;
100
              numregs = 8;
101
            }
102
        }
103
    }
104
  else if (regnamelen == 5)
105
    {
106
      if (regname[1] == '8' && regname[2] == '-' && regname[3] == '1'
107
          && regname[4] == '5')
108
        {
109
          regno = R0_REGNUM + 8;
110
          numregs = 8;
111
        }
112
    }
113
  else if (regnamelen == 17)
114
    {
115
    }
116
 
117
  if (regno >= 0)
118
    while (numregs-- > 0)
119
      val = monitor_supply_register (regno++, val);
120
}
121
 
122
static void
123
sh3_load (serial_t desc, char *file, int hashmark)
124
{
125
  if (parallel_in_use)
126
    {
127
      monitor_printf ("pl;s\r");
128
      load_srec (parallel, file, 0, 80, SREC_ALL, hashmark, NULL);
129
      monitor_expect_prompt (NULL, 0);
130
    }
131
  else
132
    {
133
      monitor_printf ("il;s:x\r");
134
      monitor_expect ("\005", NULL, 0);          /* Look for ENQ */
135
      SERIAL_WRITE (desc, "\006", 1);   /* Send ACK */
136
      monitor_expect ("LO x\r", NULL, 0);        /* Look for filename */
137
 
138
      load_srec (desc, file, 0, 80, SREC_ALL, hashmark, NULL);
139
 
140
      monitor_expect ("\005", NULL, 0);          /* Look for ENQ */
141
      SERIAL_WRITE (desc, "\006", 1);   /* Send ACK */
142
      monitor_expect_prompt (NULL, 0);
143
    }
144
}
145
 
146
/* This array of registers need to match the indexes used by GDB.
147
   This exists because the various ROM monitors use different strings
148
   than does GDB, and don't necessarily support all the registers
149
   either. So, typing "info reg sp" becomes a "r30".  */
150
 
151
static char *sh3_regnames[] =
152
{
153
  "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
154
  "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
155
  "PC", "PR", "GBR", "VBR", "MACH", "MACL", "SR",
156
  NULL, NULL,
157
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
158
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
159
  "SSR", "SPC",
160
  "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
161
  "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
162
  "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
163
  "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
164
};
165
 
166
static char *sh3e_regnames[] =
167
{
168
  "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
169
  "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
170
  "PC", "PR", "GBR", "VBR", "MACH", "MACL", "SR",
171
  "FPUL", "FPSCR",
172
  "FR0", "FR1", "FR2", "FR3", "FR4", "FR5", "FR6", "FR7",
173
  "FR8", "FR9", "FR10", "FR11", "FR12", "FR13", "FR14", "FR15",
174
  "SSR", "SPC",
175
  "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
176
  "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
177
  "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
178
  "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
179
};
180
 
181
/* Define the monitor command strings. Since these are passed directly
182
   through to a printf style function, we may include formatting
183
   strings. We also need a CR or LF on the end.  */
184
 
185
static struct target_ops sh3_ops, sh3e_ops;
186
 
187
static char *sh3_inits[] =
188
{"\003", NULL};                 /* Exits sub-command mode & download cmds */
189
 
190
static struct monitor_ops sh3_cmds;
191
 
192
static void
193
init_sh3_cmds (void)
194
{
195
  sh3_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_GETMEM_READ_SINGLE;      /* flags */
196
  sh3_cmds.init = sh3_inits;    /* monitor init string */
197
  sh3_cmds.cont = "g\r";        /* continue command */
198
  sh3_cmds.step = "s\r";        /* single step */
199
  sh3_cmds.stop = "\003";       /* Interrupt program */
200
  sh3_cmds.set_break = "b %x\r";        /* set a breakpoint */
201
  sh3_cmds.clr_break = "b -%x\r";       /* clear a breakpoint */
202
  sh3_cmds.clr_all_break = "b -\r";     /* clear all breakpoints */
203
  sh3_cmds.fill = "f %x @%x %x\r";      /* fill (start len val) */
204
  sh3_cmds.setmem.cmdb = "m %x %x\r";   /* setmem.cmdb (addr, value) */
205
  sh3_cmds.setmem.cmdw = "m %x %x;w\r";         /* setmem.cmdw (addr, value) */
206
  sh3_cmds.setmem.cmdl = "m %x %x;l\r";         /* setmem.cmdl (addr, value) */
207
  sh3_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */
208
  sh3_cmds.setmem.resp_delim = NULL;    /* setreg.resp_delim */
209
  sh3_cmds.setmem.term = NULL;  /* setreg.term */
210
  sh3_cmds.setmem.term_cmd = NULL;      /* setreg.term_cmd */
211
  sh3_cmds.getmem.cmdb = "m %x\r";      /* getmem.cmdb (addr, len) */
212
  sh3_cmds.getmem.cmdw = "m %x;w\r";    /* getmem.cmdw (addr, len) */
213
  sh3_cmds.getmem.cmdl = "m %x;l\r";    /* getmem.cmdl (addr, len) */
214
  sh3_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */
215
  sh3_cmds.getmem.resp_delim = "^ [0-9A-F]+ ";  /* getmem.resp_delim */
216
  sh3_cmds.getmem.term = "? ";  /* getmem.term */
217
  sh3_cmds.getmem.term_cmd = ".\r";     /* getmem.term_cmd */
218
  sh3_cmds.setreg.cmd = ".%s %x\r";     /* setreg.cmd (name, value) */
219
  sh3_cmds.setreg.resp_delim = NULL;    /* setreg.resp_delim */
220
  sh3_cmds.setreg.term = NULL;  /* setreg.term */
221
  sh3_cmds.setreg.term_cmd = NULL;      /* setreg.term_cmd */
222
  sh3_cmds.getreg.cmd = ".%s\r";        /* getreg.cmd (name) */
223
  sh3_cmds.getreg.resp_delim = "=";     /* getreg.resp_delim */
224
  sh3_cmds.getreg.term = "? ";  /* getreg.term */
225
  sh3_cmds.getreg.term_cmd = ".\r";     /* getreg.term_cmd */
226
  sh3_cmds.dump_registers = "r\r";      /* dump_registers */
227
  sh3_cmds.register_pattern = "\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)";
228
  sh3_cmds.supply_register = sh3_supply_register;       /* supply_register */
229
  sh3_cmds.load_routine = sh3_load;     /* load_routine */
230
  sh3_cmds.load = NULL;         /* download command */
231
  sh3_cmds.loadresp = NULL;     /* Load response */
232
  sh3_cmds.prompt = "\n:";      /* monitor command prompt */
233
  sh3_cmds.line_term = "\r";    /* end-of-line terminator */
234
  sh3_cmds.cmd_end = ".\r";     /* optional command terminator */
235
  sh3_cmds.target = &sh3_ops;   /* target operations */
236
  sh3_cmds.stopbits = SERIAL_1_STOPBITS;        /* number of stop bits */
237
  sh3_cmds.regnames = sh3_regnames;     /* registers names */
238
  sh3_cmds.magic = MONITOR_OPS_MAGIC;   /* magic */
239
}                               /* init_sh3_cmds */
240
 
241
/* This monitor structure is identical except for a couple slots, so
242
   we will fill it in from the base structure when needed.  */
243
 
244
static struct monitor_ops sh3e_cmds;
245
 
246
static void
247
sh3_open (char *args, int from_tty)
248
{
249
  char *serial_port_name = args;
250
  char *parallel_port_name = 0;
251
 
252
  if (args)
253
    {
254
      char *cursor = serial_port_name = xstrdup (args);
255
 
256
      while (*cursor && *cursor != ' ')
257
        cursor++;
258
 
259
      if (*cursor)
260
        *cursor++ = 0;
261
 
262
      while (*cursor == ' ')
263
        cursor++;
264
 
265
      if (*cursor)
266
        parallel_port_name = cursor;
267
    }
268
 
269
  monitor_open (serial_port_name, &sh3_cmds, from_tty);
270
 
271
  if (parallel_port_name)
272
    {
273
      parallel = SERIAL_OPEN (parallel_port_name);
274
 
275
      if (!parallel)
276
        perror_with_name ("Unable to open parallel port.");
277
 
278
      parallel_in_use = 1;
279
    }
280
 
281
  /* If we connected successfully, we know the processor is an SH3.  */
282
  set_architecture_from_arch_mach (bfd_arch_sh, bfd_mach_sh3);
283
}
284
 
285
 
286
static void
287
sh3e_open (char *args, int from_tty)
288
{
289
  char *serial_port_name = args;
290
  char *parallel_port_name = 0;
291
 
292
  if (args)
293
    {
294
      char *cursor = serial_port_name = xstrdup (args);
295
 
296
      while (*cursor && *cursor != ' ')
297
        cursor++;
298
 
299
      if (*cursor)
300
        *cursor++ = 0;
301
 
302
      while (*cursor == ' ')
303
        cursor++;
304
 
305
      if (*cursor)
306
        parallel_port_name = cursor;
307
    }
308
 
309
  /* Set up the SH-3E monitor commands structure.  */
310
 
311
  memcpy (&sh3e_cmds, &sh3_cmds, sizeof (struct monitor_ops));
312
 
313
  sh3e_cmds.target = &sh3e_ops;
314
  sh3e_cmds.regnames = sh3e_regnames;
315
 
316
  monitor_open (serial_port_name, &sh3e_cmds, from_tty);
317
 
318
  if (parallel_port_name)
319
    {
320
      parallel = SERIAL_OPEN (parallel_port_name);
321
 
322
      if (!parallel)
323
        perror_with_name ("Unable to open parallel port.");
324
 
325
      parallel_in_use = 1;
326
    }
327
 
328
  /* If we connected successfully, we know the processor is an SH3E.  */
329
  set_architecture_from_arch_mach (bfd_arch_sh, bfd_mach_sh3);
330
}
331
 
332
static void
333
sh3_close (int quitting)
334
{
335
  monitor_close (quitting);
336
  if (parallel_in_use)
337
    {
338
      SERIAL_CLOSE (parallel);
339
      parallel_in_use = 0;
340
    }
341
}
342
 
343
void
344
_initialize_sh3_rom (void)
345
{
346
  init_sh3_cmds ();
347
  init_monitor_ops (&sh3_ops);
348
 
349
  sh3_ops.to_shortname = "sh3";
350
  sh3_ops.to_longname = "Hitachi SH-3 rom monitor";
351
 
352
  sh3_ops.to_doc =
353
  /* We can download through the parallel port too. */
354
    "Debug on a Hitachi eval board running the SH-3E rom monitor.\n"
355
    "Specify the serial device it is connected to.\n"
356
    "If you want to use the parallel port to download to it, specify that\n"
357
    "as an additional second argument.";
358
 
359
  sh3_ops.to_open = sh3_open;
360
  sh3_ops.to_close = sh3_close;
361
 
362
  add_target (&sh3_ops);
363
 
364
  /* Setup the SH3e, which has float registers.  */
365
 
366
  init_monitor_ops (&sh3e_ops);
367
 
368
  sh3e_ops.to_shortname = "sh3e";
369
  sh3e_ops.to_longname = "Hitachi SH-3E rom monitor";
370
 
371
  sh3e_ops.to_doc =
372
  /* We can download through the parallel port too. */
373
    "Debug on a Hitachi eval board running the SH-3E rom monitor.\n"
374
    "Specify the serial device it is connected to.\n"
375
    "If you want to use the parallel port to download to it, specify that\n"
376
    "as an additional second argument.";
377
 
378
  sh3e_ops.to_open = sh3e_open;
379
  sh3e_ops.to_close = sh3_close;
380
 
381
  add_target (&sh3e_ops);
382
}

powered by: WebSVN 2.1.0

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