1 /* Target communications support for Macraigor Systems' On-Chip Debugging
2 Copyright 1996, 1997 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
33 #include "gdb-stabs.h"
35 #include <sys/types.h>
40 /* Prototypes for local functions */
42 static int ocd_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
);
44 static int ocd_start_remote (PTR dummy
);
46 static int readchar (int timeout
);
48 static void reset_packet (void);
50 static void output_packet (void);
52 static int get_quoted_char (int timeout
);
54 static void put_quoted_char (int c
);
56 static void ocd_interrupt (int signo
);
58 static void ocd_interrupt_twice (int signo
);
60 static void interrupt_query (void);
62 static unsigned char *ocd_do_command (int cmd
, int *statusp
, int *lenp
);
64 static void ocd_put_packet (unsigned char *packet
, int pktlen
);
66 static unsigned char *ocd_get_packet (int cmd
, int *pktlen
, int timeout
);
68 static struct target_ops
*current_ops
= NULL
;
70 static int last_run_status
;
72 /* This was 5 seconds, which is a long time to sit and wait.
73 Unless this is going though some terminal server or multiplexer or
74 other form of hairy serial connection, I would think 2 seconds would
78 /* FIXME: Change to allow option to set timeout value on a per target
80 static int remote_timeout
= 2;
83 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
84 ocd_open knows that we don't have a file open when the program
86 static serial_t ocd_desc
= NULL
;
89 ocd_error (char *s
, int error_code
)
93 fputs_filtered (s
, gdb_stderr
);
94 fputs_filtered (" ", gdb_stderr
);
105 s
= "Cable disconnected";
108 s
= "Couldn't enter OCD mode";
111 s
= "Target stuck in reset";
114 s
= "OCD hasn't been initialized";
117 s
= "Write verify failed";
120 s
= "Reg buff error (during MPC5xx fp reg read/write)";
123 s
= "Invalid CPU register access attempt failed";
129 s
= "Checksum error";
132 s
= "Illegal command";
135 s
= "Parameter error";
138 s
= "Internal error";
141 s
= "Flash erase error";
144 sprintf (buf
, "Unknown error code %d", error_code
);
151 /* Return nonzero if the thread TH is still alive on the remote system. */
154 ocd_thread_alive (int th
)
159 /* Clean up connection to a remote debugger. */
163 ocd_close (int quitting
)
166 SERIAL_CLOSE (ocd_desc
);
170 /* Stub for catch_errors. */
173 ocd_start_remote (PTR dummy
)
175 unsigned char buf
[10], *p
;
180 enum ocd_target_type target_type
;
182 target_type
= *(enum ocd_target_type
*) dummy
;
184 immediate_quit
++; /* Allow user to interrupt it */
186 SERIAL_SEND_BREAK (ocd_desc
); /* Wake up the wiggler */
188 speed
= 80; /* Divide clock by 4000 */
192 buf
[2] = speed
& 0xff;
193 buf
[3] = target_type
;
194 ocd_put_packet (buf
, 4); /* Init OCD params */
195 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
198 error ("Truncated response packet from OCD device");
204 ocd_error ("OCD_INIT:", error_code
);
206 ocd_do_command (OCD_AYT
, &status
, &pktlen
);
208 p
= ocd_do_command (OCD_GET_VERSION
, &status
, &pktlen
);
210 printf_unfiltered ("[Wiggler version %x.%x, capability 0x%x]\n",
211 p
[0], p
[1], (p
[2] << 16) | p
[3]);
214 /* Reset the target */
216 ocd_do_command (OCD_RESET_RUN
, &status
, &pktlen
);
217 /* ocd_do_command (OCD_RESET, &status, &pktlen); */
220 /* If processor is still running, stop it. */
222 if (!(status
& OCD_FLAG_BDM
))
226 /* When using a target box, we want to asynchronously return status when
227 target stops. The OCD_SET_CTL_FLAGS command is ignored by Wigglers.dll
228 when using a parallel Wiggler */
229 buf
[0] = OCD_SET_CTL_FLAGS
;
232 ocd_put_packet (buf
, 3);
234 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
237 error ("Truncated response packet from OCD device");
243 ocd_error ("OCD_SET_CTL_FLAGS:", error_code
);
248 /* This is really the job of start_remote however, that makes an assumption
249 that the target is about to print out a status message of some sort. That
250 doesn't happen here (in fact, it may not be possible to get the monitor to
251 send the appropriate packet). */
253 flush_cached_frames ();
254 registers_changed ();
255 stop_pc
= read_pc ();
256 set_current_frame (create_new_frame (read_fp (), stop_pc
));
257 select_frame (get_current_frame (), 0);
258 print_stack_frame (selected_frame
, -1, 1);
260 buf
[0] = OCD_LOG_FILE
;
261 buf
[1] = 3; /* close existing WIGGLERS.LOG */
262 ocd_put_packet (buf
, 2);
263 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
265 buf
[0] = OCD_LOG_FILE
;
266 buf
[1] = 2; /* append to existing WIGGLERS.LOG */
267 ocd_put_packet (buf
, 2);
268 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
273 /* Open a connection to a remote debugger.
274 NAME is the filename used for communication. */
276 static DCACHE
*ocd_dcache
;
279 ocd_open (char *name
, int from_tty
, enum ocd_target_type target_type
,
280 struct target_ops
*ops
)
282 unsigned char buf
[10], *p
;
286 error ("To open an OCD connection, you need to specify the\n\
287 device the OCD device is attached to (e.g. /dev/ttya).");
289 target_preopen (from_tty
);
293 unpush_target (current_ops
);
296 ocd_dcache
= dcache_init (ocd_read_bytes
, ocd_write_bytes
);
298 dcache_invd (ocd_dcache
);
300 if (strncmp (name
, "wiggler", 7) == 0)
302 ocd_desc
= SERIAL_OPEN ("ocd");
304 perror_with_name (name
);
306 buf
[0] = OCD_LOG_FILE
;
307 buf
[1] = 1; /* open new or overwrite existing WIGGLERS.LOG */
308 ocd_put_packet (buf
, 2);
309 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
311 buf
[0] = OCD_SET_CONNECTION
;
312 buf
[1] = 0x01; /* atoi (name[11]); */
313 ocd_put_packet (buf
, 2);
314 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
317 /* not using Wigglers.dll */
319 ocd_desc
= SERIAL_OPEN (name
);
321 perror_with_name (name
);
326 if (SERIAL_SETBAUDRATE (ocd_desc
, baud_rate
))
328 SERIAL_CLOSE (ocd_desc
);
329 perror_with_name (name
);
333 SERIAL_RAW (ocd_desc
);
335 /* If there is something sitting in the buffer we might take it as a
336 response to a command, which would be bad. */
337 SERIAL_FLUSH_INPUT (ocd_desc
);
341 puts_filtered ("Remote target wiggler connected to ");
342 puts_filtered (name
);
343 puts_filtered ("\n");
345 push_target (current_ops
); /* Switch to using remote target now */
347 /* Without this, some commands which require an active target (such as kill)
348 won't work. This variable serves (at least) double duty as both the pid
349 of the target process (if it has such), and as a flag indicating that a
350 target is active. These functions should be split out into seperate
351 variables, especially since GDB will someday have a notion of debugging
352 several processes. */
354 inferior_pid
= 42000;
355 /* Start the remote connection; if error (0), discard this target.
356 In particular, if the user quits, be sure to discard it
357 (we'd be in an inconsistent state otherwise). */
358 if (!catch_errors (ocd_start_remote
, &target_type
,
359 "Couldn't establish connection to remote target\n",
363 error ("Failed to connect to OCD.");
367 /* This takes a program previously attached to and detaches it. After
368 this is done, GDB can be used to debug some other program. We
369 better not have left any breakpoints in the target program or it'll
370 die when it hits one. */
373 ocd_detach (char *args
, int from_tty
)
376 error ("Argument given to \"detach\" when remotely debugging.");
380 puts_filtered ("Ending remote debugging.\n");
383 /* Tell the remote machine to resume. */
386 ocd_resume (int pid
, int step
, enum target_signal siggnal
)
390 dcache_invd (ocd_dcache
);
393 ocd_do_command (OCD_STEP
, &last_run_status
, &pktlen
);
395 ocd_do_command (OCD_RUN
, &last_run_status
, &pktlen
);
404 ocd_do_command (OCD_STOP
, &status
, &pktlen
);
406 if (!(status
& OCD_FLAG_BDM
))
407 error ("Can't stop target via BDM");
410 static volatile int ocd_interrupt_flag
;
412 /* Send ^C to target to halt it. Target will respond, and send us a
416 ocd_interrupt (int signo
)
418 /* If this doesn't work, try more severe steps. */
419 signal (signo
, ocd_interrupt_twice
);
422 printf_unfiltered ("ocd_interrupt called\n");
429 ocd_put_packet (buf
, 1);
430 ocd_interrupt_flag
= 1;
434 static void (*ofunc
) ();
436 /* The user typed ^C twice. */
438 ocd_interrupt_twice (int signo
)
440 signal (signo
, ofunc
);
444 signal (signo
, ocd_interrupt
);
447 /* Ask the user what to do when an interrupt is received. */
450 interrupt_query (void)
452 target_terminal_ours ();
454 if (query ("Interrupted while waiting for the program.\n\
455 Give up (and stop debugging it)? "))
457 target_mourn_inferior ();
458 return_to_top_level (RETURN_QUIT
);
461 target_terminal_inferior ();
464 /* If nonzero, ignore the next kill. */
465 static int kill_kludge
;
467 /* Wait until the remote machine stops, then return,
468 storing status in STATUS just as `wait' would.
469 Returns "pid" (though it's not clear what, if anything, that
470 means in the case of this target). */
480 ocd_interrupt_flag
= 0;
482 /* Target might already be stopped by the time we get here. */
483 /* If we aren't already stopped, we need to loop until we've dropped
484 back into BDM mode */
486 while (!(last_run_status
& OCD_FLAG_BDM
))
489 ocd_put_packet (buf
, 1);
490 p
= ocd_get_packet (OCD_AYT
, &pktlen
, -1);
492 ofunc
= (void (*)()) signal (SIGINT
, ocd_interrupt
);
493 signal (SIGINT
, ofunc
);
496 error ("Truncated response packet from OCD device");
498 last_run_status
= p
[1];
502 ocd_error ("target_wait:", error_code
);
504 if (last_run_status
& OCD_FLAG_PWF
)
505 error ("OCD device lost VCC at BDM interface.");
506 else if (last_run_status
& OCD_FLAG_CABLE_DISC
)
507 error ("OCD device cable appears to have been disconnected.");
510 if (ocd_interrupt_flag
)
516 /* Read registers from the OCD device. Specify the starting and ending
517 register number. Return the number of regs actually read in *NUMREGS.
518 Returns a pointer to a static array containing the register contents. */
521 ocd_read_bdm_registers (int first_bdm_regno
, int last_bdm_regno
, int *reglen
)
523 unsigned char buf
[10];
527 int error_code
, status
;
530 buf
[0] = OCD_READ_REGS
;
531 buf
[1] = first_bdm_regno
>> 8;
532 buf
[2] = first_bdm_regno
& 0xff;
533 buf
[3] = last_bdm_regno
>> 8;
534 buf
[4] = last_bdm_regno
& 0xff;
536 ocd_put_packet (buf
, 5);
537 p
= ocd_get_packet (OCD_READ_REGS
, &pktlen
, remote_timeout
);
543 ocd_error ("read_bdm_registers:", error_code
);
551 error ("Register block size bad: %d", i
);
560 /* Read register BDM_REGNO and returns its value ala read_register() */
563 ocd_read_bdm_register (int bdm_regno
)
569 p
= ocd_read_bdm_registers (bdm_regno
, bdm_regno
, ®len
);
570 regval
= extract_unsigned_integer (p
, reglen
);
576 ocd_write_bdm_registers (int first_bdm_regno
, unsigned char *regptr
, int reglen
)
580 int error_code
, status
;
583 buf
= alloca (4 + reglen
);
585 buf
[0] = OCD_WRITE_REGS
;
586 buf
[1] = first_bdm_regno
>> 8;
587 buf
[2] = first_bdm_regno
& 0xff;
589 memcpy (buf
+ 4, regptr
, reglen
);
591 ocd_put_packet (buf
, 4 + reglen
);
592 p
= ocd_get_packet (OCD_WRITE_REGS
, &pktlen
, remote_timeout
);
595 error ("Truncated response packet from OCD device");
601 ocd_error ("ocd_write_bdm_registers:", error_code
);
605 ocd_write_bdm_register (int bdm_regno
, CORE_ADDR reg
)
607 unsigned char buf
[4];
609 store_unsigned_integer (buf
, 4, reg
);
611 ocd_write_bdm_registers (bdm_regno
, buf
, 4);
615 ocd_prepare_to_store (void)
619 /* Write memory data directly to the remote machine.
620 This does not inform the data cache; the data cache uses this.
621 MEMADDR is the address in the remote memory space.
622 MYADDR is the address of the buffer in our space.
623 LEN is the number of bytes.
625 Returns number of bytes transferred, or 0 for error. */
627 static int write_mem_command
= OCD_WRITE_MEM
;
630 ocd_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
638 buf
[0] = write_mem_command
;
639 buf
[5] = 1; /* Write as bytes */
640 buf
[6] = 0; /* Don't verify */
646 int status
, error_code
;
648 numbytes
= min (len
, 256 - 8);
650 buf
[1] = memaddr
>> 24;
651 buf
[2] = memaddr
>> 16;
652 buf
[3] = memaddr
>> 8;
657 memcpy (&buf
[8], myaddr
, numbytes
);
658 ocd_put_packet (buf
, 8 + numbytes
);
659 p
= ocd_get_packet (OCD_WRITE_MEM
, &pktlen
, remote_timeout
);
661 error ("Truncated response packet from OCD device");
666 if (error_code
== 0x11) /* Got a bus error? */
668 CORE_ADDR error_address
;
670 error_address
= p
[3] << 24;
671 error_address
|= p
[4] << 16;
672 error_address
|= p
[5] << 8;
673 error_address
|= p
[6];
674 numbytes
= error_address
- memaddr
;
682 else if (error_code
!= 0)
683 ocd_error ("ocd_write_bytes:", error_code
);
690 return origlen
- len
;
693 /* Read memory data directly from the remote machine.
694 This does not use the data cache; the data cache uses this.
695 MEMADDR is the address in the remote memory space.
696 MYADDR is the address of the buffer in our space.
697 LEN is the number of bytes.
699 Returns number of bytes transferred, or 0 for error. */
702 ocd_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
710 buf
[0] = OCD_READ_MEM
;
711 buf
[5] = 1; /* Read as bytes */
717 int status
, error_code
;
719 numbytes
= min (len
, 256 - 7);
721 buf
[1] = memaddr
>> 24;
722 buf
[2] = memaddr
>> 16;
723 buf
[3] = memaddr
>> 8;
728 ocd_put_packet (buf
, 7);
729 p
= ocd_get_packet (OCD_READ_MEM
, &pktlen
, remote_timeout
);
731 error ("Truncated response packet from OCD device");
736 if (error_code
== 0x11) /* Got a bus error? */
738 CORE_ADDR error_address
;
740 error_address
= p
[3] << 24;
741 error_address
|= p
[4] << 16;
742 error_address
|= p
[5] << 8;
743 error_address
|= p
[6];
744 numbytes
= error_address
- memaddr
;
752 else if (error_code
!= 0)
753 ocd_error ("ocd_read_bytes:", error_code
);
755 memcpy (myaddr
, &p
[4], numbytes
);
762 return origlen
- len
;
765 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
766 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
767 nonzero. Returns length of data written or read; 0 for error. TARGET
772 ocd_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int should_write
,
773 struct target_ops
*target
)
775 return dcache_xfer_memory (ocd_dcache
, memaddr
, myaddr
, len
, should_write
);
779 ocd_files_info (struct target_ops
*ignore
)
781 puts_filtered ("Debugging a target over a serial line.\n");
784 /* Stuff for dealing with the packets which are part of this protocol.
785 See comment at top of file for details. */
787 /* Read a single character from the remote side, handling wierd errors. */
790 readchar (int timeout
)
794 ch
= SERIAL_READCHAR (ocd_desc
, timeout
);
799 error ("Remote connection closed");
801 perror_with_name ("Remote communication error");
809 /* Read a character from the data stream, dequoting as necessary. SYN is
810 treated special. Any SYNs appearing in the data stream are returned as the
811 distinct value RAW_SYN (which has a value > 8 bits and therefore cannot be
812 mistaken for real data). */
815 get_quoted_char (int timeout
)
819 ch
= readchar (timeout
);
824 error ("Timeout in mid-packet, aborting");
828 ch
= readchar (timeout
);
837 static unsigned char pkt
[256 * 2 + 10], *pktp
; /* Worst case */
848 if (SERIAL_WRITE (ocd_desc
, pkt
, pktp
- pkt
))
849 perror_with_name ("output_packet: write failed");
854 /* Output a quoted character. SYNs and DLEs are quoted. Everything else goes
855 through untouched. */
858 put_quoted_char (int c
)
871 /* Send a packet to the OCD device. The packet framed by a SYN character,
872 a byte count and a checksum. The byte count only counts the number of
873 bytes between the count and the checksum. A count of zero actually
874 means 256. Any SYNs within the packet (including the checksum and
875 count) must be quoted. The quote character must be quoted as well.
876 Quoting is done by replacing the character with the two-character sequence
877 DLE, {char} | 0100. Note that the quoting mechanism has no effect on the
881 stu_put_packet (unsigned char *buf
, int len
)
883 unsigned char checksum
;
886 if (len
== 0 || len
> 256)
887 abort (); /* Can't represent 0 length packet */
893 put_quoted_char (RAW_SYN
);
907 put_quoted_char (-checksum
& 0xff);
914 /* Send a packet to the OCD device. The packet framed by a SYN character,
915 a byte count and a checksum. The byte count only counts the number of
916 bytes between the count and the checksum. A count of zero actually
917 means 256. Any SYNs within the packet (including the checksum and
918 count) must be quoted. The quote character must be quoted as well.
919 Quoting is done by replacing the character with the two-character sequence
920 DLE, {char} | 0100. Note that the quoting mechanism has no effect on the
924 ocd_put_packet (unsigned char *buf
, int len
)
926 unsigned char checksum
;
928 unsigned char *packet
, *packet_ptr
;
930 packet
= alloca (len
+ 1 + 1); /* packet + SYN + checksum */
935 *packet_ptr
++ = 0x55;
945 *packet_ptr
++ = -checksum
;
946 if (SERIAL_WRITE (ocd_desc
, packet
, packet_ptr
- packet
))
947 perror_with_name ("output_packet: write failed");
952 /* Get a packet from the OCD device. Timeout is only enforced for the
953 first byte of the packet. Subsequent bytes are expected to arrive in
954 time <= remote_timeout. Returns a pointer to a static buffer containing
955 the payload of the packet. *LENP contains the length of the packet.
958 static unsigned char *
959 stu_get_packet (unsigned char cmd
, int *lenp
, int timeout
)
963 static unsigned char buf
[256 + 10], *p
;
964 unsigned char checksum
;
968 ch
= get_quoted_char (timeout
);
971 error ("get_packet (readchar): %d", ch
);
976 found_syn
: /* Found the start of a packet */
981 len
= get_quoted_char (remote_timeout
);
991 len
++; /* Include checksum */
995 ch
= get_quoted_char (remote_timeout
);
1007 error ("Response phase error. Got 0x%x, expected 0x%x", buf
[0], cmd
);
1009 *lenp
= p
- buf
- 1;
1015 /* Get a packet from the OCD device. Timeout is only enforced for the
1016 first byte of the packet. Subsequent bytes are expected to arrive in
1017 time <= remote_timeout. Returns a pointer to a static buffer containing
1018 the payload of the packet. *LENP contains the length of the packet.
1021 static unsigned char *
1022 ocd_get_packet (int cmd
, int *lenp
, int timeout
)
1026 static unsigned char packet
[512];
1027 unsigned char *packet_ptr
;
1028 unsigned char checksum
;
1030 ch
= readchar (timeout
);
1033 error ("ocd_get_packet (readchar): %d", ch
);
1036 error ("ocd_get_packet (readchar): %d", ch
);
1038 /* Found the start of a packet */
1040 packet_ptr
= packet
;
1043 /* Read command char. That sort of tells us how long the packet is. */
1045 ch
= readchar (timeout
);
1048 error ("ocd_get_packet (readchar): %d", ch
);
1055 ch
= readchar (timeout
);
1058 error ("ocd_get_packet (readchar): %d", ch
);
1062 /* Get error code. */
1064 ch
= readchar (timeout
);
1067 error ("ocd_get_packet (readchar): %d", ch
);
1071 switch (ch
) /* Figure out length of packet */
1073 case 0x7: /* Write verify error? */
1074 len
= 8; /* write address, value read back */
1076 case 0x11: /* Bus error? */
1077 /* write address, read flag */
1078 case 0x15: /* Internal error */
1079 len
= 5; /* error code, vector */
1081 default: /* Error w/no params */
1084 case 0x0: /* Normal result */
1087 case OCD_AYT
: /* Are You There? */
1088 case OCD_SET_BAUD_RATE
: /* Set Baud Rate */
1089 case OCD_INIT
: /* Initialize OCD device */
1090 case OCD_SET_SPEED
: /* Set Speed */
1091 case OCD_SET_FUNC_CODE
: /* Set Function Code */
1092 case OCD_SET_CTL_FLAGS
: /* Set Control Flags */
1093 case OCD_SET_BUF_ADDR
: /* Set Register Buffer Address */
1094 case OCD_RUN
: /* Run Target from PC */
1095 case OCD_RUN_ADDR
: /* Run Target from Specified Address */
1096 case OCD_STOP
: /* Stop Target */
1097 case OCD_RESET_RUN
: /* Reset Target and Run */
1098 case OCD_RESET
: /* Reset Target and Halt */
1099 case OCD_STEP
: /* Single Step */
1100 case OCD_WRITE_REGS
: /* Write Register */
1101 case OCD_WRITE_MEM
: /* Write Memory */
1102 case OCD_FILL_MEM
: /* Fill Memory */
1103 case OCD_MOVE_MEM
: /* Move Memory */
1104 case OCD_WRITE_INT_MEM
: /* Write Internal Memory */
1105 case OCD_JUMP
: /* Jump to Subroutine */
1106 case OCD_ERASE_FLASH
: /* Erase flash memory */
1107 case OCD_PROGRAM_FLASH
: /* Write flash memory */
1108 case OCD_EXIT_MON
: /* Exit the flash programming monitor */
1109 case OCD_ENTER_MON
: /* Enter the flash programming monitor */
1110 case OCD_LOG_FILE
: /* Make Wigglers.dll save Wigglers.log */
1111 case OCD_SET_CONNECTION
: /* Set type of connection in Wigglers.dll */
1114 case OCD_GET_VERSION
: /* Get Version */
1117 case OCD_GET_STATUS_MASK
: /* Get Status Mask */
1120 case OCD_GET_CTRS
: /* Get Error Counters */
1121 case OCD_READ_REGS
: /* Read Register */
1122 case OCD_READ_MEM
: /* Read Memory */
1123 case OCD_READ_INT_MEM
: /* Read Internal Memory */
1127 error ("ocd_get_packet: unknown packet type 0x%x\n", ch
);
1131 if (len
== 257) /* Byte stream? */
1132 { /* Yes, byte streams contain the length */
1133 ch
= readchar (timeout
);
1136 error ("ocd_get_packet (readchar): %d", ch
);
1144 while (len
-- >= 0) /* Do rest of packet and checksum */
1146 ch
= readchar (timeout
);
1149 error ("ocd_get_packet (readchar): %d", ch
);
1155 error ("ocd_get_packet: bad packet checksum");
1157 if (cmd
!= -1 && cmd
!= packet
[0])
1158 error ("Response phase error. Got 0x%x, expected 0x%x", packet
[0], cmd
);
1160 *lenp
= packet_ptr
- packet
- 1; /* Subtract checksum byte */
1165 /* Execute a simple (one-byte) command. Returns a pointer to the data
1166 following the error code. */
1168 static unsigned char *
1169 ocd_do_command (int cmd
, int *statusp
, int *lenp
)
1171 unsigned char buf
[100], *p
;
1172 int status
, error_code
;
1175 unsigned char logbuf
[100];
1179 ocd_put_packet (buf
, 1); /* Send command */
1180 p
= ocd_get_packet (*buf
, lenp
, remote_timeout
);
1183 error ("Truncated response packet from OCD device");
1188 if (error_code
!= 0)
1190 sprintf (errbuf
, "ocd_do_command (0x%x):", cmd
);
1191 ocd_error (errbuf
, error_code
);
1194 if (status
& OCD_FLAG_PWF
)
1195 error ("OCD device can't detect VCC at BDM interface.");
1196 else if (status
& OCD_FLAG_CABLE_DISC
)
1197 error ("BDM cable appears to be disconnected.");
1201 logbuf
[0] = OCD_LOG_FILE
;
1202 logbuf
[1] = 3; /* close existing WIGGLERS.LOG */
1203 ocd_put_packet (logbuf
, 2);
1204 ocd_get_packet (logbuf
[0], &logpktlen
, remote_timeout
);
1206 logbuf
[0] = OCD_LOG_FILE
;
1207 logbuf
[1] = 2; /* append to existing WIGGLERS.LOG */
1208 ocd_put_packet (logbuf
, 2);
1209 ocd_get_packet (logbuf
[0], &logpktlen
, remote_timeout
);
1217 /* For some mysterious reason, wait_for_inferior calls kill instead of
1218 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
1222 target_mourn_inferior ();
1226 /* Don't wait for it to die. I'm not really sure it matters whether
1228 target_mourn_inferior ();
1234 unpush_target (current_ops
);
1235 generic_mourn_inferior ();
1238 /* All we actually do is set the PC to the start address of exec_bfd, and start
1239 the program at that point. */
1242 ocd_create_inferior (char *exec_file
, char *args
, char **env
)
1244 if (args
&& (*args
!= '\000'))
1245 error ("Args are not supported by BDM.");
1247 clear_proceed_status ();
1248 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1252 ocd_load (char *args
, int from_tty
)
1254 generic_load (args
, from_tty
);
1258 /* This is necessary because many things were based on the PC at the time that
1259 we attached to the monitor, which is no longer valid now that we have loaded
1260 new code (and just changed the PC). Another way to do this might be to call
1261 normal_stop, except that the stack may not be valid, and things would get
1262 horribly confused... */
1264 clear_symtab_users ();
1267 /* This should be defined for each target */
1268 /* But we want to be able to compile this file for some configurations
1269 not yet supported fully */
1271 #define BDM_BREAKPOINT {0x0,0x0,0x0,0x0} /* For ppc 8xx */
1273 #define BDM_BREAKPOINT {0x4a,0xfa} /* BGND insn used for CPU32 */
1276 /* BDM (at least on CPU32) uses a different breakpoint */
1279 ocd_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1281 static char break_insn
[] = BDM_BREAKPOINT
;
1284 val
= target_read_memory (addr
, contents_cache
, sizeof (break_insn
));
1287 val
= target_write_memory (addr
, break_insn
, sizeof (break_insn
));
1293 ocd_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1295 static char break_insn
[] = BDM_BREAKPOINT
;
1298 val
= target_write_memory (addr
, contents_cache
, sizeof (break_insn
));
1304 bdm_command (char *args
, int from_tty
)
1306 error ("bdm command must be followed by `reset'");
1310 bdm_reset_command (char *args
, int from_tty
)
1315 error ("Not connected to OCD device.");
1317 ocd_do_command (OCD_RESET
, &status
, &pktlen
);
1318 dcache_invd (ocd_dcache
);
1319 registers_changed ();
1323 bdm_restart_command (char *args
, int from_tty
)
1328 error ("Not connected to OCD device.");
1330 ocd_do_command (OCD_RESET_RUN
, &status
, &pktlen
);
1331 last_run_status
= status
;
1332 clear_proceed_status ();
1333 wait_for_inferior ();
1337 /* Temporary replacement for target_store_registers(). This prevents
1338 generic_load from trying to set the PC. */
1341 noop_store_registers (int regno
)
1346 bdm_update_flash_command (char *args
, int from_tty
)
1349 struct cleanup
*old_chain
;
1350 void (*store_registers_tmp
) (int);
1353 error ("Not connected to OCD device.");
1356 error ("Must specify file containing new OCD code.");
1358 /* old_chain = make_cleanup (flash_cleanup, 0); */
1360 ocd_do_command (OCD_ENTER_MON
, &status
, &pktlen
);
1362 ocd_do_command (OCD_ERASE_FLASH
, &status
, &pktlen
);
1364 write_mem_command
= OCD_PROGRAM_FLASH
;
1365 store_registers_tmp
= current_target
.to_store_registers
;
1366 current_target
.to_store_registers
= noop_store_registers
;
1368 generic_load (args
, from_tty
);
1370 current_target
.to_store_registers
= store_registers_tmp
;
1371 write_mem_command
= OCD_WRITE_MEM
;
1373 ocd_do_command (OCD_EXIT_MON
, &status
, &pktlen
);
1375 /* discard_cleanups (old_chain); */
1379 bdm_read_register_command (char *args
, int from_tty
)
1381 /* XXX repeat should go on to the next register */
1384 error ("Not connected to OCD device.");
1387 error ("Must specify BDM register number.");
1392 _initialize_remote_ocd (void)
1394 extern struct cmd_list_element
*cmdlist
;
1395 static struct cmd_list_element
*ocd_cmd_list
= NULL
;
1397 add_show_from_set (add_set_cmd ("remotetimeout", no_class
,
1398 var_integer
, (char *) &remote_timeout
,
1399 "Set timeout value for remote read.\n", &setlist
),
1402 add_prefix_cmd ("ocd", class_obscure
, bdm_command
, "", &ocd_cmd_list
, "ocd ",
1405 add_cmd ("reset", class_obscure
, bdm_reset_command
, "", &ocd_cmd_list
);
1406 add_cmd ("restart", class_obscure
, bdm_restart_command
, "", &ocd_cmd_list
);
1407 add_cmd ("update-flash", class_obscure
, bdm_update_flash_command
, "", &ocd_cmd_list
);
1408 /* add_cmd ("read-register", class_obscure, bdm_read_register_command, "", &ocd_cmd_list); */