Subversion Repositories or1k

/* Target communications support for Macraigor Systems' On-Chip Debugging

   Copyright 1996, 1997, 1998, 1999, 2000, 2001

   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   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.  */

#include "defs.h"

#include "gdbcore.h"

#include "gdb_string.h"

#include <fcntl.h>

#include "frame.h"

#include "inferior.h"

#include "bfd.h"

#include "symfile.h"

#include "target.h"

#include "gdbcmd.h"

#include "objfiles.h"

#include "gdb-stabs.h"

#include <sys/types.h>

#include <signal.h>

#include "serial.h"

#include "ocd.h"

#include "regcache.h"

/* Prototypes for local functions */

static int ocd_read_bytes (CORE_ADDR memaddr, char *myaddr, int len);

static int ocd_start_remote (PTR dummy);

static int readchar (int timeout);

static void reset_packet (void);

static void output_packet (void);

static int get_quoted_char (int timeout);

static void put_quoted_char (int c);

static void ocd_interrupt (int signo);

static void ocd_interrupt_twice (int signo);

static void interrupt_query (void);

static unsigned char *ocd_do_command (int cmd, int *statusp, int *lenp);

static void ocd_put_packet (unsigned char *packet, int pktlen);

static unsigned char *ocd_get_packet (int cmd, int *pktlen, int timeout);

static struct target_ops *current_ops = NULL;

static int last_run_status;

/* This was 5 seconds, which is a long time to sit and wait.

   Unless this is going though some terminal server or multiplexer or

   other form of hairy serial connection, I would think 2 seconds would

   be plenty.  */

#if 0

/* FIXME: Change to allow option to set timeout value on a per target

   basis. */

static int remote_timeout = 2;

#endif

/* Descriptor for I/O to remote machine.  Initialize it to NULL so that

   ocd_open knows that we don't have a file open when the program

   starts.  */

static serial_t ocd_desc = NULL;

void

ocd_error (char *s, int error_code)

{

  char buf[100];

  fputs_filtered (s, gdb_stderr);

  fputs_filtered (" ", gdb_stderr);

  switch (error_code)

    {

    case 0x1:

      s = "Unknown fault";

      break;

    case 0x2:

      s = "Power failed";

      break;

    case 0x3:

      s = "Cable disconnected";

      break;

    case 0x4:

      s = "Couldn't enter OCD mode";

      break;

    case 0x5:

      s = "Target stuck in reset";

      break;

    case 0x6:

      s = "OCD hasn't been initialized";

      break;

    case 0x7:

      s = "Write verify failed";

      break;

    case 0x8:

      s = "Reg buff error (during MPC5xx fp reg read/write)";

      break;

    case 0x9:

      s = "Invalid CPU register access attempt failed";

      break;

    case 0x11:

      s = "Bus error";

      break;

    case 0x12:

      s = "Checksum error";

      break;

    case 0x13:

      s = "Illegal command";

      break;

    case 0x14:

      s = "Parameter error";

      break;

    case 0x15:

      s = "Internal error";

      break;

    case 0x80:

      s = "Flash erase error";

      break;

    default:

      sprintf (buf, "Unknown error code %d", error_code);

      s = buf;

    }

  error (s);

}

/*  Return nonzero if the thread TH is still alive on the remote system.  */

int

ocd_thread_alive (ptid_t th)

{

  return 1;

}

/* Clean up connection to a remote debugger.  */

/* ARGSUSED */

void

ocd_close (int quitting)

{

  if (ocd_desc)

    SERIAL_CLOSE (ocd_desc);

  ocd_desc = NULL;

}

/* Stub for catch_errors.  */

static int

ocd_start_remote (PTR dummy)

{

  unsigned char buf[10], *p;

  int pktlen;

  int status;

  int error_code;

  int speed;

  enum ocd_target_type target_type;

  target_type = *(enum ocd_target_type *) dummy;

  immediate_quit++;             /* Allow user to interrupt it */

  SERIAL_SEND_BREAK (ocd_desc); /* Wake up the wiggler */

  speed = 80;                   /* Divide clock by 4000 */

  buf[0] = OCD_INIT;

  buf[1] = speed >> 8;

  buf[2] = speed & 0xff;

  buf[3] = target_type;

  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 OCD device");

  status = p[1];

  error_code = p[2];

  if (error_code != 0)

    ocd_error ("OCD_INIT:", error_code);

  ocd_do_command (OCD_AYT, &status, &pktlen);

  p = ocd_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 0

  /* Reset the target */

  ocd_do_command (OCD_RESET_RUN, &status, &pktlen);

/*  ocd_do_command (OCD_RESET, &status, &pktlen); */

#endif

  /* If processor is still running, stop it.  */

  if (!(status & OCD_FLAG_BDM))

    ocd_stop ();

#if 1

  /* When using a target box, we want to asynchronously return status when

     target stops.  The OCD_SET_CTL_FLAGS command is ignored by Wigglers.dll

     when using a parallel Wiggler */

  buf[0] = OCD_SET_CTL_FLAGS;

  buf[1] = 0;

  buf[2] = 1;

  ocd_put_packet (buf, 3);

  p = ocd_get_packet (buf[0], &pktlen, remote_timeout);

  if (pktlen < 2)

    error ("Truncated response packet from OCD device");

  status = p[1];

  error_code = p[2];

  if (error_code != 0)

    ocd_error ("OCD_SET_CTL_FLAGS:", error_code);

#endif

  immediate_quit--;

/* This is really the job of start_remote however, that makes an assumption

   that the target is about to print out a status message of some sort.  That

   doesn't happen here (in fact, it may not be possible to get the monitor to

   send the appropriate packet).  */

  flush_cached_frames ();

  registers_changed ();

  stop_pc = read_pc ();

  set_current_frame (create_new_frame (read_fp (), stop_pc));

  select_frame (get_current_frame (), 0);

  print_stack_frame (selected_frame, -1, 1);

  buf[0] = OCD_LOG_FILE;

  buf[1] = 3;                   /* close existing WIGGLERS.LOG */

  ocd_put_packet (buf, 2);

  p = ocd_get_packet (buf[0], &pktlen, remote_timeout);

  buf[0] = OCD_LOG_FILE;

  buf[1] = 2;                   /* append to existing WIGGLERS.LOG */

  ocd_put_packet (buf, 2);

  p = ocd_get_packet (buf[0], &pktlen, remote_timeout);

  return 1;

}

/* Open a connection to a remote debugger.

   NAME is the filename used for communication.  */

void

ocd_open (char *name, int from_tty, enum ocd_target_type target_type,

          struct target_ops *ops)

{

  unsigned char buf[10], *p;

  int pktlen;

  if (name == 0)

    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);

  current_ops = ops;

  unpush_target (current_ops);

  if (strncmp (name, "wiggler", 7) == 0)

    {

      ocd_desc = SERIAL_OPEN ("ocd");

      if (!ocd_desc)

        perror_with_name (name);

      buf[0] = OCD_LOG_FILE;

      buf[1] = 1;               /* open new or overwrite existing WIGGLERS.LOG */

      ocd_put_packet (buf, 2);

      p = ocd_get_packet (buf[0], &pktlen, remote_timeout);

      buf[0] = OCD_SET_CONNECTION;

      buf[1] = 0x01;            /* atoi (name[11]); */

      ocd_put_packet (buf, 2);

      p = ocd_get_packet (buf[0], &pktlen, remote_timeout);

    }

  else

    /* not using Wigglers.dll */

    {

      ocd_desc = SERIAL_OPEN (name);

      if (!ocd_desc)

        perror_with_name (name);

    }

  if (baud_rate != -1)

    {

      if (SERIAL_SETBAUDRATE (ocd_desc, baud_rate))

        {

          SERIAL_CLOSE (ocd_desc);

          perror_with_name (name);

        }

    }

  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 (ocd_desc);

  if (from_tty)

    {

      puts_filtered ("Remote target wiggler connected to ");

      puts_filtered (name);

      puts_filtered ("\n");

    }

  push_target (current_ops);    /* Switch to using remote target now */

  /* Without this, some commands which require an active target (such as kill)

     won't work.  This variable serves (at least) double duty as both the pid

     of the target process (if it has such), and as a flag indicating that a

     target is active.  These functions should be split out into seperate

     variables, especially since GDB will someday have a notion of debugging

     several processes.  */

  inferior_ptid = pid_to_ptid (42000);

  /* 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 (ocd_start_remote, &target_type,

                     "Couldn't establish connection to remote target\n",

                     RETURN_MASK_ALL))

    {

      pop_target ();

      error ("Failed to connect to OCD.");

    }

}

/* This takes a program previously attached to and detaches it.  After

   this is done, GDB can be used to debug some other program.  We

   better not have left any breakpoints in the target program or it'll

   die when it hits one.  */

void

ocd_detach (char *args, int from_tty)

{

  if (args)

    error ("Argument given to \"detach\" when remotely debugging.");

  pop_target ();

  if (from_tty)

    puts_filtered ("Ending remote debugging.\n");

}

/* Tell the remote machine to resume.  */

void

ocd_resume (ptid_t ptid, int step, enum target_signal siggnal)

{

  int pktlen;

  if (step)

    ocd_do_command (OCD_STEP, &last_run_status, &pktlen);

  else

    ocd_do_command (OCD_RUN, &last_run_status, &pktlen);

}

void

ocd_stop (void)

{

  int status;

  int pktlen;

  ocd_do_command (OCD_STOP, &status, &pktlen);

  if (!(status & OCD_FLAG_BDM))

    error ("Can't stop target via BDM");

}

static volatile int ocd_interrupt_flag;

/* Send ^C to target to halt it.  Target will respond, and send us a

   packet.  */

static void

ocd_interrupt (int signo)

{

  /* If this doesn't work, try more severe steps.  */

  signal (signo, ocd_interrupt_twice);

  if (remote_debug)

    printf_unfiltered ("ocd_interrupt called\n");

  {

    char buf[1];

    ocd_stop ();

    buf[0] = OCD_AYT;

    ocd_put_packet (buf, 1);

    ocd_interrupt_flag = 1;

  }

}

static void (*ofunc) ();

/* The user typed ^C twice.  */

static void

ocd_interrupt_twice (int signo)

{

  signal (signo, ofunc);

  interrupt_query ();

  signal (signo, ocd_interrupt);

}

/* Ask the user what to do when an interrupt is received.  */

static void

interrupt_query (void)

{

  target_terminal_ours ();

  if (query ("Interrupted while waiting for the program.\n\

Give up (and stop debugging it)? "))

    {

      target_mourn_inferior ();

      return_to_top_level (RETURN_QUIT);

    }

  target_terminal_inferior ();

}

/* If nonzero, ignore the next kill.  */

static int kill_kludge;

/* Wait until the remote machine stops, then return,

   storing status in STATUS just as `wait' would.

   Returns "pid" (though it's not clear what, if anything, that

   means in the case of this target).  */

int

ocd_wait (void)

{

  unsigned char *p;

  int error_code;

  int pktlen;

  char buf[1];

  ocd_interrupt_flag = 0;

  /* Target might already be stopped by the time we get here. */

  /* If we aren't already stopped, we need to loop until we've dropped

     back into BDM mode */

  while (!(last_run_status & OCD_FLAG_BDM))

    {

      buf[0] = OCD_AYT;

      ocd_put_packet (buf, 1);

      p = ocd_get_packet (OCD_AYT, &pktlen, -1);

      ofunc = (void (*)()) signal (SIGINT, ocd_interrupt);

      signal (SIGINT, ofunc);

      if (pktlen < 2)

        error ("Truncated response packet from OCD device");

      last_run_status = p[1];

      error_code = p[2];

      if (error_code != 0)

        ocd_error ("target_wait:", error_code);

      if (last_run_status & OCD_FLAG_PWF)

        error ("OCD device lost VCC at BDM interface.");

      else if (last_run_status & OCD_FLAG_CABLE_DISC)

        error ("OCD device cable appears to have been disconnected.");

    }

  if (ocd_interrupt_flag)

    return 1;

  else

    return 0;

}

/* 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 *

ocd_read_bdm_registers (int first_bdm_regno, int last_bdm_regno, int *reglen)

{

  unsigned char buf[10];

  int i;

  unsigned char *p;

  unsigned char *regs;

  int error_code, status;

  int pktlen;

  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;

  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)

    ocd_error ("read_bdm_registers:", error_code);

  i = p[3];

  if (i == 0)

    i = 256;

  if (i > pktlen - 4

      || ((i & 3) != 0))

    error ("Register block size bad:  %d", i);

  *reglen = i;

  regs = p + 4;

  return regs;

}

/* Read register BDM_REGNO and returns its value ala read_register() */

CORE_ADDR

ocd_read_bdm_register (int bdm_regno)

{

  int reglen;

  unsigned char *p;

  CORE_ADDR regval;

  p = ocd_read_bdm_registers (bdm_regno, bdm_regno, &reglen);

  regval = extract_unsigned_integer (p, reglen);

  return regval;

}

void

ocd_write_bdm_registers (int first_bdm_regno, unsigned char *regptr, int reglen)

{

  unsigned char *buf;

  unsigned char *p;

  int error_code, status;

  int pktlen;

  buf = alloca (4 + reglen);

  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);

  ocd_put_packet (buf, 4 + reglen);

  p = ocd_get_packet (OCD_WRITE_REGS, &pktlen, remote_timeout);

  if (pktlen < 3)

    error ("Truncated response packet from OCD device");

  status = p[1];

  error_code = p[2];

  if (error_code != 0)

    ocd_error ("ocd_write_bdm_registers:", error_code);

}

void

ocd_write_bdm_register (int bdm_regno, CORE_ADDR reg)

{

  unsigned char buf[4];

  store_unsigned_integer (buf, 4, reg);

  ocd_write_bdm_registers (bdm_regno, buf, 4);

}

void

ocd_prepare_to_store (void)

{

}

/* Write memory data directly to the remote machine.

   This does not inform the data cache; the data cache uses this.

   MEMADDR is the address in the remote memory space.

   MYADDR is the address of the buffer in our space.

   LEN is the number of bytes.

   Returns number of bytes transferred, or 0 for error.  */

static int write_mem_command = OCD_WRITE_MEM;

int

ocd_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)

{

  char buf[256 + 10];

  unsigned char *p;

  int origlen;

  origlen = len;

  buf[0] = write_mem_command;

  buf[5] = 1;                   /* Write as bytes */

  buf[6] = 0;                    /* Don't verify */

  while (len > 0)

    {

      int numbytes;

      int pktlen;

      int status, error_code;

      numbytes = min (len, 256 - 8);

      buf[1] = memaddr >> 24;

      buf[2] = memaddr >> 16;

      buf[3] = memaddr >> 8;

      buf[4] = memaddr;

      buf[7] = numbytes;

      memcpy (&buf[8], myaddr, numbytes);

      ocd_put_packet (buf, 8 + numbytes);

      p = ocd_get_packet (OCD_WRITE_MEM, &pktlen, remote_timeout);

      if (pktlen < 3)

        error ("Truncated response packet from OCD device");

      status = p[1];

      error_code = p[2];

      if (error_code == 0x11)   /* Got a bus error? */

        {

          CORE_ADDR error_address;

          error_address = p[3] << 24;

          error_address |= p[4] << 16;

          error_address |= p[5] << 8;

          error_address |= p[6];

          numbytes = error_address - memaddr;

          len -= numbytes;

          errno = EIO;

          break;

        }

      else if (error_code != 0)

        ocd_error ("ocd_write_bytes:", error_code);

      len -= numbytes;

      memaddr += numbytes;

      myaddr += numbytes;

    }

  return origlen - len;

}

/* Read memory data directly from the remote machine.

   This does not use the data cache; the data cache uses this.

   MEMADDR is the address in the remote memory space.

   MYADDR is the address of the buffer in our space.

   LEN is the number of bytes.

   Returns number of bytes transferred, or 0 for error.  */

static int

ocd_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)

{