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