gdb/rdi-share/ardi.c

   1 /*
   2  * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
   3  *
   4  * This software may be freely used, copied, modified, and distributed
   5  * provided that the above copyright notice is preserved in all copies of the
   6  * software.
   7  */
   8
   9 /*
  10  * ARDI.c
  11  * Angel Remote Debug Interface
  12  *
  13  *
  14  * $Revision$
  15  *     $Date$
  16  *
  17  * This file is based on /plg/pisd/rdi.c, but instead of using RDP it uses
  18  * ADP messages.
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #define uint HIDE_HPs_uint
  26 #include <signal.h>
  27 #undef uint
  28
  29
  30 #include "endian.h"
  31 #include "ardi.h"
  32 #include "buffers.h"
  33 #include "channels.h"
  34 #include "hostchan.h"
  35 #include "host.h"
  36 #include "bytesex.h"
  37 #include "dbg_cp.h"
  38 #include "adp.h"
  39 #include "hsys.h"
  40 #include "logging.h"
  41 #include "msgbuild.h"
  42 #include "rxtx.h"
  43 #include "devsw.h"
  44 #include "params.h"
  45
  46 #ifdef COMPILING_ON_WINDOWS
  47 #  define IGNORE(x) (x = x)   /* must go after #includes to work on Windows */
  48 #endif
  49 #define NOT(x) (!(x))
  50
  51 #define ADP_INITIAL_TIMEOUT_PERIOD 5
  52
  53 static volatile int executing;
  54 static int rdi_log = 0 ; /* debugging  ? */
  55
  56 /* we need a starting point for our first buffers, this is a safe one */
  57 int Armsd_BufferSize = ADP_BUFFER_MIN_SIZE;
  58 int Armsd_LongBufSize = ADP_BUFFER_MIN_SIZE;
  59
  60 #ifdef WIN32
  61   extern int interrupted;
  62   extern int swiprocessing;
  63 #endif
  64
  65 static char dummycline = 0;
  66 char *ardi_commandline = &dummycline ; /* exported in ardi.h */
  67
  68 extern unsigned int heartbeat_enabled;
  69
  70 static unsigned char *cpwords[16];
  71
  72 typedef struct stoppedProcListElement {
  73   struct stoppedProcListElement *next;
  74   angel_RDI_TargetStoppedProc *fn;
  75   void *arg;
  76 } stoppedProcListElement;
  77
  78 static stoppedProcListElement *stopped_proc_list=NULL;
  79
  80 const struct Dbg_HostosInterface *angel_hostif;
  81 static hsys_state *hstate;
  82
  83 static void angel_DebugPrint(const char *format, ...)
  84 { va_list ap;
  85   va_start(ap, format);
  86   angel_hostif->dbgprint(angel_hostif->dbgarg, format, ap);
  87   va_end(ap);
  88 }
  89
  90 #ifdef RDI_VERBOSE
  91 #define TracePrint(s) \
  92   if (rdi_log & 2) angel_DebugPrint("\n"); \
  93   if (rdi_log & 1) angel_DebugPrint s
  94 #else
  95 #define TracePrint(s)
  96 #endif
  97
  98 typedef struct receive_dbgmsg_state {
  99   volatile int received;
 100   Packet *packet;
 101 } receive_dbgmsg_state;
 102
 103 static receive_dbgmsg_state dbgmsg_state;
 104
 105 static void receive_debug_packet(Packet *packet, void *stateptr)
 106 {
 107   receive_dbgmsg_state *state = stateptr;
 108
 109   state->packet = packet;
 110   state->received = 1;
 111 }
 112
 113 static int register_debug_message_handler(void)
 114 {
 115   int err;
 116   dbgmsg_state.received = 0;
 117
 118   err = Adp_ChannelRegisterRead(CI_HADP, receive_debug_packet, &dbgmsg_state);
 119 #ifdef DEBUG
 120   if (err!=adp_ok) angel_DebugPrint("register_debug_message_handler failed %i\n", err);
 121 #endif
 122   return err;
 123 }
 124
 125
 126 static int wait_for_debug_message(int *rcode, int *debugID,
 127                                   int *OSinfo1, int *OSinfo2,
 128                                   int *status, Packet **packet)
 129 {
 130   unsigned int reason;
 131
 132 #ifdef DEBUG
 133   angel_DebugPrint("wait_for_debug_message waiting for %X\n", *rcode);
 134 #endif
 135
 136   for ( ; dbgmsg_state.received == 0 ; )
 137     Adp_AsynchronousProcessing(async_block_on_read);
 138
 139 #ifdef DEBUG
 140   angel_DebugPrint("wait_for_debug_message got packet\n");
 141 #endif
 142
 143   *packet = dbgmsg_state.packet;
 144
 145   Adp_ChannelRegisterRead(CI_HADP, NULL, NULL);
 146
 147   /*
 148    * TODO:
 149    * If ADP_Unrecognised return error.
 150    * If ADP_Acknowledge - handle appropriately.
 151    * If expected message read arguments and return RDIError_NoError.
 152    * Note: if RDIError occurs then the data values returned are junk
 153    */
 154
 155   unpack_message(BUFFERDATA((*packet)->pk_buffer), "%w%w%w%w%w", &reason, debugID,
 156                  OSinfo1, OSinfo2, status);
 157   if (reason&0xffffff == ADP_HADPUnrecognised)
 158     return RDIError_UnimplementedMessage;
 159   if (reason != (unsigned ) *rcode) {
 160     if((reason&0xffffff) == ADP_HADPUnrecognised)
 161       return RDIError_UnimplementedMessage;
 162     else {
 163       angel_DebugPrint("ARDI ERROR: Expected reasoncode %x got reasoncode %x.\n",
 164              *rcode, reason);
 165       return RDIError_Error;
 166     }
 167   }
 168   else
 169     return RDIError_NoError;
 170   return RDIError_Error;    /* stop a pesky ANSI compiler warning */
 171 }
 172
 173
 174 /*
 175  * Handler and registration for logging messages from target
 176  */
 177 static void TargetLogCallback( Packet *packet, void *state )
 178 {
 179     p_Buffer     reply = BUFFERDATA(packet->pk_buffer);
 180     unsigned int len   = packet->pk_length;
 181     IGNORE(state);
 182     angel_hostif->write(angel_hostif->hostosarg,
 183                         (char *)reply, len - CHAN_HEADER_SIZE);
 184     DevSW_FreePacket(packet);
 185
 186     packet = DevSW_AllocatePacket(4); /* better not ask for 0 */
 187     /* the reply is the ACK - any contents are ignored */
 188     if (packet != NULL)
 189        Adp_ChannelWrite( CI_TLOG, packet );
 190 }
 191
 192 static void TargetLogInit( void )
 193 {
 194     AdpErrs err = Adp_ChannelRegisterRead( CI_TLOG, TargetLogCallback, NULL );
 195
 196 #ifdef DEBUG
 197     if (err != adp_ok)
 198        angel_DebugPrint("CI_TLOG RegisterRead failed %d\n", err);
 199 #else
 200     IGNORE(err);
 201 #endif
 202 }
 203
 204 /*----------------------------------------------------------------------*/
 205 /*----angel_RDI_open-----------------------------------------------------*/
 206 /*----------------------------------------------------------------------*/
 207
 208 typedef struct NegotiateState {
 209       bool             negotiate_resp;
 210       bool             negotiate_ack;
 211       bool             link_check_resp;
 212       ParameterConfig *accepted_config;
 213 } NegotiateState;
 214
 215 static void receive_negotiate(Packet *packet, void *stateptr)
 216 {
 217     unsigned reason, debugID, OSinfo1, OSinfo2, status;
 218     NegotiateState *n_state = (NegotiateState *)stateptr;
 219     p_Buffer reply = BUFFERDATA(packet->pk_buffer);
 220
 221     unpack_message( reply, "%w%w%w%w",
 222                     &reason, &debugID, &OSinfo1, &OSinfo2 );
 223     reply += ADP_DEFAULT_HEADER_SIZE;
 224
 225 #ifdef DEBUG
 226     angel_DebugPrint( "receive_negotiate: reason %x\n", reason );
 227 #endif
 228
 229     switch ( reason )
 230     {
 231         case ADP_ParamNegotiate | TtoH:
 232         {
 233             n_state->negotiate_resp = TRUE;
 234
 235             status = GET32LE( reply );
 236             reply += sizeof(word);
 237 #ifdef DEBUG
 238             angel_DebugPrint( "ParamNegotiate status %u\n", status );
 239 #endif
 240             if ( status == RDIError_NoError )
 241             {
 242                 if ( Angel_ReadParamConfigMessage(
 243                          reply, n_state->accepted_config ) )
 244                    n_state->negotiate_ack = TRUE;
 245             }
 246             break;
 247         }
 248
 249         case ADP_LinkCheck | TtoH:
 250         {
 251 #ifdef DEBUG
 252             angel_DebugPrint( "PONG!\n" );
 253 #endif
 254             n_state->link_check_resp = TRUE;
 255             break;
 256         }
 257
 258         default:
 259         {
 260 #ifdef DEBUG
 261             angel_DebugPrint( "Unexpected!\n" );
 262 #endif
 263             break;
 264         }
 265     }
 266     DevSW_FreePacket( packet );
 267 }
 268
 269 # include <sys/types.h>
 270 #ifdef __unix
 271 # include <sys/time.h>
 272 #else
 273 # include <time.h>
 274 #endif
 275
 276 /*
 277  * convert a config into a single-valued options list
 278  */
 279 static ParameterOptions *config_to_options( const ParameterConfig *config )
 280 {
 281     unsigned int        num_params;
 282     size_t              size;
 283     ParameterOptions   *base_p;
 284
 285     num_params  = config->num_parameters;
 286     size        =
 287         sizeof(ParameterOptions)
 288         + num_params*(sizeof(ParameterList) + sizeof(unsigned int));
 289     base_p      = malloc( size );
 290
 291     if ( base_p != NULL )
 292     {
 293         unsigned int    u;
 294         ParameterList  *list_p          =
 295             (ParameterList *)((char *)base_p + sizeof(ParameterOptions));
 296         unsigned int   *option_p        =
 297             (unsigned int *)(list_p + num_params);
 298
 299         base_p->num_param_lists = num_params;
 300         base_p->param_list = list_p;
 301
 302         for ( u = 0; u < num_params; ++u )
 303         {
 304             option_p[u]                 = config->param[u].value;
 305             list_p[u].type              = config->param[u].type;
 306             list_p[u].num_options       = 1;
 307             list_p[u].option            = &option_p[u];
 308         }
 309     }
 310
 311     return base_p;
 312 }
 313
 314 static AdpErrs negotiate_params( const ParameterOptions *user_options )
 315 {
 316     Packet                    *packet;
 317     unsigned int               count;
 318     static Parameter           params[AP_NUM_PARAMS];
 319     static ParameterConfig     accepted_config = { AP_NUM_PARAMS, params };
 320
 321     time_t t;
 322
 323     static volatile NegotiateState    n_state = {
 324         FALSE, FALSE, FALSE, &accepted_config };
 325
 326 #ifdef DEBUG
 327     angel_DebugPrint( "negotiate_params\n" );
 328 #endif
 329
 330     Adp_ChannelRegisterRead( CI_HBOOT, receive_negotiate, (void *)&n_state );
 331
 332     packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize);
 333     count = msgbuild( BUFFERDATA(packet->pk_buffer), "%w%w%w%w",
 334                       ADP_ParamNegotiate | HtoT, 0,
 335                       ADP_HandleUnknown, ADP_HandleUnknown );
 336     count += Angel_BuildParamOptionsMessage(
 337         BUFFERDATA(packet->pk_buffer) + count, user_options );
 338     packet->pk_length = count;
 339     Adp_ChannelWriteAsync( CI_HBOOT, packet );
 340
 341 #ifdef DEBUG
 342     angel_DebugPrint( "sent negotiate packet\n" );
 343 #endif
 344
 345     t=time(NULL);
 346
 347     do {
 348       Adp_AsynchronousProcessing(async_block_on_nothing);
 349
 350       if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD) {
 351         return adp_timeout_on_open;
 352       }
 353     } while ( ! n_state.negotiate_resp );
 354
 355     if ( n_state.negotiate_ack )
 356     {
 357         /* select accepted config */
 358         Adp_Ioctl( DC_SET_PARAMS, (void *)n_state.accepted_config );
 359
 360         /*
 361          * 960430 KWelton
 362          *
 363          * There is a race in the renegotiation protocol: the
 364          * target has to have had time to load new config before
 365          * we send the link check packet - insert a deliberate
 366          * pause (100ms) to give the target some time
 367          */
 368         Adp_delay(100000);
 369
 370         /* do link check */
 371         msgsend( CI_HBOOT, "%w%w%w%w", ADP_LinkCheck | HtoT, 0,
 372                  ADP_HandleUnknown, ADP_HandleUnknown );
 373 #ifdef DEBUG
 374         angel_DebugPrint("sent link check\n");
 375 #endif
 376
 377         do {
 378             Adp_AsynchronousProcessing(async_block_on_read);
 379         } while ( ! n_state.link_check_resp );
 380         Adp_initSeq();
 381     }
 382     return adp_ok;
 383 }
 384
 385 static int late_booted = FALSE;
 386 static bool ardi_handler_installed = FALSE;
 387
 388 #ifdef __unix
 389 static struct sigaction old_action;
 390 #else
 391 static void (*old_handler)();
 392 #endif
 393
 394 static bool boot_interrupted = FALSE;
 395
 396 static void ardi_sigint_handler(int sig) {
 397 #ifdef DEBUG
 398     if (sig != SIGINT)
 399        angel_DebugPrint("Expecting SIGINT got %d.\n", sig);
 400 #else
 401     IGNORE(sig);
 402 #endif
 403     boot_interrupted = TRUE;
 404 #ifndef __unix
 405     signal(SIGINT, ardi_sigint_handler);
 406 #endif
 407 }
 408
 409 static void install_ardi_handler( void ) {
 410   if (!ardi_handler_installed) {
 411     /* install a new Ctrl-C handler so we can abandon waiting */
 412 #ifdef __unix
 413     struct sigaction new_action;
 414     sigemptyset(&new_action.sa_mask);
 415     new_action.sa_handler = ardi_sigint_handler;
 416     new_action.sa_flags = 0;
 417     sigaction(SIGINT, &new_action, &old_action);
 418 #else
 419     old_handler = signal(SIGINT, ardi_sigint_handler);
 420 #endif
 421     ardi_handler_installed = TRUE;
 422   }
 423 }
 424
 425 static int angel_RDI_errmess(char *buf, int blen, int errnum);
 426
 427 static void receive_reset_acknowledge(Packet *packet, void *stateptr) {
 428   unsigned reason, debugID, OSinfo1, OSinfo2, status;
 429   IGNORE(stateptr);
 430
 431   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
 432                  &OSinfo1, &OSinfo2, &status);
 433   if (reason==(ADP_Reset | TtoH) && status==AB_NORMAL_ACK) {
 434 #ifdef DEBUG
 435     angel_DebugPrint("DEBUG: Successfully received normal reset acknowledgement\n");
 436     late_booted = FALSE;
 437 #endif
 438   } else if (reason==(ADP_Reset | TtoH) && status==AB_LATE_ACK) {
 439     char late_msg[AdpMessLen_LateStartup];
 440     int  late_len;
 441 #ifdef DEBUG
 442     angel_DebugPrint("DEBUG: Successfully received LATE reset acknowledgement\n");
 443 #endif
 444     late_booted = TRUE;
 445     install_ardi_handler();
 446     late_len = angel_RDI_errmess(late_msg,
 447                                  AdpMessLen_LateStartup, adp_late_startup);
 448     angel_hostif->write(angel_hostif->hostosarg, late_msg, late_len);
 449   } else {
 450 #ifdef DEBUG
 451     angel_DebugPrint("DEBUG: Bad reset ack: reason=%8X, status=%8X\n", reason, status);
 452 #endif
 453   }
 454   DevSW_FreePacket(packet);
 455 }
 456
 457 static int booted_not_received;
 458 static unsigned int angel_version;
 459 static unsigned int adp_version;
 460 static unsigned int arch_info;
 461 static unsigned int cpu_info;
 462 static unsigned int hw_status;
 463
 464 static void receive_booted(Packet *packet, void *stateptr) {
 465   unsigned reason, debugID, OSinfo1, OSinfo2, banner_length, bufsiz, longsiz;
 466   unsigned i, count;
 467
 468   IGNORE(stateptr);
 469
 470   count = unpack_message(BUFFERDATA(packet->pk_buffer),
 471                          "%w%w%w%w%w%w%w%w%w%w%w%w",
 472                  &reason, &debugID, &OSinfo1, &OSinfo2, &bufsiz, &longsiz,
 473                  &angel_version, &adp_version,
 474                  &arch_info, &cpu_info, &hw_status, &banner_length);
 475   if (reason==(ADP_Booted | TtoH)) {
 476 #ifdef MONITOR_DOWNLOAD_PACKETS
 477     angel_DebugPrint("DEBUG: Successfully received Booted\n");
 478     angel_DebugPrint("       cpu_info=%8X, hw_status=%8X, bufsiz=%d, longsiz=%d\n",
 479            cpu_info, hw_status, bufsiz, longsiz);
 480 #endif
 481     /* Get the banner from the booted message */
 482     for (i=0; i<banner_length; i++)
 483       angel_hostif->writec(angel_hostif->hostosarg,
 484                           (BUFFERDATA(packet->pk_buffer)+count)[i]);
 485
 486     booted_not_received=0;
 487 #ifndef NO_HEARTBEAT
 488     heartbeat_enabled = TRUE;
 489 #endif
 490     Armsd_BufferSize = bufsiz + CHAN_HEADER_SIZE;
 491     Armsd_LongBufSize = longsiz + CHAN_HEADER_SIZE;
 492   } else {
 493 #ifdef DEBUG
 494     angel_DebugPrint("DEBUG: Bad Booted msg: reason=%8X\n", reason);
 495 #endif
 496   }
 497   DevSW_FreePacket(packet);
 498 }
 499
 500
 501 /* forward declaration */
 502 static int angel_negotiate_defaults( void );
 503
 504 /* Open communications. */
 505 int angel_RDI_open(
 506     unsigned type, Dbg_ConfigBlock const *config,
 507     Dbg_HostosInterface const *hostif, struct Dbg_MCState *dbg_state)
 508 {
 509   Packet *packet;
 510   int status, reasoncode, debugID, OSinfo1, OSinfo2, err;
 511   ParameterOptions *user_options = NULL;
 512
 513   time_t t;
 514
 515   IGNORE( dbg_state );
 516
 517   if ((type & 1) == 0) {
 518     /* cold start */
 519     if (hostif != NULL) {
 520       angel_hostif = hostif;
 521       err = HostSysInit(hostif, &ardi_commandline, &hstate);
 522       if (err != RDIError_NoError) {
 523 #ifdef DEBUG
 524         angel_DebugPrint("DEBUG: HostSysInit error %i\n",err);
 525 #endif
 526         return err;
 527       }
 528     }
 529     TargetLogInit();
 530   }
 531
 532 #ifdef DEBUG
 533   angel_DebugPrint("DEBUG: Buffer allocated in angel_RDI_open(type=%i).\n",type);
 534 #endif
 535
 536   if ((type & 1) == 0) {
 537     /* cold start */
 538     unsigned endian;
 539     Adp_Ioctl( DC_GET_USER_PARAMS, (void *)&user_options );
 540     if ( user_options != NULL ) {
 541       err = negotiate_params( user_options );
 542       if (err != adp_ok) return err;
 543     }
 544     else {
 545       ParameterConfig *default_config = NULL;
 546       Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config );
 547       if ( default_config != NULL ) {
 548         ParameterOptions *default_options = config_to_options(default_config);
 549         err = negotiate_params( default_options );
 550         if (err != adp_ok) return err;
 551       }
 552     }
 553
 554     /* Register handlers before sending any messages */
 555     booted_not_received=1;
 556     Adp_ChannelRegisterRead(CI_HBOOT, receive_reset_acknowledge, NULL);
 557     Adp_ChannelRegisterRead(CI_TBOOT, receive_booted, NULL);
 558     endian = 0;
 559     if (config!=NULL) {
 560       if (config->bytesex & RDISex_Little) endian |= ADP_BootHostFeature_LittleEnd;
 561       if (config->bytesex & RDISex_Big) endian |= ADP_BootHostFeature_BigEnd;
 562     }
 563     msgsend(CI_HBOOT,"%w%w%w%w%w", ADP_Reset | HtoT, 0,
 564             ADP_HandleUnknown, ADP_HandleUnknown, endian);
 565 #ifdef DEBUG
 566     angel_DebugPrint("DEBUG: Transmitted Reset message in angel_RDI_open.\n");
 567 #endif
 568
 569     /* We will now either get an acknowledgement for the Reset message
 570      * or if the target was started after the host, we will get a
 571      * rebooted message first.
 572      */
 573
 574 #ifdef DEBUG
 575     angel_DebugPrint("DEBUG: waiting for a booted message\n");
 576 #endif
 577
 578     {
 579       boot_interrupted = FALSE;
 580
 581       if (late_booted)
 582         install_ardi_handler();
 583
 584       t=time(NULL);
 585
 586       do {
 587         Adp_AsynchronousProcessing(async_block_on_nothing);
 588         if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD && !late_booted) {
 589           return adp_timeout_on_open;
 590         }
 591       } while (booted_not_received && !boot_interrupted);
 592
 593       if (ardi_handler_installed)
 594       {
 595         /* uninstall our Ctrl-C handler */
 596 #ifdef __unix
 597         sigaction(SIGINT, &old_action, NULL);
 598 #else
 599         signal(SIGINT, old_handler);
 600 #endif
 601       }
 602
 603       if (boot_interrupted) {
 604         angel_negotiate_defaults();
 605         return adp_abandon_boot_wait;
 606       }
 607     }
 608
 609     booted_not_received=1;
 610     Adp_ChannelRegisterRead(CI_HBOOT, NULL, NULL);
 611
 612     /* Leave the booted handler installed */
 613     msgsend(CI_TBOOT, "%w%w%w%w%w", ADP_Booted | HtoT, 0,
 614             ADP_HandleUnknown, ADP_HandleUnknown, 0);
 615     Adp_initSeq();
 616 #ifdef DEBUG
 617     angel_DebugPrint("DEBUG: Transmitted ADP_Booted acknowledgement.\n");
 618     angel_DebugPrint("DEBUG: Boot sequence completed, leaving angel_RDI_open.\n");
 619 #endif
 620
 621     return (hw_status & ADP_CPU_BigEndian )? RDIError_BigEndian :
 622       RDIError_LittleEndian;
 623   }
 624   else {
 625     /* warm start */
 626     register_debug_message_handler();
 627
 628     msgsend(CI_HADP, "%w%w%w%w",
 629             ADP_InitialiseApplication | HtoT, 0,
 630             ADP_HandleUnknown, ADP_HandleUnknown);
 631 #ifdef DEBUG
 632     angel_DebugPrint("DEBUG: Transmitted Initialise Application\n");
 633 #endif
 634     reasoncode=ADP_InitialiseApplication | TtoH;
 635     err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2,
 636                                 &status, &packet);
 637     if (err != RDIError_NoError) return err;
 638     return status;
 639   }
 640   return -1;
 641 }
 642
 643
 644 /*----------------------------------------------------------------------*/
 645 /*----angel_RDI_close----------------------------------------------------*/
 646 /*----------------------------------------------------------------------*/
 647
 648 static int angel_negotiate_defaults( void ) {
 649     int err = adp_ok;
 650     ParameterConfig *default_config = NULL;
 651     Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config );
 652     if ( default_config != NULL ) {
 653         ParameterOptions *default_options = config_to_options(default_config);
 654         err = negotiate_params( default_options );
 655         free( default_options );
 656     }
 657     return err;
 658 }
 659
 660 int angel_RDI_close(void) {
 661 /*Angel host exit */
 662   int err;
 663   int status,debugID, OSinfo1,OSinfo2;
 664   int reason;
 665   Packet *packet = NULL;;
 666 #ifdef DEBUG
 667   angel_DebugPrint("DEBUG: Entered angel_RDI_Close.\n");
 668 #endif
 669
 670   register_debug_message_handler();
 671
 672   heartbeat_enabled = FALSE;
 673
 674   err = msgsend(CI_HADP,"%w%w%w%w",ADP_End | HtoT,0,
 675           ADP_HandleUnknown, ADP_HandleUnknown);
 676   if (err != RDIError_NoError) return err;
 677   reason = ADP_End | TtoH;
 678   err =  wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
 679                                   &status, &packet);
 680   DevSW_FreePacket(packet);
 681   if (err != RDIError_NoError) return err;
 682   if (status == RDIError_NoError) {
 683     err = angel_negotiate_defaults();
 684     if (err != adp_ok) return err;
 685     Adp_Ioctl( DC_RESET, NULL ); /* just to be safe */
 686     return HostSysExit(hstate);
 687   }
 688   else
 689       return status;
 690 }
 691
 692
 693 /*----------------------------------------------------------------------*/
 694 /*----angel_RDI_read-----------------------------------------------------*/
 695 /*----------------------------------------------------------------------*/
 696
 697 /* Read memory contents from target to host: use ADP_Read */
 698 int angel_RDI_read(ARMword source, void *dest, unsigned *nbytes)
 699 {
 700   Packet *packet=NULL;
 701   int len;                               /* Integer to hold message length. */
 702   unsigned int nbtogo = *nbytes, nbinpacket, nbdone=0;
 703   int rnbytes = 0, status, reason, debugID, OSinfo1, OSinfo2, err;
 704   unsigned int maxlen = Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ReadHeaderSize;
 705
 706   /* Print debug trace information, this is just copied straight from rdi.c
 707      and I can see no reason why it should have to be changed. */
 708   TracePrint(("angel_RDI_read: source=%.8lx dest=%p nbytes=%.8x\n",
 709                 (unsigned long)source, dest, *nbytes));
 710   if (*nbytes == 0) return RDIError_NoError;       /* Read nothing - easy! */
 711   /* check the buffer size */
 712   while (nbtogo >0) {
 713     register_debug_message_handler();
 714
 715     nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen;
 716     len = msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Read | HtoT, 0,
 717                   ADP_HandleUnknown, ADP_HandleUnknown, source+nbdone,
 718                   nbinpacket);
 719     reason=ADP_Read | TtoH;
 720     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
 721                                 &status, &packet);
 722     TracePrint(("angel_RDI_read: nbinpacket =%d status=%08x err = %d\n",
 723                 nbinpacket,status,err));
 724     if (err != RDIError_NoError) return err;       /* Was there an error? */
 725     if (status == RDIError_NoError){
 726       rnbytes += PREAD(LE,(unsigned int *)(BUFFERDATA(packet->pk_buffer)+20));
 727       TracePrint(("angel_RDI_read: rnbytes = %d\n",rnbytes));
 728       memcpy(((unsigned char *)dest)+nbdone, BUFFERDATA(packet->pk_buffer)+24,
 729              nbinpacket);
 730     }
 731     nbdone += nbinpacket;
 732     nbtogo -= nbinpacket;
 733   }
 734   *nbytes -= rnbytes;
 735   return status;
 736 }
 737
 738
 739 /*----------------------------------------------------------------------*/
 740 /*----angel_RDI_write----------------------------------------------------*/
 741 /*----------------------------------------------------------------------*/
 742
 743 /* Transfer memory block from host to target.  Use ADP_Write>. */
 744 int angel_RDI_write(const void *source, ARMword dest, unsigned *nbytes)
 745 {
 746   Packet *packet;/* Message buffers. */
 747   unsigned int len, nbtogo = *nbytes, nboffset = 0, nbinpacket;
 748   int status, reason, debugID, OSinfo1, OSinfo2, err;
 749   unsigned int maxlen = Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_WriteHeaderSize;
 750
 751   TracePrint(("angel_RDI_write: source=%p dest=%.8lx nbytes=%.8x\n",
 752                  source, (unsigned long)dest, *nbytes));
 753
 754   if (*nbytes == 0) return RDIError_NoError;
 755
 756   *nbytes = 0;
 757   while (nbtogo > 0) {
 758     packet = (Packet *) DevSW_AllocatePacket(Armsd_LongBufSize);
 759     nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen;
 760     len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
 761                    ADP_Write | HtoT, 0, ADP_HandleUnknown,
 762                    ADP_HandleUnknown, dest+nboffset, nbinpacket);
 763     /* Copy the data into the packet. */
 764
 765     memcpy(BUFFERDATA(packet->pk_buffer)+len,
 766            ((const unsigned char *) source)+nboffset, nbinpacket);
 767     nboffset += nbinpacket;
 768     packet->pk_length = nbinpacket+len;
 769
 770 #ifdef MONITOR_DOWNLOAD_PACKETS
 771     angel_DebugPrint("angel_RDI_write packet size=%i, bytes done=%i\n",
 772             nbinpacket, nboffset);
 773 #endif
 774
 775     register_debug_message_handler();
 776     Adp_ChannelWrite(CI_HADP, packet);
 777     reason=ADP_Write | TtoH;
 778     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
 779                                 &status, &packet);
 780     nbtogo -= nbinpacket;
 781     if (err != RDIError_NoError) return err;
 782     if (status == RDIError_NoError)
 783       *nbytes += nbinpacket;
 784
 785     DevSW_FreePacket(packet);
 786   }
 787   return status;
 788 }
 789
 790
 791 /*----------------------------------------------------------------------*/
 792 /*----angel_RDI_CPUread--------------------------------------------------*/
 793 /*----------------------------------------------------------------------*/
 794
 795 /* Reads the values of registers in the CPU, uses ADP_CPUwrite. */
 796 int angel_RDI_CPUread(unsigned mode, unsigned long mask, ARMword *buffer)
 797 {
 798   unsigned int i, j;
 799   Packet *packet = NULL;
 800   int err, status, reason, debugID, OSinfo1, OSinfo2;
 801 #ifdef DEBUG
 802   angel_DebugPrint("DEBUG: Entered angel_RDI_CPUread.\n");
 803 #endif
 804   for (i=0, j=0 ; i < RDINumCPURegs ; i++)
 805     if (mask & (1L << i)) j++;            /* Count the number of registers. */
 806
 807   register_debug_message_handler();
 808   msgsend(CI_HADP, "%w%w%w%w%c%w", ADP_CPUread | HtoT, 0,
 809           ADP_HandleUnknown, ADP_HandleUnknown, mode, mask);
 810   reason = ADP_CPUread | TtoH;
 811   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
 812                               &status, &packet);
 813   if (err != RDIError_NoError) {
 814     DevSW_FreePacket(packet);
 815     return err;
 816   }
 817   if(status == RDIError_NoError) {
 818     for (i=0; i<j; i++)
 819       buffer[i] = GET32LE(BUFFERDATA(packet->pk_buffer)+20+(i*4));
 820     TracePrint(("angel_RDI_CPUread: mode=%.8x mask=%.8lx", mode, mask));
 821     DevSW_FreePacket(packet);
 822 #ifdef RDI_VERBOSE
 823     if (rdi_log & 1) {
 824       unsigned k;
 825       for (k = 0, j = 0 ; j <= 20 ; j++)
 826         if (mask & (1L << j)) {
 827           angel_DebugPrint("%c%.8lx",k%4==0?'\n':' ',
 828                            (unsigned long)buffer[k]);
 829           k++ ;
 830         }
 831       angel_DebugPrint("\n") ;
 832     }
 833 #endif
 834
 835   }
 836   return status;
 837 }
 838
 839 /*----------------------------------------------------------------------*/
 840 /*----angel_RDI_CPUwrite-------------------------------------------------*/
 841 /*----------------------------------------------------------------------*/
 842
 843 /* Write CPU registers: use ADP_CPUwrite. */
 844 int angel_RDI_CPUwrite(unsigned mode, unsigned long mask,
 845                       ARMword const *buffer){
 846
 847   unsigned i, j, c;
 848   Packet *packet;
 849   int status, reason, debugID, OSinfo1, OSinfo2, err, len;
 850
 851   TracePrint(("angel_RDI_CPUwrite: mode=%.8x mask=%.8lx", mode, mask));
 852 #ifdef RDI_VERBOSE
 853  if (rdi_log & 1) {
 854     for (j = 0, i = 0 ; i <= 20 ; i++)
 855        if (mask & (1L << i)) {
 856           angel_DebugPrint("%c%.8lx",j%4==0?'\n':' ',
 857                            (unsigned long)buffer[j]);
 858           j++ ;
 859           }
 860     angel_DebugPrint("\n") ;
 861     }
 862 #endif
 863  packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize);
 864  for (i=0, j=0; i < RDINumCPURegs ; i++)
 865    if (mask & (1L << i)) j++; /* count the number of registers */
 866
 867  len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%b%w",
 868                 ADP_CPUwrite | HtoT, 0,
 869                 ADP_HandleUnknown, ADP_HandleUnknown, mode, mask);
 870  for(c=0; c<j; c++)
 871    PUT32LE(BUFFERDATA(packet->pk_buffer)+len+(c*4), buffer[c]);
 872  packet->pk_length = len+(j*4);
 873  register_debug_message_handler();
 874
 875  Adp_ChannelWrite(CI_HADP, packet);
 876  reason = ADP_CPUwrite | TtoH;
 877  err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
 878                              &status, &packet);
 879  unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
 880                 &OSinfo1, &OSinfo2, &status);
 881  DevSW_FreePacket(packet);
 882  if (err != RDIError_NoError)
 883    return err;      /* Was there an error? */
 884  else
 885    return status;
 886  }
 887
 888
 889 /*----------------------------------------------------------------------*/
 890 /*----angel_RDI_CPread---------------------------------------------------*/
 891 /*----------------------------------------------------------------------*/
 892
 893 /* Read coprocessor's internal state.  See dbg_cp.h for help.
 894  * Use ADP_CPRead.
 895  * It would appear that the correct behaviour at this point is to leave
 896  * the unpacking to a the caller and to simply copy the stream of data
 897  * words into the buffer
 898  */
 899
 900 int angel_RDI_CPread(unsigned CPnum, unsigned long mask, ARMword *buffer){
 901   Packet *packet = NULL;
 902   int i, j, status, reasoncode, OSinfo1, OSinfo2, err, debugID;
 903   unsigned char *rmap = cpwords[CPnum];
 904   int n;
 905 #ifdef DEBUG
 906   angel_DebugPrint("DEBUG: Entered angel_RDI_CPread.\n");
 907 #endif
 908   if (rmap == NULL) return RDIError_UnknownCoPro;
 909
 910   register_debug_message_handler();
 911   n = rmap[-1];
 912   msgsend(CI_HADP, "%w%w%w%w%b%w", ADP_CPread | HtoT, 0,
 913           ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask);
 914   reasoncode=ADP_CPread | TtoH;
 915   err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2,
 916                               &status, &packet);
 917   if (err != RDIError_NoError) {
 918     DevSW_FreePacket(packet);
 919     return err;          /* Was there an error? */
 920   }
 921   for (j=i=0; i < n ; i++) /* count the number of registers */
 922     if (mask & (1L << i)) {
 923       j++;
 924     }
 925   for (i=0; i<j; i++)
 926     buffer[i] = PREAD32(LE, BUFFERDATA(packet->pk_buffer) + 20 + (i*4));
 927   DevSW_FreePacket(packet);
 928   TracePrint(("angel_RDI_CPread: CPnum=%.8x mask=%.8lx\n", CPnum, mask));
 929 #ifdef RDI_VERBOSE
 930   if (rdi_log & 1) {
 931     for (i = 0, j = 0; j < n ; j++) {
 932       if (mask & (1L << j)) {
 933         int nw = rmap[j];
 934         angel_DebugPrint("%2d ", j);
 935         while (--nw > 0)
 936           angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]);
 937         angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]);
 938       }
 939     }
 940   }
 941 #endif
 942   return status;
 943 }
 944
 945
 946 /*----------------------------------------------------------------------*/
 947 /*----angel_RDI_CPwrite--------------------------------------------------*/
 948 /*----------------------------------------------------------------------*/
 949
 950 /* Write coprocessor's internal state.  See dbg_cp.h for help. Use
 951  * ADP_CPwrite.
 952  */
 953
 954 int angel_RDI_CPwrite(unsigned CPnum, unsigned long mask,
 955                       ARMword const *buffer)
 956 {
 957   Packet *packet = NULL;
 958   int i, j, len, status, reason, OSinfo1, OSinfo2, err, debugID;
 959   unsigned char *rmap = cpwords[CPnum];
 960   int n;
 961
 962   if (rmap == NULL) return RDIError_UnknownCoPro;
 963   n = rmap[-1];
 964
 965   TracePrint(("angel_RDI_CPwrite: CPnum=%d mask=%.8lx\n", CPnum, mask));
 966
 967 #ifdef RDI_VERBOSE
 968  if (rdi_log & 1) {
 969     for (i = 0, j = 0; j < n ; j++)
 970        if (mask & (1L << j)) {
 971           int nw = rmap[j];
 972           angel_DebugPrint("%2d ", j);
 973           while (--nw > 0)
 974              angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]);
 975           angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]);
 976        }
 977  }
 978 #endif
 979
 980   for (j=i=0; i < n ; i++) /* Count the number of registers. */
 981     if (mask & (1L << i)) j++;
 982   packet = DevSW_AllocatePacket(Armsd_BufferSize);
 983   len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%c%w",
 984                  ADP_CPwrite | HtoT, 0,
 985                  ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask);
 986   for(i=0;  i<j; i++)
 987     len+=msgbuild(BUFFERDATA(packet->pk_buffer) + len, "%w", buffer[i]);
 988   packet->pk_length = len;
 989   register_debug_message_handler();
 990   Adp_ChannelWrite(CI_HADP, packet);    /* Transmit message. */
 991   reason=ADP_CPwrite | TtoH;
 992   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
 993                               &status, &packet);
 994   DevSW_FreePacket(packet);
 995   if (err != RDIError_NoError)
 996     return err;
 997   else
 998     return status;
 999 }
1000
1001
1002 /*----------------------------------------------------------------------*/
1003 /*----angel_RDI_pointinq-------------------------------------------------*/
1004 /*----------------------------------------------------------------------*/
1005
1006 /* Do test calls to ADP_SetBreak/ADP_SetWatch to see if resources exist to
1007    carry out request. */
1008 int angel_RDI_pointinq(ARMword *address, unsigned type, unsigned datatype,
1009                        ARMword *bound)
1010 {
1011   Packet *packet = NULL;
1012   int len, status, reason, OSinfo1, OSinfo2, err=RDIError_NoError;
1013        /* stop a compiler warning */
1014   int debugID, pointhandle;
1015   TracePrint(
1016       ("angel_RDI_pointinq: address=%.8lx type=%d datatype=%d bound=%.8lx ",
1017       (unsigned long)*address, type, datatype, (unsigned long)*bound));
1018        /* for a buffer.  */
1019   packet = DevSW_AllocatePacket(Armsd_BufferSize);
1020   len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b",
1021                  ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch) | HtoT, 0,
1022                  ADP_HandleUnknown, ADP_HandleUnknown, address, type);
1023   if (datatype == 0)
1024     len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%w", bound);
1025   else
1026     len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%b%w", datatype, bound);
1027
1028   register_debug_message_handler();
1029   packet->pk_length = len;
1030   Adp_ChannelWrite(CI_HADP, packet);
1031   reason = ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch | TtoH);
1032   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1033                               &status, &packet);
1034   if (err != RDIError_NoError) {
1035     DevSW_FreePacket(packet);
1036     return err;        /* Was there an error? */
1037   }
1038   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
1039                  &reason, &debugID, &OSinfo1, &OSinfo2, &status,
1040                  &pointhandle, &address, &bound);
1041   DevSW_FreePacket(packet);
1042   return err;
1043 }
1044
1045
1046 /*----------------------------------------------------------------------*/
1047 /*----angel_RDI_setbreak-------------------------------------------------*/
1048 /*----------------------------------------------------------------------*/
1049
1050 /* Set a breakpoint: Use ADP_SetBreak */
1051 int angel_RDI_setbreak(ARMword address, unsigned type, ARMword bound,
1052                       PointHandle *handle)
1053 {
1054   int status, reason, OSinfo1, OSinfo2, err, debugID;
1055   int tmpval, tmpaddr, tmpbnd;
1056   Packet *packet;
1057   TracePrint(("angel_RDI_setbreak address=%.8lx type=%d bound=%.8lx \n",
1058               (unsigned long)address, type, (unsigned long)bound));
1059
1060   register_debug_message_handler();
1061   msgsend(CI_HADP, "%w%w%w%w%w%b%w",
1062           ADP_SetBreak| HtoT, 0,  ADP_HandleUnknown,
1063           ADP_HandleUnknown, address, type, bound);
1064   reason = ADP_SetBreak |TtoH;
1065   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1066                               &status, &packet);
1067   if (err != RDIError_NoError) {
1068     DevSW_FreePacket(packet);
1069     return err;         /* Was there an error? */
1070   }
1071   /* Work around varargs problem... -sts */
1072   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
1073                  &reason, &debugID, &OSinfo1, &OSinfo2, &status,
1074                  &tmpval, &tmpaddr, &tmpbnd);
1075   *handle = tmpval;
1076   address = tmpaddr;
1077   bound = tmpbnd;
1078   DevSW_FreePacket(packet);
1079   if (status != RDIError_NoError) return status;
1080   TracePrint(("returns handle %.8lx\n", (unsigned long)*handle));
1081   return RDIError_NoError;
1082 }
1083
1084
1085 /*----------------------------------------------------------------------*/
1086 /*----angel_RDI_clearbreak-----------------------------------------------*/
1087 /*----------------------------------------------------------------------*/
1088
1089 /* Clear a breakpoint: Use ADP_ClearBreak. */
1090 int angel_RDI_clearbreak(PointHandle handle)
1091 {
1092   Packet *packet = NULL;
1093   int status, reason, OSinfo1, OSinfo2, err, debugID;
1094
1095   TracePrint(("angel_RDI_clearbreak: handle=%.8lx\n", (unsigned long)handle));
1096
1097   register_debug_message_handler();
1098   msgsend(CI_HADP, "%w%w%w%w%w",
1099           ADP_ClearBreak| HtoT, 0,  ADP_HandleUnknown,
1100           ADP_HandleUnknown, handle);
1101   reason = ADP_ClearBreak|TtoH;
1102   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1103                               &status, &packet);
1104   if (err != RDIError_NoError) {
1105     DevSW_FreePacket(packet);
1106     angel_DebugPrint("***RECEIVE DEBUG MESSAGE RETURNED ERR = %d.\n", err);
1107     return err;          /* Was there an error? */
1108   }
1109   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w",  &reason,
1110                  &debugID, &OSinfo1, &OSinfo2, &status);
1111   DevSW_FreePacket(packet);
1112 #ifdef DEBUG
1113   angel_DebugPrint("DEBUG: Clear Break completed OK.\n");
1114 #endif
1115   return RDIError_NoError;
1116 }
1117
1118
1119 /*----------------------------------------------------------------------*/
1120 /*----angel_RDI_setwatch-------------------------------------------------*/
1121 /*----------------------------------------------------------------------*/
1122
1123 /* Set a watchpoint: use ADP_SetWatch. */
1124 int angel_RDI_setwatch(ARMword address, unsigned type, unsigned datatype,
1125                        ARMword bound, PointHandle *handle)
1126 {
1127   Packet *packet = NULL;
1128   int status, reason, OSinfo1, OSinfo2, err, debugID;
1129
1130   TracePrint(("angel_RDI_setwatch: address=%.8lx type=%d bound=%.8lx ",
1131               (unsigned long)address, type, (unsigned long)bound));
1132
1133   register_debug_message_handler();
1134   msgsend(CI_HADP, "%w%w%w%w%w%b%b%w",
1135           ADP_SetWatch| HtoT, 0,  ADP_HandleUnknown,
1136           ADP_HandleUnknown, address, type, datatype, bound);
1137
1138   reason = ADP_SetWatch | TtoH;
1139   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1140                               &status, &packet);
1141   if (err != RDIError_NoError) {
1142     DevSW_FreePacket(packet);
1143     return err;        /* Was there an error? */
1144   }
1145   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
1146                  &reason, &debugID, &OSinfo1, &OSinfo2, &status,
1147                  handle, &address, &bound);
1148   DevSW_FreePacket(packet);
1149   TracePrint(("returns handle %.8lx\n", (unsigned long)*handle));
1150   return RDIError_NoError;
1151 }
1152
1153 /*----------------------------------------------------------------------*/
1154 /*----angel_RDI_clearwatch-----------------------------------------------*/
1155 /*----------------------------------------------------------------------*/
1156
1157 /* Clear a watchpoint: use ADP_ClearWatch. */
1158 int angel_RDI_clearwatch(PointHandle handle) {
1159
1160   int status, reason, OSinfo1, OSinfo2, err, debugID;
1161   Packet *packet = NULL;
1162
1163   TracePrint(("angel_RDI_clearwatch: handle=%.8lx\n", (unsigned long)handle));
1164
1165   register_debug_message_handler();
1166   msgsend(CI_HADP, "%w%w%w%w%w",
1167           ADP_ClearWatch| HtoT, 0,  ADP_HandleUnknown,
1168           ADP_HandleUnknown, handle);
1169   reason = ADP_ClearWatch|TtoH;
1170   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1171                               &status, &packet);
1172   if (err != RDIError_NoError) {
1173     DevSW_FreePacket(packet);
1174     return err;        /* Was there an error? */
1175   }
1176   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w",  &reason, &debugID,
1177                  &OSinfo1, &OSinfo2, &status);
1178   DevSW_FreePacket(packet);
1179   return RDIError_NoError;
1180 }
1181
1182 typedef struct {
1183   unsigned stopped_reason;
1184   int stopped_status;
1185   int data;
1186 } adp_stopped_struct;
1187
1188
1189 int angel_RDI_OnTargetStopping(angel_RDI_TargetStoppedProc *fn,
1190                                void *arg)
1191 {
1192   stoppedProcListElement **lptr = &stopped_proc_list;
1193
1194   /* Find the address of the NULL ptr at the end of the list */
1195   for (; *lptr!=NULL ; lptr = &((*lptr)->next))
1196     ; /* Do nothing */
1197
1198   *lptr = (stoppedProcListElement *) malloc(sizeof(stoppedProcListElement));
1199   if (*lptr == NULL) return RDIError_OutOfStore;
1200   (*lptr)->fn = fn;
1201   (*lptr)->arg = arg;
1202
1203   return RDIError_NoError;
1204 }
1205
1206 static int CallStoppedProcs(unsigned reason)
1207 {
1208   stoppedProcListElement *p = stopped_proc_list;
1209   int err=RDIError_NoError;
1210
1211   for (; p!=NULL ; p=p->next) {
1212     int local_err = p->fn(reason, p->arg);
1213     if (local_err != RDIError_NoError) err=local_err;
1214   }
1215
1216   return err;
1217 }
1218
1219 /*----------------------------------------------------------------------*/
1220 /*----angel_RDI_execute--------------------------------------------------*/
1221 /*----------------------------------------------------------------------*/
1222
1223 static int HandleStoppedMessage(Packet *packet, void *stateptr) {
1224   unsigned int err,  reason, debugID, OSinfo1, OSinfo2, count;
1225   adp_stopped_struct *stopped_info;
1226   stopped_info = (adp_stopped_struct *) stateptr;
1227   IGNORE(stateptr);
1228   count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
1229                          &reason, &debugID,
1230                          &OSinfo1, &OSinfo2,
1231                          &stopped_info->stopped_reason, &stopped_info->data);
1232   DevSW_FreePacket(packet);
1233
1234   if (reason != (ADP_Stopped | TtoH)) {
1235 #ifdef DEBUG
1236     angel_DebugPrint("Expecting stopped message, got %x", reason);
1237 #endif
1238     return RDIError_Error;
1239   }
1240   else {
1241     executing = FALSE;
1242 #ifdef DEBUG
1243     angel_DebugPrint("Received stopped message.\n");
1244 #endif
1245   }
1246
1247   err = msgsend(CI_TADP,  "%w%w%w%w%w", (ADP_Stopped | HtoT), 0,
1248                 ADP_HandleUnknown, ADP_HandleUnknown, RDIError_NoError);
1249 #ifdef DEBUG
1250   angel_DebugPrint("Transmiting stopped acknowledge.\n");
1251 #endif
1252   if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n");
1253 #ifdef DEBUG
1254   angel_DebugPrint("DEBUG: Stopped reason : %x\n", stopped_info->stopped_reason);
1255 #endif
1256   switch (stopped_info->stopped_reason) {
1257   case ADP_Stopped_BranchThroughZero:
1258     stopped_info->stopped_status = RDIError_BranchThrough0;
1259     break;
1260   case ADP_Stopped_UndefinedInstr:
1261     stopped_info->stopped_status = RDIError_UndefinedInstruction;
1262     break;
1263   case ADP_Stopped_SoftwareInterrupt:
1264     stopped_info->stopped_status = RDIError_SoftwareInterrupt;
1265     break;
1266   case ADP_Stopped_PrefetchAbort:
1267     stopped_info->stopped_status = RDIError_PrefetchAbort;
1268     break;
1269   case ADP_Stopped_DataAbort:
1270     stopped_info->stopped_status = RDIError_DataAbort;
1271     break;
1272   case ADP_Stopped_AddressException:
1273     stopped_info->stopped_status = RDIError_AddressException;
1274     break;
1275   case ADP_Stopped_IRQ:
1276     stopped_info->stopped_status = RDIError_IRQ;
1277     break;
1278   case ADP_Stopped_BreakPoint:
1279     stopped_info->stopped_status = RDIError_BreakpointReached;
1280     break;
1281   case ADP_Stopped_WatchPoint:
1282     stopped_info->stopped_status = RDIError_WatchpointAccessed;
1283     break;
1284   case ADP_Stopped_StepComplete:
1285     stopped_info->stopped_status = RDIError_ProgramFinishedInStep;
1286     break;
1287   case ADP_Stopped_RunTimeErrorUnknown:
1288   case ADP_Stopped_StackOverflow:
1289   case ADP_Stopped_DivisionByZero:
1290     stopped_info->stopped_status = RDIError_Error;
1291     break;
1292   case ADP_Stopped_FIQ:
1293     stopped_info->stopped_status = RDIError_FIQ;
1294     break;
1295   case ADP_Stopped_UserInterruption:
1296   case ADP_Stopped_OSSpecific:
1297     stopped_info->stopped_status = RDIError_UserInterrupt;
1298     break;
1299   case ADP_Stopped_ApplicationExit:
1300     stopped_info->stopped_status = RDIError_NoError;
1301     break;
1302   default:
1303     stopped_info->stopped_status = RDIError_NoError;
1304     break;
1305   }
1306   return RDIError_NoError;
1307 }
1308
1309 static volatile bool interrupt_request = FALSE;
1310
1311 static void interrupt_target( void )
1312 {
1313     Packet *packet = NULL;
1314     int err;
1315     int reason, debugID, OSinfo1, OSinfo2, status;
1316
1317 #ifdef DEBUG
1318     angel_DebugPrint("DEBUG: interrupt_target.\n");
1319 #endif
1320
1321     register_debug_message_handler();
1322     msgsend(CI_HADP, "%w%w%w%w", ADP_InterruptRequest | HtoT, 0,
1323                    ADP_HandleUnknown, ADP_HandleUnknown);
1324
1325     reason = ADP_InterruptRequest |TtoH;
1326     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1327                               &status, &packet);
1328     DevSW_FreePacket(packet);
1329 #ifdef DEBUG
1330     angel_DebugPrint("DEBUG: got interrupt ack ok err = %d, status=%i\n",
1331                      err, status);
1332 #endif
1333
1334     return;
1335 }
1336
1337 #ifdef TEST_DC_APPL
1338   extern void test_dc_appl_handler( const DeviceDescr *device,
1339                                     Packet *packet );
1340 #endif
1341
1342 /* Core functionality for execute and step */
1343 static int angel_RDI_ExecuteOrStep(PointHandle *handle, word type,
1344                                    unsigned ninstr)
1345 {
1346   int err;
1347   adp_stopped_struct stopped_info;
1348   void* stateptr = (void *)&stopped_info;
1349   ChannelCallback HandleStoppedMessageFPtr=(ChannelCallback) HandleStoppedMessage;
1350   int status, reasoncode, debugID, OSinfo1, OSinfo2;
1351   Packet *packet = NULL;
1352
1353   TracePrint(("angel_RDI_ExecuteOrStep\n"));
1354
1355   err = Adp_ChannelRegisterRead(CI_TADP,
1356                                 HandleStoppedMessageFPtr, stateptr);
1357   if (err != RDIError_NoError) {
1358 #ifdef DEBUG
1359     angel_DebugPrint("TADP Register failed.\n");
1360 #endif
1361     return err;
1362   }
1363   /* Set executing TRUE here, as it must be set up before the target has
1364    * had any chance at all to execute, or it may send its stopped message
1365    * before we get round to setting executing = TRUE !!!
1366    */
1367   executing = TRUE;
1368
1369   register_debug_message_handler();
1370
1371 #ifdef TEST_DC_APPL
1372   Adp_Install_DC_Appl_Handler( test_dc_appl_handler );
1373 #endif
1374
1375 #ifdef DEBUG
1376   angel_DebugPrint("Transmiting %s message.\n",
1377                    type == ADP_Execute ? "execute": "step");
1378 #endif
1379
1380   register_debug_message_handler();
1381   /* Extra ninstr parameter for execute message will simply be ignored */
1382   err = msgsend(CI_HADP,"%w%w%w%w%w", type | HtoT, 0,
1383                 ADP_HandleUnknown, ADP_HandleUnknown, ninstr);
1384 #if DEBUG
1385   if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n");
1386 #endif
1387
1388   reasoncode = type | TtoH;
1389   err = wait_for_debug_message( &reasoncode, &debugID, &OSinfo1, &OSinfo2,
1390                                 &status, &packet );
1391   if (err != RDIError_NoError)
1392      return err;
1393   else if (status != RDIError_NoError)
1394      return status;
1395
1396 #ifdef DEBUG
1397   angel_DebugPrint("Waiting for program to finish...\n");
1398 #endif
1399
1400   while( executing )
1401   {
1402       if (interrupt_request)
1403       {
1404         interrupt_target();
1405         interrupt_request = FALSE;
1406       }
1407       Adp_AsynchronousProcessing( async_block_on_nothing );
1408   }
1409
1410 #ifdef TEST_DC_APPL
1411   Adp_Install_DC_Appl_Handler( NULL );
1412 #endif
1413
1414   (void)Adp_ChannelRegisterRead(CI_TADP, NULL, NULL);
1415
1416   *handle = (PointHandle)stopped_info.data;
1417
1418   CallStoppedProcs(stopped_info.stopped_reason);
1419
1420   return stopped_info.stopped_status;
1421 }
1422
1423 /* Request that the target starts executing from the stored CPU state: use
1424    ADP_Execute. */
1425 int angel_RDI_execute(PointHandle *handle)
1426 {
1427     return angel_RDI_ExecuteOrStep(handle, ADP_Execute, 0);
1428 }
1429
1430 #ifdef __WATCOMC__
1431 typedef void handlertype(int);
1432
1433 static int interrupted=0;
1434
1435 static void myhandler(int sig) {
1436   IGNORE(sig);
1437   interrupted=1;
1438   signal(SIGINT, myhandler);
1439 }
1440 #endif
1441
1442 /*----------------------------------------------------------------------*/
1443 /*----angel_RDI_step-----------------------------------------------------*/
1444 /*----------------------------------------------------------------------*/
1445
1446 /* Step 'ninstr' through the code: use ADP_Step. */
1447 int angel_RDI_step(unsigned ninstr, PointHandle *handle)
1448 {
1449     int err = angel_RDI_ExecuteOrStep(handle, ADP_Step, ninstr);
1450     if (err == RDIError_ProgramFinishedInStep)
1451        return RDIError_NoError;
1452     else
1453        return err;
1454 }
1455
1456
1457 static void SetCPWords(int cpnum, struct Dbg_CoProDesc const *cpd) {
1458   int i, rmax = 0;
1459   for (i = 0; i < cpd->entries; i++)
1460     if (cpd->regdesc[i].rmax > rmax)
1461       rmax = cpd->regdesc[i].rmax;
1462
1463   { unsigned char *rmap = (unsigned char *)malloc(rmax + 2);
1464     *rmap++ = rmax + 1;
1465     for (i = 0; i < cpd->entries; i++) {
1466       int r;
1467       for (r = cpd->regdesc[i].rmin; r <= cpd->regdesc[i].rmax; r++)
1468         rmap[r] = (cpd->regdesc[i].nbytes+3) / 4;
1469       }
1470 /*    if (cpwords[cpnum] != NULL) free(cpwords[cpnum]); */
1471     cpwords[cpnum] = rmap;
1472   }
1473 }
1474
1475 /*----------------------------------------------------------------------*/
1476 /*----angel_RDI_info-----------------------------------------------------*/
1477 /*----------------------------------------------------------------------*/
1478
1479 /* Use ADP_Info, ADP_Ctrl and ADP_Profile calls to implement these,
1480    see adp.h for more details. */
1481
1482 static int angel_cc_exists( void )
1483 {
1484   Packet *packet = NULL;
1485   int err;
1486   int reason, debugID, OSinfo1, OSinfo2, subreason, status;
1487
1488 #ifdef DEBUG
1489   angel_DebugPrint("DEBUG: ADP_ICEB_CC_Exists.\n");
1490 #endif
1491
1492   if ( angel_RDI_info( RDIInfo_Icebreaker, NULL, NULL ) == RDIError_NoError ) {
1493     register_debug_message_handler();
1494     msgsend(CI_HADP, "%w%w%w%w%w", ADP_ICEbreakerHADP | HtoT, 0,
1495             ADP_HandleUnknown, ADP_HandleUnknown,
1496             ADP_ICEB_CC_Exists );
1497     reason = ADP_ICEbreakerHADP |TtoH;
1498     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1499                                 &status, &packet);
1500     if (err != RDIError_NoError) {
1501       DevSW_FreePacket(packet);
1502       return err;
1503     }
1504     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
1505                    &debugID, &OSinfo1, &OSinfo2,  &subreason, &status);
1506     if (subreason !=  ADP_ICEB_CC_Exists) {
1507       DevSW_FreePacket(packet);
1508       return RDIError_Error;
1509     }
1510     else
1511       return status;
1512   }
1513   else
1514     return RDIError_UnimplementedMessage;
1515 }
1516
1517 typedef struct {
1518   RDICCProc_ToHost *tohost; void *tohostarg;
1519   RDICCProc_FromHost *fromhost; void *fromhostarg;
1520   bool registered;
1521 } CCState;
1522 static CCState ccstate = { NULL, NULL, NULL, NULL, FALSE };
1523
1524 static void HandleDCCMessage( Packet *packet, void *stateptr )
1525 {
1526   unsigned int reason, debugID, OSinfo1, OSinfo2;
1527   int count;
1528   CCState *ccstate_p = (CCState *)stateptr;
1529
1530   count = unpack_message( BUFFERDATA(packet->pk_buffer), "%w%w%w%w",
1531                           &reason, &debugID, &OSinfo1, &OSinfo2 );
1532   switch ( reason )
1533   {
1534       case ADP_TDCC_ToHost | TtoH:
1535       {
1536            /* only handles a single word of data, for now */
1537
1538           unsigned int nbytes, data;
1539
1540           unpack_message( BUFFERDATA(packet->pk_buffer)+count, "%w%w",
1541                           &nbytes, &data );
1542 #ifdef DEBUG
1543           angel_DebugPrint( "DEBUG: received CC_ToHost message: nbytes %d data %08x.\n",
1544                   nbytes, data );
1545 #endif
1546           ccstate_p->tohost( ccstate_p->tohostarg, data );
1547           msgsend(CI_TTDCC, "%w%w%w%w%w",
1548                   ADP_TDCC_ToHost | HtoT, debugID, OSinfo1, OSinfo2,
1549                   RDIError_NoError );
1550           break;
1551       }
1552
1553       case ADP_TDCC_FromHost | TtoH:
1554       {
1555            /* only handles a single word of data, for now */
1556
1557           int valid;
1558           ARMword data;
1559
1560           ccstate_p->fromhost( ccstate_p->fromhostarg, &data, &valid );
1561 #ifdef DEBUG
1562           angel_DebugPrint( "DEBUG: received CC_FromHost message, returning: %08x %s.\n",
1563                   data, valid ? "VALID" : "INvalid" );
1564 #endif
1565           msgsend(CI_TTDCC, "%w%w%w%w%w%w%w",
1566                   ADP_TDCC_FromHost | HtoT, debugID, OSinfo1, OSinfo2,
1567                   RDIError_NoError, valid ? 1 : 0, data );
1568           break;
1569       }
1570
1571       default:
1572 #ifdef DEBUG
1573       angel_DebugPrint( "Unexpected TDCC message %08x received\n", reason );
1574 #endif
1575       break;
1576   }
1577   DevSW_FreePacket(packet);
1578   return;
1579 }
1580
1581 static void angel_check_DCC_handler( CCState *ccstate_p )
1582 {
1583     int err;
1584
1585     if ( ccstate_p->tohost != NULL || ccstate_p->fromhost != NULL )
1586     {
1587         /* doing DCC, so need a handler */
1588         if ( ! ccstate_p->registered )
1589         {
1590 #ifdef DEBUG
1591             angel_DebugPrint( "Registering handler for TTDCC channel.\n" );
1592 #endif
1593             err = Adp_ChannelRegisterRead( CI_TTDCC, HandleDCCMessage,
1594                                            ccstate_p );
1595             if ( err == adp_ok )
1596                ccstate_p->registered = TRUE;
1597 #ifdef DEBUG
1598             else
1599                angel_DebugPrint( "angel_check_DCC_handler: register failed!\n" );
1600 #endif
1601         }
1602     }
1603     else
1604     {
1605         /* not doing DCC, so don't need a handler */
1606         if ( ccstate_p->registered )
1607         {
1608 #ifdef DEBUG
1609             angel_DebugPrint( "Unregistering handler for TTDCC channel.\n" );
1610 #endif
1611             err = Adp_ChannelRegisterRead( CI_TTDCC, NULL, NULL );
1612             if ( err == adp_ok )
1613                ccstate_p->registered = FALSE;
1614 #ifdef DEBUG
1615             else
1616                angel_DebugPrint( "angel_check_DCC_handler: unregister failed!\n" );
1617 #endif
1618         }
1619     }
1620 }
1621
1622
1623 static int CheckSubMessageReply(int reason, int subreason) {
1624   Packet *packet = NULL;
1625   int status, debugID, OSinfo1, OSinfo2;
1626   int err = RDIError_NoError;
1627   reason |= TtoH;
1628   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1629                                &status, &packet);
1630   if (err != RDIError_NoError) {
1631     status = err;
1632   } else {
1633     int sr;
1634     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
1635                    &OSinfo1, &OSinfo2, &sr, &status);
1636     if (subreason != sr) status = RDIError_Error;
1637   }
1638   DevSW_FreePacket(packet);
1639   return status;
1640 }
1641
1642 static int SendSubMessageAndCheckReply(int reason, int subreason) {
1643   register_debug_message_handler();
1644   msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0,
1645           ADP_HandleUnknown, ADP_HandleUnknown,
1646           subreason);
1647   return CheckSubMessageReply(reason, subreason);
1648 }
1649
1650 static int SendSubMessageWordAndCheckReply(int reason, int subreason, ARMword word) {
1651   register_debug_message_handler();
1652   msgsend(CI_HADP, "%w%w%w%w%w%w", reason | HtoT, 0,
1653           ADP_HandleUnknown, ADP_HandleUnknown,
1654           subreason, word);
1655   return CheckSubMessageReply(reason, subreason);
1656 }
1657
1658 static int SendSubMessageGetWordAndCheckReply(int reason, int subreason, ARMword *resp) {
1659   Packet *packet = NULL;
1660   int status, debugID, OSinfo1, OSinfo2;
1661   int err = RDIError_NoError;
1662
1663   register_debug_message_handler();
1664   msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0,
1665           ADP_HandleUnknown, ADP_HandleUnknown,
1666           subreason);
1667   reason |= TtoH;
1668   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1669                                &status, &packet);
1670   if (err != RDIError_NoError) {
1671     status = err;
1672   } else {
1673     int sr;
1674     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w", &reason, &debugID,
1675                    &OSinfo1, &OSinfo2,  &sr, &status, resp);
1676     if (subreason != sr) status = RDIError_Error;
1677   }
1678   DevSW_FreePacket(packet);
1679   return status;
1680 }
1681
1682 static int const hostsex = 1;
1683
1684 int angel_RDI_info(unsigned type, ARMword *arg1, ARMword *arg2) {
1685   Packet *packet = NULL;
1686   int len, status, c, reason, subreason, debugID, OSinfo1, OSinfo2;
1687   int err=RDIError_NoError, cpnum=0;
1688   struct Dbg_CoProDesc *cpd;
1689   int count, i;
1690   unsigned char *bp;
1691
1692 #ifdef DEBUG
1693   angel_DebugPrint("DEBUG: Entered angel_RDI_info.\n");
1694 #endif
1695   switch (type) {
1696   case RDIInfo_Target:
1697 #ifdef DEBUG
1698     angel_DebugPrint("DEBUG: RDIInfo_Target.\n");
1699 #endif
1700
1701     register_debug_message_handler();
1702     msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
1703                  ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Target);
1704     reason = ADP_Info |TtoH;
1705     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1706                               &status, &packet);
1707     if (err != RDIError_NoError) {
1708       DevSW_FreePacket(packet);
1709       return err;
1710     }
1711     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
1712                    &debugID, &OSinfo1, &OSinfo2,  &subreason, &status,
1713                    arg1, arg2);
1714     DevSW_FreePacket(packet);
1715
1716     if (subreason !=  ADP_Info_Target)
1717       return RDIError_Error;
1718     else
1719       return status;
1720
1721   case RDISignal_Stop:
1722 #ifdef DEBUG
1723     angel_DebugPrint("DEBUG: RDISignal_Stop.\n");
1724     if (interrupt_request)
1725        angel_DebugPrint("       STILL WAITING to send previous interrupt request\n");
1726 #endif
1727     interrupt_request = TRUE;
1728     return RDIError_NoError;
1729
1730   case RDIInfo_Points:
1731 #ifdef DEBUG
1732     angel_DebugPrint("DEBUG: RDIInfo_Points.\n");
1733 #endif
1734     return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Points, arg1);
1735
1736   case RDIInfo_Step:
1737 #ifdef DEBUG
1738     angel_DebugPrint("DEBUG: RDIInfo_Step.\n");
1739 #endif
1740     return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Step, arg1);
1741
1742   case RDISet_Cmdline:
1743 #ifdef DEBUG
1744     angel_DebugPrint("DEBUG: RDISet_Cmdline.\n");
1745 #endif
1746     if (ardi_commandline != &dummycline)
1747       free(ardi_commandline);
1748     ardi_commandline = (char *)malloc(strlen((char*)arg1) + 1) ;
1749     (void)strcpy(ardi_commandline, (char *)arg1) ;
1750     return RDIError_NoError;
1751
1752   case RDIInfo_SetLog:
1753 #ifdef DEBUG
1754     angel_DebugPrint("DEBUG: RDIInfo_SetLog.\n");
1755 #endif
1756     rdi_log = (int) *arg1;
1757     return RDIError_NoError;
1758
1759   case RDIInfo_Log:
1760 #ifdef DEBUG
1761     angel_DebugPrint("DEBUG: RDIInfo_Log.\n");
1762 #endif
1763     *arg1 = rdi_log;
1764     return RDIError_NoError;
1765
1766
1767   case RDIInfo_MMU:
1768 #ifdef DEBUG
1769     angel_DebugPrint("DEBUG: RDIInfo_MMU.\n");
1770 #endif
1771     return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_MMU, arg1);
1772
1773   case RDIInfo_SemiHosting:
1774 #ifdef DEBUG
1775     angel_DebugPrint("DEBUG: RDIInfo_SemiHosting.\n");
1776 #endif
1777     return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_SemiHosting);
1778
1779   case RDIInfo_CoPro:
1780 #ifdef DEBUG
1781     angel_DebugPrint("DEBUG: RDIInfo_CoPro.\n");
1782 #endif
1783     return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CoPro);
1784
1785   case RDICycles:
1786 #ifdef DEBUG
1787     angel_DebugPrint("DEBUG: RDICycles.\n");
1788 #endif
1789     register_debug_message_handler();
1790     msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
1791             ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Cycles);
1792     reason = ADP_Info |TtoH;
1793     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1794                               &status, &packet);
1795     if (err != RDIError_NoError) {
1796       DevSW_FreePacket(packet);
1797       return err;
1798     }
1799     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
1800                  &OSinfo1, &OSinfo2,  &subreason, &status);
1801     DevSW_FreePacket(packet);
1802     if (subreason !=  ADP_Info_Cycles)
1803       return RDIError_Error;
1804     if (status != RDIError_NoError) return status;
1805     for (c=0; c<12; c++)
1806       arg1[c]=GET32LE(BUFFERDATA(packet->pk_buffer)+24+(c*4));
1807     return status;
1808
1809   case RDIInfo_DescribeCoPro:
1810 #ifdef DEBUG
1811     angel_DebugPrint("DEBUG: RDIInfo_DescribeCoPro.\n");
1812 #endif
1813     cpnum = *(int *)arg1;
1814     cpd = (struct Dbg_CoProDesc *)arg2;
1815     packet = DevSW_AllocatePacket(Armsd_BufferSize);
1816     if (angel_RDI_info(ADP_Info_CoPro, NULL, NULL) != RDIError_NoError)
1817       return RDIError_Error;
1818     len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0,
1819                    ADP_HandleUnknown, ADP_HandleUnknown,
1820                    ADP_Info_DescribeCoPro);
1821     len +=msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b%b%b%b%b", cpnum,
1822                    cpd->regdesc[cpnum].rmin, cpd->regdesc[cpnum].rmax,
1823                    cpd->regdesc[cpnum].nbytes, cpd->regdesc[cpnum].access);
1824     if (cpd->regdesc[cpnum].access&0x3 == 0x3){
1825       len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b",
1826                       cpd->regdesc[cpnum].accessinst.cprt.read_b0,
1827                       cpd->regdesc[cpnum].accessinst.cprt.read_b1,
1828                       cpd->regdesc[cpnum].accessinst.cprt.write_b0,
1829                       cpd->regdesc[cpnum].accessinst.cprt.write_b1, 0xff);
1830     }
1831     else {
1832       len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b%",
1833                       cpd->regdesc[cpnum].accessinst.cpdt.rdbits,
1834                       cpd->regdesc[cpnum].accessinst.cpdt.nbit,0,0, 0xff);
1835     }
1836     register_debug_message_handler();
1837     packet->pk_length = len;
1838     Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
1839     reason = ADP_Info |TtoH;
1840     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1841                                 &status, &packet);
1842     if (err != RDIError_NoError) {
1843       DevSW_FreePacket(packet);
1844       return err;
1845     }
1846     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
1847                    &OSinfo1, &OSinfo2, &subreason, &status);
1848     DevSW_FreePacket(packet);
1849     if (subreason != ADP_Info_DescribeCoPro)
1850       return RDIError_Error;
1851     else
1852       return status;
1853
1854   case RDIInfo_RequestCoProDesc:
1855 #ifdef DEBUG
1856     angel_DebugPrint("DEBUG: RDIInfo_RequestCoProDesc.\n");
1857 #endif
1858     cpnum = *(int *)arg1;
1859     cpd = (struct Dbg_CoProDesc *)arg2;
1860     packet = DevSW_AllocatePacket(Armsd_BufferSize);
1861     len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0,
1862                    ADP_HandleUnknown, ADP_HandleUnknown,
1863                    ADP_Info_RequestCoProDesc);
1864     len += msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b", *(int *)arg1);
1865     packet->pk_length = len;
1866     register_debug_message_handler();
1867     Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
1868     reason = ADP_Info |TtoH;
1869     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1870                               &status, &packet);
1871     if (err != RDIError_NoError) {
1872       DevSW_FreePacket(packet);
1873       return err;
1874     }
1875     count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
1876                            &debugID, &OSinfo1, &OSinfo2,  &subreason, &status);
1877     if (subreason !=  ADP_Info_RequestCoProDesc) {
1878       DevSW_FreePacket(packet);
1879       return RDIError_Error;
1880     } else if ( status != RDIError_NoError ) {
1881       DevSW_FreePacket(packet);
1882       return status;
1883     } else {
1884       bp = BUFFERDATA(packet->pk_buffer)+count;
1885       for ( i = 0; *bp != 0xFF && i < cpd->entries; ++i ) {
1886         cpd->regdesc[i].rmin = *bp++;
1887         cpd->regdesc[i].rmax = *bp++;
1888         cpd->regdesc[i].nbytes = *bp++;
1889         cpd->regdesc[i].access = *bp++;
1890       }
1891       cpd->entries = i;
1892       if ( *bp != 0xFF )
1893         status = RDIError_BufferFull;
1894       else
1895         SetCPWords( cpnum, cpd );
1896       DevSW_FreePacket(packet);
1897       return status;
1898     }
1899
1900   case RDIInfo_GetLoadSize:
1901 #ifdef DEBUG
1902     angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize.\n");
1903 #endif
1904     register_debug_message_handler();
1905     msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
1906             ADP_HandleUnknown, ADP_HandleUnknown,
1907             ADP_Info_AngelBufferSize);
1908     reason = ADP_Info |TtoH;
1909     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1910                               &status, &packet);
1911     if (err != RDIError_NoError) {
1912       DevSW_FreePacket(packet);
1913       return err;
1914     }
1915     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
1916                    &debugID, &OSinfo1, &OSinfo2,  &subreason, &status);
1917     if (subreason !=  ADP_Info_AngelBufferSize) {
1918       DevSW_FreePacket(packet);
1919       return RDIError_Error;
1920     }
1921     else {
1922       word defaultsize, longsize;
1923       unpack_message(BUFFERDATA(packet->pk_buffer)+24, "%w%w",
1924                      &defaultsize, &longsize);
1925       *arg1 = longsize - ADP_WriteHeaderSize;   /* space for ADP header */
1926 #ifdef MONITOR_DOWNLOAD_PACKETS
1927       angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize: got (%d, %d), returning %d.\n",
1928              defaultsize, longsize, *arg1);
1929 #endif
1930       DevSW_FreePacket(packet);
1931       return status;
1932     }
1933
1934   case RDIVector_Catch:
1935 #ifdef DEBUG
1936     angel_DebugPrint("DEBUG: ADP_Ctrl_VectorCatch %lx.\n", *arg1);
1937 #endif
1938     return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_VectorCatch, *arg1);
1939
1940   case RDISemiHosting_SetState:
1941 #ifdef DEBUG
1942     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetState %lx.\n", *arg1);
1943 #endif
1944     return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetState, *arg1);
1945
1946   case RDISemiHosting_GetState:
1947 #ifdef DEBUG
1948     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetState.\n");
1949 #endif
1950     return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetState, arg1);
1951
1952   case RDISemiHosting_SetVector:
1953 #ifdef DEBUG
1954     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetVector %lx.\n", *arg1);
1955 #endif
1956     return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetVector, *arg1);
1957
1958   case RDISemiHosting_GetVector:
1959 #ifdef DEBUG
1960     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetVector.\n");
1961 #endif
1962     return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetVector, arg1);
1963
1964   case RDISemiHosting_SetARMSWI:
1965 #ifdef DEBUG
1966     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetARMSWI.\n");
1967 #endif
1968     return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetARMSWI, *arg1);
1969
1970   case RDISemiHosting_GetARMSWI:
1971 #ifdef DEBUG
1972     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetARMSWI.\n");
1973 #endif
1974     return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetARMSWI, arg1);
1975
1976   case RDISemiHosting_SetThumbSWI:
1977 #ifdef DEBUG
1978     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetThumbSWI.\n");
1979 #endif
1980     return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetThumbSWI, *arg1);
1981
1982   case RDISemiHosting_GetThumbSWI:
1983 #ifdef DEBUG
1984     angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetThumbSWI.\n");
1985 #endif
1986     return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetThumbSWI, arg1);
1987
1988   case RDIInfo_SetTopMem:
1989 #ifdef DEBUG
1990     angel_DebugPrint("DEBUG: ADP_Ctrl_SetTopMem.\n");
1991 #endif
1992     return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SetTopMem, *arg1);
1993
1994   case RDIPointStatus_Watch:
1995 #ifdef DEBUG
1996     angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Watch.\n");
1997 #endif
1998     register_debug_message_handler();
1999     msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0,
2000             ADP_HandleUnknown, ADP_HandleUnknown,
2001             ADP_Ctrl_PointStatus_Watch, *arg1 );
2002     reason = ADP_Control |TtoH;
2003     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2004                               &status, &packet);
2005     if (err != RDIError_NoError) {
2006       DevSW_FreePacket(packet);
2007       return err;
2008     }
2009     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
2010                    &debugID, &OSinfo1, &OSinfo2,  &subreason, &status,
2011                    arg1, arg2);
2012     if (subreason !=  ADP_Ctrl_PointStatus_Watch) {
2013       DevSW_FreePacket(packet);
2014       return RDIError_Error;
2015     }
2016     else
2017       return status;
2018
2019   case RDIPointStatus_Break:
2020 #ifdef DEBUG
2021     angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Break.\n");
2022 #endif
2023     register_debug_message_handler();
2024     msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0,
2025             ADP_HandleUnknown, ADP_HandleUnknown,
2026             ADP_Ctrl_PointStatus_Break, *arg1 );
2027     reason = ADP_Control |TtoH;
2028     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2029                               &status, &packet);
2030     if (err != RDIError_NoError) {
2031       DevSW_FreePacket(packet);
2032       return err;
2033     }
2034     unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
2035                    &debugID, &OSinfo1, &OSinfo2,  &subreason, &status,
2036                    arg1, arg2);
2037     if (subreason !=  ADP_Ctrl_PointStatus_Break) {
2038       DevSW_FreePacket(packet);
2039       return RDIError_Error;
2040     }
2041     else
2042       return status;
2043
2044   case RDIInfo_DownLoad:
2045 #ifdef DEBUG
2046     angel_DebugPrint("DEBUG: ADP_Ctrl_Download_Supported.\n");
2047 #endif
2048     return SendSubMessageAndCheckReply(ADP_Control, ADP_Ctrl_Download_Supported);
2049
2050   case RDIConfig_Count:
2051 #ifdef DEBUG
2052     angel_DebugPrint("DEBUG: ADP_ICEM_ConfigCount.\n");
2053 #endif
2054     return SendSubMessageGetWordAndCheckReply(ADP_ICEman, ADP_ICEM_ConfigCount, arg1);
2055
2056   case RDIConfig_Nth:
2057 #ifdef DEBUG
2058     angel_DebugPrint("DEBUG: ADP_ICEM_ConfigNth.\n");
2059 #endif
2060     register_debug_message_handler();
2061     msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT, 0,
2062             ADP_HandleUnknown, ADP_HandleUnknown,
2063             ADP_ICEM_ConfigNth, *arg1 );
2064     reason = ADP_ICEman |TtoH;
2065     err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2066                               &status, &packet);
2067     if (err != RDIError_NoError) {
2068       DevSW_FreePacket(packet);
2069       return err;
2070     } else {
2071       RDI_ConfigDesc *cd = (RDI_ConfigDesc *)arg2;
2072       unsigned char n;
2073       len = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%b",
2074                            &reason, &debugID,
2075                            &OSinfo1, &OSinfo2,  &subreason, &status,
2076                            &cd->version, &n);
2077       if (subreason !=  ADP_ICEM_ConfigNth) {
2078         DevSW_FreePacket(packet);
2079         return RDIError_Error;
2080       }
2081       else {
2082         memcpy( cd->name, BUFFERDATA(packet->pk_buffer)+len, n+1 );
2083         cd->name[n] = 0;
2084         return status;
2085       }
2086     }
2087
2088   case RDIInfo_Icebreaker:
2089 #ifdef DEBUG
2090     angel_DebugPrint("DEBUG: ADP_ICEB_Exists.\n");
2091 #endif
2092     return SendSubMessageAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_Exists);
2093
2094   case RDIIcebreaker_GetLocks:
2095 #ifdef DEBUG
2096     angel_DebugPrint("DEBUG: ADP_ICEB_GetLocks.\n");
2097 #endif
2098     return SendSubMessageGetWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_GetLocks, arg1);
2099
2100   case RDIIcebreaker_SetLocks:
2101 #ifdef DEBUG
2102     angel_DebugPrint("DEBUG: ADP_ICEB_SetLocks.\n");
2103 #endif
2104     return SendSubMessageWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_SetLocks, *arg1);
2105
2106   case RDICommsChannel_ToHost:
2107 #ifdef DEBUG
2108     angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_ToHost.\n");
2109 #endif
2110     if ( angel_cc_exists() == RDIError_NoError ) {
2111
2112     /*
2113      * The following three lines of code have to be removed in order to get
2114      * the Windows Angel Channel Viewer working with the Thumb comms channel.
2115      * At the moment it allows the ARMSD command line to register a CCIN/CCOUT
2116      * callback which stops the ACV working!
2117      */
2118 #ifdef __unix
2119       ccstate.tohost = (RDICCProc_ToHost *)arg1;
2120       ccstate.tohostarg = arg2;
2121       angel_check_DCC_handler( &ccstate );
2122 #endif
2123 #ifdef _WIN32
2124
2125 #endif
2126
2127       register_debug_message_handler();
2128       msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0,
2129               ADP_HandleUnknown, ADP_HandleUnknown,
2130               ADP_ICEB_CC_Connect_ToHost, (arg1 != NULL) );
2131       return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_ToHost);
2132     } else {
2133       return RDIError_UnimplementedMessage;
2134     }
2135
2136   case RDICommsChannel_FromHost:
2137 #ifdef DEBUG
2138     angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_FromHost.\n");
2139 #endif
2140     if ( angel_cc_exists() == RDIError_NoError ) {
2141
2142       ccstate.fromhost = (RDICCProc_FromHost *)arg1;
2143       ccstate.fromhostarg = arg2;
2144       angel_check_DCC_handler( &ccstate );
2145
2146       register_debug_message_handler();
2147       msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0,
2148               ADP_HandleUnknown, ADP_HandleUnknown,
2149               ADP_ICEB_CC_Connect_FromHost, (arg1 != NULL) );
2150       return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_FromHost);
2151     } else {
2152       return RDIError_UnimplementedMessage;
2153     }
2154
2155   case RDIProfile_Stop:
2156     return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_Stop);
2157
2158   case RDIProfile_ClearCounts:
2159     return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_ClearCounts);
2160
2161   case RDIProfile_Start:
2162 #ifdef DEBUG
2163     angel_DebugPrint("DEBUG: ADP_Profile_Start %ld.\n", (long)*arg1);
2164 #endif
2165     return SendSubMessageWordAndCheckReply(ADP_Profile, ADP_Profile_Start, *arg1);
2166
2167   case RDIProfile_WriteMap:
2168     { RDI_ProfileMap *map = (RDI_ProfileMap *)arg1;
2169       int32 maplen = map->len,
2170             offset,
2171             size;
2172       int32 chunk = (Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_ProfileWriteHeaderSize) / sizeof(ARMword);
2173                      /* Maximum number of words sendable in one message */
2174       int oldrev = bytesex_reversing();
2175       int host_little = *(uint8 const *)&hostsex;
2176 #ifdef DEBUG
2177       angel_DebugPrint("DEBUG: ADP_Profile_WriteMap %ld.\n", maplen);
2178 #endif
2179       status = RDIError_NoError;
2180       if (!host_little) {
2181         bytesex_reverse(1);
2182         for (offset = 0; offset < maplen; offset++)
2183           map->map[offset] = bytesex_hostval(map->map[offset]);
2184       }
2185       for (offset = 0; offset < maplen; offset += size) {
2186         unsigned hdrlen;
2187         size = maplen - offset;
2188         packet = (Packet *)DevSW_AllocatePacket(Armsd_LongBufSize);
2189         if (size > chunk) size = chunk;
2190         hdrlen = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
2191                           ADP_Profile | HtoT, 0, ADP_HandleUnknown,
2192                           ADP_HandleUnknown, ADP_Profile_WriteMap,
2193                           maplen, size, offset);
2194
2195         /* Copy the data into the packet. */
2196         memcpy(BUFFERDATA(packet->pk_buffer)+hdrlen,
2197                &map->map[offset], (size_t)size * sizeof(ARMword));
2198         packet->pk_length = size * sizeof(ARMword) + hdrlen;
2199         register_debug_message_handler();
2200         Adp_ChannelWrite(CI_HADP, packet);
2201         reason = ADP_Profile | TtoH;
2202         err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2203                                      &status, &packet);
2204         if (err == RDIError_NoError) {
2205           unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
2206                          &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
2207           if (subreason !=  ADP_Profile_WriteMap) {
2208             err = RDIError_Error;
2209           }
2210           DevSW_FreePacket(packet);
2211         }
2212         if (err != RDIError_NoError) { status = err; break; }
2213       }
2214       if (!host_little) {
2215         for (offset = 0; offset < maplen; offset++)
2216           map->map[offset] = bytesex_hostval(map->map[offset]);
2217         bytesex_reverse(oldrev);
2218       }
2219       return status;
2220     }
2221
2222   case RDIProfile_ReadMap:
2223     { int32 maplen = *(int32 *)arg1,
2224             offset = 0,
2225             size;
2226       int32 chunk = (Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ProfileReadHeaderSize) / sizeof(ARMword);
2227 #ifdef DEBUG
2228       angel_DebugPrint("DEBUG: ADP_Profile_ReadMap %ld.\n", maplen);
2229 #endif
2230       status = RDIError_NoError;
2231       for (offset = 0; offset < maplen; offset += size) {
2232         size = maplen - offset;
2233         if (size > chunk) size = chunk;
2234         register_debug_message_handler();
2235         msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Profile | HtoT, 0,
2236                 ADP_HandleUnknown, ADP_HandleUnknown,
2237                 ADP_Profile_ReadMap, offset, size);
2238         reason = ADP_Profile | TtoH;
2239         err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2240                                      &status, &packet);
2241         if (err != RDIError_NoError) return err;
2242         unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
2243                        &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
2244         memcpy(&arg2[offset], BUFFERDATA(packet->pk_buffer)+ADP_ProfileReadHeaderSize,
2245                size * sizeof(ARMword));
2246         DevSW_FreePacket(packet);
2247         if (status != RDIError_NoError) break;
2248       }
2249       { int oldrev = bytesex_reversing();
2250         int host_little = *(uint8 const *)&hostsex;
2251         if (!host_little) {
2252           bytesex_reverse(1);
2253           for (offset = 0; offset < maplen; offset++)
2254             arg2[offset] = bytesex_hostval(arg2[offset]);
2255         }
2256         bytesex_reverse(oldrev);
2257       }
2258       return status;
2259     }
2260
2261   case RDIInfo_CanTargetExecute:
2262 #ifdef DEBUG
2263     printf("DEBUG: RDIInfo_CanTargetExecute.\n");
2264 #endif
2265     return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CanTargetExecute);
2266
2267   case RDIInfo_AgentEndianess:
2268     return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_AgentEndianess);
2269
2270   default:
2271 #ifdef DEBUG
2272     angel_DebugPrint("DEBUG: Fell through ADP_Info, default case taken.\n");
2273     angel_DebugPrint("DEBUG: type = 0x%x.\n", type);
2274 #endif
2275     if (type & RDIInfo_CapabilityRequest) {
2276       switch (type & ~RDIInfo_CapabilityRequest) {
2277         case RDISemiHosting_SetARMSWI:
2278           return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_ChangeableSHSWI);
2279         default:
2280 #ifdef DEBUG
2281           angel_DebugPrint(
2282           "DEBUG: ADP_Info - Capability Request(%d) - reporting unimplemented \n",
2283                  type & ~RDIInfo_CapabilityRequest);
2284 #endif
2285           break;
2286       }
2287     }
2288     return RDIError_UnimplementedMessage;
2289   }
2290 }
2291
2292
2293 /*----------------------------------------------------------------------*/
2294 /*----angel_RDI_AddConfig------------------------------------------------*/
2295 /*----------------------------------------------------------------------*/
2296
2297 /* Add a configuration: use ADP_ICEM_AddConfig. */
2298 int angel_RDI_AddConfig(unsigned long nbytes) {
2299   Packet *packet = NULL;
2300   int status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2301
2302 #ifdef DEBUG
2303   angel_DebugPrint("DEBUG: Entered angel_RDI_AddConfig.\n");
2304 #endif
2305   register_debug_message_handler();
2306   msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT,
2307           0, ADP_HandleUnknown, ADP_HandleUnknown,
2308           ADP_ICEM_AddConfig, nbytes);
2309   reason=ADP_ICEman | TtoH;
2310   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2311                               &status, &packet);
2312   if (err != RDIError_NoError) {
2313     DevSW_FreePacket(packet);
2314     return -1;
2315   }
2316   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
2317                  &OSinfo1, &OSinfo2, &subreason, &status);
2318   DevSW_FreePacket(packet);
2319   if ( subreason != ADP_ICEM_AddConfig )
2320     return RDIError_Error;
2321   else
2322     return status;
2323 }
2324
2325
2326 /*----------------------------------------------------------------------*/
2327 /*----angel_RDI_LoadConfigData-------------------------------------------*/
2328 /*----------------------------------------------------------------------*/
2329
2330 /* Load configuration data: use ADP_Ctrl_Download_Data. */
2331 int angel_RDI_LoadConfigData(unsigned long nbytes, char const *data) {
2332   Packet *packet = NULL;
2333   int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2334
2335 #ifdef DEBUG
2336   angel_DebugPrint("DEBUG: Entered angel_RDI_LoadConfigData (%d bytes)\n", nbytes);
2337 #endif
2338 #if 0
2339   if (err = angel_RDI_AddConfig(nbytes) != RDIError_NoError)
2340     return err;
2341 #endif
2342   packet = DevSW_AllocatePacket(Armsd_LongBufSize);
2343   len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
2344                  ADP_Control | HtoT, 0,
2345                  ADP_HandleUnknown, ADP_HandleUnknown,
2346                  ADP_Ctrl_Download_Data, nbytes);
2347   memcpy(BUFFERDATA(packet->pk_buffer)+len, data, nbytes);
2348   len += nbytes;
2349   packet->pk_length = len;
2350 #ifdef DEBUG
2351   angel_DebugPrint("DEBUG: packet len %d.\n", len);
2352 #endif
2353   register_debug_message_handler();
2354   Adp_ChannelWrite(CI_HADP, packet);
2355   reason=ADP_Control | TtoH;
2356   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2357                               &status, &packet);
2358   if (err != RDIError_NoError) {
2359     DevSW_FreePacket(packet);
2360     return -1;
2361   }
2362   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
2363                  &OSinfo1, &OSinfo2, &subreason, &status);
2364   DevSW_FreePacket(packet);
2365   if ( subreason != ADP_Ctrl_Download_Data )
2366     return RDIError_Error;
2367   else
2368     return status;
2369 }
2370
2371
2372 /*----------------------------------------------------------------------*/
2373 /*----angel_RDI_SelectConfig---------------------------------------------*/
2374 /*----------------------------------------------------------------------*/
2375
2376 /* Select a configuration: use ADP_ICEM_SelecConfig.*/
2377 int angel_RDI_SelectConfig(RDI_ConfigAspect aspect, char const *name,
2378                            RDI_ConfigMatchType matchtype, unsigned versionreq,
2379                             unsigned *versionp)
2380 {
2381   Packet *packet = NULL;
2382   int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2383
2384 #ifdef DEBUG
2385   angel_DebugPrint("DEBUG: Entered angel_RDI_SelectConfig.\n");
2386 #endif
2387   packet = DevSW_AllocatePacket(Armsd_BufferSize);
2388   len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b%b%b%w",
2389                  ADP_ICEman | HtoT, 0,
2390                  ADP_HandleUnknown, ADP_HandleUnknown,
2391                  ADP_ICEM_SelectConfig, aspect, strlen(name),
2392                  matchtype, versionreq);
2393   /* copy the name into the buffer */
2394   memcpy(BUFFERDATA(packet->pk_buffer)+len, name, strlen(name));
2395   len += strlen(name);
2396   packet->pk_length = len;
2397   register_debug_message_handler();
2398   Adp_ChannelWrite(CI_HADP, packet);
2399   reason=ADP_ICEman | TtoH;
2400   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2401                               &status, &packet);
2402   if (err != RDIError_NoError) {
2403     DevSW_FreePacket(packet);
2404     return err;
2405   }
2406   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w",
2407                  &reason, &debugID, &OSinfo1, &OSinfo2,
2408                  &subreason, &status, versionp);
2409   DevSW_FreePacket(packet);
2410   if ( subreason != ADP_ICEM_SelectConfig )
2411     return RDIError_Error;
2412   else
2413     return status;
2414 }
2415
2416
2417 /*----------------------------------------------------------------------*/
2418 /*----angel_RDI_LoadAgent------------------------------------------------*/
2419 /*----------------------------------------------------------------------*/
2420
2421 /* Load a new debug agent: use ADP_Ctrl_Download_Agent. */
2422 int angel_RDI_LoadAgent(ARMword dest, unsigned long size,
2423                        getbufferproc *getb, void *getbarg)
2424 {
2425   Packet *packet = NULL;
2426   int  status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2427   time_t t;
2428
2429 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2430   angel_DebugPrint("DEBUG: Entered angel_RDI_LoadAgent.\n");
2431 #endif
2432   register_debug_message_handler();
2433   msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Control | HtoT,
2434           0, ADP_HandleUnknown, ADP_HandleUnknown,
2435           ADP_Ctrl_Download_Agent, dest, size);
2436   reason=ADP_Control | TtoH;
2437   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2438                               &status, &packet);
2439   if (err != RDIError_NoError) {
2440     DevSW_FreePacket(packet);
2441     return -1;
2442   }
2443   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
2444                  &OSinfo1, &OSinfo2, &subreason, &status);
2445     DevSW_FreePacket(packet);
2446   if ( subreason != ADP_Ctrl_Download_Agent )
2447     return RDIError_Error;
2448   if ( status != RDIError_NoError )
2449     return status;
2450
2451 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2452   angel_DebugPrint("DEBUG: starting agent data download.\n");
2453 #endif
2454   { unsigned long pos = 0, segsize;
2455     for (; pos < size; pos += segsize) {
2456       char *b = getb(getbarg, &segsize);
2457       if (b == NULL) return RDIError_NoError;
2458       err = angel_RDI_LoadConfigData( segsize, b );
2459       if (err != RDIError_NoError) return err;
2460     }
2461   }
2462 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2463   angel_DebugPrint("DEBUG: finished downloading new agent.\n");
2464 #endif
2465
2466   /* renegotiate back down */
2467   err = angel_negotiate_defaults();
2468   if (err != adp_ok)
2469      return err;
2470
2471   /* Output a message to tell the user what is going on.  This is vital
2472    * when switching from ADP EICE to ADP over JTAG, as then the user
2473    * has to reset the target board !
2474    */
2475   { char msg[256];
2476     int len=angel_RDI_errmess(msg, 256, adp_new_agent_starting);
2477     angel_hostif->write(angel_hostif->hostosarg, msg, len);
2478   }
2479
2480   /* get new image started */
2481 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2482   angel_DebugPrint("DEBUG: sending start message for new agent.\n");
2483 #endif
2484
2485   register_debug_message_handler();
2486   msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT,
2487           0, ADP_HandleUnknown, ADP_HandleUnknown,
2488           ADP_Ctrl_Start_Agent, dest);
2489   reason=ADP_Control | TtoH;
2490   err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2491                               &status, &packet);
2492   if (err != RDIError_NoError) {
2493     DevSW_FreePacket(packet);
2494     return -1;
2495   }
2496   unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
2497                  &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
2498     DevSW_FreePacket(packet);
2499   if ( subreason != ADP_Ctrl_Start_Agent )
2500     return RDIError_Error;
2501   if ( status != RDIError_NoError )
2502     return status;
2503
2504   /* wait for image to start up */
2505   heartbeat_enabled = FALSE;
2506   t=time(NULL);
2507   do {
2508     Adp_AsynchronousProcessing(async_block_on_nothing);
2509     if ((time(NULL)-t) > 2) {
2510 #ifdef DEBUG
2511       angel_DebugPrint("DEBUG: no booted message from new image yet.\n");
2512 #endif
2513       break;
2514     }
2515   } while (booted_not_received);
2516   booted_not_received=1;
2517
2518   /* Give device driver a chance to do any necessary resyncing with new agent.
2519    * Only used by etherdrv.c at the moment.
2520    */
2521   (void)Adp_Ioctl( DC_RESYNC, NULL );
2522
2523 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2524   angel_DebugPrint("DEBUG: reopening to new agent.\n");
2525 #endif
2526   err = angel_RDI_open(0, NULL, NULL, NULL);
2527   switch ( err )
2528   {
2529       case RDIError_NoError:
2530       {
2531 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2532           angel_DebugPrint( "LoadAgent: Open returned RDIError_NoError\n" );
2533 #endif
2534           break;
2535       }
2536
2537       case RDIError_LittleEndian:
2538       {
2539 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2540           angel_DebugPrint( "LoadAgent: Open returned RDIError_LittleEndian (OK)\n" );
2541 #endif
2542           err = RDIError_NoError;
2543           break;
2544       }
2545
2546       case RDIError_BigEndian:
2547       {
2548 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2549           angel_DebugPrint( "LoadAgent: Open returned RDIError_BigEndian (OK)\n" );
2550 #endif
2551           err = RDIError_NoError;
2552           break;
2553       }
2554
2555       default:
2556       {
2557 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2558           angel_DebugPrint( "LoadAgent: Open returned %d - unexpected!\n", err );
2559 #endif
2560           break;
2561       }
2562   }
2563 #ifndef NO_HEARTBEAT
2564   heartbeat_enabled = TRUE;
2565 #endif
2566   return err;
2567 }
2568
2569 static int angel_RDI_errmess(char *buf, int blen, int errnum) {
2570   char *s=NULL;
2571   int n;
2572
2573   switch (errnum) {
2574     case adp_malloc_failure:
2575       s=AdpMess_MallocFailed; break;
2576     case adp_illegal_args:
2577       s=AdpMess_IllegalArgs; break;
2578     case adp_device_not_found:
2579       s=AdpMess_DeviceNotFound; break;
2580     case adp_device_open_failed:
2581       s=AdpMess_DeviceOpenFailed; break;
2582     case adp_device_already_open:
2583       s=AdpMess_DeviceAlreadyOpen; break;
2584     case adp_device_not_open:
2585       s=AdpMess_DeviceNotOpen; break;
2586     case adp_bad_channel_id:
2587       s=AdpMess_BadChannelId; break;
2588     case adp_callback_already_registered:
2589       s=AdpMess_CBAlreadyRegd; break;
2590     case adp_write_busy:
2591       s=AdpMess_WriteBusy; break;
2592     case adp_bad_packet:
2593       s=AdpMess_BadPacket; break;
2594     case adp_seq_high:
2595       s=AdpMess_SeqHigh; break;
2596     case adp_seq_low:
2597       s=AdpMess_SeqLow; break;
2598     case adp_timeout_on_open:
2599       s=AdpMess_TimeoutOnOpen; break;
2600     case adp_failed:
2601       s=AdpMess_Failed; break;
2602     case adp_abandon_boot_wait:
2603       s=AdpMess_AbandonBootWait; break;
2604     case adp_late_startup:
2605       s=AdpMess_LateStartup; break;
2606     case adp_new_agent_starting:
2607       s=AdpMess_NewAgentStarting; break;
2608     default: return 0;
2609   }
2610   n=strlen(s);
2611   if (n>blen-1) n=blen-1;
2612   memcpy(buf, s, n);
2613   buf[n++]=0;
2614   return n;
2615 }
2616
2617 extern const struct RDIProcVec angel_rdi;
2618 const struct RDIProcVec angel_rdi = {
2619     "ADP",
2620     angel_RDI_open,
2621     angel_RDI_close,
2622     angel_RDI_read,
2623     angel_RDI_write,
2624     angel_RDI_CPUread,
2625     angel_RDI_CPUwrite,
2626     angel_RDI_CPread,
2627     angel_RDI_CPwrite,
2628     angel_RDI_setbreak,
2629     angel_RDI_clearbreak,
2630     angel_RDI_setwatch,
2631     angel_RDI_clearwatch,
2632     angel_RDI_execute,
2633     angel_RDI_step,
2634     angel_RDI_info,
2635     angel_RDI_pointinq,
2636
2637     angel_RDI_AddConfig,
2638     angel_RDI_LoadConfigData,
2639     angel_RDI_SelectConfig,
2640
2641     0, /*angel_RDI_drivernames,*/
2642     0,   /* cpunames */
2643
2644     angel_RDI_errmess,
2645
2646     angel_RDI_LoadAgent
2647 };
2648
2649 /* EOF ardi.c */
2650
2651 /* Not strictly necessary, but allows linking this code into armsd. */
2652
2653 struct foo {
2654     char *name;
2655     int (*action)();
2656     char *syntax;
2657     char **helpmessage;
2658     int doafterend;
2659     int dobeforestart;
2660     int doinmidline;
2661 } hostappl_CmdTable[1] = {{"", NULL}};
2662
2663 void
2664 hostappl_Init()
2665 {
2666 }
2667
2668 int
2669 hostappl_Backstop()
2670 {
2671   return -30;
2672 }