/* 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));
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;
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;
\f
void
-wiggler_error (s, error_code)
+ocd_error (s, error_code)
char *s;
int 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;
/* 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;
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]);
#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;
/* 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);
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)
{
/* 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();
}
die when it hits one. */
void
-wiggler_detach (args, from_tty)
+ocd_detach (args, from_tty)
char *args;
int 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);
}
\f
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;
}
}
/* 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. */
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;
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)
/* 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, ®len);
+ p = ocd_read_bdm_registers (bdm_regno, bdm_regno, ®len);
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;
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;
{
store_unsigned_integer (buf, 4, reg);
- wiggler_write_bdm_registers (bdm_regno, buf, 4);
+ ocd_write_bdm_registers (bdm_regno, buf, 4);
}
\f
void
-wiggler_prepare_to_store ()
+ocd_prepare_to_store ()
{
}
\f
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;
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];
break;
}
else if (error_code != 0)
- wiggler_error ("wiggler_write_bytes:", error_code);
+ ocd_error ("ocd_write_bytes:", error_code);
len -= numbytes;
memaddr += numbytes;
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;
origlen = len;
- buf[0] = WIGGLER_READ_MEM;
+ buf[0] = OCD_READ_MEM;
buf[5] = 1; /* Read as bytes */
while (len > 0)
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];
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);
/* 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);
}
\f
void
-wiggler_files_info (ignore)
+ocd_files_info (ignore)
struct target_ops *ignore;
{
puts_filtered ("Debugging a target over a serial line.\n");
{
int ch;
- ch = SERIAL_READCHAR (wiggler_desc, timeout);
+ ch = SERIAL_READCHAR (ocd_desc, timeout);
switch (ch)
{
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 ();
*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)
#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;
{
}
*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 *
#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;
{
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;
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;
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;
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;
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:
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;
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;
}
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];
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;
}
\f
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. */
}
void
-wiggler_mourn ()
+ocd_mourn ()
{
unpush_target (current_ops);
generic_mourn_inferior ();
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;
}
void
-wiggler_load (args, from_tty)
+ocd_load (args, from_tty)
char *args;
int 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;
{
{
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 ();
}
{
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 ();
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);*/
}
{
/* 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.");
}
\f
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);*/
}
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 */
/* 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 */
projects / platform / upstream / binutils.git / commitdiff