1 /* Target communications support for Macraigor Systems' On-Chip Debugging
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
34 #include "gdb-stabs.h"
35 #include <sys/types.h>
41 /* Prototypes for local functions */
43 static int ocd_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
);
45 static int ocd_start_remote (void *dummy
);
47 static int readchar (int timeout
);
49 static void reset_packet (void);
51 static void output_packet (void);
53 static int get_quoted_char (int timeout
);
55 static void put_quoted_char (int c
);
57 static void ocd_interrupt (int signo
);
59 static void ocd_interrupt_twice (int signo
);
61 static void interrupt_query (void);
63 static unsigned char *ocd_do_command (int cmd
, int *statusp
, int *lenp
);
65 static void ocd_put_packet (unsigned char *packet
, int pktlen
);
67 static unsigned char *ocd_get_packet (int cmd
, int *pktlen
, int timeout
);
69 static struct target_ops
*current_ops
= NULL
;
71 static int last_run_status
;
73 /* This was 5 seconds, which is a long time to sit and wait.
74 Unless this is going though some terminal server or multiplexer or
75 other form of hairy serial connection, I would think 2 seconds would
79 /* FIXME: Change to allow option to set timeout value on a per target
81 static int remote_timeout
= 2;
84 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
85 ocd_open knows that we don't have a file open when the program
87 static struct serial
*ocd_desc
= NULL
;
90 ocd_error (char *s
, int error_code
)
94 fputs_filtered (s
, gdb_stderr
);
95 fputs_filtered (" ", gdb_stderr
);
106 s
= "Cable disconnected";
109 s
= "Couldn't enter OCD mode";
112 s
= "Target stuck in reset";
115 s
= "OCD hasn't been initialized";
118 s
= "Write verify failed";
121 s
= "Reg buff error (during MPC5xx fp reg read/write)";
124 s
= "Invalid CPU register access attempt failed";
130 s
= "Checksum error";
133 s
= "Illegal command";
136 s
= "Parameter error";
139 s
= "Internal error";
142 s
= "Flash erase error";
145 sprintf (buf
, "Unknown error code %d", error_code
);
152 /* Return nonzero if the thread TH is still alive on the remote system. */
155 ocd_thread_alive (ptid_t th
)
160 /* Clean up connection to a remote debugger. */
164 ocd_close (int quitting
)
167 serial_close (ocd_desc
);
171 /* Stub for catch_errors. */
174 ocd_start_remote (void *dummy
)
176 unsigned char buf
[10], *p
;
181 enum ocd_target_type target_type
;
183 target_type
= *(enum ocd_target_type
*) dummy
;
185 immediate_quit
++; /* Allow user to interrupt it */
187 serial_send_break (ocd_desc
); /* Wake up the wiggler */
189 speed
= 80; /* Divide clock by 4000 */
193 buf
[2] = speed
& 0xff;
194 buf
[3] = target_type
;
195 ocd_put_packet (buf
, 4); /* Init OCD params */
196 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
199 error ("Truncated response packet from OCD device");
205 ocd_error ("OCD_INIT:", error_code
);
207 ocd_do_command (OCD_AYT
, &status
, &pktlen
);
209 p
= ocd_do_command (OCD_GET_VERSION
, &status
, &pktlen
);
211 printf_unfiltered ("[Wiggler version %x.%x, capability 0x%x]\n",
212 p
[0], p
[1], (p
[2] << 16) | p
[3]);
215 /* Reset the target */
217 ocd_do_command (OCD_RESET_RUN
, &status
, &pktlen
);
218 /* ocd_do_command (OCD_RESET, &status, &pktlen); */
221 /* If processor is still running, stop it. */
223 if (!(status
& OCD_FLAG_BDM
))
227 /* When using a target box, we want to asynchronously return status when
228 target stops. The OCD_SET_CTL_FLAGS command is ignored by Wigglers.dll
229 when using a parallel Wiggler */
230 buf
[0] = OCD_SET_CTL_FLAGS
;
233 ocd_put_packet (buf
, 3);
235 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
238 error ("Truncated response packet from OCD device");
244 ocd_error ("OCD_SET_CTL_FLAGS:", error_code
);
249 /* This is really the job of start_remote however, that makes an assumption
250 that the target is about to print out a status message of some sort. That
251 doesn't happen here (in fact, it may not be possible to get the monitor to
252 send the appropriate packet). */
254 flush_cached_frames ();
255 registers_changed ();
256 stop_pc
= read_pc ();
257 print_stack_frame (get_selected_frame (), -1, 1);
259 buf
[0] = OCD_LOG_FILE
;
260 buf
[1] = 3; /* close existing WIGGLERS.LOG */
261 ocd_put_packet (buf
, 2);
262 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
264 buf
[0] = OCD_LOG_FILE
;
265 buf
[1] = 2; /* append to existing WIGGLERS.LOG */
266 ocd_put_packet (buf
, 2);
267 p
= ocd_get_packet (buf
[0], &pktlen
, remote_timeout
);
272 /* Open a connection to a remote debugger.
273 NAME is the filename used for communication. */
276 ocd_open (char *name
, int from_tty
, enum ocd_target_type target_type
,
277 struct target_ops
*ops
)
279 unsigned char buf
[10], *p
;
283 error ("To open an OCD connection, you need to specify the\n\
284 device the OCD device is attached to (e.g. /dev/ttya).");
286 target_preopen (from_tty
);
290 unpush_target (current_ops
);
292 ocd_desc
= serial_open (name
);
294 perror_with_name (name
);
298 if (serial_setbaudrate (ocd_desc
, baud_rate
))
300 serial_close (ocd_desc
);
301 perror_with_name (name
);
305 serial_raw (ocd_desc
);
307 /* If there is something sitting in the buffer we might take it as a
308 response to a command, which would be bad. */
309 serial_flush_input (ocd_desc
);
313 puts_filtered ("Remote target wiggler connected to ");
314 puts_filtered (name
);
315 puts_filtered ("\n");
317 push_target (current_ops
); /* Switch to using remote target now */
319 /* Without this, some commands which require an active target (such as kill)
320 won't work. This variable serves (at least) double duty as both the pid
321 of the target process (if it has such), and as a flag indicating that a
322 target is active. These functions should be split out into seperate
323 variables, especially since GDB will someday have a notion of debugging
324 several processes. */
326 inferior_ptid
= pid_to_ptid (42000);
327 /* Start the remote connection; if error (0), discard this target.
328 In particular, if the user quits, be sure to discard it
329 (we'd be in an inconsistent state otherwise). */
330 if (!catch_errors (ocd_start_remote
, &target_type
,
331 "Couldn't establish connection to remote target\n",
335 error ("Failed to connect to OCD.");
339 /* This takes a program previously attached to and detaches it. After
340 this is done, GDB can be used to debug some other program. We
341 better not have left any breakpoints in the target program or it'll
342 die when it hits one. */
345 ocd_detach (char *args
, int from_tty
)
348 error ("Argument given to \"detach\" when remotely debugging.");
352 puts_filtered ("Ending remote debugging.\n");
355 /* Tell the remote machine to resume. */
358 ocd_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
363 ocd_do_command (OCD_STEP
, &last_run_status
, &pktlen
);
365 ocd_do_command (OCD_RUN
, &last_run_status
, &pktlen
);
374 ocd_do_command (OCD_STOP
, &status
, &pktlen
);
376 if (!(status
& OCD_FLAG_BDM
))
377 error ("Can't stop target via BDM");
380 static volatile int ocd_interrupt_flag
;
382 /* Send ^C to target to halt it. Target will respond, and send us a
386 ocd_interrupt (int signo
)
388 /* If this doesn't work, try more severe steps. */
389 signal (signo
, ocd_interrupt_twice
);
392 printf_unfiltered ("ocd_interrupt called\n");
399 ocd_put_packet (buf
, 1);
400 ocd_interrupt_flag
= 1;
404 static void (*ofunc
) ();
406 /* The user typed ^C twice. */
408 ocd_interrupt_twice (int signo
)
410 signal (signo
, ofunc
);
414 signal (signo
, ocd_interrupt
);
417 /* Ask the user what to do when an interrupt is received. */
420 interrupt_query (void)
422 target_terminal_ours ();
424 if (query ("Interrupted while waiting for the program.\n\
425 Give up (and stop debugging it)? "))
427 target_mourn_inferior ();
428 throw_exception (RETURN_QUIT
);
431 target_terminal_inferior ();
434 /* If nonzero, ignore the next kill. */
435 static int kill_kludge
;
437 /* Wait until the remote machine stops, then return,
438 storing status in STATUS just as `wait' would.
439 Returns "pid" (though it's not clear what, if anything, that
440 means in the case of this target). */
450 ocd_interrupt_flag
= 0;
452 /* Target might already be stopped by the time we get here. */
453 /* If we aren't already stopped, we need to loop until we've dropped
454 back into BDM mode */
456 while (!(last_run_status
& OCD_FLAG_BDM
))
459 ocd_put_packet (buf
, 1);
460 p
= ocd_get_packet (OCD_AYT
, &pktlen
, -1);
462 ofunc
= (void (*)()) signal (SIGINT
, ocd_interrupt
);
463 signal (SIGINT
, ofunc
);
466 error ("Truncated response packet from OCD device");
468 last_run_status
= p
[1];
472 ocd_error ("target_wait:", error_code
);
474 if (last_run_status
& OCD_FLAG_PWF
)
475 error ("OCD device lost VCC at BDM interface.");
476 else if (last_run_status
& OCD_FLAG_CABLE_DISC
)
477 error ("OCD device cable appears to have been disconnected.");
480 if (ocd_interrupt_flag
)
486 /* Read registers from the OCD device. Specify the starting and ending
487 register number. Return the number of regs actually read in *NUMREGS.
488 Returns a pointer to a static array containing the register contents. */
491 ocd_read_bdm_registers (int first_bdm_regno
, int last_bdm_regno
, int *reglen
)
493 unsigned char buf
[10];
497 int error_code
, status
;
500 buf
[0] = OCD_READ_REGS
;
501 buf
[1] = first_bdm_regno
>> 8;
502 buf
[2] = first_bdm_regno
& 0xff;
503 buf
[3] = last_bdm_regno
>> 8;
504 buf
[4] = last_bdm_regno
& 0xff;
506 ocd_put_packet (buf
, 5);
507 p
= ocd_get_packet (OCD_READ_REGS
, &pktlen
, remote_timeout
);
513 ocd_error ("read_bdm_registers:", error_code
);
521 error ("Register block size bad: %d", i
);
530 /* Read register BDM_REGNO and returns its value ala read_register() */
533 ocd_read_bdm_register (int bdm_regno
)
539 p
= ocd_read_bdm_registers (bdm_regno
, bdm_regno
, ®len
);
540 regval
= extract_unsigned_integer (p
, reglen
);
546 ocd_write_bdm_registers (int first_bdm_regno
, unsigned char *regptr
, int reglen
)
550 int error_code
, status
;
553 buf
= alloca (4 + reglen
);
555 buf
[0] = OCD_WRITE_REGS
;
556 buf
[1] = first_bdm_regno
>> 8;
557 buf
[2] = first_bdm_regno
& 0xff;
559 memcpy (buf
+ 4, regptr
, reglen
);
561 ocd_put_packet (buf
, 4 + reglen
);
562 p
= ocd_get_packet (OCD_WRITE_REGS
, &pktlen
, remote_timeout
);
565 error ("Truncated response packet from OCD device");
571 ocd_error ("ocd_write_bdm_registers:", error_code
);
575 ocd_write_bdm_register (int bdm_regno
, CORE_ADDR reg
)
577 unsigned char buf
[4];
579 store_unsigned_integer (buf
, 4, reg
);
581 ocd_write_bdm_registers (bdm_regno
, buf
, 4);
585 ocd_prepare_to_store (void)
589 /* Write memory data directly to the remote machine.
590 This does not inform the data cache; the data cache uses this.
591 MEMADDR is the address in the remote memory space.
592 MYADDR is the address of the buffer in our space.
593 LEN is the number of bytes.
595 Returns number of bytes transferred, or 0 for error. */
597 static int write_mem_command
= OCD_WRITE_MEM
;
600 ocd_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
608 buf
[0] = write_mem_command
;
609 buf
[5] = 1; /* Write as bytes */
610 buf
[6] = 0; /* Don't verify */
616 int status
, error_code
;
618 numbytes
= min (len
, 256 - 8);
620 buf
[1] = memaddr
>> 24;
621 buf
[2] = memaddr
>> 16;
622 buf
[3] = memaddr
>> 8;
627 memcpy (&buf
[8], myaddr
, numbytes
);
628 ocd_put_packet (buf
, 8 + numbytes
);
629 p
= ocd_get_packet (OCD_WRITE_MEM
, &pktlen
, remote_timeout
);
631 error ("Truncated response packet from OCD device");
636 if (error_code
== 0x11) /* Got a bus error? */
638 CORE_ADDR error_address
;
640 error_address
= p
[3] << 24;
641 error_address
|= p
[4] << 16;
642 error_address
|= p
[5] << 8;
643 error_address
|= p
[6];
644 numbytes
= error_address
- memaddr
;
652 else if (error_code
!= 0)
653 ocd_error ("ocd_write_bytes:", error_code
);
660 return origlen
- len
;
663 /* Read memory data directly from the remote machine.
664 This does not use the data cache; the data cache uses this.
665 MEMADDR is the address in the remote memory space.
666 MYADDR is the address of the buffer in our space.
667 LEN is the number of bytes.
669 Returns number of bytes transferred, or 0 for error. */
672 ocd_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
680 buf
[0] = OCD_READ_MEM
;
681 buf
[5] = 1; /* Read as bytes */
687 int status
, error_code
;
689 numbytes
= min (len
, 256 - 7);
691 buf
[1] = memaddr
>> 24;
692 buf
[2] = memaddr
>> 16;
693 buf
[3] = memaddr
>> 8;
698 ocd_put_packet (buf
, 7);
699 p
= ocd_get_packet (OCD_READ_MEM
, &pktlen
, remote_timeout
);
701 error ("Truncated response packet from OCD device");
706 if (error_code
== 0x11) /* Got a bus error? */
708 CORE_ADDR error_address
;
710 error_address
= p
[3] << 24;
711 error_address
|= p
[4] << 16;
712 error_address
|= p
[5] << 8;
713 error_address
|= p
[6];
714 numbytes
= error_address
- memaddr
;
722 else if (error_code
!= 0)
723 ocd_error ("ocd_read_bytes:", error_code
);
725 memcpy (myaddr
, &p
[4], numbytes
);
732 return origlen
- len
;
735 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
736 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
737 nonzero. Returns length of data written or read; 0 for error. TARGET
742 ocd_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int should_write
,
743 struct mem_attrib
*attrib
, struct target_ops
*target
)
748 res
= ocd_write_bytes (memaddr
, myaddr
, len
);
750 res
= ocd_read_bytes (memaddr
, myaddr
, len
);
756 ocd_files_info (struct target_ops
*ignore
)
758 puts_filtered ("Debugging a target over a serial line.\n");
761 /* Stuff for dealing with the packets which are part of this protocol.
762 See comment at top of file for details. */
764 /* Read a single character from the remote side, handling wierd errors. */
767 readchar (int timeout
)
771 ch
= serial_readchar (ocd_desc
, timeout
);
776 error ("Remote connection closed");
778 perror_with_name ("Remote communication error");
786 /* Read a character from the data stream, dequoting as necessary. SYN is
787 treated special. Any SYNs appearing in the data stream are returned as the
788 distinct value RAW_SYN (which has a value > 8 bits and therefore cannot be
789 mistaken for real data). */
792 get_quoted_char (int timeout
)
796 ch
= readchar (timeout
);
801 error ("Timeout in mid-packet, aborting");
805 ch
= readchar (timeout
);
814 static unsigned char pkt
[256 * 2 + 10], *pktp
; /* Worst case */
825 if (serial_write (ocd_desc
, pkt
, pktp
- pkt
))
826 perror_with_name ("output_packet: write failed");
831 /* Output a quoted character. SYNs and DLEs are quoted. Everything else goes
832 through untouched. */
835 put_quoted_char (int c
)
848 /* Send a packet to the OCD device. The packet framed by a SYN character,
849 a byte count and a checksum. The byte count only counts the number of
850 bytes between the count and the checksum. A count of zero actually
851 means 256. Any SYNs within the packet (including the checksum and
852 count) must be quoted. The quote character must be quoted as well.
853 Quoting is done by replacing the character with the two-character sequence
854 DLE, {char} | 0100. Note that the quoting mechanism has no effect on the
858 stu_put_packet (unsigned char *buf
, int len
)
860 unsigned char checksum
;
863 if (len
== 0 || len
> 256)
864 internal_error (__FILE__
, __LINE__
, "failed internal consistency check"); /* Can't represent 0 length packet */
870 put_quoted_char (RAW_SYN
);
884 put_quoted_char (-checksum
& 0xff);
891 /* Send a packet to the OCD device. The packet framed by a SYN character,
892 a byte count and a checksum. The byte count only counts the number of
893 bytes between the count and the checksum. A count of zero actually
894 means 256. Any SYNs within the packet (including the checksum and
895 count) must be quoted. The quote character must be quoted as well.
896 Quoting is done by replacing the character with the two-character sequence
897 DLE, {char} | 0100. Note that the quoting mechanism has no effect on the
901 ocd_put_packet (unsigned char *buf
, int len
)
903 unsigned char checksum
;
905 unsigned char *packet
, *packet_ptr
;
907 packet
= alloca (len
+ 1 + 1); /* packet + SYN + checksum */
912 *packet_ptr
++ = 0x55;
922 *packet_ptr
++ = -checksum
;
923 if (serial_write (ocd_desc
, packet
, packet_ptr
- packet
))
924 perror_with_name ("output_packet: write failed");
929 /* Get a packet from the OCD device. Timeout is only enforced for the
930 first byte of the packet. Subsequent bytes are expected to arrive in
931 time <= remote_timeout. Returns a pointer to a static buffer containing
932 the payload of the packet. *LENP contains the length of the packet.
935 static unsigned char *
936 stu_get_packet (unsigned char cmd
, int *lenp
, int timeout
)
940 static unsigned char buf
[256 + 10], *p
;
941 unsigned char checksum
;
945 ch
= get_quoted_char (timeout
);
948 error ("get_packet (readchar): %d", ch
);
953 found_syn
: /* Found the start of a packet */
958 len
= get_quoted_char (remote_timeout
);
968 len
++; /* Include checksum */
972 ch
= get_quoted_char (remote_timeout
);
984 error ("Response phase error. Got 0x%x, expected 0x%x", buf
[0], cmd
);
992 /* Get a packet from the OCD device. Timeout is only enforced for the
993 first byte of the packet. Subsequent bytes are expected to arrive in
994 time <= remote_timeout. Returns a pointer to a static buffer containing
995 the payload of the packet. *LENP contains the length of the packet.
998 static unsigned char *
999 ocd_get_packet (int cmd
, int *lenp
, int timeout
)
1003 static unsigned char packet
[512];
1004 unsigned char *packet_ptr
;
1005 unsigned char checksum
;
1007 ch
= readchar (timeout
);
1010 error ("ocd_get_packet (readchar): %d", ch
);
1013 error ("ocd_get_packet (readchar): %d", ch
);
1015 /* Found the start of a packet */
1017 packet_ptr
= packet
;
1020 /* Read command char. That sort of tells us how long the packet is. */
1022 ch
= readchar (timeout
);
1025 error ("ocd_get_packet (readchar): %d", ch
);
1032 ch
= readchar (timeout
);
1035 error ("ocd_get_packet (readchar): %d", ch
);
1039 /* Get error code. */
1041 ch
= readchar (timeout
);
1044 error ("ocd_get_packet (readchar): %d", ch
);
1048 switch (ch
) /* Figure out length of packet */
1050 case 0x7: /* Write verify error? */
1051 len
= 8; /* write address, value read back */
1053 case 0x11: /* Bus error? */
1054 /* write address, read flag */
1055 case 0x15: /* Internal error */
1056 len
= 5; /* error code, vector */
1058 default: /* Error w/no params */
1061 case 0x0: /* Normal result */
1064 case OCD_AYT
: /* Are You There? */
1065 case OCD_SET_BAUD_RATE
: /* Set Baud Rate */
1066 case OCD_INIT
: /* Initialize OCD device */
1067 case OCD_SET_SPEED
: /* Set Speed */
1068 case OCD_SET_FUNC_CODE
: /* Set Function Code */
1069 case OCD_SET_CTL_FLAGS
: /* Set Control Flags */
1070 case OCD_SET_BUF_ADDR
: /* Set Register Buffer Address */
1071 case OCD_RUN
: /* Run Target from PC */
1072 case OCD_RUN_ADDR
: /* Run Target from Specified Address */
1073 case OCD_STOP
: /* Stop Target */
1074 case OCD_RESET_RUN
: /* Reset Target and Run */
1075 case OCD_RESET
: /* Reset Target and Halt */
1076 case OCD_STEP
: /* Single Step */
1077 case OCD_WRITE_REGS
: /* Write Register */
1078 case OCD_WRITE_MEM
: /* Write Memory */
1079 case OCD_FILL_MEM
: /* Fill Memory */
1080 case OCD_MOVE_MEM
: /* Move Memory */
1081 case OCD_WRITE_INT_MEM
: /* Write Internal Memory */
1082 case OCD_JUMP
: /* Jump to Subroutine */
1083 case OCD_ERASE_FLASH
: /* Erase flash memory */
1084 case OCD_PROGRAM_FLASH
: /* Write flash memory */
1085 case OCD_EXIT_MON
: /* Exit the flash programming monitor */
1086 case OCD_ENTER_MON
: /* Enter the flash programming monitor */
1087 case OCD_LOG_FILE
: /* Make Wigglers.dll save Wigglers.log */
1088 case OCD_SET_CONNECTION
: /* Set type of connection in Wigglers.dll */
1091 case OCD_GET_VERSION
: /* Get Version */
1094 case OCD_GET_STATUS_MASK
: /* Get Status Mask */
1097 case OCD_GET_CTRS
: /* Get Error Counters */
1098 case OCD_READ_REGS
: /* Read Register */
1099 case OCD_READ_MEM
: /* Read Memory */
1100 case OCD_READ_INT_MEM
: /* Read Internal Memory */
1104 error ("ocd_get_packet: unknown packet type 0x%x\n", ch
);
1108 if (len
== 257) /* Byte stream? */
1109 { /* Yes, byte streams contain the length */
1110 ch
= readchar (timeout
);
1113 error ("ocd_get_packet (readchar): %d", ch
);
1121 while (len
-- >= 0) /* Do rest of packet and checksum */
1123 ch
= readchar (timeout
);
1126 error ("ocd_get_packet (readchar): %d", ch
);
1132 error ("ocd_get_packet: bad packet checksum");
1134 if (cmd
!= -1 && cmd
!= packet
[0])
1135 error ("Response phase error. Got 0x%x, expected 0x%x", packet
[0], cmd
);
1137 *lenp
= packet_ptr
- packet
- 1; /* Subtract checksum byte */
1142 /* Execute a simple (one-byte) command. Returns a pointer to the data
1143 following the error code. */
1145 static unsigned char *
1146 ocd_do_command (int cmd
, int *statusp
, int *lenp
)
1148 unsigned char buf
[100], *p
;
1149 int status
, error_code
;
1152 unsigned char logbuf
[100];
1156 ocd_put_packet (buf
, 1); /* Send command */
1157 p
= ocd_get_packet (*buf
, lenp
, remote_timeout
);
1160 error ("Truncated response packet from OCD device");
1165 if (error_code
!= 0)
1167 sprintf (errbuf
, "ocd_do_command (0x%x):", cmd
);
1168 ocd_error (errbuf
, error_code
);
1171 if (status
& OCD_FLAG_PWF
)
1172 error ("OCD device can't detect VCC at BDM interface.");
1173 else if (status
& OCD_FLAG_CABLE_DISC
)
1174 error ("BDM cable appears to be disconnected.");
1178 logbuf
[0] = OCD_LOG_FILE
;
1179 logbuf
[1] = 3; /* close existing WIGGLERS.LOG */
1180 ocd_put_packet (logbuf
, 2);
1181 ocd_get_packet (logbuf
[0], &logpktlen
, remote_timeout
);
1183 logbuf
[0] = OCD_LOG_FILE
;
1184 logbuf
[1] = 2; /* append to existing WIGGLERS.LOG */
1185 ocd_put_packet (logbuf
, 2);
1186 ocd_get_packet (logbuf
[0], &logpktlen
, remote_timeout
);
1194 /* For some mysterious reason, wait_for_inferior calls kill instead of
1195 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
1199 target_mourn_inferior ();
1203 /* Don't wait for it to die. I'm not really sure it matters whether
1205 target_mourn_inferior ();
1211 unpush_target (current_ops
);
1212 generic_mourn_inferior ();
1215 /* All we actually do is set the PC to the start address of exec_bfd, and start
1216 the program at that point. */
1219 ocd_create_inferior (char *exec_file
, char *args
, char **env
)
1221 if (args
&& (*args
!= '\000'))
1222 error ("Args are not supported by BDM.");
1224 clear_proceed_status ();
1225 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1229 ocd_load (char *args
, int from_tty
)
1231 generic_load (args
, from_tty
);
1233 inferior_ptid
= null_ptid
;
1235 /* This is necessary because many things were based on the PC at the time that
1236 we attached to the monitor, which is no longer valid now that we have loaded
1237 new code (and just changed the PC). Another way to do this might be to call
1238 normal_stop, except that the stack may not be valid, and things would get
1239 horribly confused... */
1241 clear_symtab_users ();
1244 /* This should be defined for each target */
1245 /* But we want to be able to compile this file for some configurations
1246 not yet supported fully */
1248 #define BDM_BREAKPOINT {0x0,0x0,0x0,0x0} /* For ppc 8xx */
1250 #define BDM_BREAKPOINT {0x4a,0xfa} /* BGND insn used for CPU32 */
1253 /* BDM (at least on CPU32) uses a different breakpoint */
1256 ocd_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1258 static char break_insn
[] = BDM_BREAKPOINT
;
1261 val
= target_read_memory (addr
, contents_cache
, sizeof (break_insn
));
1264 val
= target_write_memory (addr
, break_insn
, sizeof (break_insn
));
1270 ocd_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1272 static char break_insn
[] = BDM_BREAKPOINT
;
1275 val
= target_write_memory (addr
, contents_cache
, sizeof (break_insn
));
1281 bdm_command (char *args
, int from_tty
)
1283 error ("bdm command must be followed by `reset'");
1287 bdm_reset_command (char *args
, int from_tty
)
1292 error ("Not connected to OCD device.");
1294 ocd_do_command (OCD_RESET
, &status
, &pktlen
);
1295 dcache_invalidate (target_dcache
);
1296 registers_changed ();
1300 bdm_restart_command (char *args
, int from_tty
)
1305 error ("Not connected to OCD device.");
1307 ocd_do_command (OCD_RESET_RUN
, &status
, &pktlen
);
1308 last_run_status
= status
;
1309 clear_proceed_status ();
1310 wait_for_inferior ();
1314 /* Temporary replacement for target_store_registers(). This prevents
1315 generic_load from trying to set the PC. */
1318 noop_store_registers (int regno
)
1323 bdm_update_flash_command (char *args
, int from_tty
)
1326 struct cleanup
*old_chain
;
1327 void (*store_registers_tmp
) (int);
1330 error ("Not connected to OCD device.");
1333 error ("Must specify file containing new OCD code.");
1335 /* old_chain = make_cleanup (flash_cleanup, 0); */
1337 ocd_do_command (OCD_ENTER_MON
, &status
, &pktlen
);
1339 ocd_do_command (OCD_ERASE_FLASH
, &status
, &pktlen
);
1341 write_mem_command
= OCD_PROGRAM_FLASH
;
1342 store_registers_tmp
= current_target
.to_store_registers
;
1343 current_target
.to_store_registers
= noop_store_registers
;
1345 generic_load (args
, from_tty
);
1347 current_target
.to_store_registers
= store_registers_tmp
;
1348 write_mem_command
= OCD_WRITE_MEM
;
1350 ocd_do_command (OCD_EXIT_MON
, &status
, &pktlen
);
1352 /* discard_cleanups (old_chain); */
1356 bdm_read_register_command (char *args
, int from_tty
)
1358 /* XXX repeat should go on to the next register */
1361 error ("Not connected to OCD device.");
1364 error ("Must specify BDM register number.");
1369 _initialize_remote_ocd (void)
1371 extern struct cmd_list_element
*cmdlist
;
1372 static struct cmd_list_element
*ocd_cmd_list
= NULL
;
1374 add_show_from_set (add_set_cmd ("remotetimeout", no_class
,
1375 var_integer
, (char *) &remote_timeout
,
1376 "Set timeout value for remote read.\n", &setlist
),
1379 add_prefix_cmd ("ocd", class_obscure
, bdm_command
, "", &ocd_cmd_list
, "ocd ",
1382 add_cmd ("reset", class_obscure
, bdm_reset_command
, "", &ocd_cmd_list
);
1383 add_cmd ("restart", class_obscure
, bdm_restart_command
, "", &ocd_cmd_list
);
1384 add_cmd ("update-flash", class_obscure
, bdm_update_flash_command
, "", &ocd_cmd_list
);
1385 /* add_cmd ("read-register", class_obscure, bdm_read_register_command, "", &ocd_cmd_list); */