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