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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [dve3900-rom.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Remote debugging interface for Densan DVE-R3900 ROM monitor for
2
   GDB, the GNU debugger.
3
   Copyright 1997, 1998, 2000, 2001 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 "inferior.h"
28
#include "command.h"
29
#include "gdb_string.h"
30
#include <time.h>
31
#include "regcache.h"
32
 
33
/* Type of function passed to bfd_map_over_sections.  */
34
 
35
typedef void (*section_map_func) (bfd * abfd, asection * sect, PTR obj);
36
 
37
/* Packet escape character used by Densan monitor.  */
38
 
39
#define PESC 0xdc
40
 
41
/* Maximum packet size.  This is actually smaller than necessary
42
   just to be safe.  */
43
 
44
#define MAXPSIZE 1024
45
 
46
/* External functions.  */
47
 
48
extern void report_transfer_performance (unsigned long, time_t, time_t);
49
 
50
/* Certain registers are "bitmapped", in that the monitor can only display
51
   them or let the user modify them as a series of named bitfields.
52
   This structure describes a field in a bitmapped register.  */
53
 
54
struct bit_field
55
  {
56
    char *prefix;               /* string appearing before the value */
57
    char *suffix;               /* string appearing after the value */
58
    char *user_name;            /* name used by human when entering field value */
59
    int length;                 /* number of bits in the field */
60
    int start;                  /* starting (least significant) bit number of field */
61
  };
62
 
63
/* Local functions for register manipulation.  */
64
 
65
static void r3900_supply_register (char *regname, int regnamelen,
66
                                   char *val, int vallen);
67
static void fetch_bad_vaddr (void);
68
static unsigned long fetch_fields (struct bit_field *bf);
69
static void fetch_bitmapped_register (int regno, struct bit_field *bf);
70
static void r3900_fetch_registers (int regno);
71
static void store_bitmapped_register (int regno, struct bit_field *bf);
72
static void r3900_store_registers (int regno);
73
 
74
/* Local functions for fast binary loading.  */
75
 
76
static void write_long (char *buf, long n);
77
static void write_long_le (char *buf, long n);
78
static int debug_readchar (int hex);
79
static void debug_write (unsigned char *buf, int buflen);
80
static void ignore_packet (void);
81
static void send_packet (char type, unsigned char *buf, int buflen, int seq);
82
static void process_read_request (unsigned char *buf, int buflen);
83
static void count_section (bfd * abfd, asection * s,
84
                           unsigned int *section_count);
85
static void load_section (bfd * abfd, asection * s, unsigned int *data_count);
86
static void r3900_load (char *filename, int from_tty);
87
 
88
/* Miscellaneous local functions.  */
89
 
90
static void r3900_open (char *args, int from_tty);
91
 
92
 
93
/* Pointers to static functions in monitor.c for fetching and storing
94
   registers.  We can't use these function in certain cases where the Densan
95
   monitor acts perversely: for registers that it displays in bit-map
96
   format, and those that can't be modified at all.  In those cases
97
   we have to use our own functions to fetch and store their values.  */
98
 
99
static void (*orig_monitor_fetch_registers) (int regno);
100
static void (*orig_monitor_store_registers) (int regno);
101
 
102
/* Pointer to static function in monitor. for loading programs.
103
   We use this function for loading S-records via the serial link.  */
104
 
105
static void (*orig_monitor_load) (char *file, int from_tty);
106
 
107
/* This flag is set if a fast ethernet download should be used.  */
108
 
109
static int ethernet = 0;
110
 
111
/* This array of registers needs to match the indexes used by GDB. The
112
   whole reason this exists is because the various ROM monitors use
113
   different names than GDB does, and don't support all the registers
114
   either.  */
115
 
116
static char *r3900_regnames[NUM_REGS] =
117
{
118
  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
119
  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
120
  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
121
  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
122
 
123
  "S",                          /* PS_REGNUM */
124
  "l",                          /* LO_REGNUM */
125
  "h",                          /* HI_REGNUM */
126
  "B",                          /* BADVADDR_REGNUM */
127
  "Pcause",                     /* CAUSE_REGNUM */
128
  "p"                           /* PC_REGNUM */
129
};
130
 
131
 
132
/* Table of register names produced by monitor's register dump command.  */
133
 
134
static struct reg_entry
135
  {
136
    char *name;
137
    int regno;
138
  }
139
reg_table[] =
140
{
141
  {
142
    "r0_zero", 0
143
  }
144
  ,
145
  {
146
    "r1_at", 1
147
  }
148
  ,
149
  {
150
    "r2_v0", 2
151
  }
152
  ,
153
  {
154
    "r3_v1", 3
155
  }
156
  ,
157
  {
158
    "r4_a0", 4
159
  }
160
  ,
161
  {
162
    "r5_a1", 5
163
  }
164
  ,
165
  {
166
    "r6_a2", 6
167
  }
168
  ,
169
  {
170
    "r7_a3", 7
171
  }
172
  ,
173
  {
174
    "r8_t0", 8
175
  }
176
  ,
177
  {
178
    "r9_t1", 9
179
  }
180
  ,
181
  {
182
    "r10_t2", 10
183
  }
184
  ,
185
  {
186
    "r11_t3", 11
187
  }
188
  ,
189
  {
190
    "r12_t4", 12
191
  }
192
  ,
193
  {
194
    "r13_t5", 13
195
  }
196
  ,
197
  {
198
    "r14_t6", 14
199
  }
200
  ,
201
  {
202
    "r15_t7", 15
203
  }
204
  ,
205
  {
206
    "r16_s0", 16
207
  }
208
  ,
209
  {
210
    "r17_s1", 17
211
  }
212
  ,
213
  {
214
    "r18_s2", 18
215
  }
216
  ,
217
  {
218
    "r19_s3", 19
219
  }
220
  ,
221
  {
222
    "r20_s4", 20
223
  }
224
  ,
225
  {
226
    "r21_s5", 21
227
  }
228
  ,
229
  {
230
    "r22_s6", 22
231
  }
232
  ,
233
  {
234
    "r23_s7", 23
235
  }
236
  ,
237
  {
238
    "r24_t8", 24
239
  }
240
  ,
241
  {
242
    "r25_t9", 25
243
  }
244
  ,
245
  {
246
    "r26_k0", 26
247
  }
248
  ,
249
  {
250
    "r27_k1", 27
251
  }
252
  ,
253
  {
254
    "r28_gp", 28
255
  }
256
  ,
257
  {
258
    "r29_sp", 29
259
  }
260
  ,
261
  {
262
    "r30_fp", 30
263
  }
264
  ,
265
  {
266
    "r31_ra", 31
267
  }
268
  ,
269
  {
270
    "HI", HI_REGNUM
271
  }
272
  ,
273
  {
274
    "LO", LO_REGNUM
275
  }
276
  ,
277
  {
278
    "PC", PC_REGNUM
279
  }
280
  ,
281
  {
282
    "BadV", BADVADDR_REGNUM
283
  }
284
  ,
285
  {
286
    NULL, 0
287
  }
288
};
289
 
290
 
291
/* The monitor displays the cache register along with the status register,
292
   as if they were a single register.  So when we want to fetch the
293
   status register, parse but otherwise ignore the fields of the
294
   cache register that the monitor displays.  Register fields that should
295
   be ignored have a length of zero in the tables below.  */
296
 
297
static struct bit_field status_fields[] =
298
{
299
  /* Status register portion */
300
  {"SR[<CU=", " ", "cu", 4, 28},
301
  {"RE=", " ", "re", 1, 25},
302
  {"BEV=", " ", "bev", 1, 22},
303
  {"TS=", " ", "ts", 1, 21},
304
  {"Nmi=", " ", "nmi", 1, 20},
305
  {"INT=", " ", "int", 6, 10},
306
  {"SW=", ">]", "sw", 2, 8},
307
  {"[<KUO=", " ", "kuo", 1, 5},
308
  {"IEO=", " ", "ieo", 1, 4},
309
  {"KUP=", " ", "kup", 1, 3},
310
  {"IEP=", " ", "iep", 1, 2},
311
  {"KUC=", " ", "kuc", 1, 1},
312
  {"IEC=", ">]", "iec", 1, 0},
313
 
314
  /* Cache register portion (dummy for parsing only) */
315
  {"CR[<IalO=", " ", "ialo", 0, 13},
316
  {"DalO=", " ", "dalo", 0, 12},
317
  {"IalP=", " ", "ialp", 0, 11},
318
  {"DalP=", " ", "dalp", 0, 10},
319
  {"IalC=", " ", "ialc", 0, 9},
320
  {"DalC=", ">] ", "dalc", 0, 8},
321
 
322
  {NULL, NULL, 0, 0}              /* end of table marker */
323
};
324
 
325
 
326
#if 0                           /* FIXME: Enable when we add support for modifying cache register.  */
327
static struct bit_field cache_fields[] =
328
{
329
  /* Status register portion (dummy for parsing only) */
330
  {"SR[<CU=", " ", "cu", 0, 28},
331
  {"RE=", " ", "re", 0, 25},
332
  {"BEV=", " ", "bev", 0, 22},
333
  {"TS=", " ", "ts", 0, 21},
334
  {"Nmi=", " ", "nmi", 0, 20},
335
  {"INT=", " ", "int", 0, 10},
336
  {"SW=", ">]", "sw", 0, 8},
337
  {"[<KUO=", " ", "kuo", 0, 5},
338
  {"IEO=", " ", "ieo", 0, 4},
339
  {"KUP=", " ", "kup", 0, 3},
340
  {"IEP=", " ", "iep", 0, 2},
341
  {"KUC=", " ", "kuc", 0, 1},
342
  {"IEC=", ">]", "iec", 0, 0},
343
 
344
  /* Cache register portion  */
345
  {"CR[<IalO=", " ", "ialo", 1, 13},
346
  {"DalO=", " ", "dalo", 1, 12},
347
  {"IalP=", " ", "ialp", 1, 11},
348
  {"DalP=", " ", "dalp", 1, 10},
349
  {"IalC=", " ", "ialc", 1, 9},
350
  {"DalC=", ">] ", "dalc", 1, 8},
351
 
352
  {NULL, NULL, NULL, 0, 0}        /* end of table marker */
353
};
354
#endif
355
 
356
 
357
static struct bit_field cause_fields[] =
358
{
359
  {"<BD=", " ", "bd", 1, 31},
360
  {"CE=", " ", "ce", 2, 28},
361
  {"IP=", " ", "ip", 6, 10},
362
  {"SW=", " ", "sw", 2, 8},
363
  {"EC=", ">]", "ec", 5, 2},
364
 
365
  {NULL, NULL, NULL, 0, 0}        /* end of table marker */
366
};
367
 
368
 
369
/* The monitor prints register values in the form
370
 
371
   regname = xxxx xxxx
372
 
373
   We look up the register name in a table, and remove the embedded space in
374
   the hex value before passing it to monitor_supply_register.  */
375
 
376
static void
377
r3900_supply_register (char *regname, int regnamelen, char *val, int vallen)
378
{
379
  int regno = -1;
380
  int i;
381
  char valbuf[10];
382
  char *p;
383
 
384
  /* Perform some sanity checks on the register name and value.  */
385
  if (regnamelen < 2 || regnamelen > 7 || vallen != 9)
386
    return;
387
 
388
  /* Look up the register name.  */
389
  for (i = 0; reg_table[i].name != NULL; i++)
390
    {
391
      int rlen = strlen (reg_table[i].name);
392
      if (rlen == regnamelen && strncmp (regname, reg_table[i].name, rlen) == 0)
393
        {
394
          regno = reg_table[i].regno;
395
          break;
396
        }
397
    }
398
  if (regno == -1)
399
    return;
400
 
401
  /* Copy the hex value to a buffer and eliminate the embedded space. */
402
  for (i = 0, p = valbuf; i < vallen; i++)
403
    if (val[i] != ' ')
404
      *p++ = val[i];
405
  *p = '\0';
406
 
407
  monitor_supply_register (regno, valbuf);
408
}
409
 
410
 
411
/* Fetch the BadVaddr register.  Unlike the other registers, this
412
   one can't be modified, and the monitor won't even prompt to let
413
   you modify it.  */
414
 
415
static void
416
fetch_bad_vaddr (void)
417
{
418
  char buf[20];
419
 
420
  monitor_printf ("xB\r");
421
  monitor_expect ("BadV=", NULL, 0);
422
  monitor_expect_prompt (buf, sizeof (buf));
423
  monitor_supply_register (BADVADDR_REGNUM, buf);
424
}
425
 
426
 
427
/* Read a series of bit fields from the monitor, and return their
428
   combined binary value.  */
429
 
430
static unsigned long
431
fetch_fields (struct bit_field *bf)
432
{
433
  char buf[20];
434
  unsigned long val = 0;
435
  unsigned long bits;
436
 
437
  for (; bf->prefix != NULL; bf++)
438
    {
439
      monitor_expect (bf->prefix, NULL, 0);      /* get prefix */
440
      monitor_expect (bf->suffix, buf, sizeof (buf));   /* hex value, suffix */
441
      if (bf->length != 0)
442
        {
443
          bits = strtoul (buf, NULL, 16);       /* get field value */
444
          bits &= ((1 << bf->length) - 1);      /* mask out useless bits */
445
          val |= bits << bf->start;     /* insert into register */
446
        }
447
 
448
    }
449
 
450
  return val;
451
}
452
 
453
 
454
static void
455
fetch_bitmapped_register (int regno, struct bit_field *bf)
456
{
457
  unsigned long val;
458
  unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
459
 
460
  monitor_printf ("x%s\r", r3900_regnames[regno]);
461
  val = fetch_fields (bf);
462
  monitor_printf (".\r");
463
  monitor_expect_prompt (NULL, 0);
464
 
465
  /* supply register stores in target byte order, so swap here */
466
 
467
  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
468
  supply_register (regno, regbuf);
469
 
470
}
471
 
472
 
473
/* Fetch all registers (if regno is -1), or one register from the
474
   monitor.  For most registers, we can use the generic monitor_
475
   monitor_fetch_registers function.  But others are displayed in
476
   a very unusual fashion by the monitor, and must be handled specially.  */
477
 
478
static void
479
r3900_fetch_registers (int regno)
480
{
481
  switch (regno)
482
    {
483
    case BADVADDR_REGNUM:
484
      fetch_bad_vaddr ();
485
      return;
486
    case PS_REGNUM:
487
      fetch_bitmapped_register (PS_REGNUM, status_fields);
488
      return;
489
    case CAUSE_REGNUM:
490
      fetch_bitmapped_register (CAUSE_REGNUM, cause_fields);
491
      return;
492
    default:
493
      orig_monitor_fetch_registers (regno);
494
    }
495
}
496
 
497
 
498
/* Write the new value of the bitmapped register to the monitor.  */
499
 
500
static void
501
store_bitmapped_register (int regno, struct bit_field *bf)
502
{
503
  unsigned long oldval, newval;
504
 
505
  /* Fetch the current value of the register.  */
506
  monitor_printf ("x%s\r", r3900_regnames[regno]);
507
  oldval = fetch_fields (bf);
508
  newval = read_register (regno);
509
 
510
  /* To save time, write just the fields that have changed.  */
511
  for (; bf->prefix != NULL; bf++)
512
    {
513
      if (bf->length != 0)
514
        {
515
          unsigned long oldbits, newbits, mask;
516
 
517
          mask = (1 << bf->length) - 1;
518
          oldbits = (oldval >> bf->start) & mask;
519
          newbits = (newval >> bf->start) & mask;
520
          if (oldbits != newbits)
521
            monitor_printf ("%s %lx ", bf->user_name, newbits);
522
        }
523
    }
524
 
525
  monitor_printf (".\r");
526
  monitor_expect_prompt (NULL, 0);
527
}
528
 
529
 
530
static void
531
r3900_store_registers (int regno)
532
{
533
  switch (regno)
534
    {
535
    case PS_REGNUM:
536
      store_bitmapped_register (PS_REGNUM, status_fields);
537
      return;
538
    case CAUSE_REGNUM:
539
      store_bitmapped_register (CAUSE_REGNUM, cause_fields);
540
      return;
541
    default:
542
      orig_monitor_store_registers (regno);
543
    }
544
}
545
 
546
 
547
/* Write a 4-byte integer to the buffer in big-endian order.  */
548
 
549
static void
550
write_long (char *buf, long n)
551
{
552
  buf[0] = (n >> 24) & 0xff;
553
  buf[1] = (n >> 16) & 0xff;
554
  buf[2] = (n >> 8) & 0xff;
555
  buf[3] = n & 0xff;
556
}
557
 
558
 
559
/* Write a 4-byte integer to the buffer in little-endian order.  */
560
 
561
static void
562
write_long_le (char *buf, long n)
563
{
564
  buf[0] = n & 0xff;
565
  buf[1] = (n >> 8) & 0xff;
566
  buf[2] = (n >> 16) & 0xff;
567
  buf[3] = (n >> 24) & 0xff;
568
}
569
 
570
 
571
/* Read a character from the monitor.  If remote debugging is on,
572
   print the received character.  If HEX is non-zero, print the
573
   character in hexadecimal; otherwise, print it in ASCII.  */
574
 
575
static int
576
debug_readchar (int hex)
577
{
578
  char buf[10];
579
  int c = monitor_readchar ();
580
 
581
  if (remote_debug > 0)
582
    {
583
      if (hex)
584
        sprintf (buf, "[%02x]", c & 0xff);
585
      else if (c == '\0')
586
        strcpy (buf, "\\0");
587
      else
588
        {
589
          buf[0] = c;
590
          buf[1] = '\0';
591
        }
592
      puts_debug ("Read -->", buf, "<--");
593
    }
594
  return c;
595
}
596
 
597
 
598
/* Send a buffer of characters to the monitor.  If remote debugging is on,
599
   print the sent buffer in hex.  */
600
 
601
static void
602
debug_write (unsigned char *buf, int buflen)
603
{
604
  char s[10];
605
 
606
  monitor_write (buf, buflen);
607
 
608
  if (remote_debug > 0)
609
    {
610
      while (buflen-- > 0)
611
        {
612
          sprintf (s, "[%02x]", *buf & 0xff);
613
          puts_debug ("Sent -->", s, "<--");
614
          buf++;
615
        }
616
    }
617
}
618
 
619
 
620
/* Ignore a packet sent to us by the monitor.  It send packets
621
   when its console is in "communications interface" mode.   A packet
622
   is of this form:
623
 
624
   start of packet flag (one byte: 0xdc)
625
   packet type (one byte)
626
   length (low byte)
627
   length (high byte)
628
   data (length bytes)
629
 
630
   The last two bytes of the data field are a checksum, but we don't
631
   bother to verify it.
632
 */
633
 
634
static void
635
ignore_packet (void)
636
{
637
  int c;
638
  int len;
639
 
640
  /* Ignore lots of trash (messages about section addresses, for example)
641
     until we see the start of a packet.  */
642
  for (len = 0; len < 256; len++)
643
    {
644
      c = debug_readchar (0);
645
      if (c == PESC)
646
        break;
647
    }
648
  if (len == 8)
649
    error ("Packet header byte not found; %02x seen instead.", c);
650
 
651
  /* Read the packet type and length.  */
652
  c = debug_readchar (1);       /* type */
653
 
654
  c = debug_readchar (1);       /* low byte of length */
655
  len = c & 0xff;
656
 
657
  c = debug_readchar (1);       /* high byte of length */
658
  len += (c & 0xff) << 8;
659
 
660
  /* Ignore the rest of the packet.  */
661
  while (len-- > 0)
662
    c = debug_readchar (1);
663
}
664
 
665
 
666
/* Encapsulate some data into a packet and send it to the monitor.
667
 
668
   The 'p' packet is a special case.  This is a packet we send
669
   in response to a read ('r') packet from the monitor.  This function
670
   appends a one-byte sequence number to the data field of such a packet.
671
 */
672
 
673
static void
674
send_packet (char type, unsigned char *buf, int buflen, int seq)
675
{
676
  unsigned char hdr[4];
677
  int len = buflen;
678
  int sum, i;
679
 
680
  /* If this is a 'p' packet, add one byte for a sequence number.  */
681
  if (type == 'p')
682
    len++;
683
 
684
  /* If the buffer has a non-zero length, add two bytes for a checksum.  */
685
  if (len > 0)
686
    len += 2;
687
 
688
  /* Write the packet header.  */
689
  hdr[0] = PESC;
690
  hdr[1] = type;
691
  hdr[2] = len & 0xff;
692
  hdr[3] = (len >> 8) & 0xff;
693
  debug_write (hdr, sizeof (hdr));
694
 
695
  if (len)
696
    {
697
      /* Write the packet data.  */
698
      debug_write (buf, buflen);
699
 
700
      /* Write the sequence number if this is a 'p' packet.  */
701
      if (type == 'p')
702
        {
703
          hdr[0] = seq;
704
          debug_write (hdr, 1);
705
        }
706
 
707
      /* Write the checksum.  */
708
      sum = 0;
709
      for (i = 0; i < buflen; i++)
710
        {
711
          int tmp = (buf[i] & 0xff);
712
          if (i & 1)
713
            sum += tmp;
714
          else
715
            sum += tmp << 8;
716
        }
717
      if (type == 'p')
718
        {
719
          if (buflen & 1)
720
            sum += (seq & 0xff);
721
          else
722
            sum += (seq & 0xff) << 8;
723
        }
724
      sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
725
      sum += (sum >> 16) & 1;
726
      sum = ~sum;
727
 
728
      hdr[0] = (sum >> 8) & 0xff;
729
      hdr[1] = sum & 0xff;
730
      debug_write (hdr, 2);
731
    }
732
}
733
 
734
 
735
/* Respond to an expected read request from the monitor by sending
736
   data in chunks.  Handle all acknowledgements and handshaking packets.
737
 
738
   The monitor expects a response consisting of a one or more 'p' packets,
739
   each followed by a portion of the data requested.  The 'p' packet
740
   contains only a four-byte integer, the value of which is the number
741
   of bytes of data we are about to send.  Following the 'p' packet,
742
   the monitor expects the data bytes themselves in raw, unpacketized,
743
   form, without even a checksum.
744
 */
745
 
746
static void
747
process_read_request (unsigned char *buf, int buflen)
748
{
749
  unsigned char len[4];
750
  int i, chunk;
751
  unsigned char seq;
752
 
753
  /* Discard the read request.  FIXME: we have to hope it's for
754
     the exact number of bytes we want to send; should check for this.  */
755
  ignore_packet ();
756
 
757
  for (i = chunk = 0, seq = 0; i < buflen; i += chunk, seq++)
758
    {
759
      /* Don't send more than MAXPSIZE bytes at a time.  */
760
      chunk = buflen - i;
761
      if (chunk > MAXPSIZE)
762
        chunk = MAXPSIZE;
763
 
764
      /* Write a packet containing the number of bytes we are sending.  */
765
      write_long_le (len, chunk);
766
      send_packet ('p', len, sizeof (len), seq);
767
 
768
      /* Write the data in raw form following the packet.  */
769
      debug_write (&buf[i], chunk);
770
 
771
      /* Discard the ACK packet.  */
772
      ignore_packet ();
773
    }
774
 
775
  /* Send an "end of data" packet.  */
776
  send_packet ('e', "", 0, 0);
777
}
778
 
779
 
780
/* Count loadable sections (helper function for r3900_load).  */
781
 
782
static void
783
count_section (bfd *abfd, asection *s, unsigned int *section_count)
784
{
785
  if (s->flags & SEC_LOAD && bfd_section_size (abfd, s) != 0)
786
    (*section_count)++;
787
}
788
 
789
 
790
/* Load a single BFD section (helper function for r3900_load).
791
 
792
   WARNING: this code is filled with assumptions about how
793
   the Densan monitor loads programs.  The monitor issues
794
   packets containing read requests, but rather than respond
795
   to them in an general way, we expect them to following
796
   a certain pattern.
797
 
798
   For example, we know that the monitor will start loading by
799
   issuing an 8-byte read request for the binary file header.
800
   We know this is coming and ignore the actual contents
801
   of the read request packet.
802
 */
803
 
804
static void
805
load_section (bfd *abfd, asection *s, unsigned int *data_count)
806
{
807
  if (s->flags & SEC_LOAD)
808
    {
809
      bfd_size_type section_size = bfd_section_size (abfd, s);
810
      bfd_vma section_base = bfd_section_lma (abfd, s);
811
      unsigned char *buffer;
812
      unsigned char header[8];
813
 
814
      /* Don't output zero-length sections.  */
815
      if (section_size == 0)
816
        return;
817
      if (data_count)
818
        *data_count += section_size;
819
 
820
      /* Print some fluff about the section being loaded.  */
821
      printf_filtered ("Loading section %s, size 0x%lx lma ",
822
                       bfd_section_name (abfd, s), (long) section_size);
823
      print_address_numeric (section_base, 1, gdb_stdout);
824
      printf_filtered ("\n");
825
      gdb_flush (gdb_stdout);
826
 
827
      /* Write the section header (location and size).  */
828
      write_long (&header[0], (long) section_base);
829
      write_long (&header[4], (long) section_size);
830
      process_read_request (header, sizeof (header));
831
 
832
      /* Read the section contents into a buffer, write it out,
833
         then free the buffer.  */
834
      buffer = (unsigned char *) xmalloc (section_size);
835
      bfd_get_section_contents (abfd, s, buffer, 0, section_size);
836
      process_read_request (buffer, section_size);
837
      xfree (buffer);
838
    }
839
}
840
 
841
 
842
/* When the ethernet is used as the console port on the Densan board,
843
   we can use the "Rm" command to do a fast binary load.  The format
844
   of the download data is:
845
 
846
   number of sections (4 bytes)
847
   starting address (4 bytes)
848
   repeat for each section:
849
   location address (4 bytes)
850
   section size (4 bytes)
851
   binary data
852
 
853
   The 4-byte fields are all in big-endian order.
854
 
855
   Using this command is tricky because we have to put the monitor
856
   into a special funky "communications interface" mode, in which
857
   it sends and receives packets of data along with the normal prompt.
858
 */
859
 
860
static void
861
r3900_load (char *filename, int from_tty)
862
{
863
  bfd *abfd;
864
  unsigned int data_count = 0;
865
  time_t start_time, end_time;  /* for timing of download */
866
  int section_count = 0;
867
  unsigned char buffer[8];
868
 
869
  /* If we are not using the ethernet, use the normal monitor load,
870
     which sends S-records over the serial link.  */
871
  if (!ethernet)
872
    {
873
      orig_monitor_load (filename, from_tty);
874
      return;
875
    }
876
 
877
  /* Open the file.  */
878
  if (filename == NULL || filename[0] == 0)
879
    filename = get_exec_file (1);
880
  abfd = bfd_openr (filename, 0);
881
  if (!abfd)
882
    error ("Unable to open file %s\n", filename);
883
  if (bfd_check_format (abfd, bfd_object) == 0)
884
    error ("File is not an object file\n");
885
 
886
  /* Output the "vconsi" command to get the monitor in the communication
887
     state where it will accept a load command.  This will cause
888
     the monitor to emit a packet before each prompt, so ignore the packet.  */
889
  monitor_printf ("vconsi\r");
890
  ignore_packet ();
891
  monitor_expect_prompt (NULL, 0);
892
 
893
  /* Output the "Rm" (load) command and respond to the subsequent "open"
894
     packet by sending an ACK packet.  */
895
  monitor_printf ("Rm\r");
896
  ignore_packet ();
897
  send_packet ('a', "", 0, 0);
898
 
899
  /* Output the fast load header (number of sections and starting address).  */
900
  bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
901
                         &section_count);
902
  write_long (&buffer[0], (long) section_count);
903
  if (exec_bfd)
904
    write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
905
  else
906
    write_long (&buffer[4], 0);
907
  process_read_request (buffer, sizeof (buffer));
908
 
909
  /* Output the section data.  */
910
  start_time = time (NULL);
911
  bfd_map_over_sections (abfd, (section_map_func) load_section, &data_count);
912
  end_time = time (NULL);
913
 
914
  /* Acknowledge the close packet and put the monitor back into
915
     "normal" mode so it won't send packets any more.  */
916
  ignore_packet ();
917
  send_packet ('a', "", 0, 0);
918
  monitor_expect_prompt (NULL, 0);
919
  monitor_printf ("vconsx\r");
920
  monitor_expect_prompt (NULL, 0);
921
 
922
  /* Print start address and download performance information.  */
923
  printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
924
  report_transfer_performance (data_count, start_time, end_time);
925
 
926
  /* Finally, make the PC point at the start address */
927
  if (exec_bfd)
928
    write_pc (bfd_get_start_address (exec_bfd));
929
 
930
  inferior_ptid = null_ptid;            /* No process now */
931
 
932
  /* This is necessary because many things were based on the PC at the
933
     time that we attached to the monitor, which is no longer valid
934
     now that we have loaded new code (and just changed the PC).
935
     Another way to do this might be to call normal_stop, except that
936
     the stack may not be valid, and things would get horribly
937
     confused... */
938
  clear_symtab_users ();
939
}
940
 
941
 
942
/* Commands to send to the monitor when first connecting:
943
   * The bare carriage return forces a prompt from the monitor
944
   (monitor doesn't prompt immediately after a reset).
945
   * The "vconsx" switches the monitor back to interactive mode
946
   in case an aborted download had left it in packet mode.
947
   * The "Xtr" command causes subsequent "t" (trace) commands to display
948
   the general registers only.
949
   * The "Xxr" command does the same thing for the "x" (examine
950
   registers) command.
951
   * The "bx" command clears all breakpoints.
952
 */
953
 
954
static char *r3900_inits[] =
955
{"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
956
static char *dummy_inits[] =
957
{NULL};
958
 
959
static struct target_ops r3900_ops;
960
static struct monitor_ops r3900_cmds;
961
 
962
static void
963
r3900_open (char *args, int from_tty)
964
{
965
  char buf[64];
966
  int i;
967
 
968
  monitor_open (args, &r3900_cmds, from_tty);
969
 
970
  /* We have to handle sending the init strings ourselves, because
971
     the first two strings we send (carriage returns) may not be echoed
972
     by the monitor, but the rest will be.  */
973
  monitor_printf_noecho ("\r\r");
974
  for (i = 0; r3900_inits[i] != NULL; i++)
975
    {
976
      monitor_printf (r3900_inits[i]);
977
      monitor_expect_prompt (NULL, 0);
978
    }
979
 
980
  /* Attempt to determine whether the console device is ethernet or serial.
981
     This will tell us which kind of load to use (S-records over a serial
982
     link, or the Densan fast binary multi-section format over the net).  */
983
 
984
  ethernet = 0;
985
  monitor_printf ("v\r");
986
  if (monitor_expect ("console device :", NULL, 0) != -1)
987
    if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
988
      if (strstr (buf, "ethernet") != NULL)
989
        ethernet = 1;
990
  monitor_expect_prompt (NULL, 0);
991
}
992
 
993
void
994
_initialize_r3900_rom (void)
995
{
996
  r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
997
    MO_ADDR_BITS_REMOVE |
998
    MO_CLR_BREAK_USES_ADDR |
999
    MO_GETMEM_READ_SINGLE |
1000
    MO_PRINT_PROGRAM_OUTPUT;
1001
 
1002
  r3900_cmds.init = dummy_inits;
1003
  r3900_cmds.cont = "g\r";
1004
  r3900_cmds.step = "t\r";
1005
  r3900_cmds.set_break = "b %A\r";      /* COREADDR */
1006
  r3900_cmds.clr_break = "b %A,0\r";    /* COREADDR */
1007
  r3900_cmds.fill = "fx %A s %x %x\r";  /* COREADDR, len, val */
1008
 
1009
  r3900_cmds.setmem.cmdb = "sx %A %x\r";        /* COREADDR, val */
1010
  r3900_cmds.setmem.cmdw = "sh %A %x\r";        /* COREADDR, val */
1011
  r3900_cmds.setmem.cmdl = "sw %A %x\r";        /* COREADDR, val */
1012
 
1013
  r3900_cmds.getmem.cmdb = "sx %A\r";   /* COREADDR */
1014
  r3900_cmds.getmem.cmdw = "sh %A\r";   /* COREADDR */
1015
  r3900_cmds.getmem.cmdl = "sw %A\r";   /* COREADDR */
1016
  r3900_cmds.getmem.resp_delim = " : ";
1017
  r3900_cmds.getmem.term = " ";
1018
  r3900_cmds.getmem.term_cmd = ".\r";
1019
 
1020
  r3900_cmds.setreg.cmd = "x%s %x\r";   /* regname, val */
1021
 
1022
  r3900_cmds.getreg.cmd = "x%s\r";      /* regname */
1023
  r3900_cmds.getreg.resp_delim = "=";
1024
  r3900_cmds.getreg.term = " ";
1025
  r3900_cmds.getreg.term_cmd = ".\r";
1026
 
1027
  r3900_cmds.dump_registers = "x\r";
1028
  r3900_cmds.register_pattern =
1029
    "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
1030
  r3900_cmds.supply_register = r3900_supply_register;
1031
  /* S-record download, via "keyboard port".  */
1032
  r3900_cmds.load = "r0\r";
1033
  r3900_cmds.prompt = "#";
1034
  r3900_cmds.line_term = "\r";
1035
  r3900_cmds.target = &r3900_ops;
1036
  r3900_cmds.stopbits = SERIAL_1_STOPBITS;
1037
  r3900_cmds.regnames = r3900_regnames;
1038
  r3900_cmds.magic = MONITOR_OPS_MAGIC;
1039
 
1040
  init_monitor_ops (&r3900_ops);
1041
 
1042
  r3900_ops.to_shortname = "r3900";
1043
  r3900_ops.to_longname = "R3900 monitor";
1044
  r3900_ops.to_doc = "Debug using the DVE R3900 monitor.\n\
1045
Specify the serial device it is connected to (e.g. /dev/ttya).";
1046
  r3900_ops.to_open = r3900_open;
1047
 
1048
  /* Override the functions to fetch and store registers.  But save the
1049
     addresses of the default functions, because we will use those functions
1050
     for "normal" registers.  */
1051
 
1052
  orig_monitor_fetch_registers = r3900_ops.to_fetch_registers;
1053
  orig_monitor_store_registers = r3900_ops.to_store_registers;
1054
  r3900_ops.to_fetch_registers = r3900_fetch_registers;
1055
  r3900_ops.to_store_registers = r3900_store_registers;
1056
 
1057
  /* Override the load function, but save the address of the default
1058
     function to use when loading S-records over a serial link.  */
1059
  orig_monitor_load = r3900_ops.to_load;
1060
  r3900_ops.to_load = r3900_load;
1061
 
1062
  add_target (&r3900_ops);
1063
}

powered by: WebSVN 2.1.0

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