Thu Aug 7 13:09:17 1997 Geoffrey Noer <noer@cygnus.com>

        Nomenclature change.  BDM is a specific type of OCD
        (On chip debugging).  Wiggler is the parallel port box controlled
        by Wigglers.dll.  The faster target box from Macraigor Systems
        is not a wiggler.
        * ocd.c:
        * ocd.h:
        * ppc-bdm.c:
	* ser-ocd.c:
        Replace all instances of "wiggler_" with "ocd_" and change most other
        instances of "wiggler" to "ocd" or "ocd device" depending on context.
        * config/m68k/monitor.mt: remove remote-wiggler.o from TDEPFILES
        until OCD with that target is supported again.

4 files changed, 305 insertions, 305 deletions

diff --git a/gdb/ocd.c b/gdb/ocd.c
index b20bd9c..7895beb7 100644
--- a/gdb/ocd.c
+++ b/gdb/ocd.c
@@ -38,13 +38,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Prototypes for local functions */
 
-static int wiggler_write_bytes PARAMS ((CORE_ADDR memaddr,
+static int ocd_write_bytes PARAMS ((CORE_ADDR memaddr,
 				       char *myaddr, int len));
 
-static int wiggler_read_bytes PARAMS ((CORE_ADDR memaddr,
+static int ocd_read_bytes PARAMS ((CORE_ADDR memaddr,
 				      char *myaddr, int len));
 
-static int wiggler_start_remote PARAMS ((char *dummy));
+static int ocd_start_remote PARAMS ((char *dummy));
 
 static int readchar PARAMS ((int timeout));
 
@@ -56,17 +56,17 @@ static int get_quoted_char PARAMS ((int timeout));
 
 static void put_quoted_char PARAMS ((int c));
 
-static void wiggler_interrupt PARAMS ((int signo));
+static void ocd_interrupt PARAMS ((int signo));
 
-static void wiggler_interrupt_twice PARAMS ((int signo));
+static void ocd_interrupt_twice PARAMS ((int signo));
 
 static void interrupt_query PARAMS ((void));
 
 static unsigned char * do_command PARAMS ((int cmd, int *statusp, int *lenp));
 
-static void wiggler_put_packet PARAMS ((unsigned char *packet, int pktlen));
+static void ocd_put_packet PARAMS ((unsigned char *packet, int pktlen));
 
-static unsigned char * wiggler_get_packet PARAMS ((int cmd, int *pktlen, int timeout));
+static unsigned char * ocd_get_packet PARAMS ((int cmd, int *pktlen, int timeout));
 
 static struct target_ops *current_ops = NULL;
 
@@ -82,12 +82,12 @@ static int last_run_status;
 extern int remote_timeout;
 
 /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
-   wiggler_open knows that we don't have a file open when the program
+   ocd_open knows that we don't have a file open when the program
    starts.  */
-static serial_t wiggler_desc = NULL;
+static serial_t ocd_desc = NULL;
 
 void
-wiggler_error (s, error_code)
+ocd_error (s, error_code)
      char *s;
      int error_code;
 {
@@ -123,7 +123,7 @@ wiggler_error (s, error_code)
 /*  Return nonzero if the thread TH is still alive on the remote system.  */
 
 int
-wiggler_thread_alive (th)
+ocd_thread_alive (th)
      int th;
 {
   return 1;
@@ -133,18 +133,18 @@ wiggler_thread_alive (th)
 
 /* ARGSUSED */
 void
-wiggler_close (quitting)
+ocd_close (quitting)
      int quitting;
 {
-  if (wiggler_desc)
-    SERIAL_CLOSE (wiggler_desc);
-  wiggler_desc = NULL;
+  if (ocd_desc)
+    SERIAL_CLOSE (ocd_desc);
+  ocd_desc = NULL;
 }
 
 /* Stub for catch_errors.  */
 
 static int
-wiggler_start_remote (dummy)
+ocd_start_remote (dummy)
      char *dummy;
 {
   unsigned char buf[10], *p;
@@ -152,17 +152,17 @@ wiggler_start_remote (dummy)
   int status;
   int error_code;
   int speed;
-  enum wiggler_target_type target_type;
+  enum ocd_target_type target_type;
 
-  target_type = (enum wiggler_target_type)dummy;
+  target_type = (enum ocd_target_type)dummy;
 
   immediate_quit = 1;		/* Allow user to interrupt it */
 
-  SERIAL_SEND_BREAK (wiggler_desc); /* Wake up the wiggler */
+  SERIAL_SEND_BREAK (ocd_desc); /* Wake up the wiggler */
 
-  do_command (WIGGLER_AYT, &status, &pktlen);
+  do_command (OCD_AYT, &status, &pktlen);
 
-  p = do_command (WIGGLER_GET_VERSION, &status, &pktlen);
+  p = do_command (OCD_GET_VERSION, &status, &pktlen);
 
   printf_unfiltered ("[Wiggler version %x.%x, capability 0x%x]\n",
 		     p[0], p[1], (p[2] << 16) | p[3]);
@@ -170,51 +170,51 @@ wiggler_start_remote (dummy)
 #if 1
   speed = 80;			/* Divide clock by 4000 */
 
-  buf[0] = WIGGLER_INIT;
+  buf[0] = OCD_INIT;
   buf[1] = speed >> 8;
   buf[2] = speed & 0xff;
   buf[3] = target_type;
-  wiggler_put_packet (buf, 4);	/* Init Wiggler params */
-  p = wiggler_get_packet (buf[0], &pktlen, remote_timeout);
+  ocd_put_packet (buf, 4);	/* Init OCD params */
+  p = ocd_get_packet (buf[0], &pktlen, remote_timeout);
 
   if (pktlen < 2)
-    error ("Truncated response packet from Wiggler");
+    error ("Truncated response packet from OCD device");
 
   status = p[1];
   error_code = p[2];
 
   if (error_code != 0)
-    wiggler_error ("WIGGLER_INIT:", error_code);
+    ocd_error ("OCD_INIT:", error_code);
 #endif
 
 #if 0
   /* Reset the target */
 
-  do_command (WIGGLER_RESET_RUN, &status, &pktlen);
-/*  do_command (WIGGLER_RESET, &status, &pktlen);*/
+  do_command (OCD_RESET_RUN, &status, &pktlen);
+/*  do_command (OCD_RESET, &status, &pktlen);*/
 #endif
 
   /* If processor is still running, stop it.  */
 
-  if (!(status & WIGGLER_FLAG_BDM))
-    wiggler_stop ();
+  if (!(status & OCD_FLAG_BDM))
+    ocd_stop ();
 
 #if 1
-  buf[0] = WIGGLER_SET_CTL_FLAGS;
+  buf[0] = OCD_SET_CTL_FLAGS;
   buf[1] = 0;
   buf[2] = 1;		/* Asynchronously return status when target stops */
-  wiggler_put_packet (buf, 3);
+  ocd_put_packet (buf, 3);
 
-  p = wiggler_get_packet (buf[0], &pktlen, remote_timeout);
+  p = ocd_get_packet (buf[0], &pktlen, remote_timeout);
 
   if (pktlen < 2)
-    error ("Truncated response packet from Wiggler");
+    error ("Truncated response packet from OCD device");
 
   status = p[1];
   error_code = p[2];
 
   if (error_code != 0)
-    wiggler_error ("WIGGLER_SET_CTL_FLAGS:", error_code);
+    ocd_error ("OCD_SET_CTL_FLAGS:", error_code);
 #endif
 
   immediate_quit = 0;
@@ -237,18 +237,18 @@ wiggler_start_remote (dummy)
 /* Open a connection to a remote debugger.
    NAME is the filename used for communication.  */
 
-static DCACHE *wiggler_dcache;
+static DCACHE *ocd_dcache;
 
 void
-wiggler_open (name, from_tty, target_type, ops)
+ocd_open (name, from_tty, target_type, ops)
      char *name;
      int from_tty;
-     enum wiggler_target_type target_type;
+     enum ocd_target_type target_type;
      struct target_ops *ops;
 {
   if (name == 0)
-    error ("To open a Wiggler connection, you need to specify what serial\n\
-device the Wiggler is attached to (e.g. /dev/ttya).");
+    error ("To open an OCD connection, you need to specify the\n\
+device the OCD device is attached to (e.g. /dev/ttya).");
 
   target_preopen (from_tty);
 
@@ -256,26 +256,26 @@ device the Wiggler is attached to (e.g. /dev/ttya).");
 
   unpush_target (current_ops);
 
-  wiggler_dcache = dcache_init (wiggler_read_bytes, wiggler_write_bytes);
+  ocd_dcache = dcache_init (ocd_read_bytes, ocd_write_bytes);
 
-  wiggler_desc = SERIAL_OPEN (name);
-  if (!wiggler_desc)
+  ocd_desc = SERIAL_OPEN (name);
+  if (!ocd_desc)
     perror_with_name (name);
 
   if (baud_rate != -1)
     {
-      if (SERIAL_SETBAUDRATE (wiggler_desc, baud_rate))
+      if (SERIAL_SETBAUDRATE (ocd_desc, baud_rate))
 	{
-	  SERIAL_CLOSE (wiggler_desc);
+	  SERIAL_CLOSE (ocd_desc);
 	  perror_with_name (name);
 	}
     }
 
-  SERIAL_RAW (wiggler_desc);
+  SERIAL_RAW (ocd_desc);
 
   /* If there is something sitting in the buffer we might take it as a
      response to a command, which would be bad.  */
-  SERIAL_FLUSH_INPUT (wiggler_desc);
+  SERIAL_FLUSH_INPUT (ocd_desc);
 
   if (from_tty)
     {
@@ -296,7 +296,7 @@ device the Wiggler is attached to (e.g. /dev/ttya).");
   /* Start the remote connection; if error (0), discard this target.
      In particular, if the user quits, be sure to discard it
      (we'd be in an inconsistent state otherwise).  */
-  if (!catch_errors (wiggler_start_remote, (char *)target_type,
+  if (!catch_errors (ocd_start_remote, (char *)target_type,
 		     "Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
     pop_target();
 }
@@ -307,7 +307,7 @@ device the Wiggler is attached to (e.g. /dev/ttya).");
    die when it hits one.  */
 
 void
-wiggler_detach (args, from_tty)
+ocd_detach (args, from_tty)
      char *args;
      int from_tty;
 {
@@ -322,54 +322,54 @@ wiggler_detach (args, from_tty)
 /* Tell the remote machine to resume.  */
 
 void
-wiggler_resume (pid, step, siggnal)
+ocd_resume (pid, step, siggnal)
      int pid, step;
      enum target_signal siggnal;
 {
   int pktlen;
 
-  dcache_flush (wiggler_dcache);
+  dcache_flush (ocd_dcache);
 
   if (step)
-    do_command (WIGGLER_STEP, &last_run_status, &pktlen);
+    do_command (OCD_STEP, &last_run_status, &pktlen);
   else
-    do_command (WIGGLER_RUN, &last_run_status, &pktlen);
+    do_command (OCD_RUN, &last_run_status, &pktlen);
 }
 
 void
-wiggler_stop ()
+ocd_stop ()
 {
   int status;
   int pktlen;
 
-  do_command (WIGGLER_STOP, &status, &pktlen);
+  do_command (OCD_STOP, &status, &pktlen);
 
-  if (!(status & WIGGLER_FLAG_BDM))
+  if (!(status & OCD_FLAG_BDM))
     error ("Can't stop target via BDM");
 }
 
-static volatile int wiggler_interrupt_flag;
+static volatile int ocd_interrupt_flag;
 
 /* Send ^C to target to halt it.  Target will respond, and send us a
    packet.  */
 
 static void
-wiggler_interrupt (signo)
+ocd_interrupt (signo)
      int signo;
 {
   /* If this doesn't work, try more severe steps.  */
-  signal (signo, wiggler_interrupt_twice);
+  signal (signo, ocd_interrupt_twice);
   
   if (remote_debug)
-    printf_unfiltered ("wiggler_interrupt called\n");
+    printf_unfiltered ("ocd_interrupt called\n");
 
   {
     char buf[1];
 
-    wiggler_stop ();
-    buf[0] = WIGGLER_AYT;
-    wiggler_put_packet (buf, 1);
-    wiggler_interrupt_flag = 1;
+    ocd_stop ();
+    buf[0] = OCD_AYT;
+    ocd_put_packet (buf, 1);
+    ocd_interrupt_flag = 1;
   }
 }
 
@@ -377,14 +377,14 @@ static void (*ofunc)();
 
 /* The user typed ^C twice.  */
 static void
-wiggler_interrupt_twice (signo)
+ocd_interrupt_twice (signo)
      int signo;
 {
   signal (signo, ofunc);
   
   interrupt_query ();
 
-  signal (signo, wiggler_interrupt);
+  signal (signo, ocd_interrupt);
 }
 
 /* Ask the user what to do when an interrupt is received.  */
@@ -413,54 +413,54 @@ static int kill_kludge;
    means in the case of this target).  */
 
 int
-wiggler_wait ()
+ocd_wait ()
 {
   unsigned char *p;
   int error_code, status;
   int pktlen;
 
-  wiggler_interrupt_flag = 0;
+  ocd_interrupt_flag = 0;
 
   /* Target may already be stopped by the time we get here. */
 
-  if (!(last_run_status & WIGGLER_FLAG_BDM))
+  if (!(last_run_status & OCD_FLAG_BDM))
     {
-      ofunc = (void (*)()) signal (SIGINT, wiggler_interrupt);
+      ofunc = (void (*)()) signal (SIGINT, ocd_interrupt);
 
-      p = wiggler_get_packet (WIGGLER_AYT, &pktlen, -1);
+      p = ocd_get_packet (OCD_AYT, &pktlen, -1);
 
       signal (SIGINT, ofunc);
 
       if (pktlen < 2)
-	error ("Truncated response packet from Wiggler");
+	error ("Truncated response packet from OCD device");
 
       status = p[1];
       error_code = p[2];
 
       if (error_code != 0)
-	wiggler_error ("target_wait:", error_code);
+	ocd_error ("target_wait:", error_code);
 
-      if (status & WIGGLER_FLAG_PWF)
-	error ("Wiggler lost VCC at BDM interface.");
-      else if (status & WIGGLER_FLAG_CABLE_DISC)
+      if (status & OCD_FLAG_PWF)
+	error ("OCD device lost VCC at BDM interface.");
+      else if (status & OCD_FLAG_CABLE_DISC)
 	error ("BDM cable appears to have been disconnected.");
 
-      if (!(status & WIGGLER_FLAG_BDM))
-	error ("Wiggler woke up, but wasn't stopped: 0x%x", status);
+      if (!(status & OCD_FLAG_BDM))
+	error ("OCD device woke up, but wasn't stopped: 0x%x", status);
     }
 
-  if (wiggler_interrupt_flag)
+  if (ocd_interrupt_flag)
     return 1;
   else
     return 0;
 }
 
-/* Read registers from the Wiggler.  Specify the starting and ending register
-   number.  Return the number of regs actually read in *NUMREGS.  Returns a
-   pointer to a static array containing the register contents.  */
+/* Read registers from the OCD device.  Specify the starting and ending
+   register number.  Return the number of regs actually read in *NUMREGS.
+   Returns a pointer to a static array containing the register contents.  */
 
 unsigned char *
-wiggler_read_bdm_registers (first_bdm_regno, last_bdm_regno, reglen)
+ocd_read_bdm_registers (first_bdm_regno, last_bdm_regno, reglen)
      int first_bdm_regno;
      int last_bdm_regno;
      int *reglen;
@@ -472,20 +472,20 @@ wiggler_read_bdm_registers (first_bdm_regno, last_bdm_regno, reglen)
   int error_code, status;
   int pktlen;
 
-  buf[0] = WIGGLER_READ_REGS;
+  buf[0] = OCD_READ_REGS;
   buf[1] = first_bdm_regno >> 8;
   buf[2] = first_bdm_regno & 0xff;
   buf[3] = last_bdm_regno >> 8;
   buf[4] = last_bdm_regno & 0xff;
 
-  wiggler_put_packet (buf, 5);
-  p = wiggler_get_packet (WIGGLER_READ_REGS, &pktlen, remote_timeout);
+  ocd_put_packet (buf, 5);
+  p = ocd_get_packet (OCD_READ_REGS, &pktlen, remote_timeout);
 
   status = p[1];
   error_code = p[2];
 
   if (error_code != 0)
-    wiggler_error ("read_bdm_registers:", error_code);
+    ocd_error ("read_bdm_registers:", error_code);
 
   i = p[3];
   if (i == 0)
@@ -505,21 +505,21 @@ wiggler_read_bdm_registers (first_bdm_regno, last_bdm_regno, reglen)
 /* Read register BDM_REGNO and returns its value ala read_register() */
 
 CORE_ADDR
-wiggler_read_bdm_register (bdm_regno)
+ocd_read_bdm_register (bdm_regno)
      int bdm_regno;
 {
   int reglen;
   unsigned char *p;
   CORE_ADDR regval;
 
-  p = wiggler_read_bdm_registers (bdm_regno, bdm_regno, &reglen);
+  p = ocd_read_bdm_registers (bdm_regno, bdm_regno, &reglen);
   regval = extract_unsigned_integer (p, reglen);
 
   return regval;
 }
 
 void
-wiggler_write_bdm_registers (first_bdm_regno, regptr, reglen)
+ocd_write_bdm_registers (first_bdm_regno, regptr, reglen)
      int first_bdm_regno;
      unsigned char *regptr;
      int reglen;
@@ -531,27 +531,27 @@ wiggler_write_bdm_registers (first_bdm_regno, regptr, reglen)
 
   buf = alloca (4 + reglen);
 
-  buf[0] = WIGGLER_WRITE_REGS;
+  buf[0] = OCD_WRITE_REGS;
   buf[1] = first_bdm_regno >> 8;
   buf[2] = first_bdm_regno & 0xff;
   buf[3] = reglen;
   memcpy (buf + 4, regptr, reglen);
 
-  wiggler_put_packet (buf, 4 + reglen);
-  p = wiggler_get_packet (WIGGLER_WRITE_REGS, &pktlen, remote_timeout);
+  ocd_put_packet (buf, 4 + reglen);
+  p = ocd_get_packet (OCD_WRITE_REGS, &pktlen, remote_timeout);
 
   if (pktlen < 3)
-    error ("Truncated response packet from Wiggler");
+    error ("Truncated response packet from OCD device");
 
   status = p[1];
   error_code = p[2];
 
   if (error_code != 0)
-    wiggler_error ("wiggler_write_bdm_registers:", error_code);
+    ocd_error ("ocd_write_bdm_registers:", error_code);
 }
 
 void
-wiggler_write_bdm_register (bdm_regno, reg)
+ocd_write_bdm_register (bdm_regno, reg)
      int bdm_regno;
      CORE_ADDR reg;
 {
@@ -559,11 +559,11 @@ wiggler_write_bdm_register (bdm_regno, reg)
 
   store_unsigned_integer (buf, 4, reg);
 
-  wiggler_write_bdm_registers (bdm_regno, buf, 4);
+  ocd_write_bdm_registers (bdm_regno, buf, 4);
 }
 
 void 
-wiggler_prepare_to_store ()
+ocd_prepare_to_store ()
 {
 }
 
@@ -575,10 +575,10 @@ wiggler_prepare_to_store ()
 
    Returns number of bytes transferred, or 0 for error.  */
 
-static int write_mem_command = WIGGLER_WRITE_MEM;
+static int write_mem_command = OCD_WRITE_MEM;
 
 static int
-wiggler_write_bytes (memaddr, myaddr, len)
+ocd_write_bytes (memaddr, myaddr, len)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
@@ -609,10 +609,10 @@ wiggler_write_bytes (memaddr, myaddr, len)
       buf[7] = numbytes;
 
       memcpy (&buf[8], myaddr, numbytes);
-      wiggler_put_packet (buf, 8 + numbytes);
-      p = wiggler_get_packet (WIGGLER_WRITE_MEM, &pktlen, remote_timeout);
+      ocd_put_packet (buf, 8 + numbytes);
+      p = ocd_get_packet (OCD_WRITE_MEM, &pktlen, remote_timeout);
       if (pktlen < 3)
-	error ("Truncated response packet from Wiggler");
+	error ("Truncated response packet from OCD device");
 
       status = p[1];
       error_code = p[2];
@@ -634,7 +634,7 @@ wiggler_write_bytes (memaddr, myaddr, len)
 	  break;
 	}
       else if (error_code != 0)
-	wiggler_error ("wiggler_write_bytes:", error_code);
+	ocd_error ("ocd_write_bytes:", error_code);
 
       len -= numbytes;
       memaddr += numbytes;
@@ -653,7 +653,7 @@ wiggler_write_bytes (memaddr, myaddr, len)
    Returns number of bytes transferred, or 0 for error.  */
 
 static int
-wiggler_read_bytes (memaddr, myaddr, len)
+ocd_read_bytes (memaddr, myaddr, len)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
@@ -664,7 +664,7 @@ wiggler_read_bytes (memaddr, myaddr, len)
 
   origlen = len;
 
-  buf[0] = WIGGLER_READ_MEM;
+  buf[0] = OCD_READ_MEM;
   buf[5] = 1;			/* Read as bytes */
 
   while (len > 0)
@@ -682,10 +682,10 @@ wiggler_read_bytes (memaddr, myaddr, len)
 
       buf[6] = numbytes;
 
-      wiggler_put_packet (buf, 7);
-      p = wiggler_get_packet (WIGGLER_READ_MEM, &pktlen, remote_timeout);
+      ocd_put_packet (buf, 7);
+      p = ocd_get_packet (OCD_READ_MEM, &pktlen, remote_timeout);
       if (pktlen < 4)
-	error ("Truncated response packet from Wiggler");
+	error ("Truncated response packet from OCD device");
 
       status = p[1];
       error_code = p[2];
@@ -707,7 +707,7 @@ wiggler_read_bytes (memaddr, myaddr, len)
 	  break;
 	}
       else if (error_code != 0)
-	wiggler_error ("wiggler_read_bytes:", error_code);
+	ocd_error ("ocd_read_bytes:", error_code);
 
       memcpy (myaddr, &p[4], numbytes);
 
@@ -725,18 +725,18 @@ wiggler_read_bytes (memaddr, myaddr, len)
 
 /* ARGSUSED */
 int
-wiggler_xfer_memory (memaddr, myaddr, len, should_write, target)
+ocd_xfer_memory (memaddr, myaddr, len, should_write, target)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
      int should_write;
      struct target_ops *target;			/* ignored */
 {
-  return dcache_xfer_memory (wiggler_dcache, memaddr, myaddr, len, should_write);
+  return dcache_xfer_memory (ocd_dcache, memaddr, myaddr, len, should_write);
 }
 
 void
-wiggler_files_info (ignore)
+ocd_files_info (ignore)
      struct target_ops *ignore;
 {
   puts_filtered ("Debugging a target over a serial line.\n");
@@ -753,7 +753,7 @@ readchar (timeout)
 {
   int ch;
 
-  ch = SERIAL_READCHAR (wiggler_desc, timeout);
+  ch = SERIAL_READCHAR (ocd_desc, timeout);
 
   switch (ch)
     {
@@ -808,7 +808,7 @@ reset_packet ()
 static void
 output_packet ()
 {
-  if (SERIAL_WRITE (wiggler_desc, pkt, pktp - pkt))
+  if (SERIAL_WRITE (ocd_desc, pkt, pktp - pkt))
     perror_with_name ("output_packet: write failed");
 
   reset_packet ();
@@ -832,14 +832,14 @@ put_quoted_char (c)
   *pktp++ = c;
 }
 
-/* Send a packet to the Wiggler.  The packet framed by a SYN character, a byte
-   count and a checksum.  The byte count only counts the number of bytes
-   between the count and the checksum.  A count of zero actually means 256.
-   Any SYNs within the packet (including the checksum and count) must be
-   quoted.  The quote character must be quoted as well.  Quoting is done by
-   replacing the character with the two-character sequence DLE, {char} | 0100.
-   Note that the quoting mechanism has no effect on the byte count.
- */
+/* Send a packet to the OCD device.  The packet framed by a SYN character,
+   a byte count and a checksum.  The byte count only counts the number of
+   bytes between the count and the checksum.  A count of zero actually
+   means 256.  Any SYNs within the packet (including the checksum and
+   count) must be quoted.  The quote character must be quoted as well.
+   Quoting is done by replacing the character with the two-character sequence
+   DLE, {char} | 0100.  Note that the quoting mechanism has no effect on the
+   byte count. */
 
 static void
 stu_put_packet (buf, len)
@@ -877,17 +877,17 @@ stu_put_packet (buf, len)
 
 #else
 
-/* Send a packet to the Wiggler.  The packet framed by a SYN character, a byte
-   count and a checksum.  The byte count only counts the number of bytes
-   between the count and the checksum.  A count of zero actually means 256.
-   Any SYNs within the packet (including the checksum and count) must be
-   quoted.  The quote character must be quoted as well.  Quoting is done by
-   replacing the character with the two-character sequence DLE, {char} | 0100.
-   Note that the quoting mechanism has no effect on the byte count.
- */
+/* Send a packet to the OCD device.  The packet framed by a SYN character,
+   a byte count and a checksum.  The byte count only counts the number of
+   bytes between the count and the checksum.  A count of zero actually
+   means 256.  Any SYNs within the packet (including the checksum and
+   count) must be quoted.  The quote character must be quoted as well.
+   Quoting is done by replacing the character with the two-character sequence
+   DLE, {char} | 0100.  Note that the quoting mechanism has no effect on the
+   byte count.  */
 
 static void
-wiggler_put_packet (buf, len)
+ocd_put_packet (buf, len)
      unsigned char *buf;
      int len;
 {
@@ -911,16 +911,16 @@ wiggler_put_packet (buf, len)
     }
 
   *packet_ptr++ = -checksum;
-  if (SERIAL_WRITE (wiggler_desc, packet, packet_ptr - packet))
+  if (SERIAL_WRITE (ocd_desc, packet, packet_ptr - packet))
     perror_with_name ("output_packet: write failed");
 }
 #endif
 
 #if 0
-/* Get a packet from the Wiggler.  Timeout is only enforced for the first byte
-   of the packet.  Subsequent bytes are expected to arrive in time <= 
-   remote_timeout.  Returns a pointer to a static buffer containing the payload
-   of the packet.  *LENP contains the length of the packet.
+/* Get a packet from the OCD device.  Timeout is only enforced for the
+   first byte of the packet.  Subsequent bytes are expected to arrive in
+   time <= remote_timeout.  Returns a pointer to a static buffer containing
+   the payload of the packet.  *LENP contains the length of the packet.
 */
 
 static unsigned char *
@@ -982,14 +982,14 @@ stu_get_packet (cmd, lenp, timeout)
 
 #else
 
-/* Get a packet from the Wiggler.  Timeout is only enforced for the first byte
-   of the packet.  Subsequent bytes are expected to arrive in time <= 
-   remote_timeout.  Returns a pointer to a static buffer containing the payload
-   of the packet.  *LENP contains the length of the packet.
+/* Get a packet from the OCD device.  Timeout is only enforced for the
+   first byte of the packet.  Subsequent bytes are expected to arrive in
+   time <= remote_timeout.  Returns a pointer to a static buffer containing
+   the payload of the packet.  *LENP contains the length of the packet.
 */
 
 static unsigned char *
-wiggler_get_packet (cmd, lenp, timeout)
+ocd_get_packet (cmd, lenp, timeout)
      int cmd;
      int *lenp;
 {
@@ -1005,7 +1005,7 @@ wiggler_get_packet (cmd, lenp, timeout)
   ch = readchar (timeout);
 
   if (ch < 0)
-    error ("wiggler_get_packet (readchar): %d", ch);
+    error ("ocd_get_packet (readchar): %d", ch);
 
   if (ch != 0x55)
     goto find_packet;
@@ -1020,7 +1020,7 @@ wiggler_get_packet (cmd, lenp, timeout)
   ch = readchar (timeout);
 
   if (ch < 0)
-    error ("wiggler_get_packet (readchar): %d", ch);
+    error ("ocd_get_packet (readchar): %d", ch);
 
   *packet_ptr++ = ch;
   checksum += ch;
@@ -1030,7 +1030,7 @@ wiggler_get_packet (cmd, lenp, timeout)
   ch = readchar (timeout);
 
   if (ch < 0)
-    error ("wiggler_get_packet (readchar): %d", ch);
+    error ("ocd_get_packet (readchar): %d", ch);
   *packet_ptr++ = ch;
   checksum += ch;
 
@@ -1039,7 +1039,7 @@ wiggler_get_packet (cmd, lenp, timeout)
   ch = readchar (timeout);
 
   if (ch < 0)
-    error ("wiggler_get_packet (readchar): %d", ch);
+    error ("ocd_get_packet (readchar): %d", ch);
   *packet_ptr++ = ch;
   checksum += ch;
 
@@ -1059,41 +1059,41 @@ wiggler_get_packet (cmd, lenp, timeout)
     case 0x0:			/* Normal result */
       switch (packet[0])
 	{
-	case WIGGLER_AYT:	/* Are You There? */
-	case WIGGLER_SET_BAUD_RATE: /* Set Baud Rate */
-	case WIGGLER_INIT:	/* Initialize wiggler */
-	case WIGGLER_SET_SPEED:	/* Set Speed */
-	case WIGGLER_SET_FUNC_CODE: /* Set Function Code */
-	case WIGGLER_SET_CTL_FLAGS: /* Set Control Flags */
-	case WIGGLER_SET_BUF_ADDR: /* Set Register Buffer Address */
-	case WIGGLER_RUN:	/* Run Target from PC  */
-	case WIGGLER_RUN_ADDR:	/* Run Target from Specified Address  */
-	case WIGGLER_STOP:	/* Stop Target */
-	case WIGGLER_RESET_RUN:	/* Reset Target and Run */
-	case WIGGLER_RESET:	/* Reset Target and Halt */
-	case WIGGLER_STEP:	/* Single Step */
-	case WIGGLER_WRITE_REGS: /* Write Register */
-	case WIGGLER_WRITE_MEM:	/* Write Memory */
-	case WIGGLER_FILL_MEM:	/* Fill Memory */
-	case WIGGLER_MOVE_MEM:	/* Move Memory */
-	case WIGGLER_WRITE_INT_MEM: /* Write Internal Memory */
-	case WIGGLER_JUMP:	/* Jump to Subroutine */
-	case WIGGLER_ERASE_FLASH: /* Erase flash memory */
-	case WIGGLER_PROGRAM_FLASH: /* Write flash memory */
-	case WIGGLER_EXIT_MON:	/* Exit the flash programming monitor  */
-	case WIGGLER_ENTER_MON:	/* Enter the flash programming monitor  */
+	case OCD_AYT:	/* Are You There? */
+	case OCD_SET_BAUD_RATE: /* Set Baud Rate */
+	case OCD_INIT:	/* Initialize OCD device */
+	case OCD_SET_SPEED:	/* Set Speed */
+	case OCD_SET_FUNC_CODE: /* Set Function Code */
+	case OCD_SET_CTL_FLAGS: /* Set Control Flags */
+	case OCD_SET_BUF_ADDR: /* Set Register Buffer Address */
+	case OCD_RUN:	/* Run Target from PC  */
+	case OCD_RUN_ADDR:	/* Run Target from Specified Address  */
+	case OCD_STOP:	/* Stop Target */
+	case OCD_RESET_RUN:	/* Reset Target and Run */
+	case OCD_RESET:	/* Reset Target and Halt */
+	case OCD_STEP:	/* Single Step */
+	case OCD_WRITE_REGS: /* Write Register */
+	case OCD_WRITE_MEM:	/* Write Memory */
+	case OCD_FILL_MEM:	/* Fill Memory */
+	case OCD_MOVE_MEM:	/* Move Memory */
+	case OCD_WRITE_INT_MEM: /* Write Internal Memory */
+	case OCD_JUMP:	/* Jump to Subroutine */
+	case OCD_ERASE_FLASH: /* Erase flash memory */
+	case OCD_PROGRAM_FLASH: /* Write flash memory */
+	case OCD_EXIT_MON:	/* Exit the flash programming monitor  */
+	case OCD_ENTER_MON:	/* Enter the flash programming monitor  */
 	  len = 0;
 	  break;
-	case WIGGLER_GET_VERSION: /* Get Version */
+	case OCD_GET_VERSION: /* Get Version */
 	  len = 10;
 	  break;
-	case WIGGLER_GET_STATUS_MASK: /* Get Status Mask */
+	case OCD_GET_STATUS_MASK: /* Get Status Mask */
 	  len = 1;
 	  break;
-	case WIGGLER_GET_CTRS:	/* Get Error Counters */
-	case WIGGLER_READ_REGS:	/* Read Register */
-	case WIGGLER_READ_MEM:	/* Read Memory */
-	case WIGGLER_READ_INT_MEM: /* Read Internal Memory */
+	case OCD_GET_CTRS:	/* Get Error Counters */
+	case OCD_READ_REGS:	/* Read Register */
+	case OCD_READ_MEM:	/* Read Memory */
+	case OCD_READ_INT_MEM: /* Read Internal Memory */
 	  len = 257;
 	  break;
 	default:
@@ -1107,7 +1107,7 @@ wiggler_get_packet (cmd, lenp, timeout)
       ch = readchar (timeout);
 
       if (ch < 0)
-	error ("wiggler_get_packet (readchar): %d", ch);
+	error ("ocd_get_packet (readchar): %d", ch);
       *packet_ptr++ = ch;
       checksum += ch;
       len = ch;
@@ -1120,7 +1120,7 @@ wiggler_get_packet (cmd, lenp, timeout)
       ch = readchar (timeout);
 
       if (ch < 0)
-	error ("wiggler_get_packet (readchar): %d", ch);
+	error ("ocd_get_packet (readchar): %d", ch);
       *packet_ptr++ = ch;
       checksum += ch;
     }
@@ -1150,11 +1150,11 @@ do_command (cmd, statusp, lenp)
   char errbuf[100];
 
   buf[0] = cmd;
-  wiggler_put_packet (buf, 1);		/* Send command */
-  p = wiggler_get_packet (*buf, lenp, remote_timeout);
+  ocd_put_packet (buf, 1);		/* Send command */
+  p = ocd_get_packet (*buf, lenp, remote_timeout);
 
   if (*lenp < 3)
-    error ("Truncated response packet from Wiggler");
+    error ("Truncated response packet from OCD device");
 
   status = p[1];
   error_code = p[2];
@@ -1162,12 +1162,12 @@ do_command (cmd, statusp, lenp)
   if (error_code != 0)
     {
       sprintf (errbuf, "do_command (0x%x):", cmd);
-      wiggler_error (errbuf, error_code);
+      ocd_error (errbuf, error_code);
     }
 
-  if (status & WIGGLER_FLAG_PWF)
-    error ("Wiggler can't detect VCC at BDM interface.");
-  else if (status & WIGGLER_FLAG_CABLE_DISC)
+  if (status & OCD_FLAG_PWF)
+    error ("OCD device can't detect VCC at BDM interface.");
+  else if (status & OCD_FLAG_CABLE_DISC)
     error ("BDM cable appears to be disconnected.");
 
   *statusp = status;
@@ -1176,7 +1176,7 @@ do_command (cmd, statusp, lenp)
 }
 
 void
-wiggler_kill ()
+ocd_kill ()
 {
   /* For some mysterious reason, wait_for_inferior calls kill instead of
      mourn after it gets TARGET_WAITKIND_SIGNALLED.  Work around it.  */
@@ -1193,7 +1193,7 @@ wiggler_kill ()
 }
 
 void
-wiggler_mourn ()
+ocd_mourn ()
 {
   unpush_target (current_ops);
   generic_mourn_inferior ();
@@ -1203,7 +1203,7 @@ wiggler_mourn ()
    the program at that point.  */
 
 void
-wiggler_create_inferior (exec_file, args, env)
+ocd_create_inferior (exec_file, args, env)
      char *exec_file;
      char *args;
      char **env;
@@ -1216,7 +1216,7 @@ wiggler_create_inferior (exec_file, args, env)
 }
 
 void
-wiggler_load (args, from_tty)
+ocd_load (args, from_tty)
      char *args;
      int from_tty;
 {
@@ -1236,7 +1236,7 @@ wiggler_load (args, from_tty)
 /* BDM (at least on CPU32) uses a different breakpoint */
 
 static int
-wiggler_insert_breakpoint (addr, contents_cache)
+ocd_insert_breakpoint (addr, contents_cache)
      CORE_ADDR addr;
      char *contents_cache;
 {
@@ -1266,11 +1266,11 @@ bdm_reset_command (args, from_tty)
 {
   int status, pktlen;
 
-  if (!wiggler_desc)
-    error ("Not connected to wiggler.");
+  if (!ocd_desc)
+    error ("Not connected to OCD device.");
 
-  do_command (WIGGLER_RESET, &status, &pktlen);
-  dcache_flush (wiggler_dcache);
+  do_command (OCD_RESET, &status, &pktlen);
+  dcache_flush (ocd_dcache);
   registers_changed ();
 }
 
@@ -1281,10 +1281,10 @@ bdm_restart_command (args, from_tty)
 {
   int status, pktlen;
 
-  if (!wiggler_desc)
-    error ("Not connected to wiggler.");
+  if (!ocd_desc)
+    error ("Not connected to OCD device.");
 
-  do_command (WIGGLER_RESET_RUN, &status, &pktlen);
+  do_command (OCD_RESET_RUN, &status, &pktlen);
   last_run_status = status;
   clear_proceed_status ();
   wait_for_inferior ();
@@ -1309,28 +1309,28 @@ bdm_update_flash_command (args, from_tty)
   struct cleanup *old_chain;
   void (*store_registers_tmp) PARAMS ((int));
 
-  if (!wiggler_desc)
-    error ("Not connected to wiggler.");
+  if (!ocd_desc)
+    error ("Not connected to OCD device.");
 
   if (!args)
-    error ("Must specify file containing new Wiggler code.");
+    error ("Must specify file containing new OCD code.");
 
 /*  old_chain = make_cleanup (flash_cleanup, 0);*/
 
-  do_command (WIGGLER_ENTER_MON, &status, &pktlen);
+  do_command (OCD_ENTER_MON, &status, &pktlen);
 
-  do_command (WIGGLER_ERASE_FLASH, &status, &pktlen);
+  do_command (OCD_ERASE_FLASH, &status, &pktlen);
 
-  write_mem_command = WIGGLER_PROGRAM_FLASH;
+  write_mem_command = OCD_PROGRAM_FLASH;
   store_registers_tmp = current_target.to_store_registers;
   current_target.to_store_registers = noop_store_registers;
 
   generic_load (args, from_tty);
 
   current_target.to_store_registers = store_registers_tmp;
-  write_mem_command = WIGGLER_WRITE_MEM;
+  write_mem_command = OCD_WRITE_MEM;
 
-  do_command (WIGGLER_EXIT_MON, &status, &pktlen);
+  do_command (OCD_EXIT_MON, &status, &pktlen);
 
 /*  discard_cleanups (old_chain);*/
 }
@@ -1342,8 +1342,8 @@ bdm_read_register_command (args, from_tty)
 {
   /* XXX repeat should go on to the next register */
 
-  if (!wiggler_desc)
-    error ("Not connected to wiggler.");
+  if (!ocd_desc)
+    error ("Not connected to OCD device.");
 
   if (!args)
     error ("Must specify BDM register number.");
@@ -1351,21 +1351,21 @@ bdm_read_register_command (args, from_tty)
 }
 
 void
-_initialize_remote_wiggler ()
+_initialize_remote_ocd ()
 {
   extern struct cmd_list_element *cmdlist;
-  static struct cmd_list_element *bdm_cmd_list = NULL;
+  static struct cmd_list_element *ocd_cmd_list = NULL;
 
   add_show_from_set (add_set_cmd ("remotetimeout", no_class,
 				  var_integer, (char *)&remote_timeout,
 				  "Set timeout value for remote read.\n", &setlist),
 		     &showlist);
 
-  add_prefix_cmd ("bdm", class_obscure, bdm_command, "", &bdm_cmd_list, "bdm ",
+  add_prefix_cmd ("ocd", class_obscure, bdm_command, "", &ocd_cmd_list, "ocd ",
 		  0, &cmdlist);
 
-  add_cmd ("reset", class_obscure, bdm_reset_command, "", &bdm_cmd_list);
-  add_cmd ("restart", class_obscure, bdm_restart_command, "", &bdm_cmd_list);
-  add_cmd ("update-flash", class_obscure, bdm_update_flash_command, "", &bdm_cmd_list);
-  /*  add_cmd ("read-register", class_obscure, bdm_read_register_command, "", &bdm_cmd_list);*/
+  add_cmd ("reset", class_obscure, bdm_reset_command, "", &ocd_cmd_list);
+  add_cmd ("restart", class_obscure, bdm_restart_command, "", &ocd_cmd_list);
+  add_cmd ("update-flash", class_obscure, bdm_update_flash_command, "", &ocd_cmd_list);
+  /*  add_cmd ("read-register", class_obscure, bdm_read_register_command, "", &ocd_cmd_list);*/
 }
diff --git a/gdb/ocd.h b/gdb/ocd.h
index a8e0494..d0980a9 100644
--- a/gdb/ocd.h
+++ b/gdb/ocd.h
@@ -17,8 +17,8 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-#ifndef WIGGLER_H
-#define WIGGLER_H
+#ifndef OCD_H
+#define OCD_H
 
 /* Wiggler serial protocol definitions */
 
@@ -28,105 +28,105 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Status flags */
 
-#define WIGGLER_FLAG_RESET 0x01 /* Target is being reset */
-#define WIGGLER_FLAG_STOPPED 0x02 /* Target is halted */
-#define WIGGLER_FLAG_BDM 0x04	/* Target is in BDM */
-#define WIGGLER_FLAG_PWF 0x08	/* Power failed */
-#define WIGGLER_FLAG_CABLE_DISC 0x10 /* BDM cable disconnected */
+#define OCD_FLAG_RESET 0x01	/* Target is being reset */
+#define OCD_FLAG_STOPPED 0x02	/* Target is halted */
+#define OCD_FLAG_BDM 0x04	/* Target is in BDM */
+#define OCD_FLAG_PWF 0x08	/* Power failed */
+#define OCD_FLAG_CABLE_DISC 0x10 /* BDM cable disconnected */
 
 /* Commands */
 
-#define WIGGLER_AYT 0x0		/* Are you there? */
-#define WIGGLER_GET_VERSION 0x1	/* Get Version */
-#define WIGGLER_SET_BAUD_RATE 0x2 /* Set Baud Rate */
-#define WIGGLER_INIT 0x10	/* Initialize Wiggler */
-#define WIGGLER_SET_SPEED 0x11	/* Set Speed */
-#define WIGGLER_GET_STATUS_MASK 0x12 /* Get Status Mask */
-#define WIGGLER_GET_CTRS 0x13	/* Get Error Counters */
-#define WIGGLER_SET_FUNC_CODE 0x14 /* Set Function Code */
-#define WIGGLER_SET_CTL_FLAGS 0x15 /* Set Control Flags */
-#define WIGGLER_SET_BUF_ADDR 0x16 /* Set Register Buffer Address */
-#define WIGGLER_RUN 0x20	/* Run Target from PC */
-#define WIGGLER_RUN_ADDR 0x21	/* Run Target from Specified Address */
-#define WIGGLER_STOP 0x22	/* Stop Target */
-#define WIGGLER_RESET_RUN 0x23	/* Reset Target and Run */
-#define WIGGLER_RESET 0x24	/* Reset Target and Halt */
-#define WIGGLER_STEP 0x25	/* Single step */
-#define WIGGLER_READ_REGS 0x30	/* Read Registers */
-#define WIGGLER_WRITE_REGS 0x31	/* Write Registers */
-#define WIGGLER_READ_MEM 0x32	/* Read Memory */
-#define WIGGLER_WRITE_MEM 0x33	/* Write Memory */
-#define WIGGLER_FILL_MEM 0x34	/* Fill Memory */
-#define WIGGLER_MOVE_MEM 0x35	/* Move Memory */
-
-#define WIGGLER_READ_INT_MEM 0x80 /* Read Internal Memory */
-#define WIGGLER_WRITE_INT_MEM 0x81 /* Write Internal Memory */
-#define WIGGLER_JUMP 0x82	/* Jump to Subroutine */
-
-#define WIGGLER_ERASE_FLASH 0x90 /* Erase flash memory */
-#define WIGGLER_PROGRAM_FLASH 0x91 /* Write flash memory */
-#define WIGGLER_EXIT_MON 0x93	/* Exit the flash programming monitor  */
-#define WIGGLER_ENTER_MON 0x94	/* Enter the flash programming monitor  */
-
-#define WIGGLER_SET_STATUS 0x0a	/* Set status */
-#define   WIGGLER_FLAG_STOP 0x0 /* Stop the target, enter BDM */
-#define   WIGGLER_FLAG_START 0x01 /* Start the target at PC */
-#define   WIGGLER_FLAG_RETURN_STATUS 0x04 /* Return async status */
-
-/* Target type (for WIGGLER_INIT command) */
-
-enum wiggler_target_type {
-  WIGGLER_TARGET_CPU32=0x0,	/* Moto cpu32 family */
-  WIGGLER_TARGET_CPU16=0x1,
-  WIGGLER_TARGET_MOTO_PPC=0x2,	/* Motorola PPC 5xx/8xx */
-  WIGGLER_TARGET_IBM_PPC=0x3};	/* IBM PPC 4xx */
-
-void wiggler_open PARAMS ((char *name, int from_tty, enum wiggler_target_type,
+#define OCD_AYT 0x0		/* Are you there? */
+#define OCD_GET_VERSION 0x1	/* Get Version */
+#define OCD_SET_BAUD_RATE 0x2	/* Set Baud Rate */
+#define OCD_INIT 0x10		/* Initialize Wiggler */
+#define OCD_SET_SPEED 0x11	/* Set Speed */
+#define OCD_GET_STATUS_MASK 0x12 /* Get Status Mask */
+#define OCD_GET_CTRS 0x13	/* Get Error Counters */
+#define OCD_SET_FUNC_CODE 0x14	/* Set Function Code */
+#define OCD_SET_CTL_FLAGS 0x15	/* Set Control Flags */
+#define OCD_SET_BUF_ADDR 0x16	/* Set Register Buffer Address */
+#define OCD_RUN 0x20		/* Run Target from PC */
+#define OCD_RUN_ADDR 0x21	/* Run Target from Specified Address */
+#define OCD_STOP 0x22		/* Stop Target */
+#define OCD_RESET_RUN 0x23	/* Reset Target and Run */
+#define OCD_RESET 0x24		/* Reset Target and Halt */
+#define OCD_STEP 0x25		/* Single step */
+#define OCD_READ_REGS 0x30	/* Read Registers */
+#define OCD_WRITE_REGS 0x31	/* Write Registers */
+#define OCD_READ_MEM 0x32	/* Read Memory */
+#define OCD_WRITE_MEM 0x33	/* Write Memory */
+#define OCD_FILL_MEM 0x34	/* Fill Memory */
+#define OCD_MOVE_MEM 0x35	/* Move Memory */
+
+#define OCD_READ_INT_MEM 0x80	/* Read Internal Memory */
+#define OCD_WRITE_INT_MEM 0x81	/* Write Internal Memory */
+#define OCD_JUMP 0x82		/* Jump to Subroutine */
+
+#define OCD_ERASE_FLASH 0x90	/* Erase flash memory */
+#define OCD_PROGRAM_FLASH 0x91	/* Write flash memory */
+#define OCD_EXIT_MON 0x93	/* Exit the flash programming monitor  */
+#define OCD_ENTER_MON 0x94	/* Enter the flash programming monitor  */
+
+#define OCD_SET_STATUS 0x0a	/* Set status */
+#define OCD_FLAG_STOP 0x0	/* Stop the target, enter BDM */
+#define OCD_FLAG_START 0x01	/* Start the target at PC */
+#define OCD_FLAG_RETURN_STATUS 0x04 /* Return async status */
+
+/* Target type (for OCD_INIT command) */
+
+enum ocd_target_type {
+  OCD_TARGET_CPU32=0x0,		/* Moto cpu32 family */
+  OCD_TARGET_CPU16=0x1,
+  OCD_TARGET_MOTO_PPC=0x2,	/* Motorola PPC 5xx/8xx */
+  OCD_TARGET_IBM_PPC=0x3};	/* IBM PPC 4xx */
+
+void ocd_open PARAMS ((char *name, int from_tty, enum ocd_target_type,
 			   struct target_ops *ops));
 
-void wiggler_close PARAMS ((int quitting));
+void ocd_close PARAMS ((int quitting));
 
-void wiggler_detach PARAMS ((char *args, int from_tty));
+void ocd_detach PARAMS ((char *args, int from_tty));
 
-void wiggler_resume PARAMS ((int pid, int step, enum target_signal siggnal));
+void ocd_resume PARAMS ((int pid, int step, enum target_signal siggnal));
 
-void wiggler_prepare_to_store PARAMS ((void));
+void ocd_prepare_to_store PARAMS ((void));
 
-void wiggler_stop PARAMS ((void));
+void ocd_stop PARAMS ((void));
 
-void wiggler_files_info PARAMS ((struct target_ops *ignore));
+void ocd_files_info PARAMS ((struct target_ops *ignore));
 
 
-int wiggler_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
+int ocd_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
 				 int len, int should_write,
 				 struct target_ops *target));
 
-void wiggler_mourn PARAMS ((void));
+void ocd_mourn PARAMS ((void));
 
-void wiggler_create_inferior PARAMS ((char *exec_file,
+void ocd_create_inferior PARAMS ((char *exec_file,
 				      char *args,
 				      char **env));
 
-int wiggler_thread_alive PARAMS ((int th));
+int ocd_thread_alive PARAMS ((int th));
 
-void wiggler_error PARAMS ((char *s, int error_code));
+void ocd_error PARAMS ((char *s, int error_code));
 
-void wiggler_kill PARAMS ((void));
+void ocd_kill PARAMS ((void));
 
-void wiggler_load PARAMS((char *args, int from_tty));
+void ocd_load PARAMS((char *args, int from_tty));
 
-unsigned char * wiggler_read_bdm_registers PARAMS ((int first_bdm_regno,
+unsigned char * ocd_read_bdm_registers PARAMS ((int first_bdm_regno,
 						    int last_bdm_regno,
 						    int *reglen));
 
-CORE_ADDR wiggler_read_bdm_register PARAMS ((int bdm_regno));
+CORE_ADDR ocd_read_bdm_register PARAMS ((int bdm_regno));
 
-void wiggler_write_bdm_registers PARAMS ((int first_bdm_regno,
+void ocd_write_bdm_registers PARAMS ((int first_bdm_regno,
 					  unsigned char *regptr,
 					  int reglen));
 
-void wiggler_write_bdm_register PARAMS ((int bdm_regno, CORE_ADDR reg));
+void ocd_write_bdm_register PARAMS ((int bdm_regno, CORE_ADDR reg));
 
-int wiggler_wait PARAMS ((void));
+int ocd_wait PARAMS ((void));
 
-#endif /* WIGGLER_H */
+#endif /* OCD_H */
diff --git a/gdb/ppc-bdm.c b/gdb/ppc-bdm.c
index 6181298..38878d0 100644
--- a/gdb/ppc-bdm.c
+++ b/gdb/ppc-bdm.c
@@ -55,7 +55,7 @@ bdm_ppc_open (name, from_tty)
      char *name;
      int from_tty;
 {
-  wiggler_open (name, from_tty, WIGGLER_TARGET_MOTO_PPC, &bdm_ppc_ops);
+  ocd_open (name, from_tty, OCD_TARGET_MOTO_PPC, &bdm_ppc_ops);
 }
 
 /* Wait until the remote machine stops, then return,
@@ -72,7 +72,7 @@ bdm_ppc_wait (pid, target_status)
 
   target_status->kind = TARGET_WAITKIND_STOPPED;
 
-  stop_reason = wiggler_wait ();
+  stop_reason = ocd_wait ();
 
   if (stop_reason)
     {
@@ -85,8 +85,8 @@ bdm_ppc_wait (pid, target_status)
   {
     unsigned long ecr, der;
 
-    ecr = wiggler_read_bdm_register (148); /* Read the exception cause register */
-    der = wiggler_read_bdm_register (149); /* Read the debug enables register */
+    ecr = ocd_read_bdm_register (148); /* Read the exception cause register */
+    der = ocd_read_bdm_register (149); /* Read the debug enables register */
     fprintf_unfiltered (gdb_stdout, "ecr = 0x%x, der = 0x%x\n", ecr, der);
   }
 
@@ -146,7 +146,7 @@ bdm_ppc_fetch_registers (regno)
       return;			/* Unsupported register */
     }
 
-  regs = wiggler_read_bdm_registers (first_bdm_regno, last_bdm_regno, &reglen);
+  regs = ocd_read_bdm_registers (first_bdm_regno, last_bdm_regno, &reglen);
 
   for (i = first_regno; i <= last_regno; i++)
     {
@@ -204,27 +204,27 @@ bdm_ppc_store_registers (regno)
 
       bdm_regno = bdm_regmap [i];
 
-      wiggler_write_bdm_registers (bdm_regno, registers + REGISTER_BYTE (i), 4);
+      ocd_write_bdm_registers (bdm_regno, registers + REGISTER_BYTE (i), 4);
     }
 }
 
 /* Define the target subroutine names */
 
 struct target_ops bdm_ppc_ops = {
-  "wiggler",			/* to_shortname */
+  "ocd",			/* to_shortname */
   "",				/* to_longname */
   "",				/* to_doc */
   bdm_ppc_open,			/* to_open */
-  wiggler_close,		/* to_close */
+  ocd_close,		/* to_close */
   NULL,				/* to_attach */
-  wiggler_detach,		/* to_detach */
-  wiggler_resume,		/* to_resume */
+  ocd_detach,		/* to_detach */
+  ocd_resume,		/* to_resume */
   bdm_ppc_wait,			/* to_wait */
   bdm_ppc_fetch_registers,	/* to_fetch_registers */
   bdm_ppc_store_registers,	/* to_store_registers */
-  wiggler_prepare_to_store,	/* to_prepare_to_store */
-  wiggler_xfer_memory,		/* to_xfer_memory */
-  wiggler_files_info,		/* to_files_info */
+  ocd_prepare_to_store,	/* to_prepare_to_store */
+  ocd_xfer_memory,		/* to_xfer_memory */
+  ocd_files_info,		/* to_files_info */
   memory_insert_breakpoint,	/* to_insert_breakpoint */
   memory_remove_breakpoint,	/* to_remove_breakpoint */
   NULL,				/* to_terminal_init */
@@ -232,15 +232,15 @@ struct target_ops bdm_ppc_ops = {
   NULL,				/* to_terminal_ours_for_output */
   NULL,				/* to_terminal_ours */
   NULL,				/* to_terminal_info */
-  wiggler_kill,			/* to_kill */
-  wiggler_load,			/* to_load */
+  ocd_kill,			/* to_kill */
+  ocd_load,			/* to_load */
   NULL,				/* to_lookup_symbol */
-  wiggler_create_inferior,	/* to_create_inferior */
-  wiggler_mourn,		/* to_mourn_inferior */
+  ocd_create_inferior,	/* to_create_inferior */
+  ocd_mourn,		/* to_mourn_inferior */
   0,				/* to_can_run */
   0,				/* to_notice_signals */
-  wiggler_thread_alive,		/* to_thread_alive */
-  wiggler_stop,			/* to_stop */
+  ocd_thread_alive,		/* to_thread_alive */
+  ocd_stop,			/* to_stop */
   process_stratum,		/* to_stratum */
   NULL,				/* to_next */
   1,				/* to_has_all_memory */
diff --git a/gdb/ser-ocd.c b/gdb/ser-ocd.c
index d3f1c8e..1b1213e 100644
--- a/gdb/ser-ocd.c
+++ b/gdb/ser-ocd.c
@@ -145,7 +145,7 @@ static void
 ocd_close (scb)
      serial_t scb;
 {
-  wiggler_close (0);
+  ocd_close (0);
 }
 
 static struct serial_ops ocd_ops =