/* 
 * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
 * 
 * This software may be freely used, copied, modified, and distributed
 * provided that the above copyright notice is preserved in all copies of the
 * software.
 */

/*
 * ARDI.c
 * Angel Remote Debug Interface
 *
 *
 * $Revision$
 *     $Date$
 *
 * This file is based on /plg/pisd/rdi.c, but instead of using RDP it uses
 * ADP messages.
 */

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define uint HIDE_HPs_uint
#include <signal.h>
#undef uint


#include "angel_endian.h"
#include "ardi.h"
#include "buffers.h"
#include "channels.h"
#include "hostchan.h"
#include "host.h"
#include "angel_bytesex.h"
#include "dbg_cp.h"
#include "adp.h"
#include "hsys.h"
#include "logging.h"
#include "msgbuild.h"
#include "rxtx.h"
#include "devsw.h"
#include "params.h"

#ifdef COMPILING_ON_WINDOWS
#  define IGNORE(x) (x = x)   /* must go after #includes to work on Windows */
#endif
#define NOT(x) (!(x))

#define ADP_INITIAL_TIMEOUT_PERIOD 5

static volatile int executing;
static int rdi_log = 0 ; /* debugging  ? */

/* we need a starting point for our first buffers, this is a safe one */
int Armsd_BufferSize = ADP_BUFFER_MIN_SIZE;
int Armsd_LongBufSize = ADP_BUFFER_MIN_SIZE;

#ifdef WIN32
  extern int interrupted;
  extern int swiprocessing;
#endif

static char dummycline = 0;
char *ardi_commandline = &dummycline ; /* exported in ardi.h */

extern unsigned int heartbeat_enabled;

static unsigned char *cpwords[16];

typedef struct stoppedProcListElement {
  struct stoppedProcListElement *next;
  angel_RDI_TargetStoppedProc *fn;
  void *arg;
} stoppedProcListElement;

static stoppedProcListElement *stopped_proc_list=NULL;

const struct Dbg_HostosInterface *angel_hostif;
static hsys_state *hstate;

static void angel_DebugPrint(const char *format, ...)
{ va_list ap;
  va_start(ap, format);
  angel_hostif->dbgprint(angel_hostif->dbgarg, format, ap);
  va_end(ap);
}

#ifdef RDI_VERBOSE
#define TracePrint(s) \
  if (rdi_log & 2) angel_DebugPrint("\n"); \
  if (rdi_log & 1) angel_DebugPrint s
#else
#define TracePrint(s)
#endif

typedef struct receive_dbgmsg_state {
  volatile int received;
  Packet *packet;
} receive_dbgmsg_state;

static receive_dbgmsg_state dbgmsg_state;

static void receive_debug_packet(Packet *packet, void *stateptr)
{
  receive_dbgmsg_state *state = stateptr;

  state->packet = packet;
  state->received = 1;
}

static int register_debug_message_handler(void)
{
  int err;
  dbgmsg_state.received = 0;

  err = Adp_ChannelRegisterRead(CI_HADP, receive_debug_packet, &dbgmsg_state);
#ifdef DEBUG
  if (err!=adp_ok) angel_DebugPrint("register_debug_message_handler failed %i\n", err);
#endif
  return err;
}


static int wait_for_debug_message(int *rcode, int *debugID,
                                  int *OSinfo1, int *OSinfo2,
                                  int *status, Packet **packet)
{
  unsigned int reason;

#ifdef DEBUG
  angel_DebugPrint("wait_for_debug_message waiting for %X\n", *rcode);
#endif

  for ( ; dbgmsg_state.received == 0 ; )
    Adp_AsynchronousProcessing(async_block_on_read);

#ifdef DEBUG
  angel_DebugPrint("wait_for_debug_message got packet\n");
#endif

  *packet = dbgmsg_state.packet;

  Adp_ChannelRegisterRead(CI_HADP, NULL, NULL);

  /*
   * TODO:
   * If ADP_Unrecognised return error.
   * If ADP_Acknowledge - handle appropriately.
   * If expected message read arguments and return RDIError_NoError.
   * Note: if RDIError occurs then the data values returned are junk
   */

  unpack_message(BUFFERDATA((*packet)->pk_buffer), "%w%w%w%w%w", &reason, debugID,
                 OSinfo1, OSinfo2, status);
  if (reason&0xffffff == ADP_HADPUnrecognised)
    return RDIError_UnimplementedMessage;
  if (reason != (unsigned ) *rcode) {
    if((reason&0xffffff) == ADP_HADPUnrecognised)
      return RDIError_UnimplementedMessage;
    else {
      angel_DebugPrint("ARDI ERROR: Expected reasoncode %x got reasoncode %x.\n",
             *rcode, reason);
      return RDIError_Error;
    }
  }
  else
    return RDIError_NoError;
  return RDIError_Error;    /* stop a pesky ANSI compiler warning */
}


/*
 * Handler and registration for logging messages from target
 */
static void TargetLogCallback( Packet *packet, void *state )
{
    p_Buffer     reply = BUFFERDATA(packet->pk_buffer);
    unsigned int len   = packet->pk_length;
    IGNORE(state);
    angel_hostif->write(angel_hostif->hostosarg,
                        (char *)reply, len - CHAN_HEADER_SIZE);
    DevSW_FreePacket(packet);

    packet = DevSW_AllocatePacket(4); /* better not ask for 0 */
    /* the reply is the ACK - any contents are ignored */
    if (packet != NULL)
       Adp_ChannelWrite( CI_TLOG, packet );
}

static void TargetLogInit( void )
{
    AdpErrs err = Adp_ChannelRegisterRead( CI_TLOG, TargetLogCallback, NULL );

#ifdef DEBUG
    if (err != adp_ok)
       angel_DebugPrint("CI_TLOG RegisterRead failed %d\n", err);
#else
    IGNORE(err);
#endif
}

/*----------------------------------------------------------------------*/
/*----angel_RDI_open-----------------------------------------------------*/
/*----------------------------------------------------------------------*/

typedef struct NegotiateState {
      bool             negotiate_resp;
      bool             negotiate_ack;
      bool             link_check_resp;
      ParameterConfig *accepted_config;
} NegotiateState;

static void receive_negotiate(Packet *packet, void *stateptr)
{
    unsigned reason, debugID, OSinfo1, OSinfo2, status;
    NegotiateState *n_state = (NegotiateState *)stateptr;
    p_Buffer reply = BUFFERDATA(packet->pk_buffer);

    unpack_message( reply, "%w%w%w%w",
                    &reason, &debugID, &OSinfo1, &OSinfo2 );
    reply += ADP_DEFAULT_HEADER_SIZE;

#ifdef DEBUG
    angel_DebugPrint( "receive_negotiate: reason %x\n", reason );
#endif

    switch ( reason )
    {
        case ADP_ParamNegotiate | TtoH:
        {
            n_state->negotiate_resp = TRUE;

            status = GET32LE( reply );
            reply += sizeof(word);
#ifdef DEBUG
            angel_DebugPrint( "ParamNegotiate status %u\n", status );
#endif
            if ( status == RDIError_NoError )
            {
                if ( Angel_ReadParamConfigMessage(
                         reply, n_state->accepted_config ) )
                   n_state->negotiate_ack = TRUE;
            }
            break;
        }

        case ADP_LinkCheck | TtoH:
        {
#ifdef DEBUG
            angel_DebugPrint( "PONG!\n" );
#endif
            n_state->link_check_resp = TRUE;
            break;
        }

        default:
        {
#ifdef DEBUG
            angel_DebugPrint( "Unexpected!\n" );
#endif
            break;
        }
    }
    DevSW_FreePacket( packet );
}

# include <sys/types.h>
#ifdef __unix
# include <sys/time.h>
#else
# include <time.h>
#endif

/*
 * convert a config into a single-valued options list
 */
static ParameterOptions *config_to_options( const ParameterConfig *config )
{
    unsigned int        num_params;
    size_t              size;
    ParameterOptions   *base_p;

    num_params  = config->num_parameters;
    size        =
        sizeof(ParameterOptions)
        + num_params*(sizeof(ParameterList) + sizeof(unsigned int));
    base_p      = malloc( size );

    if ( base_p != NULL )
    {
        unsigned int    u;
        ParameterList  *list_p          =
            (ParameterList *)((char *)base_p + sizeof(ParameterOptions));
        unsigned int   *option_p        =
            (unsigned int *)(list_p + num_params);

        base_p->num_param_lists = num_params;
        base_p->param_list = list_p;

        for ( u = 0; u < num_params; ++u )
        {
            option_p[u]                 = config->param[u].value;
            list_p[u].type              = config->param[u].type;
            list_p[u].num_options       = 1;
            list_p[u].option            = &option_p[u];
        }
    }

    return base_p;
}

static AdpErrs negotiate_params( const ParameterOptions *user_options )
{
    Packet                    *packet;
    unsigned int               count;
    static Parameter           params[AP_NUM_PARAMS];
    static ParameterConfig     accepted_config = { AP_NUM_PARAMS, params };

    time_t t;

    static volatile NegotiateState    n_state;
    n_state.negotiate_resp = FALSE;
    n_state.negotiate_ack = FALSE;
    n_state.link_check_resp = FALSE;
    n_state.accepted_config = &accepted_config;
    
#ifdef DEBUG
    angel_DebugPrint( "negotiate_params\n" );
#endif

    Adp_ChannelRegisterRead( CI_HBOOT, receive_negotiate, (void *)&n_state );

    packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize);
    count = msgbuild( BUFFERDATA(packet->pk_buffer), "%w%w%w%w",
                      ADP_ParamNegotiate | HtoT, 0,
                      ADP_HandleUnknown, ADP_HandleUnknown );
    count += Angel_BuildParamOptionsMessage(
        BUFFERDATA(packet->pk_buffer) + count, user_options );
    packet->pk_length = count;
    Adp_ChannelWriteAsync( CI_HBOOT, packet );

#ifdef DEBUG
    angel_DebugPrint( "sent negotiate packet\n" );
#endif

    t=time(NULL);

    do {
      Adp_AsynchronousProcessing(async_block_on_nothing);

      if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD) {
        return adp_timeout_on_open;
      }
    } while ( ! n_state.negotiate_resp );

    if ( n_state.negotiate_ack )
    {
        /* select accepted config */
        Adp_Ioctl( DC_SET_PARAMS, (void *)n_state.accepted_config );

        /*
         * 960430 KWelton
         *
         * There is a race in the renegotiation protocol: the
         * target has to have had time to load new config before
         * we send the link check packet - insert a deliberate
         * pause (100ms) to give the target some time
         */
        Adp_delay(100000);

        /* do link check */
        msgsend( CI_HBOOT, "%w%w%w%w", ADP_LinkCheck | HtoT, 0,
                 ADP_HandleUnknown, ADP_HandleUnknown );
#ifdef DEBUG
        angel_DebugPrint("sent link check\n");
#endif

        do {
            Adp_AsynchronousProcessing(async_block_on_read);
        } while ( ! n_state.link_check_resp );
        Adp_initSeq();
    }
    return adp_ok;
}

static int late_booted = FALSE;
static bool ardi_handler_installed = FALSE;

#ifdef __unix
static struct sigaction old_action;
#else
static void (*old_handler)();
#endif

static bool boot_interrupted = FALSE;
static volatile bool interrupt_request = FALSE;
static volatile bool stop_request = FALSE;

static void ardi_sigint_handler(int sig) {
#ifdef DEBUG
    if (sig != SIGINT)
       angel_DebugPrint("Expecting SIGINT got %d.\n", sig);
#else
    IGNORE(sig);
#endif
    boot_interrupted = TRUE;
    interrupt_request = TRUE;
#ifndef __unix
    signal(SIGINT, ardi_sigint_handler);
#endif
}

static void install_ardi_handler( void ) {
  if (!ardi_handler_installed) {
    /* install a new Ctrl-C handler so we can abandon waiting */
#ifdef __unix
    struct sigaction new_action;
    sigemptyset(&new_action.sa_mask);
    new_action.sa_handler = ardi_sigint_handler;
    new_action.sa_flags = 0;
    sigaction(SIGINT, &new_action, &old_action);
#else
    old_handler = signal(SIGINT, ardi_sigint_handler);
#endif
    ardi_handler_installed = TRUE;
  }
}

static int angel_RDI_errmess(char *buf, int blen, int errnum);

static void receive_reset_acknowledge(Packet *packet, void *stateptr) {
  unsigned reason, debugID, OSinfo1, OSinfo2, status;
  IGNORE(stateptr);

  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
                 &OSinfo1, &OSinfo2, &status);
  if (reason==(ADP_Reset | TtoH) && status==AB_NORMAL_ACK) {
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Successfully received normal reset acknowledgement\n");
    late_booted = FALSE;
#endif
  } else if (reason==(ADP_Reset | TtoH) && status==AB_LATE_ACK) {
    char late_msg[AdpMessLen_LateStartup];
    int  late_len;
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Successfully received LATE reset acknowledgement\n");
#endif
    late_booted = TRUE;
    install_ardi_handler();
    late_len = angel_RDI_errmess(late_msg,
                                 AdpMessLen_LateStartup, adp_late_startup);
    angel_hostif->write(angel_hostif->hostosarg, late_msg, late_len);
  } else {
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Bad reset ack: reason=%8X, status=%8X\n", reason, status);
#endif
  }
  DevSW_FreePacket(packet);
}

static int booted_not_received;
static unsigned int angel_version;
static unsigned int adp_version;
static unsigned int arch_info;
static unsigned int cpu_info;
static unsigned int hw_status;

static void receive_booted(Packet *packet, void *stateptr) {
  unsigned reason, debugID, OSinfo1, OSinfo2, banner_length, bufsiz, longsiz;
  unsigned i, count;

  IGNORE(stateptr);

  count = unpack_message(BUFFERDATA(packet->pk_buffer),
                         "%w%w%w%w%w%w%w%w%w%w%w%w",
                 &reason, &debugID, &OSinfo1, &OSinfo2, &bufsiz, &longsiz,
                 &angel_version, &adp_version,
                 &arch_info, &cpu_info, &hw_status, &banner_length);
  if (reason==(ADP_Booted | TtoH)) {
#ifdef MONITOR_DOWNLOAD_PACKETS
    angel_DebugPrint("DEBUG: Successfully received Booted\n");
    angel_DebugPrint("       cpu_info=%8X, hw_status=%8X, bufsiz=%d, longsiz=%d\n",
           cpu_info, hw_status, bufsiz, longsiz);
#endif
    /* Get the banner from the booted message */
    for (i=0; i<banner_length; i++)
      angel_hostif->writec(angel_hostif->hostosarg,
                          (BUFFERDATA(packet->pk_buffer)+count)[i]);

    booted_not_received=0;
#ifndef NO_HEARTBEAT
    heartbeat_enabled = TRUE;
#endif
    Armsd_BufferSize = bufsiz + CHAN_HEADER_SIZE;
    Armsd_LongBufSize = longsiz + CHAN_HEADER_SIZE;
  } else {
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Bad Booted msg: reason=%8X\n", reason);
#endif
  }
  DevSW_FreePacket(packet);
}


/* forward declaration */
static int angel_negotiate_defaults( void );

/* Open communications. */
int angel_RDI_open(
    unsigned type, Dbg_ConfigBlock const *config,
    Dbg_HostosInterface const *hostif, struct Dbg_MCState *dbg_state)
{
  Packet *packet;
  int status, reasoncode, debugID, OSinfo1, OSinfo2, err;
  ParameterOptions *user_options = NULL;

  time_t t;

  IGNORE( dbg_state );

  if ((type & 1) == 0) {
    /* cold start */
    if (hostif != NULL) {
      angel_hostif = hostif;
      err = HostSysInit(hostif, &ardi_commandline, &hstate);
      if (err != RDIError_NoError) {
#ifdef DEBUG
        angel_DebugPrint("DEBUG: HostSysInit error %i\n",err);
#endif
        return err;
      }
    }
    TargetLogInit();
  }

#ifdef DEBUG
  angel_DebugPrint("DEBUG: Buffer allocated in angel_RDI_open(type=%i).\n",type);
#endif

  if ((type & 1) == 0) {
    /* cold start */
    unsigned endian;
    Adp_Ioctl( DC_GET_USER_PARAMS, (void *)&user_options );
    if ( user_options != NULL ) {
      err = negotiate_params( user_options );
      if (err != adp_ok) return err;
    }
    else {
      ParameterConfig *default_config = NULL;
      Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config );
      if ( default_config != NULL ) {
        ParameterOptions *default_options = config_to_options(default_config);
        err = negotiate_params( default_options );
        if (err != adp_ok) return err;
      }
    }

    /* Register handlers before sending any messages */
    booted_not_received=1;
    Adp_ChannelRegisterRead(CI_HBOOT, receive_reset_acknowledge, NULL);
    Adp_ChannelRegisterRead(CI_TBOOT, receive_booted, NULL);
    endian = 0;
    if (config!=NULL) {
      if (config->bytesex & RDISex_Little) endian |= ADP_BootHostFeature_LittleEnd;
      if (config->bytesex & RDISex_Big) endian |= ADP_BootHostFeature_BigEnd;
    }
    msgsend(CI_HBOOT,"%w%w%w%w%w", ADP_Reset | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown, endian);
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Transmitted Reset message in angel_RDI_open.\n");
#endif

    /* We will now either get an acknowledgement for the Reset message
     * or if the target was started after the host, we will get a
     * rebooted message first.
     */

#ifdef DEBUG
    angel_DebugPrint("DEBUG: waiting for a booted message\n");
#endif

    {
      boot_interrupted = FALSE;

      if (late_booted)
        install_ardi_handler();

      t=time(NULL);

      do {
        Adp_AsynchronousProcessing(async_block_on_nothing);
        if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD && !late_booted) {
          return adp_timeout_on_open;
        }
      } while (booted_not_received && !boot_interrupted);

      if (ardi_handler_installed)
      {
        /* uninstall our Ctrl-C handler */
#ifdef __unix
        sigaction(SIGINT, &old_action, NULL);
#else
        signal(SIGINT, old_handler);
#endif
      }

      if (boot_interrupted) {
        angel_negotiate_defaults();
        return adp_abandon_boot_wait;
      }
    }

    booted_not_received=1;
    Adp_ChannelRegisterRead(CI_HBOOT, NULL, NULL);

    /* Leave the booted handler installed */
    msgsend(CI_TBOOT, "%w%w%w%w%w", ADP_Booted | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown, 0);
    Adp_initSeq();
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Transmitted ADP_Booted acknowledgement.\n");
    angel_DebugPrint("DEBUG: Boot sequence completed, leaving angel_RDI_open.\n");
#endif

    return (hw_status & ADP_CPU_BigEndian )? RDIError_BigEndian :
      RDIError_LittleEndian;
  }
  else {
    /* warm start */
    register_debug_message_handler();

    msgsend(CI_HADP, "%w%w%w%w",
            ADP_InitialiseApplication | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown);
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Transmitted Initialise Application\n");
#endif
    reasoncode=ADP_InitialiseApplication | TtoH;
    err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2,
                                &status, &packet);
    if (err != RDIError_NoError) return err;
    return status;
  }
  return -1;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_close----------------------------------------------------*/
/*----------------------------------------------------------------------*/

static int angel_negotiate_defaults( void ) {
    int err = adp_ok;
    ParameterConfig *default_config = NULL;
    Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config );
    if ( default_config != NULL ) {
        ParameterOptions *default_options = config_to_options(default_config);
        err = negotiate_params( default_options );
        free( default_options );
    }
    return err;
}

int angel_RDI_close(void) {
/*Angel host exit */
  int err;
  int status,debugID, OSinfo1,OSinfo2;
  int reason;
  Packet *packet = NULL;;
#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_Close.\n");
#endif

  register_debug_message_handler();

  heartbeat_enabled = FALSE;

  err = msgsend(CI_HADP,"%w%w%w%w",ADP_End | HtoT,0,
          ADP_HandleUnknown, ADP_HandleUnknown);
  if (err != RDIError_NoError) return err;
  reason = ADP_End | TtoH;
  err =  wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                  &status, &packet);
  DevSW_FreePacket(packet);
  if (err != RDIError_NoError) return err;
  if (status == RDIError_NoError) {
    err = angel_negotiate_defaults();
    if (err != adp_ok) return err;
    Adp_Ioctl( DC_RESET, NULL ); /* just to be safe */
    return HostSysExit(hstate);
  }
  else
      return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_read-----------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Read memory contents from target to host: use ADP_Read */
int angel_RDI_read(ARMword source, void *dest, unsigned *nbytes)
{
  Packet *packet=NULL;
  int len;                               /* Integer to hold message length. */
  unsigned int nbtogo = *nbytes, nbinpacket, nbdone=0;
  int rnbytes = 0, status, reason, debugID, OSinfo1, OSinfo2, err;
  unsigned int maxlen = Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ReadHeaderSize;

  /* Print debug trace information, this is just copied straight from rdi.c
     and I can see no reason why it should have to be changed. */
  TracePrint(("angel_RDI_read: source=%.8lx dest=%p nbytes=%.8x\n",
                (unsigned long)source, dest, *nbytes));
  if (*nbytes == 0) return RDIError_NoError;       /* Read nothing - easy! */
  /* check the buffer size */
  while (nbtogo >0) {
    register_debug_message_handler();

    nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen;
    len = msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Read | HtoT, 0,
                  ADP_HandleUnknown, ADP_HandleUnknown, source+nbdone,
                  nbinpacket);
    reason=ADP_Read | TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                &status, &packet);
    TracePrint(("angel_RDI_read: nbinpacket =%d status=%08x err = %d\n",
                nbinpacket,status,err));
    if (err != RDIError_NoError) return err;       /* Was there an error? */
    if (status == RDIError_NoError){
      rnbytes += PREAD(LE,(unsigned int *)(BUFFERDATA(packet->pk_buffer)+20));
      TracePrint(("angel_RDI_read: rnbytes = %d\n",rnbytes));
      memcpy(((unsigned char *)dest)+nbdone, BUFFERDATA(packet->pk_buffer)+24,
             nbinpacket);
    }
    nbdone += nbinpacket;
    nbtogo -= nbinpacket;
  }
  *nbytes -= rnbytes;
  return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_write----------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Transfer memory block from host to target.  Use ADP_Write>. */
int angel_RDI_write(const void *source, ARMword dest, unsigned *nbytes)
{
  Packet *packet;/* Message buffers. */
  unsigned int len, nbtogo = *nbytes, nboffset = 0, nbinpacket;
  int status, reason, debugID, OSinfo1, OSinfo2, err;
  unsigned int maxlen = Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_WriteHeaderSize;

  TracePrint(("angel_RDI_write: source=%p dest=%.8lx nbytes=%.8x\n",
                 source, (unsigned long)dest, *nbytes));

  if (*nbytes == 0) return RDIError_NoError;

  *nbytes = 0;
  while (nbtogo > 0) {
    packet = (Packet *) DevSW_AllocatePacket(Armsd_LongBufSize);
    nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen;
    len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
                   ADP_Write | HtoT, 0, ADP_HandleUnknown,
                   ADP_HandleUnknown, dest+nboffset, nbinpacket);
    /* Copy the data into the packet. */

    memcpy(BUFFERDATA(packet->pk_buffer)+len,
           ((const unsigned char *) source)+nboffset, nbinpacket);
    nboffset += nbinpacket;
    packet->pk_length = nbinpacket+len;

#ifdef MONITOR_DOWNLOAD_PACKETS
    angel_DebugPrint("angel_RDI_write packet size=%i, bytes done=%i\n",
            nbinpacket, nboffset);
#endif

    register_debug_message_handler();
    Adp_ChannelWrite(CI_HADP, packet);
    reason=ADP_Write | TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                &status, &packet);
    nbtogo -= nbinpacket;
    if (err != RDIError_NoError) return err;
    if (status == RDIError_NoError)
      *nbytes += nbinpacket;

    DevSW_FreePacket(packet);
  }
  return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_CPUread--------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Reads the values of registers in the CPU, uses ADP_CPUwrite. */
int angel_RDI_CPUread(unsigned mode, unsigned long mask, ARMword *buffer)
{
  unsigned int i, j;
  Packet *packet = NULL;
  int err, status, reason, debugID, OSinfo1, OSinfo2;
#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_CPUread.\n");
#endif
  for (i=0, j=0 ; i < RDINumCPURegs ; i++)
    if (mask & (1L << i)) j++;            /* Count the number of registers. */

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%c%w", ADP_CPUread | HtoT, 0,
          ADP_HandleUnknown, ADP_HandleUnknown, mode, mask);
  reason = ADP_CPUread | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;
  }
  if(status == RDIError_NoError) {
    for (i=0; i<j; i++)
      buffer[i] = GET32LE(BUFFERDATA(packet->pk_buffer)+20+(i*4));
    TracePrint(("angel_RDI_CPUread: mode=%.8x mask=%.8lx", mode, mask));
    DevSW_FreePacket(packet);
#ifdef RDI_VERBOSE
    if (rdi_log & 1) {
      unsigned k;
      for (k = 0, j = 0 ; j <= 20 ; j++)
        if (mask & (1L << j)) {
          angel_DebugPrint("%c%.8lx",k%4==0?'\n':' ',
                           (unsigned long)buffer[k]);
          k++ ;
        }
      angel_DebugPrint("\n") ;
    }
#endif

  }
  return status;
}

/*----------------------------------------------------------------------*/
/*----angel_RDI_CPUwrite-------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Write CPU registers: use ADP_CPUwrite. */
int angel_RDI_CPUwrite(unsigned mode, unsigned long mask,
                      ARMword const *buffer){

  unsigned i, j, c;
  Packet *packet;
  int status, reason, debugID, OSinfo1, OSinfo2, err, len;

  TracePrint(("angel_RDI_CPUwrite: mode=%.8x mask=%.8lx", mode, mask));
#ifdef RDI_VERBOSE
 if (rdi_log & 1) {
    for (j = 0, i = 0 ; i <= 20 ; i++)
       if (mask & (1L << i)) {
          angel_DebugPrint("%c%.8lx",j%4==0?'\n':' ',
                           (unsigned long)buffer[j]);
          j++ ;
          }
    angel_DebugPrint("\n") ;
    }
#endif
 packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize);
 for (i=0, j=0; i < RDINumCPURegs ; i++)
   if (mask & (1L << i)) j++; /* count the number of registers */

 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%b%w",
                ADP_CPUwrite | HtoT, 0,
                ADP_HandleUnknown, ADP_HandleUnknown, mode, mask);
 for(c=0; c<j; c++)
   PUT32LE(BUFFERDATA(packet->pk_buffer)+len+(c*4), buffer[c]);
 packet->pk_length = len+(j*4);
 register_debug_message_handler();

 Adp_ChannelWrite(CI_HADP, packet);
 reason = ADP_CPUwrite | TtoH;
 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                             &status, &packet);
 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
                &OSinfo1, &OSinfo2, &status);
 DevSW_FreePacket(packet);
 if (err != RDIError_NoError)
   return err;      /* Was there an error? */
 else
   return status;
 }


/*----------------------------------------------------------------------*/
/*----angel_RDI_CPread---------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Read coprocessor's internal state.  See dbg_cp.h for help.
 * Use ADP_CPRead.
 * It would appear that the correct behaviour at this point is to leave
 * the unpacking to a the caller and to simply copy the stream of data
 * words into the buffer
 */

int angel_RDI_CPread(unsigned CPnum, unsigned long mask, ARMword *buffer){
  Packet *packet = NULL;
  int i, j, status, reasoncode, OSinfo1, OSinfo2, err, debugID;
  unsigned char *rmap = cpwords[CPnum];
  int n;
#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_CPread.\n");
#endif
  if (rmap == NULL) return RDIError_UnknownCoPro;

  register_debug_message_handler();
  n = rmap[-1];
  msgsend(CI_HADP, "%w%w%w%w%b%w", ADP_CPread | HtoT, 0,
          ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask);
  reasoncode=ADP_CPread | TtoH;
  err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;          /* Was there an error? */
  }
  for (j=i=0; i < n ; i++) /* count the number of registers */
    if (mask & (1L << i)) {
      j++;
    }
  for (i=0; i<j; i++)
    buffer[i] = PREAD32(LE, BUFFERDATA(packet->pk_buffer) + 20 + (i*4));
  DevSW_FreePacket(packet);
  TracePrint(("angel_RDI_CPread: CPnum=%.8x mask=%.8lx\n", CPnum, mask));
#ifdef RDI_VERBOSE
  if (rdi_log & 1) {
    for (i = 0, j = 0; j < n ; j++) {
      if (mask & (1L << j)) {
        int nw = rmap[j];
        angel_DebugPrint("%2d ", j);
        while (--nw > 0)
          angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]);
        angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]);
      }
    }
  }
#endif
  return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_CPwrite--------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Write coprocessor's internal state.  See dbg_cp.h for help. Use
 * ADP_CPwrite.
 */

int angel_RDI_CPwrite(unsigned CPnum, unsigned long mask,
                      ARMword const *buffer)
{
  Packet *packet = NULL;
  int i, j, len, status, reason, OSinfo1, OSinfo2, err, debugID;
  unsigned char *rmap = cpwords[CPnum];
  int n;

  if (rmap == NULL) return RDIError_UnknownCoPro;
  n = rmap[-1];

  TracePrint(("angel_RDI_CPwrite: CPnum=%d mask=%.8lx\n", CPnum, mask));

#ifdef RDI_VERBOSE
 if (rdi_log & 1) {
    for (i = 0, j = 0; j < n ; j++)
       if (mask & (1L << j)) {
          int nw = rmap[j];
          angel_DebugPrint("%2d ", j);
          while (--nw > 0)
             angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]);
          angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]);
       }
 }
#endif

  for (j=i=0; i < n ; i++) /* Count the number of registers. */
    if (mask & (1L << i)) j++;
  packet = DevSW_AllocatePacket(Armsd_BufferSize);
  len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%c%w",
                 ADP_CPwrite | HtoT, 0,
                 ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask);
  for(i=0;  i<j; i++)
    len+=msgbuild(BUFFERDATA(packet->pk_buffer) + len, "%w", buffer[i]);
  packet->pk_length = len;
  register_debug_message_handler();
  Adp_ChannelWrite(CI_HADP, packet);    /* Transmit message. */
  reason=ADP_CPwrite | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  DevSW_FreePacket(packet);
  if (err != RDIError_NoError)
    return err;
  else
    return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_pointinq-------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Do test calls to ADP_SetBreak/ADP_SetWatch to see if resources exist to
   carry out request. */
int angel_RDI_pointinq(ARMword *address, unsigned type, unsigned datatype,
                       ARMword *bound)
{
  Packet *packet = NULL;
  int len, status, reason, OSinfo1, OSinfo2, err=RDIError_NoError;
       /* stop a compiler warning */
  int debugID, pointhandle;
  TracePrint(
      ("angel_RDI_pointinq: address=%.8lx type=%d datatype=%d bound=%.8lx ",
      (unsigned long)*address, type, datatype, (unsigned long)*bound));
       /* for a buffer.  */
  packet = DevSW_AllocatePacket(Armsd_BufferSize);
  len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b",
                 ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch) | HtoT, 0,
                 ADP_HandleUnknown, ADP_HandleUnknown, address, type);
  if (datatype == 0)
    len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%w", bound);
  else
    len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%b%w", datatype, bound);

  register_debug_message_handler();
  packet->pk_length = len;
  Adp_ChannelWrite(CI_HADP, packet);
  reason = ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch | TtoH);
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;        /* Was there an error? */
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
                 &reason, &debugID, &OSinfo1, &OSinfo2, &status,
                 &pointhandle, &address, &bound);
  DevSW_FreePacket(packet);
  return err;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_setbreak-------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Set a breakpoint: Use ADP_SetBreak */
int angel_RDI_setbreak(ARMword address, unsigned type, ARMword bound,
                      PointHandle *handle)
{
  int status, reason, OSinfo1, OSinfo2, err, debugID;
  int tmpval, tmpaddr, tmpbnd;
  Packet *packet;
  TracePrint(("angel_RDI_setbreak address=%.8lx type=%d bound=%.8lx \n",
              (unsigned long)address, type, (unsigned long)bound));

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w%b%w",
          ADP_SetBreak| HtoT, 0,  ADP_HandleUnknown,
          ADP_HandleUnknown, address, type, bound);
  reason = ADP_SetBreak |TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;         /* Was there an error? */
  }
  /* Work around varargs problem... -sts */
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
                 &reason, &debugID, &OSinfo1, &OSinfo2, &status,
                 &tmpval, &tmpaddr, &tmpbnd);
  *handle = tmpval;
  address = tmpaddr;
  bound = tmpbnd;
  DevSW_FreePacket(packet);
  if (status != RDIError_NoError) return status;
  TracePrint(("returns handle %.8lx\n", (unsigned long)*handle));
  return RDIError_NoError;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_clearbreak-----------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Clear a breakpoint: Use ADP_ClearBreak. */
int angel_RDI_clearbreak(PointHandle handle)
{
  Packet *packet = NULL;
  int status, reason, OSinfo1, OSinfo2, err, debugID;

  TracePrint(("angel_RDI_clearbreak: handle=%.8lx\n", (unsigned long)handle));

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w",
          ADP_ClearBreak| HtoT, 0,  ADP_HandleUnknown,
          ADP_HandleUnknown, handle);
  reason = ADP_ClearBreak|TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    angel_DebugPrint("***RECEIVE DEBUG MESSAGE RETURNED ERR = %d.\n", err);
    return err;          /* Was there an error? */
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w",  &reason,
                 &debugID, &OSinfo1, &OSinfo2, &status);
  DevSW_FreePacket(packet);
#ifdef DEBUG
  angel_DebugPrint("DEBUG: Clear Break completed OK.\n");
#endif
  return RDIError_NoError;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_setwatch-------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Set a watchpoint: use ADP_SetWatch. */
int angel_RDI_setwatch(ARMword address, unsigned type, unsigned datatype,
                       ARMword bound, PointHandle *handle)
{
  Packet *packet = NULL;
  int status, reason, OSinfo1, OSinfo2, err, debugID;

  TracePrint(("angel_RDI_setwatch: address=%.8lx type=%d bound=%.8lx ",
              (unsigned long)address, type, (unsigned long)bound));

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w%b%b%w",
          ADP_SetWatch| HtoT, 0,  ADP_HandleUnknown,
          ADP_HandleUnknown, address, type, datatype, bound);

  reason = ADP_SetWatch | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;        /* Was there an error? */
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
                 &reason, &debugID, &OSinfo1, &OSinfo2, &status,
                 handle, &address, &bound);
  DevSW_FreePacket(packet);
  TracePrint(("returns handle %.8lx\n", (unsigned long)*handle));
  return RDIError_NoError;
}

/*----------------------------------------------------------------------*/
/*----angel_RDI_clearwatch-----------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Clear a watchpoint: use ADP_ClearWatch. */
int angel_RDI_clearwatch(PointHandle handle) {

  int status, reason, OSinfo1, OSinfo2, err, debugID;
  Packet *packet = NULL;

  TracePrint(("angel_RDI_clearwatch: handle=%.8lx\n", (unsigned long)handle));

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w",
          ADP_ClearWatch| HtoT, 0,  ADP_HandleUnknown,
          ADP_HandleUnknown, handle);
  reason = ADP_ClearWatch|TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;        /* Was there an error? */
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w",  &reason, &debugID,
                 &OSinfo1, &OSinfo2, &status);
  DevSW_FreePacket(packet);
  return RDIError_NoError;
}

typedef struct {
  unsigned stopped_reason;
  int stopped_status;
  int data;
} adp_stopped_struct;


int angel_RDI_OnTargetStopping(angel_RDI_TargetStoppedProc *fn,
                               void *arg)
{
  stoppedProcListElement **lptr = &stopped_proc_list;

  /* Find the address of the NULL ptr at the end of the list */
  for (; *lptr!=NULL ; lptr = &((*lptr)->next))
    ; /* Do nothing */

  *lptr = (stoppedProcListElement *) malloc(sizeof(stoppedProcListElement));
  if (*lptr == NULL) return RDIError_OutOfStore;
  (*lptr)->fn = fn;
  (*lptr)->arg = arg;

  return RDIError_NoError;
}

static int CallStoppedProcs(unsigned reason)
{
  stoppedProcListElement *p = stopped_proc_list;
  int err=RDIError_NoError;
  
  for (; p!=NULL ; p=p->next) {
    int local_err = p->fn(reason, p->arg);
    if (local_err != RDIError_NoError) err=local_err;
  }

  return err;
}

/*----------------------------------------------------------------------*/
/*----angel_RDI_execute--------------------------------------------------*/
/*----------------------------------------------------------------------*/

static int HandleStoppedMessage(Packet *packet, void *stateptr) {
  unsigned int err,  reason, debugID, OSinfo1, OSinfo2, count;
  adp_stopped_struct *stopped_info;
  stopped_info = (adp_stopped_struct *) stateptr;
  IGNORE(stateptr);
  count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
                         &reason, &debugID,
                         &OSinfo1, &OSinfo2,
                         &stopped_info->stopped_reason, &stopped_info->data);
  DevSW_FreePacket(packet);

  if (reason != (ADP_Stopped | TtoH)) {
#ifdef DEBUG
    angel_DebugPrint("Expecting stopped message, got %x", reason);
#endif
    return RDIError_Error;
  }
  else {
    executing = FALSE;
#ifdef DEBUG
    angel_DebugPrint("Received stopped message.\n");
#endif
  }

  err = msgsend(CI_TADP,  "%w%w%w%w%w", (ADP_Stopped | HtoT), 0,
                ADP_HandleUnknown, ADP_HandleUnknown, RDIError_NoError);
#ifdef DEBUG
  angel_DebugPrint("Transmiting stopped acknowledge.\n");
#endif
  if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n");
#ifdef DEBUG
  angel_DebugPrint("DEBUG: Stopped reason : %x\n", stopped_info->stopped_reason);
#endif
  switch (stopped_info->stopped_reason) {
  case ADP_Stopped_BranchThroughZero:
    stopped_info->stopped_status = RDIError_BranchThrough0;
    break;
  case ADP_Stopped_UndefinedInstr:
    stopped_info->stopped_status = RDIError_UndefinedInstruction;
    break;
  case ADP_Stopped_SoftwareInterrupt:
    stopped_info->stopped_status = RDIError_SoftwareInterrupt;
    break;
  case ADP_Stopped_PrefetchAbort:
    stopped_info->stopped_status = RDIError_PrefetchAbort;
    break;
  case ADP_Stopped_DataAbort:
    stopped_info->stopped_status = RDIError_DataAbort;
    break;
  case ADP_Stopped_AddressException:
    stopped_info->stopped_status = RDIError_AddressException;
    break;
  case ADP_Stopped_IRQ:
    stopped_info->stopped_status = RDIError_IRQ;
    break;
  case ADP_Stopped_BreakPoint:
    stopped_info->stopped_status = RDIError_BreakpointReached;
    break;
  case ADP_Stopped_WatchPoint:
    stopped_info->stopped_status = RDIError_WatchpointAccessed;
    break;
  case ADP_Stopped_StepComplete:
    stopped_info->stopped_status = RDIError_ProgramFinishedInStep;
    break;
  case ADP_Stopped_RunTimeErrorUnknown:
  case ADP_Stopped_StackOverflow:
  case ADP_Stopped_DivisionByZero:
    stopped_info->stopped_status = RDIError_Error;
    break;
  case ADP_Stopped_FIQ:
    stopped_info->stopped_status = RDIError_FIQ;
    break;
  case ADP_Stopped_UserInterruption:
  case ADP_Stopped_OSSpecific:
    stopped_info->stopped_status = RDIError_UserInterrupt;
    break;
  case ADP_Stopped_ApplicationExit:
    stopped_info->stopped_status = RDIError_NoError;
    break;
  default:
    stopped_info->stopped_status = RDIError_Error;
    break;
  }
  return RDIError_NoError;
}


static void interrupt_target( void )
{
    Packet *packet = NULL;
    int err;
    int reason, debugID, OSinfo1, OSinfo2, status;

#ifdef DEBUG
    angel_DebugPrint("DEBUG: interrupt_target.\n");
#endif

    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w", ADP_InterruptRequest | HtoT, 0,
                   ADP_HandleUnknown, ADP_HandleUnknown);

    reason = ADP_InterruptRequest |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    DevSW_FreePacket(packet);
#ifdef DEBUG
    angel_DebugPrint("DEBUG: got interrupt ack ok err = %d, status=%i\n",
                     err, status);
#endif

    return;
}

#ifdef TEST_DC_APPL
  extern void test_dc_appl_handler( const DeviceDescr *device,
                                    Packet *packet );
#endif

void angel_RDI_stop_request(void)
{
  stop_request = 1;
}

/* Core functionality for execute and step */
static int angel_RDI_ExecuteOrStep(PointHandle *handle, word type, 
                                   unsigned ninstr)
{
  extern int (*ui_loop_hook) (int);
  int err;
  adp_stopped_struct stopped_info;
  void* stateptr = (void *)&stopped_info;
  ChannelCallback HandleStoppedMessageFPtr=(ChannelCallback) HandleStoppedMessage;
  int status, reasoncode, debugID, OSinfo1, OSinfo2;
  Packet *packet = NULL;

  TracePrint(("angel_RDI_ExecuteOrStep\n"));

  err = Adp_ChannelRegisterRead(CI_TADP,
                                HandleStoppedMessageFPtr, stateptr);
  if (err != RDIError_NoError) {
#ifdef DEBUG
    angel_DebugPrint("TADP Register failed.\n");
#endif
    return err;
  }
  /* Set executing TRUE here, as it must be set up before the target has
   * had any chance at all to execute, or it may send its stopped message
   * before we get round to setting executing = TRUE !!!
   */
  executing = TRUE;

  register_debug_message_handler();

#ifdef TEST_DC_APPL
  Adp_Install_DC_Appl_Handler( test_dc_appl_handler );
#endif

#ifdef DEBUG
  angel_DebugPrint("Transmiting %s message.\n",
                   type == ADP_Execute ? "execute": "step");
#endif

  register_debug_message_handler();
  /* Extra ninstr parameter for execute message will simply be ignored */
  err = msgsend(CI_HADP,"%w%w%w%w%w", type | HtoT, 0,
                ADP_HandleUnknown, ADP_HandleUnknown, ninstr);
#if DEBUG
  if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n");
#endif

  reasoncode = type | TtoH;
  err = wait_for_debug_message( &reasoncode, &debugID, &OSinfo1, &OSinfo2,
                                &status, &packet );
  if (err != RDIError_NoError)
     return err;
  else if (status != RDIError_NoError)
     return status;

#ifdef DEBUG
  angel_DebugPrint("Waiting for program to finish...\n");
#endif

  interrupt_request = FALSE;
  stop_request = FALSE;
  
  signal(SIGINT, ardi_sigint_handler);
  while( executing )
  {
    if (ui_loop_hook)
      ui_loop_hook(0);
    
    if (interrupt_request || stop_request)
      {
        interrupt_target();
        interrupt_request = FALSE;
        stop_request = FALSE;
      }
    Adp_AsynchronousProcessing( async_block_on_nothing );
  }
  signal(SIGINT, SIG_IGN);


#ifdef TEST_DC_APPL
  Adp_Install_DC_Appl_Handler( NULL );
#endif

  (void)Adp_ChannelRegisterRead(CI_TADP, NULL, NULL);

  *handle = (PointHandle)stopped_info.data;

  CallStoppedProcs(stopped_info.stopped_reason);

  return stopped_info.stopped_status;
}

/* Request that the target starts executing from the stored CPU state: use
   ADP_Execute. */
int angel_RDI_execute(PointHandle *handle)
{
    return angel_RDI_ExecuteOrStep(handle, ADP_Execute, 0);
}

#ifdef __WATCOMC__
typedef void handlertype(int);

static int interrupted=0;

static void myhandler(int sig) {
  IGNORE(sig);
  interrupted=1;
  signal(SIGINT, myhandler);
}
#endif

/*----------------------------------------------------------------------*/
/*----angel_RDI_step-----------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Step 'ninstr' through the code: use ADP_Step. */
int angel_RDI_step(unsigned ninstr, PointHandle *handle)
{
    int err = angel_RDI_ExecuteOrStep(handle, ADP_Step, ninstr);
    if (err == RDIError_ProgramFinishedInStep)
       return RDIError_NoError;
    else
       return err;
}


static void SetCPWords(int cpnum, struct Dbg_CoProDesc const *cpd) {
  int i, rmax = 0;
  for (i = 0; i < cpd->entries; i++)
    if (cpd->regdesc[i].rmax > rmax)
      rmax = cpd->regdesc[i].rmax;

  { unsigned char *rmap = (unsigned char *)malloc(rmax + 2);
    *rmap++ = rmax + 1;
    for (i = 0; i < cpd->entries; i++) {
      int r;
      for (r = cpd->regdesc[i].rmin; r <= cpd->regdesc[i].rmax; r++)
        rmap[r] = (cpd->regdesc[i].nbytes+3) / 4;
      }
/*    if (cpwords[cpnum] != NULL) free(cpwords[cpnum]); */
    cpwords[cpnum] = rmap;
  }
}

/*----------------------------------------------------------------------*/
/*----angel_RDI_info-----------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Use ADP_Info, ADP_Ctrl and ADP_Profile calls to implement these,
   see adp.h for more details. */

static int angel_cc_exists( void )
{
  Packet *packet = NULL;
  int err;
  int reason, debugID, OSinfo1, OSinfo2, subreason, status;

#ifdef DEBUG
  angel_DebugPrint("DEBUG: ADP_ICEB_CC_Exists.\n");
#endif

  if ( angel_RDI_info( RDIInfo_Icebreaker, NULL, NULL ) == RDIError_NoError ) {
    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w", ADP_ICEbreakerHADP | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown,
            ADP_ICEB_CC_Exists );
    reason = ADP_ICEbreakerHADP |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
                   &debugID, &OSinfo1, &OSinfo2,  &subreason, &status);
    if (subreason !=  ADP_ICEB_CC_Exists) {
      DevSW_FreePacket(packet);
      return RDIError_Error;
    }
    else
      return status;
  }
  else
    return RDIError_UnimplementedMessage;
}

typedef struct {
  RDICCProc_ToHost *tohost; void *tohostarg;
  RDICCProc_FromHost *fromhost; void *fromhostarg;
  bool registered;
} CCState;
static CCState ccstate = { NULL, NULL, NULL, NULL, FALSE };

static void HandleDCCMessage( Packet *packet, void *stateptr )
{
  unsigned int reason, debugID, OSinfo1, OSinfo2;
  int count;
  CCState *ccstate_p = (CCState *)stateptr;

  count = unpack_message( BUFFERDATA(packet->pk_buffer), "%w%w%w%w",
                          &reason, &debugID, &OSinfo1, &OSinfo2 );
  switch ( reason )
  {
      case ADP_TDCC_ToHost | TtoH:
      {
           /* only handles a single word of data, for now */

          unsigned int nbytes, data;

          unpack_message( BUFFERDATA(packet->pk_buffer)+count, "%w%w",
                          &nbytes, &data );
#ifdef DEBUG
          angel_DebugPrint( "DEBUG: received CC_ToHost message: nbytes %d data %08x.\n",
                  nbytes, data );
#endif
          ccstate_p->tohost( ccstate_p->tohostarg, data );
          msgsend(CI_TTDCC, "%w%w%w%w%w",
                  ADP_TDCC_ToHost | HtoT, debugID, OSinfo1, OSinfo2,
                  RDIError_NoError );
          break;
      }

      case ADP_TDCC_FromHost | TtoH:
      {
           /* only handles a single word of data, for now */

          int valid;
          ARMword data;

          ccstate_p->fromhost( ccstate_p->fromhostarg, &data, &valid );
#ifdef DEBUG
          angel_DebugPrint( "DEBUG: received CC_FromHost message, returning: %08x %s.\n",
                  data, valid ? "VALID" : "INvalid" );
#endif
          msgsend(CI_TTDCC, "%w%w%w%w%w%w%w",
                  ADP_TDCC_FromHost | HtoT, debugID, OSinfo1, OSinfo2,
                  RDIError_NoError, valid ? 1 : 0, data );
          break;
      }

      default:
#ifdef DEBUG
      angel_DebugPrint( "Unexpected TDCC message %08x received\n", reason );
#endif
      break;
  }
  DevSW_FreePacket(packet);
  return;
}

static void angel_check_DCC_handler( CCState *ccstate_p )
{
    int err;

    if ( ccstate_p->tohost != NULL || ccstate_p->fromhost != NULL )
    {
        /* doing DCC, so need a handler */
        if ( ! ccstate_p->registered )
        {
#ifdef DEBUG
            angel_DebugPrint( "Registering handler for TTDCC channel.\n" );
#endif
            err = Adp_ChannelRegisterRead( CI_TTDCC, HandleDCCMessage,
                                           ccstate_p );
            if ( err == adp_ok )
               ccstate_p->registered = TRUE;
#ifdef DEBUG
            else
               angel_DebugPrint( "angel_check_DCC_handler: register failed!\n" );
#endif
        }
    }
    else
    {
        /* not doing DCC, so don't need a handler */
        if ( ccstate_p->registered )
        {
#ifdef DEBUG
            angel_DebugPrint( "Unregistering handler for TTDCC channel.\n" );
#endif
            err = Adp_ChannelRegisterRead( CI_TTDCC, NULL, NULL );
            if ( err == adp_ok )
               ccstate_p->registered = FALSE;
#ifdef DEBUG
            else
               angel_DebugPrint( "angel_check_DCC_handler: unregister failed!\n" );
#endif
        }
    }
}


static int CheckSubMessageReply(int reason, int subreason) {
  Packet *packet = NULL;
  int status, debugID, OSinfo1, OSinfo2;
  int err = RDIError_NoError;
  reason |= TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                               &status, &packet);
  if (err != RDIError_NoError) {
    status = err;
  } else {
    int sr;
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
                   &OSinfo1, &OSinfo2, &sr, &status);
    if (subreason != sr) status = RDIError_Error;
  }
  DevSW_FreePacket(packet);
  return status;
}

static int SendSubMessageAndCheckReply(int reason, int subreason) {
  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0,
          ADP_HandleUnknown, ADP_HandleUnknown,
          subreason);
  return CheckSubMessageReply(reason, subreason);
}

static int SendSubMessageWordAndCheckReply(int reason, int subreason, ARMword word) {
  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w%w", reason | HtoT, 0,
          ADP_HandleUnknown, ADP_HandleUnknown,
          subreason, word);
  return CheckSubMessageReply(reason, subreason);
}

static int SendSubMessageGetWordAndCheckReply(int reason, int subreason, ARMword *resp) {
  Packet *packet = NULL;
  int status, debugID, OSinfo1, OSinfo2;
  int err = RDIError_NoError;

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0,
          ADP_HandleUnknown, ADP_HandleUnknown,
          subreason);
  reason |= TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                               &status, &packet);
  if (err != RDIError_NoError) {
    status = err;
  } else {
    int sr;
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w", &reason, &debugID,
                   &OSinfo1, &OSinfo2,  &sr, &status, resp);
    if (subreason != sr) status = RDIError_Error;
  }
  DevSW_FreePacket(packet);
  return status;
}

static int const hostsex = 1;

int angel_RDI_info(unsigned type, ARMword *arg1, ARMword *arg2) {
  Packet *packet = NULL;
  int len, status, c, reason, subreason, debugID, OSinfo1, OSinfo2;
  int err=RDIError_NoError, cpnum=0;
  struct Dbg_CoProDesc *cpd;
  int count, i;
  unsigned char *bp;

#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_info.\n");
#endif
  switch (type) {
  case RDIInfo_Target:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_Target.\n");
#endif

    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
                 ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Target);
    reason = ADP_Info |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
                   &debugID, &OSinfo1, &OSinfo2,  &subreason, &status,
                   arg1, arg2);
    DevSW_FreePacket(packet);

    if (subreason !=  ADP_Info_Target)
      return RDIError_Error;
    else
      return status;

  case RDISignal_Stop:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDISignal_Stop.\n");
    if (interrupt_request)
       angel_DebugPrint("       STILL WAITING to send previous interrupt request\n");
#endif
    interrupt_request = TRUE;
    return RDIError_NoError;

  case RDIInfo_Points:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_Points.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Points, arg1);

  case RDIInfo_Step:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_Step.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Step, arg1);

  case RDISet_Cmdline:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDISet_Cmdline.\n");
#endif
    if (ardi_commandline != &dummycline)
      free(ardi_commandline);
    ardi_commandline = (char *)malloc(strlen((char*)arg1) + 1) ;
    (void)strcpy(ardi_commandline, (char *)arg1) ;
    return RDIError_NoError;

  case RDIInfo_SetLog:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_SetLog.\n");
#endif
    rdi_log = (int) *arg1;
    return RDIError_NoError;

  case RDIInfo_Log:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_Log.\n");
#endif
    *arg1 = rdi_log;
    return RDIError_NoError;


  case RDIInfo_MMU:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_MMU.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_MMU, arg1);

  case RDIInfo_SemiHosting:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_SemiHosting.\n");
#endif
    return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_SemiHosting);

  case RDIInfo_CoPro:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_CoPro.\n");
#endif
    return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CoPro);

  case RDICycles:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDICycles.\n");
#endif
    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Cycles);
    reason = ADP_Info |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
                 &OSinfo1, &OSinfo2,  &subreason, &status);
    DevSW_FreePacket(packet);
    if (subreason !=  ADP_Info_Cycles)
      return RDIError_Error;
    if (status != RDIError_NoError) return status;
    for (c=0; c<12; c++)
      arg1[c]=GET32LE(BUFFERDATA(packet->pk_buffer)+24+(c*4));
    return status;

  case RDIInfo_DescribeCoPro:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_DescribeCoPro.\n");
#endif
    cpnum = *(int *)arg1;
    cpd = (struct Dbg_CoProDesc *)arg2;
    packet = DevSW_AllocatePacket(Armsd_BufferSize);
    if (angel_RDI_info(ADP_Info_CoPro, NULL, NULL) != RDIError_NoError)
      return RDIError_Error;
    len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0,
                   ADP_HandleUnknown, ADP_HandleUnknown,
                   ADP_Info_DescribeCoPro);
    len +=msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b%b%b%b%b", cpnum,
                   cpd->regdesc[cpnum].rmin, cpd->regdesc[cpnum].rmax,
                   cpd->regdesc[cpnum].nbytes, cpd->regdesc[cpnum].access);
    if (cpd->regdesc[cpnum].access&0x3 == 0x3){
      len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b",
                      cpd->regdesc[cpnum].accessinst.cprt.read_b0,
                      cpd->regdesc[cpnum].accessinst.cprt.read_b1,
                      cpd->regdesc[cpnum].accessinst.cprt.write_b0,
                      cpd->regdesc[cpnum].accessinst.cprt.write_b1, 0xff);
    }
    else {
      len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b%",
                      cpd->regdesc[cpnum].accessinst.cpdt.rdbits,
                      cpd->regdesc[cpnum].accessinst.cpdt.nbit,0,0, 0xff);
    }
    register_debug_message_handler();
    packet->pk_length = len;
    Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
    reason = ADP_Info |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
                   &OSinfo1, &OSinfo2, &subreason, &status);
    DevSW_FreePacket(packet);
    if (subreason != ADP_Info_DescribeCoPro)
      return RDIError_Error;
    else
      return status;

  case RDIInfo_RequestCoProDesc:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: RDIInfo_RequestCoProDesc.\n");
#endif
    cpnum = *(int *)arg1;
    cpd = (struct Dbg_CoProDesc *)arg2;
    packet = DevSW_AllocatePacket(Armsd_BufferSize);
    len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0,
                   ADP_HandleUnknown, ADP_HandleUnknown,
                   ADP_Info_RequestCoProDesc);
    len += msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b", *(int *)arg1);
    packet->pk_length = len;
    register_debug_message_handler();
    Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
    reason = ADP_Info |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
                           &debugID, &OSinfo1, &OSinfo2,  &subreason, &status);
    if (subreason !=  ADP_Info_RequestCoProDesc) {
      DevSW_FreePacket(packet);
      return RDIError_Error;
    } else if ( status != RDIError_NoError ) {
      DevSW_FreePacket(packet);
      return status;
    } else {
      bp = BUFFERDATA(packet->pk_buffer)+count;
      for ( i = 0; *bp != 0xFF && i < cpd->entries; ++i ) {
        cpd->regdesc[i].rmin = *bp++;
        cpd->regdesc[i].rmax = *bp++;
        cpd->regdesc[i].nbytes = *bp++;
        cpd->regdesc[i].access = *bp++;
      }
      cpd->entries = i;
      if ( *bp != 0xFF )
        status = RDIError_BufferFull;
      else
        SetCPWords( cpnum, cpd );
      DevSW_FreePacket(packet);
      return status;
    }

  case RDIInfo_GetLoadSize:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize.\n");
#endif
    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown,
            ADP_Info_AngelBufferSize);
    reason = ADP_Info |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
                   &debugID, &OSinfo1, &OSinfo2,  &subreason, &status);
    if (subreason !=  ADP_Info_AngelBufferSize) {
      DevSW_FreePacket(packet);
      return RDIError_Error;
    }
    else {
      word defaultsize, longsize;
      unpack_message(BUFFERDATA(packet->pk_buffer)+24, "%w%w",
                     &defaultsize, &longsize);
      *arg1 = longsize - ADP_WriteHeaderSize;   /* space for ADP header */
#ifdef MONITOR_DOWNLOAD_PACKETS
      angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize: got (%d, %d), returning %d.\n",
             defaultsize, longsize, *arg1);
#endif
      DevSW_FreePacket(packet);
      return status;
    }

  case RDIVector_Catch:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_VectorCatch %lx.\n", *arg1);
#endif
    return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_VectorCatch, *arg1);

  case RDISemiHosting_SetState:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetState %lx.\n", *arg1);
#endif
    return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetState, *arg1);

  case RDISemiHosting_GetState:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetState.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetState, arg1);

  case RDISemiHosting_SetVector:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetVector %lx.\n", *arg1);
#endif
    return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetVector, *arg1);

  case RDISemiHosting_GetVector:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetVector.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetVector, arg1);

  case RDISemiHosting_SetARMSWI:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetARMSWI.\n");
#endif
    return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetARMSWI, *arg1);

  case RDISemiHosting_GetARMSWI:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetARMSWI.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetARMSWI, arg1);

  case RDISemiHosting_SetThumbSWI:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetThumbSWI.\n");
#endif
    return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetThumbSWI, *arg1);

  case RDISemiHosting_GetThumbSWI:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetThumbSWI.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetThumbSWI, arg1);

  case RDIInfo_SetTopMem:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_SetTopMem.\n");
#endif
    return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SetTopMem, *arg1);

  case RDIPointStatus_Watch:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Watch.\n");
#endif
    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown,
            ADP_Ctrl_PointStatus_Watch, *arg1 );
    reason = ADP_Control |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
                   &debugID, &OSinfo1, &OSinfo2,  &subreason, &status,
                   arg1, arg2);
    if (subreason !=  ADP_Ctrl_PointStatus_Watch) {
      DevSW_FreePacket(packet);
      return RDIError_Error;
    }
    else
      return status;

  case RDIPointStatus_Break:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Break.\n");
#endif
    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown,
            ADP_Ctrl_PointStatus_Break, *arg1 );
    reason = ADP_Control |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    }
    unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
                   &debugID, &OSinfo1, &OSinfo2,  &subreason, &status,
                   arg1, arg2);
    if (subreason !=  ADP_Ctrl_PointStatus_Break) {
      DevSW_FreePacket(packet);
      return RDIError_Error;
    }
    else
      return status;

  case RDIInfo_DownLoad:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Ctrl_Download_Supported.\n");
#endif
    return SendSubMessageAndCheckReply(ADP_Control, ADP_Ctrl_Download_Supported);

  case RDIConfig_Count:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEM_ConfigCount.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_ICEman, ADP_ICEM_ConfigCount, arg1);

  case RDIConfig_Nth:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEM_ConfigNth.\n");
#endif
    register_debug_message_handler();
    msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT, 0,
            ADP_HandleUnknown, ADP_HandleUnknown,
            ADP_ICEM_ConfigNth, *arg1 );
    reason = ADP_ICEman |TtoH;
    err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
    if (err != RDIError_NoError) {
      DevSW_FreePacket(packet);
      return err;
    } else {
      RDI_ConfigDesc *cd = (RDI_ConfigDesc *)arg2;
      unsigned char n;
      len = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%b",
                           &reason, &debugID,
                           &OSinfo1, &OSinfo2,  &subreason, &status,
                           &cd->version, &n);
      if (subreason !=  ADP_ICEM_ConfigNth) {
        DevSW_FreePacket(packet);
        return RDIError_Error;
      }
      else {
        memcpy( cd->name, BUFFERDATA(packet->pk_buffer)+len, n+1 );
        cd->name[n] = 0;
        return status;
      }
    }

  case RDIInfo_Icebreaker:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEB_Exists.\n");
#endif
    return SendSubMessageAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_Exists);

  case RDIIcebreaker_GetLocks:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEB_GetLocks.\n");
#endif
    return SendSubMessageGetWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_GetLocks, arg1);

  case RDIIcebreaker_SetLocks:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEB_SetLocks.\n");
#endif
    return SendSubMessageWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_SetLocks, *arg1);

  case RDICommsChannel_ToHost:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_ToHost.\n");
#endif
    if ( angel_cc_exists() == RDIError_NoError ) {

    /*
     * The following three lines of code have to be removed in order to get
     * the Windows Angel Channel Viewer working with the Thumb comms channel.
     * At the moment it allows the ARMSD command line to register a CCIN/CCOUT
     * callback which stops the ACV working!
     */
#ifdef __unix
      ccstate.tohost = (RDICCProc_ToHost *)arg1;
      ccstate.tohostarg = arg2;
      angel_check_DCC_handler( &ccstate );
#endif
#ifdef _WIN32
      
#endif

      register_debug_message_handler();
      msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0,
              ADP_HandleUnknown, ADP_HandleUnknown,
              ADP_ICEB_CC_Connect_ToHost, (arg1 != NULL) );
      return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_ToHost);
    } else {
      return RDIError_UnimplementedMessage;
    }

  case RDICommsChannel_FromHost:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_FromHost.\n");
#endif
    if ( angel_cc_exists() == RDIError_NoError ) {

      ccstate.fromhost = (RDICCProc_FromHost *)arg1;
      ccstate.fromhostarg = arg2;
      angel_check_DCC_handler( &ccstate );

      register_debug_message_handler();
      msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0,
              ADP_HandleUnknown, ADP_HandleUnknown,
              ADP_ICEB_CC_Connect_FromHost, (arg1 != NULL) );
      return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_FromHost);
    } else {
      return RDIError_UnimplementedMessage;
    }

  case RDIProfile_Stop:
    return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_Stop);

  case RDIProfile_ClearCounts:
    return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_ClearCounts);

  case RDIProfile_Start:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: ADP_Profile_Start %ld.\n", (long)*arg1);
#endif
    return SendSubMessageWordAndCheckReply(ADP_Profile, ADP_Profile_Start, *arg1);

  case RDIProfile_WriteMap:
    { RDI_ProfileMap *map = (RDI_ProfileMap *)arg1;
      int32 maplen = map->len,
            offset,
            size;
      int32 chunk = (Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_ProfileWriteHeaderSize) / sizeof(ARMword);
                     /* Maximum number of words sendable in one message */
      int oldrev = bytesex_reversing();
      int host_little = *(uint8 const *)&hostsex;
#ifdef DEBUG
      angel_DebugPrint("DEBUG: ADP_Profile_WriteMap %ld.\n", maplen);
#endif
      status = RDIError_NoError;
      if (!host_little) {
        bytesex_reverse(1);
        for (offset = 0; offset < maplen; offset++)
          map->map[offset] = bytesex_hostval(map->map[offset]);
      }
      for (offset = 0; offset < maplen; offset += size) {
        unsigned hdrlen;
        size = maplen - offset;
        packet = (Packet *)DevSW_AllocatePacket(Armsd_LongBufSize);
        if (size > chunk) size = chunk;
        hdrlen = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
                          ADP_Profile | HtoT, 0, ADP_HandleUnknown,
                          ADP_HandleUnknown, ADP_Profile_WriteMap,
                          maplen, size, offset);

        /* Copy the data into the packet. */
        memcpy(BUFFERDATA(packet->pk_buffer)+hdrlen,
               &map->map[offset], (size_t)size * sizeof(ARMword));
        packet->pk_length = size * sizeof(ARMword) + hdrlen;
        register_debug_message_handler();
        Adp_ChannelWrite(CI_HADP, packet);
        reason = ADP_Profile | TtoH;
        err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                     &status, &packet);
        if (err == RDIError_NoError) {
          unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
                         &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
          if (subreason !=  ADP_Profile_WriteMap) {
            err = RDIError_Error;
          }
          DevSW_FreePacket(packet);
        }
        if (err != RDIError_NoError) { status = err; break; }
      }
      if (!host_little) {
        for (offset = 0; offset < maplen; offset++)
          map->map[offset] = bytesex_hostval(map->map[offset]);
        bytesex_reverse(oldrev);
      }
      return status;
    }

  case RDIProfile_ReadMap:
    { int32 maplen = *(int32 *)arg1,
            offset = 0,
            size;
      int32 chunk = (Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ProfileReadHeaderSize) / sizeof(ARMword);
#ifdef DEBUG
      angel_DebugPrint("DEBUG: ADP_Profile_ReadMap %ld.\n", maplen);
#endif
      status = RDIError_NoError;
      for (offset = 0; offset < maplen; offset += size) {
        size = maplen - offset;
        if (size > chunk) size = chunk;
        register_debug_message_handler();
        msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Profile | HtoT, 0,
                ADP_HandleUnknown, ADP_HandleUnknown,
                ADP_Profile_ReadMap, offset, size);
        reason = ADP_Profile | TtoH;
        err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                                     &status, &packet);
        if (err != RDIError_NoError) return err;
        unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
                       &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
        memcpy(&arg2[offset], BUFFERDATA(packet->pk_buffer)+ADP_ProfileReadHeaderSize,
               size * sizeof(ARMword));
        DevSW_FreePacket(packet);
        if (status != RDIError_NoError) break;
      }
      { int oldrev = bytesex_reversing();
        int host_little = *(uint8 const *)&hostsex;
        if (!host_little) {
          bytesex_reverse(1);
          for (offset = 0; offset < maplen; offset++)
            arg2[offset] = bytesex_hostval(arg2[offset]);
        }
        bytesex_reverse(oldrev);
      }
      return status;
    }

  case RDIInfo_CanTargetExecute:
#ifdef DEBUG
    printf("DEBUG: RDIInfo_CanTargetExecute.\n");
#endif
    return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CanTargetExecute);

  case RDIInfo_AgentEndianess:
    return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_AgentEndianess);

  default:
#ifdef DEBUG
    angel_DebugPrint("DEBUG: Fell through ADP_Info, default case taken.\n");
    angel_DebugPrint("DEBUG: type = 0x%x.\n", type);
#endif
    if (type & RDIInfo_CapabilityRequest) {
      switch (type & ~RDIInfo_CapabilityRequest) {
        case RDISemiHosting_SetARMSWI:
          return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_ChangeableSHSWI);
        default:
#ifdef DEBUG
          angel_DebugPrint(
          "DEBUG: ADP_Info - Capability Request(%d) - reporting unimplemented \n",
                 type & ~RDIInfo_CapabilityRequest);
#endif
          break;
      }
    }
    return RDIError_UnimplementedMessage;
  }
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_AddConfig------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Add a configuration: use ADP_ICEM_AddConfig. */
int angel_RDI_AddConfig(unsigned long nbytes) {
  Packet *packet = NULL;
  int status, reason, subreason, debugID, OSinfo1, OSinfo2, err;

#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_AddConfig.\n");
#endif
  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT,
          0, ADP_HandleUnknown, ADP_HandleUnknown,
          ADP_ICEM_AddConfig, nbytes);
  reason=ADP_ICEman | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return -1;
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
                 &OSinfo1, &OSinfo2, &subreason, &status);
  DevSW_FreePacket(packet);
  if ( subreason != ADP_ICEM_AddConfig )
    return RDIError_Error;
  else
    return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_LoadConfigData-------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Load configuration data: use ADP_Ctrl_Download_Data. */
int angel_RDI_LoadConfigData(unsigned long nbytes, char const *data) {
  Packet *packet = NULL;
  int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err;

#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_LoadConfigData (%d bytes)\n", nbytes);
#endif
#if 0
  if (err = angel_RDI_AddConfig(nbytes) != RDIError_NoError)
    return err;
#endif
  packet = DevSW_AllocatePacket(Armsd_LongBufSize);
  len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
                 ADP_Control | HtoT, 0,
                 ADP_HandleUnknown, ADP_HandleUnknown,
                 ADP_Ctrl_Download_Data, nbytes);
  memcpy(BUFFERDATA(packet->pk_buffer)+len, data, nbytes);
  len += nbytes;
  packet->pk_length = len;
#ifdef DEBUG
  angel_DebugPrint("DEBUG: packet len %d.\n", len);
#endif
  register_debug_message_handler();
  Adp_ChannelWrite(CI_HADP, packet);
  reason=ADP_Control | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return -1;
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
                 &OSinfo1, &OSinfo2, &subreason, &status);
  DevSW_FreePacket(packet);
  if ( subreason != ADP_Ctrl_Download_Data )
    return RDIError_Error;
  else
    return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_SelectConfig---------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Select a configuration: use ADP_ICEM_SelecConfig.*/
int angel_RDI_SelectConfig(RDI_ConfigAspect aspect, char const *name,
                           RDI_ConfigMatchType matchtype, unsigned versionreq,
                            unsigned *versionp)
{
  Packet *packet = NULL;
  int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err;

#ifdef DEBUG
  angel_DebugPrint("DEBUG: Entered angel_RDI_SelectConfig.\n");
#endif
  packet = DevSW_AllocatePacket(Armsd_BufferSize);
  len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b%b%b%w",
                 ADP_ICEman | HtoT, 0,
                 ADP_HandleUnknown, ADP_HandleUnknown,
                 ADP_ICEM_SelectConfig, aspect, strlen(name),
                 matchtype, versionreq);
  /* copy the name into the buffer */
  memcpy(BUFFERDATA(packet->pk_buffer)+len, name, strlen(name));
  len += strlen(name);
  packet->pk_length = len;
  register_debug_message_handler();
  Adp_ChannelWrite(CI_HADP, packet);
  reason=ADP_ICEman | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return err;
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w",
                 &reason, &debugID, &OSinfo1, &OSinfo2,
                 &subreason, &status, versionp);
  DevSW_FreePacket(packet);
  if ( subreason != ADP_ICEM_SelectConfig )
    return RDIError_Error;
  else
    return status;
}


/*----------------------------------------------------------------------*/
/*----angel_RDI_LoadAgent------------------------------------------------*/
/*----------------------------------------------------------------------*/

/* Load a new debug agent: use ADP_Ctrl_Download_Agent. */
int angel_RDI_LoadAgent(ARMword dest, unsigned long size,
                       getbufferproc *getb, void *getbarg)
{
  Packet *packet = NULL;
  int  status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
  time_t t;

#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
  angel_DebugPrint("DEBUG: Entered angel_RDI_LoadAgent.\n");
#endif
  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Control | HtoT,
          0, ADP_HandleUnknown, ADP_HandleUnknown,
          ADP_Ctrl_Download_Agent, dest, size);
  reason=ADP_Control | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return -1;
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
                 &OSinfo1, &OSinfo2, &subreason, &status);
    DevSW_FreePacket(packet);
  if ( subreason != ADP_Ctrl_Download_Agent )
    return RDIError_Error;
  if ( status != RDIError_NoError )
    return status;

#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
  angel_DebugPrint("DEBUG: starting agent data download.\n");
#endif
  { unsigned long pos = 0, segsize;
    for (; pos < size; pos += segsize) {
      char *b = getb(getbarg, &segsize);
      if (b == NULL) return RDIError_NoError;
      err = angel_RDI_LoadConfigData( segsize, b );
      if (err != RDIError_NoError) return err;
    }
  }
#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
  angel_DebugPrint("DEBUG: finished downloading new agent.\n");
#endif

  /* renegotiate back down */
  err = angel_negotiate_defaults();
  if (err != adp_ok)
     return err;

  /* Output a message to tell the user what is going on.  This is vital
   * when switching from ADP EICE to ADP over JTAG, as then the user
   * has to reset the target board !
   */
  { char msg[256];
    int len=angel_RDI_errmess(msg, 256, adp_new_agent_starting);
    angel_hostif->write(angel_hostif->hostosarg, msg, len);
  }

  /* get new image started */
#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
  angel_DebugPrint("DEBUG: sending start message for new agent.\n");
#endif

  register_debug_message_handler();
  msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT,
          0, ADP_HandleUnknown, ADP_HandleUnknown,
          ADP_Ctrl_Start_Agent, dest);
  reason=ADP_Control | TtoH;
  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
                              &status, &packet);
  if (err != RDIError_NoError) {
    DevSW_FreePacket(packet);
    return -1;
  }
  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
                 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
    DevSW_FreePacket(packet);
  if ( subreason != ADP_Ctrl_Start_Agent )
    return RDIError_Error;
  if ( status != RDIError_NoError )
    return status;

  /* wait for image to start up */
  heartbeat_enabled = FALSE;
  t=time(NULL);
  do {
    Adp_AsynchronousProcessing(async_block_on_nothing);
    if ((time(NULL)-t) > 2) {
#ifdef DEBUG
      angel_DebugPrint("DEBUG: no booted message from new image yet.\n");
#endif
      break;
    }
  } while (booted_not_received);
  booted_not_received=1;

  /* Give device driver a chance to do any necessary resyncing with new agent.
   * Only used by etherdrv.c at the moment.
   */
  (void)Adp_Ioctl( DC_RESYNC, NULL );

#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
  angel_DebugPrint("DEBUG: reopening to new agent.\n");
#endif
  err = angel_RDI_open(0, NULL, NULL, NULL);
  switch ( err )
  {
      case RDIError_NoError:
      {
#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
          angel_DebugPrint( "LoadAgent: Open returned RDIError_NoError\n" );
#endif
          break;
      }

      case RDIError_LittleEndian:
      {
#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
          angel_DebugPrint( "LoadAgent: Open returned RDIError_LittleEndian (OK)\n" );
#endif
          err = RDIError_NoError;
          break;
      }

      case RDIError_BigEndian:
      {
#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
          angel_DebugPrint( "LoadAgent: Open returned RDIError_BigEndian (OK)\n" );
#endif
          err = RDIError_NoError;
          break;
      }

      default:
      {
#if defined(DEBUG) || defined(DEBUG_LOADAGENT)
          angel_DebugPrint( "LoadAgent: Open returned %d - unexpected!\n", err );
#endif
          break;
      }
  }
#ifndef NO_HEARTBEAT
  heartbeat_enabled = TRUE;
#endif
  return err;
}

static int angel_RDI_errmess(char *buf, int blen, int errnum) {
  char *s=NULL;
  int n;

  switch (errnum) {
    case adp_malloc_failure:
      s=AdpMess_MallocFailed; break;
    case adp_illegal_args:
      s=AdpMess_IllegalArgs; break;
    case adp_device_not_found:
      s=AdpMess_DeviceNotFound; break;
    case adp_device_open_failed:
      s=AdpMess_DeviceOpenFailed; break;
    case adp_device_already_open:
      s=AdpMess_DeviceAlreadyOpen; break;
    case adp_device_not_open:
      s=AdpMess_DeviceNotOpen; break;
    case adp_bad_channel_id:
      s=AdpMess_BadChannelId; break;
    case adp_callback_already_registered:
      s=AdpMess_CBAlreadyRegd; break;
    case adp_write_busy:
      s=AdpMess_WriteBusy; break;
    case adp_bad_packet:
      s=AdpMess_BadPacket; break;
    case adp_seq_high:
      s=AdpMess_SeqHigh; break;
    case adp_seq_low:
      s=AdpMess_SeqLow; break;
    case adp_timeout_on_open:
      s=AdpMess_TimeoutOnOpen; break;
    case adp_failed:
      s=AdpMess_Failed; break;
    case adp_abandon_boot_wait:
      s=AdpMess_AbandonBootWait; break;
    case adp_late_startup:
      s=AdpMess_LateStartup; break;
    case adp_new_agent_starting:
      s=AdpMess_NewAgentStarting; break;
    default: return 0;
  }
  n=strlen(s);
  if (n>blen-1) n=blen-1;
  memcpy(buf, s, n);
  buf[n++]=0;
  return n;
}

extern const struct RDIProcVec angel_rdi;
const struct RDIProcVec angel_rdi = {
    "ADP",
    angel_RDI_open,
    angel_RDI_close,
    angel_RDI_read,
    angel_RDI_write,
    angel_RDI_CPUread,
    angel_RDI_CPUwrite,
    angel_RDI_CPread,
    angel_RDI_CPwrite,
    angel_RDI_setbreak,
    angel_RDI_clearbreak,
    angel_RDI_setwatch,
    angel_RDI_clearwatch,
    angel_RDI_execute,
    angel_RDI_step,
    angel_RDI_info,
    angel_RDI_pointinq,

    angel_RDI_AddConfig,
    angel_RDI_LoadConfigData,
    angel_RDI_SelectConfig,

    0, /*angel_RDI_drivernames,*/
    0,   /* cpunames */

    angel_RDI_errmess,

    angel_RDI_LoadAgent
};

/* EOF ardi.c */

/* Not strictly necessary, but allows linking this code into armsd. */

struct foo {
    char *name;
    int (*action)();
    char *syntax;
    char **helpmessage;
    int doafterend;
    int dobeforestart;
    int doinmidline;
} hostappl_CmdTable[1] = {{"", NULL}};

void
hostappl_Init()
{
}

int
hostappl_Backstop()
{
  return -30;
}