| /* |
| * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved. |
| * |
| * This software may be freely used, copied, modified, and distributed |
| * provided that the above copyright notice is preserved in all copies of the |
| * software. |
| */ |
| |
| /* |
| * ARDI.c |
| * Angel Remote Debug Interface |
| * |
| * |
| * $Revision$ |
| * $Date$ |
| * |
| * This file is based on /plg/pisd/rdi.c, but instead of using RDP it uses |
| * ADP messages. |
| */ |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #define uint HIDE_HPs_uint |
| #include <signal.h> |
| #undef uint |
| |
| |
| #include "angel_endian.h" |
| #include "ardi.h" |
| #include "buffers.h" |
| #include "channels.h" |
| #include "hostchan.h" |
| #include "host.h" |
| #include "angel_bytesex.h" |
| #include "dbg_cp.h" |
| #include "adp.h" |
| #include "hsys.h" |
| #include "logging.h" |
| #include "msgbuild.h" |
| #include "rxtx.h" |
| #include "devsw.h" |
| #include "params.h" |
| |
| #ifdef COMPILING_ON_WINDOWS |
| # define IGNORE(x) (x = x) /* must go after #includes to work on Windows */ |
| #endif |
| #define NOT(x) (!(x)) |
| |
| #define ADP_INITIAL_TIMEOUT_PERIOD 5 |
| |
| static volatile int executing; |
| static int rdi_log = 0 ; /* debugging ? */ |
| |
| /* we need a starting point for our first buffers, this is a safe one */ |
| int Armsd_BufferSize = ADP_BUFFER_MIN_SIZE; |
| int Armsd_LongBufSize = ADP_BUFFER_MIN_SIZE; |
| |
| #ifdef WIN32 |
| extern int interrupted; |
| extern int swiprocessing; |
| #endif |
| |
| static char dummycline = 0; |
| char *ardi_commandline = &dummycline ; /* exported in ardi.h */ |
| |
| extern unsigned int heartbeat_enabled; |
| |
| static unsigned char *cpwords[16]; |
| |
| typedef struct stoppedProcListElement { |
| struct stoppedProcListElement *next; |
| angel_RDI_TargetStoppedProc *fn; |
| void *arg; |
| } stoppedProcListElement; |
| |
| static stoppedProcListElement *stopped_proc_list=NULL; |
| |
| const struct Dbg_HostosInterface *angel_hostif; |
| static hsys_state *hstate; |
| |
| static void angel_DebugPrint(const char *format, ...) |
| { va_list ap; |
| va_start(ap, format); |
| angel_hostif->dbgprint(angel_hostif->dbgarg, format, ap); |
| va_end(ap); |
| } |
| |
| #ifdef RDI_VERBOSE |
| #define TracePrint(s) \ |
| if (rdi_log & 2) angel_DebugPrint("\n"); \ |
| if (rdi_log & 1) angel_DebugPrint s |
| #else |
| #define TracePrint(s) |
| #endif |
| |
| typedef struct receive_dbgmsg_state { |
| volatile int received; |
| Packet *packet; |
| } receive_dbgmsg_state; |
| |
| static receive_dbgmsg_state dbgmsg_state; |
| |
| static void receive_debug_packet(Packet *packet, void *stateptr) |
| { |
| receive_dbgmsg_state *state = stateptr; |
| |
| state->packet = packet; |
| state->received = 1; |
| } |
| |
| static int register_debug_message_handler(void) |
| { |
| int err; |
| dbgmsg_state.received = 0; |
| |
| err = Adp_ChannelRegisterRead(CI_HADP, receive_debug_packet, &dbgmsg_state); |
| #ifdef DEBUG |
| if (err!=adp_ok) angel_DebugPrint("register_debug_message_handler failed %i\n", err); |
| #endif |
| return err; |
| } |
| |
| |
| static int wait_for_debug_message(int *rcode, int *debugID, |
| int *OSinfo1, int *OSinfo2, |
| int *status, Packet **packet) |
| { |
| unsigned int reason; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("wait_for_debug_message waiting for %X\n", *rcode); |
| #endif |
| |
| for ( ; dbgmsg_state.received == 0 ; ) |
| Adp_AsynchronousProcessing(async_block_on_read); |
| |
| #ifdef DEBUG |
| angel_DebugPrint("wait_for_debug_message got packet\n"); |
| #endif |
| |
| *packet = dbgmsg_state.packet; |
| |
| Adp_ChannelRegisterRead(CI_HADP, NULL, NULL); |
| |
| /* |
| * TODO: |
| * If ADP_Unrecognised return error. |
| * If ADP_Acknowledge - handle appropriately. |
| * If expected message read arguments and return RDIError_NoError. |
| * Note: if RDIError occurs then the data values returned are junk |
| */ |
| |
| unpack_message(BUFFERDATA((*packet)->pk_buffer), "%w%w%w%w%w", &reason, debugID, |
| OSinfo1, OSinfo2, status); |
| if ((reason&0xffffff) == ADP_HADPUnrecognised) |
| return RDIError_UnimplementedMessage; |
| if (reason != (unsigned ) *rcode) { |
| if((reason&0xffffff) == ADP_HADPUnrecognised) |
| return RDIError_UnimplementedMessage; |
| else { |
| angel_DebugPrint("ARDI ERROR: Expected reasoncode %x got reasoncode %x.\n", |
| *rcode, reason); |
| return RDIError_Error; |
| } |
| } |
| else |
| return RDIError_NoError; |
| return RDIError_Error; /* stop a pesky ANSI compiler warning */ |
| } |
| |
| |
| /* |
| * Handler and registration for logging messages from target |
| */ |
| static void TargetLogCallback( Packet *packet, void *state ) |
| { |
| p_Buffer reply = BUFFERDATA(packet->pk_buffer); |
| unsigned int len = packet->pk_length; |
| IGNORE(state); |
| angel_hostif->write(angel_hostif->hostosarg, |
| (char *)reply, len - CHAN_HEADER_SIZE); |
| DevSW_FreePacket(packet); |
| |
| packet = DevSW_AllocatePacket(4); /* better not ask for 0 */ |
| /* the reply is the ACK - any contents are ignored */ |
| if (packet != NULL) |
| Adp_ChannelWrite( CI_TLOG, packet ); |
| } |
| |
| static void TargetLogInit( void ) |
| { |
| AdpErrs err = Adp_ChannelRegisterRead( CI_TLOG, TargetLogCallback, NULL ); |
| |
| #ifdef DEBUG |
| if (err != adp_ok) |
| angel_DebugPrint("CI_TLOG RegisterRead failed %d\n", err); |
| #else |
| IGNORE(err); |
| #endif |
| } |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_open-----------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| typedef struct NegotiateState { |
| bool negotiate_resp; |
| bool negotiate_ack; |
| bool link_check_resp; |
| ParameterConfig *accepted_config; |
| } NegotiateState; |
| |
| static void receive_negotiate(Packet *packet, void *stateptr) |
| { |
| unsigned reason, debugID, OSinfo1, OSinfo2, status; |
| NegotiateState *n_state = (NegotiateState *)stateptr; |
| p_Buffer reply = BUFFERDATA(packet->pk_buffer); |
| |
| unpack_message( reply, "%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2 ); |
| reply += ADP_DEFAULT_HEADER_SIZE; |
| |
| #ifdef DEBUG |
| angel_DebugPrint( "receive_negotiate: reason %x\n", reason ); |
| #endif |
| |
| switch ( reason ) |
| { |
| case ADP_ParamNegotiate | TtoH: |
| { |
| n_state->negotiate_resp = TRUE; |
| |
| status = GET32LE( reply ); |
| reply += sizeof(word); |
| #ifdef DEBUG |
| angel_DebugPrint( "ParamNegotiate status %u\n", status ); |
| #endif |
| if ( status == RDIError_NoError ) |
| { |
| if ( Angel_ReadParamConfigMessage( |
| reply, n_state->accepted_config ) ) |
| n_state->negotiate_ack = TRUE; |
| } |
| break; |
| } |
| |
| case ADP_LinkCheck | TtoH: |
| { |
| #ifdef DEBUG |
| angel_DebugPrint( "PONG!\n" ); |
| #endif |
| n_state->link_check_resp = TRUE; |
| break; |
| } |
| |
| default: |
| { |
| #ifdef DEBUG |
| angel_DebugPrint( "Unexpected!\n" ); |
| #endif |
| break; |
| } |
| } |
| DevSW_FreePacket( packet ); |
| } |
| |
| # include <sys/types.h> |
| #ifdef __unix |
| # include <sys/time.h> |
| #else |
| # include <time.h> |
| #endif |
| |
| /* |
| * convert a config into a single-valued options list |
| */ |
| static ParameterOptions *config_to_options( const ParameterConfig *config ) |
| { |
| unsigned int num_params; |
| size_t size; |
| ParameterOptions *base_p; |
| |
| num_params = config->num_parameters; |
| size = |
| sizeof(ParameterOptions) |
| + num_params*(sizeof(ParameterList) + sizeof(unsigned int)); |
| base_p = malloc( size ); |
| |
| if ( base_p != NULL ) |
| { |
| unsigned int u; |
| ParameterList *list_p = |
| (ParameterList *)((char *)base_p + sizeof(ParameterOptions)); |
| unsigned int *option_p = |
| (unsigned int *)(list_p + num_params); |
| |
| base_p->num_param_lists = num_params; |
| base_p->param_list = list_p; |
| |
| for ( u = 0; u < num_params; ++u ) |
| { |
| option_p[u] = config->param[u].value; |
| list_p[u].type = config->param[u].type; |
| list_p[u].num_options = 1; |
| list_p[u].option = &option_p[u]; |
| } |
| } |
| |
| return base_p; |
| } |
| |
| static AdpErrs negotiate_params( const ParameterOptions *user_options ) |
| { |
| Packet *packet; |
| unsigned int count; |
| static Parameter params[AP_NUM_PARAMS]; |
| static ParameterConfig accepted_config = { AP_NUM_PARAMS, params }; |
| |
| time_t t; |
| |
| static volatile NegotiateState n_state; |
| n_state.negotiate_resp = FALSE; |
| n_state.negotiate_ack = FALSE; |
| n_state.link_check_resp = FALSE; |
| n_state.accepted_config = &accepted_config; |
| |
| #ifdef DEBUG |
| angel_DebugPrint( "negotiate_params\n" ); |
| #endif |
| |
| Adp_ChannelRegisterRead( CI_HBOOT, receive_negotiate, (void *)&n_state ); |
| |
| packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize); |
| count = msgbuild( BUFFERDATA(packet->pk_buffer), "%w%w%w%w", |
| ADP_ParamNegotiate | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown ); |
| count += Angel_BuildParamOptionsMessage( |
| BUFFERDATA(packet->pk_buffer) + count, user_options ); |
| packet->pk_length = count; |
| Adp_ChannelWriteAsync( CI_HBOOT, packet ); |
| |
| #ifdef DEBUG |
| angel_DebugPrint( "sent negotiate packet\n" ); |
| #endif |
| |
| t=time(NULL); |
| |
| do { |
| Adp_AsynchronousProcessing(async_block_on_nothing); |
| |
| if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD) { |
| return adp_timeout_on_open; |
| } |
| } while ( ! n_state.negotiate_resp ); |
| |
| if ( n_state.negotiate_ack ) |
| { |
| /* select accepted config */ |
| Adp_Ioctl( DC_SET_PARAMS, (void *)n_state.accepted_config ); |
| |
| /* |
| * 960430 KWelton |
| * |
| * There is a race in the renegotiation protocol: the |
| * target has to have had time to load new config before |
| * we send the link check packet - insert a deliberate |
| * pause (100ms) to give the target some time |
| */ |
| Adp_delay(100000); |
| |
| /* do link check */ |
| msgsend( CI_HBOOT, "%w%w%w%w", ADP_LinkCheck | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown ); |
| #ifdef DEBUG |
| angel_DebugPrint("sent link check\n"); |
| #endif |
| |
| do { |
| Adp_AsynchronousProcessing(async_block_on_read); |
| } while ( ! n_state.link_check_resp ); |
| Adp_initSeq(); |
| } |
| return adp_ok; |
| } |
| |
| static int late_booted = FALSE; |
| static bool ardi_handler_installed = FALSE; |
| |
| #ifdef __unix |
| static struct sigaction old_action; |
| #else |
| static void (*old_handler)(); |
| #endif |
| |
| static bool boot_interrupted = FALSE; |
| static volatile bool interrupt_request = FALSE; |
| static volatile bool stop_request = FALSE; |
| |
| static void ardi_sigint_handler(int sig) { |
| #ifdef DEBUG |
| if (sig != SIGINT) |
| angel_DebugPrint("Expecting SIGINT got %d.\n", sig); |
| #else |
| IGNORE(sig); |
| #endif |
| boot_interrupted = TRUE; |
| interrupt_request = TRUE; |
| #ifndef __unix |
| signal(SIGINT, ardi_sigint_handler); |
| #endif |
| } |
| |
| static void install_ardi_handler( void ) { |
| if (!ardi_handler_installed) { |
| /* install a new Ctrl-C handler so we can abandon waiting */ |
| #ifdef __unix |
| struct sigaction new_action; |
| sigemptyset(&new_action.sa_mask); |
| new_action.sa_handler = ardi_sigint_handler; |
| new_action.sa_flags = 0; |
| sigaction(SIGINT, &new_action, &old_action); |
| #else |
| old_handler = signal(SIGINT, ardi_sigint_handler); |
| #endif |
| ardi_handler_installed = TRUE; |
| } |
| } |
| |
| static int angel_RDI_errmess(char *buf, int blen, int errnum); |
| |
| static void receive_reset_acknowledge(Packet *packet, void *stateptr) { |
| unsigned reason, debugID, OSinfo1, OSinfo2, status; |
| IGNORE(stateptr); |
| |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &status); |
| if (reason==(ADP_Reset | TtoH) && status==AB_NORMAL_ACK) { |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Successfully received normal reset acknowledgement\n"); |
| late_booted = FALSE; |
| #endif |
| } else if (reason==(ADP_Reset | TtoH) && status==AB_LATE_ACK) { |
| char late_msg[AdpMessLen_LateStartup]; |
| int late_len; |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Successfully received LATE reset acknowledgement\n"); |
| #endif |
| late_booted = TRUE; |
| install_ardi_handler(); |
| late_len = angel_RDI_errmess(late_msg, |
| AdpMessLen_LateStartup, adp_late_startup); |
| angel_hostif->write(angel_hostif->hostosarg, late_msg, late_len); |
| } else { |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Bad reset ack: reason=%8X, status=%8X\n", reason, status); |
| #endif |
| } |
| DevSW_FreePacket(packet); |
| } |
| |
| static int booted_not_received; |
| static unsigned int angel_version; |
| static unsigned int adp_version; |
| static unsigned int arch_info; |
| static unsigned int cpu_info; |
| static unsigned int hw_status; |
| |
| static void receive_booted(Packet *packet, void *stateptr) { |
| unsigned reason, debugID, OSinfo1, OSinfo2, banner_length, bufsiz, longsiz; |
| unsigned i, count; |
| |
| IGNORE(stateptr); |
| |
| count = unpack_message(BUFFERDATA(packet->pk_buffer), |
| "%w%w%w%w%w%w%w%w%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2, &bufsiz, &longsiz, |
| &angel_version, &adp_version, |
| &arch_info, &cpu_info, &hw_status, &banner_length); |
| if (reason==(ADP_Booted | TtoH)) { |
| #ifdef MONITOR_DOWNLOAD_PACKETS |
| angel_DebugPrint("DEBUG: Successfully received Booted\n"); |
| angel_DebugPrint(" cpu_info=%8X, hw_status=%8X, bufsiz=%d, longsiz=%d\n", |
| cpu_info, hw_status, bufsiz, longsiz); |
| #endif |
| /* Get the banner from the booted message */ |
| for (i=0; i<banner_length; i++) |
| angel_hostif->writec(angel_hostif->hostosarg, |
| (BUFFERDATA(packet->pk_buffer)+count)[i]); |
| |
| booted_not_received=0; |
| #ifndef NO_HEARTBEAT |
| heartbeat_enabled = TRUE; |
| #endif |
| Armsd_BufferSize = bufsiz + CHAN_HEADER_SIZE; |
| Armsd_LongBufSize = longsiz + CHAN_HEADER_SIZE; |
| } else { |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Bad Booted msg: reason=%8X\n", reason); |
| #endif |
| } |
| DevSW_FreePacket(packet); |
| } |
| |
| |
| /* forward declaration */ |
| static int angel_negotiate_defaults( void ); |
| |
| /* Open communications. */ |
| int angel_RDI_open( |
| unsigned type, Dbg_ConfigBlock const *config, |
| Dbg_HostosInterface const *hostif, struct Dbg_MCState *dbg_state) |
| { |
| Packet *packet; |
| int status, reasoncode, debugID, OSinfo1, OSinfo2, err; |
| ParameterOptions *user_options = NULL; |
| |
| time_t t; |
| |
| IGNORE( dbg_state ); |
| |
| if ((type & 1) == 0) { |
| /* cold start */ |
| if (hostif != NULL) { |
| angel_hostif = hostif; |
| err = HostSysInit(hostif, &ardi_commandline, &hstate); |
| if (err != RDIError_NoError) { |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: HostSysInit error %i\n",err); |
| #endif |
| return err; |
| } |
| } |
| TargetLogInit(); |
| } |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Buffer allocated in angel_RDI_open(type=%i).\n",type); |
| #endif |
| |
| if ((type & 1) == 0) { |
| /* cold start */ |
| unsigned endian; |
| Adp_Ioctl( DC_GET_USER_PARAMS, (void *)&user_options ); |
| if ( user_options != NULL ) { |
| err = negotiate_params( user_options ); |
| if (err != adp_ok) return err; |
| } |
| else { |
| ParameterConfig *default_config = NULL; |
| Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config ); |
| if ( default_config != NULL ) { |
| ParameterOptions *default_options = config_to_options(default_config); |
| err = negotiate_params( default_options ); |
| if (err != adp_ok) return err; |
| } |
| } |
| |
| /* Register handlers before sending any messages */ |
| booted_not_received=1; |
| Adp_ChannelRegisterRead(CI_HBOOT, receive_reset_acknowledge, NULL); |
| Adp_ChannelRegisterRead(CI_TBOOT, receive_booted, NULL); |
| endian = 0; |
| if (config!=NULL) { |
| if (config->bytesex & RDISex_Little) endian |= ADP_BootHostFeature_LittleEnd; |
| if (config->bytesex & RDISex_Big) endian |= ADP_BootHostFeature_BigEnd; |
| } |
| msgsend(CI_HBOOT,"%w%w%w%w%w", ADP_Reset | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, endian); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Transmitted Reset message in angel_RDI_open.\n"); |
| #endif |
| |
| /* We will now either get an acknowledgement for the Reset message |
| * or if the target was started after the host, we will get a |
| * rebooted message first. |
| */ |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: waiting for a booted message\n"); |
| #endif |
| |
| { |
| boot_interrupted = FALSE; |
| |
| if (late_booted) |
| install_ardi_handler(); |
| |
| t=time(NULL); |
| |
| do { |
| Adp_AsynchronousProcessing(async_block_on_nothing); |
| if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD && !late_booted) { |
| return adp_timeout_on_open; |
| } |
| } while (booted_not_received && !boot_interrupted); |
| |
| if (ardi_handler_installed) |
| { |
| /* uninstall our Ctrl-C handler */ |
| #ifdef __unix |
| sigaction(SIGINT, &old_action, NULL); |
| #else |
| signal(SIGINT, old_handler); |
| #endif |
| } |
| |
| if (boot_interrupted) { |
| angel_negotiate_defaults(); |
| return adp_abandon_boot_wait; |
| } |
| } |
| |
| booted_not_received=1; |
| Adp_ChannelRegisterRead(CI_HBOOT, NULL, NULL); |
| |
| /* Leave the booted handler installed */ |
| msgsend(CI_TBOOT, "%w%w%w%w%w", ADP_Booted | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, 0); |
| Adp_initSeq(); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Transmitted ADP_Booted acknowledgement.\n"); |
| angel_DebugPrint("DEBUG: Boot sequence completed, leaving angel_RDI_open.\n"); |
| #endif |
| |
| return (hw_status & ADP_CPU_BigEndian )? RDIError_BigEndian : |
| RDIError_LittleEndian; |
| } |
| else { |
| /* warm start */ |
| register_debug_message_handler(); |
| |
| msgsend(CI_HADP, "%w%w%w%w", |
| ADP_InitialiseApplication | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Transmitted Initialise Application\n"); |
| #endif |
| reasoncode=ADP_InitialiseApplication | TtoH; |
| err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) return err; |
| return status; |
| } |
| return -1; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_close----------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| static int angel_negotiate_defaults( void ) { |
| int err = adp_ok; |
| ParameterConfig *default_config = NULL; |
| Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config ); |
| if ( default_config != NULL ) { |
| ParameterOptions *default_options = config_to_options(default_config); |
| err = negotiate_params( default_options ); |
| free( default_options ); |
| } |
| return err; |
| } |
| |
| int angel_RDI_close(void) { |
| /*Angel host exit */ |
| int err; |
| int status,debugID, OSinfo1,OSinfo2; |
| int reason; |
| Packet *packet = NULL;; |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_Close.\n"); |
| #endif |
| |
| register_debug_message_handler(); |
| |
| heartbeat_enabled = FALSE; |
| |
| err = msgsend(CI_HADP,"%w%w%w%w",ADP_End | HtoT,0, |
| ADP_HandleUnknown, ADP_HandleUnknown); |
| if (err != RDIError_NoError) return err; |
| reason = ADP_End | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| DevSW_FreePacket(packet); |
| if (err != RDIError_NoError) return err; |
| if (status == RDIError_NoError) { |
| err = angel_negotiate_defaults(); |
| if (err != adp_ok) return err; |
| Adp_Ioctl( DC_RESET, NULL ); /* just to be safe */ |
| return HostSysExit(hstate); |
| } |
| else |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_read-----------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Read memory contents from target to host: use ADP_Read */ |
| int angel_RDI_read(ARMword source, void *dest, unsigned *nbytes) |
| { |
| Packet *packet=NULL; |
| int len; /* Integer to hold message length. */ |
| unsigned int nbtogo = *nbytes, nbinpacket, nbdone=0; |
| int rnbytes = 0, status, reason, debugID, OSinfo1, OSinfo2, err; |
| unsigned int maxlen = Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ReadHeaderSize; |
| |
| /* Print debug trace information, this is just copied straight from rdi.c |
| and I can see no reason why it should have to be changed. */ |
| TracePrint(("angel_RDI_read: source=%.8lx dest=%p nbytes=%.8x\n", |
| (unsigned long)source, dest, *nbytes)); |
| if (*nbytes == 0) return RDIError_NoError; /* Read nothing - easy! */ |
| /* check the buffer size */ |
| while (nbtogo >0) { |
| register_debug_message_handler(); |
| |
| nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen; |
| len = msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Read | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, source+nbdone, |
| nbinpacket); |
| reason=ADP_Read | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| TracePrint(("angel_RDI_read: nbinpacket =%d status=%08x err = %d\n", |
| nbinpacket,status,err)); |
| if (err != RDIError_NoError) return err; /* Was there an error? */ |
| if (status == RDIError_NoError){ |
| rnbytes += PREAD(LE,(unsigned int *)(BUFFERDATA(packet->pk_buffer)+20)); |
| TracePrint(("angel_RDI_read: rnbytes = %d\n",rnbytes)); |
| memcpy(((unsigned char *)dest)+nbdone, BUFFERDATA(packet->pk_buffer)+24, |
| nbinpacket); |
| } |
| nbdone += nbinpacket; |
| nbtogo -= nbinpacket; |
| } |
| *nbytes -= rnbytes; |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_write----------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Transfer memory block from host to target. Use ADP_Write>. */ |
| int angel_RDI_write(const void *source, ARMword dest, unsigned *nbytes) |
| { |
| Packet *packet;/* Message buffers. */ |
| unsigned int len, nbtogo = *nbytes, nboffset = 0, nbinpacket; |
| int status, reason, debugID, OSinfo1, OSinfo2, err; |
| unsigned int maxlen = Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_WriteHeaderSize; |
| |
| TracePrint(("angel_RDI_write: source=%p dest=%.8lx nbytes=%.8x\n", |
| source, (unsigned long)dest, *nbytes)); |
| |
| if (*nbytes == 0) return RDIError_NoError; |
| |
| *nbytes = 0; |
| while (nbtogo > 0) { |
| packet = (Packet *) DevSW_AllocatePacket(Armsd_LongBufSize); |
| nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen; |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", |
| ADP_Write | HtoT, 0, ADP_HandleUnknown, |
| ADP_HandleUnknown, dest+nboffset, nbinpacket); |
| /* Copy the data into the packet. */ |
| |
| memcpy(BUFFERDATA(packet->pk_buffer)+len, |
| ((const unsigned char *) source)+nboffset, nbinpacket); |
| nboffset += nbinpacket; |
| packet->pk_length = nbinpacket+len; |
| |
| #ifdef MONITOR_DOWNLOAD_PACKETS |
| angel_DebugPrint("angel_RDI_write packet size=%i, bytes done=%i\n", |
| nbinpacket, nboffset); |
| #endif |
| |
| register_debug_message_handler(); |
| Adp_ChannelWrite(CI_HADP, packet); |
| reason=ADP_Write | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| nbtogo -= nbinpacket; |
| if (err != RDIError_NoError) return err; |
| if (status == RDIError_NoError) |
| *nbytes += nbinpacket; |
| |
| DevSW_FreePacket(packet); |
| } |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_CPUread--------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Reads the values of registers in the CPU, uses ADP_CPUwrite. */ |
| int angel_RDI_CPUread(unsigned mode, unsigned long mask, ARMword *buffer) |
| { |
| unsigned int i, j; |
| Packet *packet = NULL; |
| int err, status, reason, debugID, OSinfo1, OSinfo2; |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_CPUread.\n"); |
| #endif |
| for (i=0, j=0 ; i < RDINumCPURegs ; i++) |
| if (mask & (1L << i)) j++; /* Count the number of registers. */ |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%c%w", ADP_CPUread | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, mode, mask); |
| reason = ADP_CPUread | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| if(status == RDIError_NoError) { |
| for (i=0; i<j; i++) |
| buffer[i] = GET32LE(BUFFERDATA(packet->pk_buffer)+20+(i*4)); |
| TracePrint(("angel_RDI_CPUread: mode=%.8x mask=%.8lx", mode, mask)); |
| DevSW_FreePacket(packet); |
| #ifdef RDI_VERBOSE |
| if (rdi_log & 1) { |
| unsigned k; |
| for (k = 0, j = 0 ; j <= 20 ; j++) |
| if (mask & (1L << j)) { |
| angel_DebugPrint("%c%.8lx",k%4==0?'\n':' ', |
| (unsigned long)buffer[k]); |
| k++ ; |
| } |
| angel_DebugPrint("\n") ; |
| } |
| #endif |
| |
| } |
| return status; |
| } |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_CPUwrite-------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Write CPU registers: use ADP_CPUwrite. */ |
| int angel_RDI_CPUwrite(unsigned mode, unsigned long mask, |
| ARMword const *buffer){ |
| |
| unsigned i, j, c; |
| Packet *packet; |
| int status, reason, debugID, OSinfo1, OSinfo2, err, len; |
| |
| TracePrint(("angel_RDI_CPUwrite: mode=%.8x mask=%.8lx", mode, mask)); |
| #ifdef RDI_VERBOSE |
| if (rdi_log & 1) { |
| for (j = 0, i = 0 ; i <= 20 ; i++) |
| if (mask & (1L << i)) { |
| angel_DebugPrint("%c%.8lx",j%4==0?'\n':' ', |
| (unsigned long)buffer[j]); |
| j++ ; |
| } |
| angel_DebugPrint("\n") ; |
| } |
| #endif |
| packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize); |
| for (i=0, j=0; i < RDINumCPURegs ; i++) |
| if (mask & (1L << i)) j++; /* count the number of registers */ |
| |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%b%w", |
| ADP_CPUwrite | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, mode, mask); |
| for(c=0; c<j; c++) |
| PUT32LE(BUFFERDATA(packet->pk_buffer)+len+(c*4), buffer[c]); |
| packet->pk_length = len+(j*4); |
| register_debug_message_handler(); |
| |
| Adp_ChannelWrite(CI_HADP, packet); |
| reason = ADP_CPUwrite | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &status); |
| DevSW_FreePacket(packet); |
| if (err != RDIError_NoError) |
| return err; /* Was there an error? */ |
| else |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_CPread---------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Read coprocessor's internal state. See dbg_cp.h for help. |
| * Use ADP_CPRead. |
| * It would appear that the correct behaviour at this point is to leave |
| * the unpacking to a the caller and to simply copy the stream of data |
| * words into the buffer |
| */ |
| |
| int angel_RDI_CPread(unsigned CPnum, unsigned long mask, ARMword *buffer){ |
| Packet *packet = NULL; |
| int i, j, status, reasoncode, OSinfo1, OSinfo2, err, debugID; |
| unsigned char *rmap = cpwords[CPnum]; |
| int n; |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_CPread.\n"); |
| #endif |
| if (rmap == NULL) return RDIError_UnknownCoPro; |
| |
| register_debug_message_handler(); |
| n = rmap[-1]; |
| msgsend(CI_HADP, "%w%w%w%w%b%w", ADP_CPread | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask); |
| reasoncode=ADP_CPread | TtoH; |
| err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; /* Was there an error? */ |
| } |
| for (j=i=0; i < n ; i++) /* count the number of registers */ |
| if (mask & (1L << i)) { |
| j++; |
| } |
| for (i=0; i<j; i++) |
| buffer[i] = PREAD32(LE, BUFFERDATA(packet->pk_buffer) + 20 + (i*4)); |
| DevSW_FreePacket(packet); |
| TracePrint(("angel_RDI_CPread: CPnum=%.8x mask=%.8lx\n", CPnum, mask)); |
| #ifdef RDI_VERBOSE |
| if (rdi_log & 1) { |
| for (i = 0, j = 0; j < n ; j++) { |
| if (mask & (1L << j)) { |
| int nw = rmap[j]; |
| angel_DebugPrint("%2d ", j); |
| while (--nw > 0) |
| angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]); |
| angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]); |
| } |
| } |
| } |
| #endif |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_CPwrite--------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Write coprocessor's internal state. See dbg_cp.h for help. Use |
| * ADP_CPwrite. |
| */ |
| |
| int angel_RDI_CPwrite(unsigned CPnum, unsigned long mask, |
| ARMword const *buffer) |
| { |
| Packet *packet = NULL; |
| int i, j, len, status, reason, OSinfo1, OSinfo2, err, debugID; |
| unsigned char *rmap = cpwords[CPnum]; |
| int n; |
| |
| if (rmap == NULL) return RDIError_UnknownCoPro; |
| n = rmap[-1]; |
| |
| TracePrint(("angel_RDI_CPwrite: CPnum=%d mask=%.8lx\n", CPnum, mask)); |
| |
| #ifdef RDI_VERBOSE |
| if (rdi_log & 1) { |
| for (i = 0, j = 0; j < n ; j++) |
| if (mask & (1L << j)) { |
| int nw = rmap[j]; |
| angel_DebugPrint("%2d ", j); |
| while (--nw > 0) |
| angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]); |
| angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]); |
| } |
| } |
| #endif |
| |
| for (j=i=0; i < n ; i++) /* Count the number of registers. */ |
| if (mask & (1L << i)) j++; |
| packet = DevSW_AllocatePacket(Armsd_BufferSize); |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%c%w", |
| ADP_CPwrite | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask); |
| for(i=0; i<j; i++) |
| len+=msgbuild(BUFFERDATA(packet->pk_buffer) + len, "%w", buffer[i]); |
| packet->pk_length = len; |
| register_debug_message_handler(); |
| Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */ |
| reason=ADP_CPwrite | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| DevSW_FreePacket(packet); |
| if (err != RDIError_NoError) |
| return err; |
| else |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_pointinq-------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Do test calls to ADP_SetBreak/ADP_SetWatch to see if resources exist to |
| carry out request. */ |
| int angel_RDI_pointinq(ARMword *address, unsigned type, unsigned datatype, |
| ARMword *bound) |
| { |
| Packet *packet = NULL; |
| int len, status, reason, OSinfo1, OSinfo2, err=RDIError_NoError; |
| /* stop a compiler warning */ |
| int debugID, pointhandle; |
| TracePrint( |
| ("angel_RDI_pointinq: address=%.8lx type=%d datatype=%d bound=%.8lx ", |
| (unsigned long)*address, type, datatype, (unsigned long)*bound)); |
| /* for a buffer. */ |
| packet = DevSW_AllocatePacket(Armsd_BufferSize); |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b", |
| ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch) | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, address, type); |
| if (datatype == 0) |
| len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%w", bound); |
| else |
| len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%b%w", datatype, bound); |
| |
| register_debug_message_handler(); |
| packet->pk_length = len; |
| Adp_ChannelWrite(CI_HADP, packet); |
| reason = ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch | TtoH); |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; /* Was there an error? */ |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2, &status, |
| &pointhandle, &address, &bound); |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_setbreak-------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Set a breakpoint: Use ADP_SetBreak */ |
| int angel_RDI_setbreak(ARMword address, unsigned type, ARMword bound, |
| PointHandle *handle) |
| { |
| int status, reason, OSinfo1, OSinfo2, err, debugID; |
| int tmpval, tmpaddr, tmpbnd; |
| Packet *packet; |
| TracePrint(("angel_RDI_setbreak address=%.8lx type=%d bound=%.8lx \n", |
| (unsigned long)address, type, (unsigned long)bound)); |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%b%w", |
| ADP_SetBreak| HtoT, 0, ADP_HandleUnknown, |
| ADP_HandleUnknown, address, type, bound); |
| reason = ADP_SetBreak |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; /* Was there an error? */ |
| } |
| /* Work around varargs problem... -sts */ |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2, &status, |
| &tmpval, &tmpaddr, &tmpbnd); |
| *handle = tmpval; |
| address = tmpaddr; |
| bound = tmpbnd; |
| DevSW_FreePacket(packet); |
| if (status != RDIError_NoError) return status; |
| TracePrint(("returns handle %.8lx\n", (unsigned long)*handle)); |
| return RDIError_NoError; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_clearbreak-----------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Clear a breakpoint: Use ADP_ClearBreak. */ |
| int angel_RDI_clearbreak(PointHandle handle) |
| { |
| Packet *packet = NULL; |
| int status, reason, OSinfo1, OSinfo2, err, debugID; |
| |
| TracePrint(("angel_RDI_clearbreak: handle=%.8lx\n", (unsigned long)handle)); |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", |
| ADP_ClearBreak| HtoT, 0, ADP_HandleUnknown, |
| ADP_HandleUnknown, handle); |
| reason = ADP_ClearBreak|TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| angel_DebugPrint("***RECEIVE DEBUG MESSAGE RETURNED ERR = %d.\n", err); |
| return err; /* Was there an error? */ |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &status); |
| DevSW_FreePacket(packet); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Clear Break completed OK.\n"); |
| #endif |
| return RDIError_NoError; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_setwatch-------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Set a watchpoint: use ADP_SetWatch. */ |
| int angel_RDI_setwatch(ARMword address, unsigned type, unsigned datatype, |
| ARMword bound, PointHandle *handle) |
| { |
| Packet *packet = NULL; |
| int status, reason, OSinfo1, OSinfo2, err, debugID; |
| |
| TracePrint(("angel_RDI_setwatch: address=%.8lx type=%d bound=%.8lx ", |
| (unsigned long)address, type, (unsigned long)bound)); |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%b%b%w", |
| ADP_SetWatch| HtoT, 0, ADP_HandleUnknown, |
| ADP_HandleUnknown, address, type, datatype, bound); |
| |
| reason = ADP_SetWatch | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; /* Was there an error? */ |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2, &status, |
| handle, &address, &bound); |
| DevSW_FreePacket(packet); |
| TracePrint(("returns handle %.8lx\n", (unsigned long)*handle)); |
| return RDIError_NoError; |
| } |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_clearwatch-----------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Clear a watchpoint: use ADP_ClearWatch. */ |
| int angel_RDI_clearwatch(PointHandle handle) { |
| |
| int status, reason, OSinfo1, OSinfo2, err, debugID; |
| Packet *packet = NULL; |
| |
| TracePrint(("angel_RDI_clearwatch: handle=%.8lx\n", (unsigned long)handle)); |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", |
| ADP_ClearWatch| HtoT, 0, ADP_HandleUnknown, |
| ADP_HandleUnknown, handle); |
| reason = ADP_ClearWatch|TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; /* Was there an error? */ |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &status); |
| DevSW_FreePacket(packet); |
| return RDIError_NoError; |
| } |
| |
| typedef struct { |
| unsigned stopped_reason; |
| int stopped_status; |
| int data; |
| } adp_stopped_struct; |
| |
| |
| int angel_RDI_OnTargetStopping(angel_RDI_TargetStoppedProc *fn, |
| void *arg) |
| { |
| stoppedProcListElement **lptr = &stopped_proc_list; |
| |
| /* Find the address of the NULL ptr at the end of the list */ |
| for (; *lptr!=NULL ; lptr = &((*lptr)->next)) |
| ; /* Do nothing */ |
| |
| *lptr = (stoppedProcListElement *) malloc(sizeof(stoppedProcListElement)); |
| if (*lptr == NULL) return RDIError_OutOfStore; |
| (*lptr)->fn = fn; |
| (*lptr)->arg = arg; |
| |
| return RDIError_NoError; |
| } |
| |
| static int CallStoppedProcs(unsigned reason) |
| { |
| stoppedProcListElement *p = stopped_proc_list; |
| int err=RDIError_NoError; |
| |
| for (; p!=NULL ; p=p->next) { |
| int local_err = p->fn(reason, p->arg); |
| if (local_err != RDIError_NoError) err=local_err; |
| } |
| |
| return err; |
| } |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_execute--------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| static int HandleStoppedMessage(Packet *packet, void *stateptr) { |
| unsigned int err, reason, debugID, OSinfo1, OSinfo2, count; |
| adp_stopped_struct *stopped_info; |
| stopped_info = (adp_stopped_struct *) stateptr; |
| IGNORE(stateptr); |
| count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", |
| &reason, &debugID, |
| &OSinfo1, &OSinfo2, |
| &stopped_info->stopped_reason, &stopped_info->data); |
| DevSW_FreePacket(packet); |
| |
| if (reason != (ADP_Stopped | TtoH)) { |
| #ifdef DEBUG |
| angel_DebugPrint("Expecting stopped message, got %x", reason); |
| #endif |
| return RDIError_Error; |
| } |
| else { |
| executing = FALSE; |
| #ifdef DEBUG |
| angel_DebugPrint("Received stopped message.\n"); |
| #endif |
| } |
| |
| err = msgsend(CI_TADP, "%w%w%w%w%w", (ADP_Stopped | HtoT), 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, RDIError_NoError); |
| #ifdef DEBUG |
| angel_DebugPrint("Transmiting stopped acknowledge.\n"); |
| #endif |
| if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n"); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Stopped reason : %x\n", stopped_info->stopped_reason); |
| #endif |
| switch (stopped_info->stopped_reason) { |
| case ADP_Stopped_BranchThroughZero: |
| stopped_info->stopped_status = RDIError_BranchThrough0; |
| break; |
| case ADP_Stopped_UndefinedInstr: |
| stopped_info->stopped_status = RDIError_UndefinedInstruction; |
| break; |
| case ADP_Stopped_SoftwareInterrupt: |
| stopped_info->stopped_status = RDIError_SoftwareInterrupt; |
| break; |
| case ADP_Stopped_PrefetchAbort: |
| stopped_info->stopped_status = RDIError_PrefetchAbort; |
| break; |
| case ADP_Stopped_DataAbort: |
| stopped_info->stopped_status = RDIError_DataAbort; |
| break; |
| case ADP_Stopped_AddressException: |
| stopped_info->stopped_status = RDIError_AddressException; |
| break; |
| case ADP_Stopped_IRQ: |
| stopped_info->stopped_status = RDIError_IRQ; |
| break; |
| case ADP_Stopped_BreakPoint: |
| stopped_info->stopped_status = RDIError_BreakpointReached; |
| break; |
| case ADP_Stopped_WatchPoint: |
| stopped_info->stopped_status = RDIError_WatchpointAccessed; |
| break; |
| case ADP_Stopped_StepComplete: |
| stopped_info->stopped_status = RDIError_ProgramFinishedInStep; |
| break; |
| case ADP_Stopped_RunTimeErrorUnknown: |
| case ADP_Stopped_StackOverflow: |
| case ADP_Stopped_DivisionByZero: |
| stopped_info->stopped_status = RDIError_Error; |
| break; |
| case ADP_Stopped_FIQ: |
| stopped_info->stopped_status = RDIError_FIQ; |
| break; |
| case ADP_Stopped_UserInterruption: |
| case ADP_Stopped_OSSpecific: |
| stopped_info->stopped_status = RDIError_UserInterrupt; |
| break; |
| case ADP_Stopped_ApplicationExit: |
| stopped_info->stopped_status = RDIError_NoError; |
| break; |
| default: |
| stopped_info->stopped_status = RDIError_Error; |
| break; |
| } |
| return RDIError_NoError; |
| } |
| |
| |
| static void interrupt_target( void ) |
| { |
| Packet *packet = NULL; |
| int err; |
| int reason, debugID, OSinfo1, OSinfo2, status; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: interrupt_target.\n"); |
| #endif |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w", ADP_InterruptRequest | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown); |
| |
| reason = ADP_InterruptRequest |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| DevSW_FreePacket(packet); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: got interrupt ack ok err = %d, status=%i\n", |
| err, status); |
| #endif |
| |
| return; |
| } |
| |
| #ifdef TEST_DC_APPL |
| extern void test_dc_appl_handler( const DeviceDescr *device, |
| Packet *packet ); |
| #endif |
| |
| void angel_RDI_stop_request(void) |
| { |
| stop_request = 1; |
| } |
| |
| /* Core functionality for execute and step */ |
| static int angel_RDI_ExecuteOrStep(PointHandle *handle, word type, |
| unsigned ninstr) |
| { |
| extern int (*ui_loop_hook) (int); |
| int err; |
| adp_stopped_struct stopped_info; |
| void* stateptr = (void *)&stopped_info; |
| ChannelCallback HandleStoppedMessageFPtr=(ChannelCallback) HandleStoppedMessage; |
| int status, reasoncode, debugID, OSinfo1, OSinfo2; |
| Packet *packet = NULL; |
| |
| TracePrint(("angel_RDI_ExecuteOrStep\n")); |
| |
| err = Adp_ChannelRegisterRead(CI_TADP, |
| HandleStoppedMessageFPtr, stateptr); |
| if (err != RDIError_NoError) { |
| #ifdef DEBUG |
| angel_DebugPrint("TADP Register failed.\n"); |
| #endif |
| return err; |
| } |
| /* Set executing TRUE here, as it must be set up before the target has |
| * had any chance at all to execute, or it may send its stopped message |
| * before we get round to setting executing = TRUE !!! |
| */ |
| executing = TRUE; |
| |
| register_debug_message_handler(); |
| |
| #ifdef TEST_DC_APPL |
| Adp_Install_DC_Appl_Handler( test_dc_appl_handler ); |
| #endif |
| |
| #ifdef DEBUG |
| angel_DebugPrint("Transmiting %s message.\n", |
| type == ADP_Execute ? "execute": "step"); |
| #endif |
| |
| register_debug_message_handler(); |
| /* Extra ninstr parameter for execute message will simply be ignored */ |
| err = msgsend(CI_HADP,"%w%w%w%w%w", type | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, ninstr); |
| #if DEBUG |
| if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n"); |
| #endif |
| |
| reasoncode = type | TtoH; |
| err = wait_for_debug_message( &reasoncode, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet ); |
| if (err != RDIError_NoError) |
| return err; |
| else if (status != RDIError_NoError) |
| return status; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("Waiting for program to finish...\n"); |
| #endif |
| |
| interrupt_request = FALSE; |
| stop_request = FALSE; |
| |
| signal(SIGINT, ardi_sigint_handler); |
| while( executing ) |
| { |
| if (ui_loop_hook) |
| ui_loop_hook(0); |
| |
| if (interrupt_request || stop_request) |
| { |
| interrupt_target(); |
| interrupt_request = FALSE; |
| stop_request = FALSE; |
| } |
| Adp_AsynchronousProcessing( async_block_on_nothing ); |
| } |
| signal(SIGINT, SIG_IGN); |
| |
| |
| #ifdef TEST_DC_APPL |
| Adp_Install_DC_Appl_Handler( NULL ); |
| #endif |
| |
| (void)Adp_ChannelRegisterRead(CI_TADP, NULL, NULL); |
| |
| *handle = (PointHandle)stopped_info.data; |
| |
| CallStoppedProcs(stopped_info.stopped_reason); |
| |
| return stopped_info.stopped_status; |
| } |
| |
| /* Request that the target starts executing from the stored CPU state: use |
| ADP_Execute. */ |
| int angel_RDI_execute(PointHandle *handle) |
| { |
| return angel_RDI_ExecuteOrStep(handle, ADP_Execute, 0); |
| } |
| |
| #ifdef __WATCOMC__ |
| typedef void handlertype(int); |
| |
| static int interrupted=0; |
| |
| static void myhandler(int sig) { |
| IGNORE(sig); |
| interrupted=1; |
| signal(SIGINT, myhandler); |
| } |
| #endif |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_step-----------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Step 'ninstr' through the code: use ADP_Step. */ |
| int angel_RDI_step(unsigned ninstr, PointHandle *handle) |
| { |
| int err = angel_RDI_ExecuteOrStep(handle, ADP_Step, ninstr); |
| if (err == RDIError_ProgramFinishedInStep) |
| return RDIError_NoError; |
| else |
| return err; |
| } |
| |
| |
| static void SetCPWords(int cpnum, struct Dbg_CoProDesc const *cpd) { |
| int i, rmax = 0; |
| for (i = 0; i < cpd->entries; i++) |
| if (cpd->regdesc[i].rmax > rmax) |
| rmax = cpd->regdesc[i].rmax; |
| |
| { unsigned char *rmap = (unsigned char *)malloc(rmax + 2); |
| *rmap++ = rmax + 1; |
| for (i = 0; i < cpd->entries; i++) { |
| int r; |
| for (r = cpd->regdesc[i].rmin; r <= cpd->regdesc[i].rmax; r++) |
| rmap[r] = (cpd->regdesc[i].nbytes+3) / 4; |
| } |
| /* if (cpwords[cpnum] != NULL) free(cpwords[cpnum]); */ |
| cpwords[cpnum] = rmap; |
| } |
| } |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_info-----------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Use ADP_Info, ADP_Ctrl and ADP_Profile calls to implement these, |
| see adp.h for more details. */ |
| |
| static int angel_cc_exists( void ) |
| { |
| Packet *packet = NULL; |
| int err; |
| int reason, debugID, OSinfo1, OSinfo2, subreason, status; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEB_CC_Exists.\n"); |
| #endif |
| |
| if ( angel_RDI_info( RDIInfo_Icebreaker, NULL, NULL ) == RDIError_NoError ) { |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", ADP_ICEbreakerHADP | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_ICEB_CC_Exists ); |
| reason = ADP_ICEbreakerHADP |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status); |
| if (subreason != ADP_ICEB_CC_Exists) { |
| DevSW_FreePacket(packet); |
| return RDIError_Error; |
| } |
| else |
| return status; |
| } |
| else |
| return RDIError_UnimplementedMessage; |
| } |
| |
| typedef struct { |
| RDICCProc_ToHost *tohost; void *tohostarg; |
| RDICCProc_FromHost *fromhost; void *fromhostarg; |
| bool registered; |
| } CCState; |
| static CCState ccstate = { NULL, NULL, NULL, NULL, FALSE }; |
| |
| static void HandleDCCMessage( Packet *packet, void *stateptr ) |
| { |
| unsigned int reason, debugID, OSinfo1, OSinfo2; |
| int count; |
| CCState *ccstate_p = (CCState *)stateptr; |
| |
| count = unpack_message( BUFFERDATA(packet->pk_buffer), "%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2 ); |
| switch ( reason ) |
| { |
| case ADP_TDCC_ToHost | TtoH: |
| { |
| /* only handles a single word of data, for now */ |
| |
| unsigned int nbytes, data; |
| |
| unpack_message( BUFFERDATA(packet->pk_buffer)+count, "%w%w", |
| &nbytes, &data ); |
| #ifdef DEBUG |
| angel_DebugPrint( "DEBUG: received CC_ToHost message: nbytes %d data %08x.\n", |
| nbytes, data ); |
| #endif |
| ccstate_p->tohost( ccstate_p->tohostarg, data ); |
| msgsend(CI_TTDCC, "%w%w%w%w%w", |
| ADP_TDCC_ToHost | HtoT, debugID, OSinfo1, OSinfo2, |
| RDIError_NoError ); |
| break; |
| } |
| |
| case ADP_TDCC_FromHost | TtoH: |
| { |
| /* only handles a single word of data, for now */ |
| |
| int valid; |
| ARMword data; |
| |
| ccstate_p->fromhost( ccstate_p->fromhostarg, &data, &valid ); |
| #ifdef DEBUG |
| angel_DebugPrint( "DEBUG: received CC_FromHost message, returning: %08x %s.\n", |
| data, valid ? "VALID" : "INvalid" ); |
| #endif |
| msgsend(CI_TTDCC, "%w%w%w%w%w%w%w", |
| ADP_TDCC_FromHost | HtoT, debugID, OSinfo1, OSinfo2, |
| RDIError_NoError, valid ? 1 : 0, data ); |
| break; |
| } |
| |
| default: |
| #ifdef DEBUG |
| angel_DebugPrint( "Unexpected TDCC message %08x received\n", reason ); |
| #endif |
| break; |
| } |
| DevSW_FreePacket(packet); |
| return; |
| } |
| |
| static void angel_check_DCC_handler( CCState *ccstate_p ) |
| { |
| int err; |
| |
| if ( ccstate_p->tohost != NULL || ccstate_p->fromhost != NULL ) |
| { |
| /* doing DCC, so need a handler */ |
| if ( ! ccstate_p->registered ) |
| { |
| #ifdef DEBUG |
| angel_DebugPrint( "Registering handler for TTDCC channel.\n" ); |
| #endif |
| err = Adp_ChannelRegisterRead( CI_TTDCC, HandleDCCMessage, |
| ccstate_p ); |
| if ( err == adp_ok ) |
| ccstate_p->registered = TRUE; |
| #ifdef DEBUG |
| else |
| angel_DebugPrint( "angel_check_DCC_handler: register failed!\n" ); |
| #endif |
| } |
| } |
| else |
| { |
| /* not doing DCC, so don't need a handler */ |
| if ( ccstate_p->registered ) |
| { |
| #ifdef DEBUG |
| angel_DebugPrint( "Unregistering handler for TTDCC channel.\n" ); |
| #endif |
| err = Adp_ChannelRegisterRead( CI_TTDCC, NULL, NULL ); |
| if ( err == adp_ok ) |
| ccstate_p->registered = FALSE; |
| #ifdef DEBUG |
| else |
| angel_DebugPrint( "angel_check_DCC_handler: unregister failed!\n" ); |
| #endif |
| } |
| } |
| } |
| |
| |
| static int CheckSubMessageReply(int reason, int subreason) { |
| Packet *packet = NULL; |
| int status, debugID, OSinfo1, OSinfo2; |
| int err = RDIError_NoError; |
| reason |= TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| status = err; |
| } else { |
| int sr; |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &sr, &status); |
| if (subreason != sr) status = RDIError_Error; |
| } |
| DevSW_FreePacket(packet); |
| return status; |
| } |
| |
| static int SendSubMessageAndCheckReply(int reason, int subreason) { |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| subreason); |
| return CheckSubMessageReply(reason, subreason); |
| } |
| |
| static int SendSubMessageWordAndCheckReply(int reason, int subreason, ARMword word) { |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w", reason | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| subreason, word); |
| return CheckSubMessageReply(reason, subreason); |
| } |
| |
| static int SendSubMessageGetWordAndCheckReply(int reason, int subreason, ARMword *resp) { |
| Packet *packet = NULL; |
| int status, debugID, OSinfo1, OSinfo2; |
| int err = RDIError_NoError; |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| subreason); |
| reason |= TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| status = err; |
| } else { |
| int sr; |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &sr, &status, resp); |
| if (subreason != sr) status = RDIError_Error; |
| } |
| DevSW_FreePacket(packet); |
| return status; |
| } |
| |
| static int const hostsex = 1; |
| |
| int angel_RDI_info(unsigned type, ARMword *arg1, ARMword *arg2) { |
| Packet *packet = NULL; |
| int len, status, c, reason, subreason, debugID, OSinfo1, OSinfo2; |
| int err=RDIError_NoError, cpnum=0; |
| struct Dbg_CoProDesc *cpd; |
| int count, i; |
| unsigned char *bp; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_info.\n"); |
| #endif |
| switch (type) { |
| case RDIInfo_Target: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_Target.\n"); |
| #endif |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Target); |
| reason = ADP_Info |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status, |
| arg1, arg2); |
| DevSW_FreePacket(packet); |
| |
| if (subreason != ADP_Info_Target) |
| return RDIError_Error; |
| else |
| return status; |
| |
| case RDISignal_Stop: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDISignal_Stop.\n"); |
| if (interrupt_request) |
| angel_DebugPrint(" STILL WAITING to send previous interrupt request\n"); |
| #endif |
| interrupt_request = TRUE; |
| return RDIError_NoError; |
| |
| case RDIInfo_Points: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_Points.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Points, arg1); |
| |
| case RDIInfo_Step: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_Step.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Step, arg1); |
| |
| case RDISet_Cmdline: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDISet_Cmdline.\n"); |
| #endif |
| if (ardi_commandline != &dummycline) |
| free(ardi_commandline); |
| ardi_commandline = (char *)malloc(strlen((char*)arg1) + 1) ; |
| (void)strcpy(ardi_commandline, (char *)arg1) ; |
| return RDIError_NoError; |
| |
| case RDIInfo_SetLog: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_SetLog.\n"); |
| #endif |
| rdi_log = (int) *arg1; |
| return RDIError_NoError; |
| |
| case RDIInfo_Log: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_Log.\n"); |
| #endif |
| *arg1 = rdi_log; |
| return RDIError_NoError; |
| |
| |
| case RDIInfo_MMU: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_MMU.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_MMU, arg1); |
| |
| case RDIInfo_SemiHosting: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_SemiHosting.\n"); |
| #endif |
| return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_SemiHosting); |
| |
| case RDIInfo_CoPro: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_CoPro.\n"); |
| #endif |
| return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CoPro); |
| |
| case RDICycles: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDICycles.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Cycles); |
| reason = ADP_Info |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &subreason, &status); |
| DevSW_FreePacket(packet); |
| if (subreason != ADP_Info_Cycles) |
| return RDIError_Error; |
| if (status != RDIError_NoError) return status; |
| for (c=0; c<12; c++) |
| arg1[c]=GET32LE(BUFFERDATA(packet->pk_buffer)+24+(c*4)); |
| return status; |
| |
| case RDIInfo_DescribeCoPro: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_DescribeCoPro.\n"); |
| #endif |
| cpnum = *(int *)arg1; |
| cpd = (struct Dbg_CoProDesc *)arg2; |
| packet = DevSW_AllocatePacket(Armsd_BufferSize); |
| if (angel_RDI_info(ADP_Info_CoPro, NULL, NULL) != RDIError_NoError) |
| return RDIError_Error; |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Info_DescribeCoPro); |
| len +=msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b%b%b%b%b", cpnum, |
| cpd->regdesc[cpnum].rmin, cpd->regdesc[cpnum].rmax, |
| cpd->regdesc[cpnum].nbytes, cpd->regdesc[cpnum].access); |
| if ((cpd->regdesc[cpnum].access&0x3) == 0x3){ |
| len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b", |
| cpd->regdesc[cpnum].accessinst.cprt.read_b0, |
| cpd->regdesc[cpnum].accessinst.cprt.read_b1, |
| cpd->regdesc[cpnum].accessinst.cprt.write_b0, |
| cpd->regdesc[cpnum].accessinst.cprt.write_b1, 0xff); |
| } |
| else { |
| len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b%", |
| cpd->regdesc[cpnum].accessinst.cpdt.rdbits, |
| cpd->regdesc[cpnum].accessinst.cpdt.nbit,0,0, 0xff); |
| } |
| register_debug_message_handler(); |
| packet->pk_length = len; |
| Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */ |
| reason = ADP_Info |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &subreason, &status); |
| DevSW_FreePacket(packet); |
| if (subreason != ADP_Info_DescribeCoPro) |
| return RDIError_Error; |
| else |
| return status; |
| |
| case RDIInfo_RequestCoProDesc: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: RDIInfo_RequestCoProDesc.\n"); |
| #endif |
| cpnum = *(int *)arg1; |
| cpd = (struct Dbg_CoProDesc *)arg2; |
| packet = DevSW_AllocatePacket(Armsd_BufferSize); |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Info_RequestCoProDesc); |
| len += msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b", *(int *)arg1); |
| packet->pk_length = len; |
| register_debug_message_handler(); |
| Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */ |
| reason = ADP_Info |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status); |
| if (subreason != ADP_Info_RequestCoProDesc) { |
| DevSW_FreePacket(packet); |
| return RDIError_Error; |
| } else if ( status != RDIError_NoError ) { |
| DevSW_FreePacket(packet); |
| return status; |
| } else { |
| bp = BUFFERDATA(packet->pk_buffer)+count; |
| for ( i = 0; *bp != 0xFF && i < cpd->entries; ++i ) { |
| cpd->regdesc[i].rmin = *bp++; |
| cpd->regdesc[i].rmax = *bp++; |
| cpd->regdesc[i].nbytes = *bp++; |
| cpd->regdesc[i].access = *bp++; |
| } |
| cpd->entries = i; |
| if ( *bp != 0xFF ) |
| status = RDIError_BufferFull; |
| else |
| SetCPWords( cpnum, cpd ); |
| DevSW_FreePacket(packet); |
| return status; |
| } |
| |
| case RDIInfo_GetLoadSize: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Info_AngelBufferSize); |
| reason = ADP_Info |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status); |
| if (subreason != ADP_Info_AngelBufferSize) { |
| DevSW_FreePacket(packet); |
| return RDIError_Error; |
| } |
| else { |
| word defaultsize, longsize; |
| unpack_message(BUFFERDATA(packet->pk_buffer)+24, "%w%w", |
| &defaultsize, &longsize); |
| *arg1 = longsize - ADP_WriteHeaderSize; /* space for ADP header */ |
| #ifdef MONITOR_DOWNLOAD_PACKETS |
| angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize: got (%d, %d), returning %d.\n", |
| defaultsize, longsize, *arg1); |
| #endif |
| DevSW_FreePacket(packet); |
| return status; |
| } |
| |
| case RDIVector_Catch: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_VectorCatch %lx.\n", *arg1); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_VectorCatch, *arg1); |
| |
| case RDISemiHosting_SetState: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetState %lx.\n", *arg1); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetState, *arg1); |
| |
| case RDISemiHosting_GetState: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetState.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetState, arg1); |
| |
| case RDISemiHosting_SetVector: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetVector %lx.\n", *arg1); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetVector, *arg1); |
| |
| case RDISemiHosting_GetVector: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetVector.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetVector, arg1); |
| |
| case RDISemiHosting_SetARMSWI: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetARMSWI.\n"); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetARMSWI, *arg1); |
| |
| case RDISemiHosting_GetARMSWI: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetARMSWI.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetARMSWI, arg1); |
| |
| case RDISemiHosting_SetThumbSWI: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetThumbSWI.\n"); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetThumbSWI, *arg1); |
| |
| case RDISemiHosting_GetThumbSWI: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetThumbSWI.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetThumbSWI, arg1); |
| |
| case RDIInfo_SetTopMem: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_SetTopMem.\n"); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SetTopMem, *arg1); |
| |
| case RDIPointStatus_Watch: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Watch.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Ctrl_PointStatus_Watch, *arg1 ); |
| reason = ADP_Control |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status, |
| arg1, arg2); |
| if (subreason != ADP_Ctrl_PointStatus_Watch) { |
| DevSW_FreePacket(packet); |
| return RDIError_Error; |
| } |
| else |
| return status; |
| |
| case RDIPointStatus_Break: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Break.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Ctrl_PointStatus_Break, *arg1 ); |
| reason = ADP_Control |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status, |
| arg1, arg2); |
| if (subreason != ADP_Ctrl_PointStatus_Break) { |
| DevSW_FreePacket(packet); |
| return RDIError_Error; |
| } |
| else |
| return status; |
| |
| case RDIInfo_DownLoad: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Ctrl_Download_Supported.\n"); |
| #endif |
| return SendSubMessageAndCheckReply(ADP_Control, ADP_Ctrl_Download_Supported); |
| |
| case RDIConfig_Count: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEM_ConfigCount.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_ICEman, ADP_ICEM_ConfigCount, arg1); |
| |
| case RDIConfig_Nth: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEM_ConfigNth.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_ICEM_ConfigNth, *arg1 ); |
| reason = ADP_ICEman |TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } else { |
| RDI_ConfigDesc *cd = (RDI_ConfigDesc *)arg2; |
| unsigned char n; |
| len = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%b", |
| &reason, &debugID, |
| &OSinfo1, &OSinfo2, &subreason, &status, |
| &cd->version, &n); |
| if (subreason != ADP_ICEM_ConfigNth) { |
| DevSW_FreePacket(packet); |
| return RDIError_Error; |
| } |
| else { |
| memcpy( cd->name, BUFFERDATA(packet->pk_buffer)+len, n+1 ); |
| cd->name[n] = 0; |
| return status; |
| } |
| } |
| |
| case RDIInfo_Icebreaker: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEB_Exists.\n"); |
| #endif |
| return SendSubMessageAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_Exists); |
| |
| case RDIIcebreaker_GetLocks: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEB_GetLocks.\n"); |
| #endif |
| return SendSubMessageGetWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_GetLocks, arg1); |
| |
| case RDIIcebreaker_SetLocks: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEB_SetLocks.\n"); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_SetLocks, *arg1); |
| |
| case RDICommsChannel_ToHost: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_ToHost.\n"); |
| #endif |
| if ( angel_cc_exists() == RDIError_NoError ) { |
| |
| /* |
| * The following three lines of code have to be removed in order to get |
| * the Windows Angel Channel Viewer working with the Thumb comms channel. |
| * At the moment it allows the ARMSD command line to register a CCIN/CCOUT |
| * callback which stops the ACV working! |
| */ |
| #ifdef __unix |
| ccstate.tohost = (RDICCProc_ToHost *)arg1; |
| ccstate.tohostarg = arg2; |
| angel_check_DCC_handler( &ccstate ); |
| #endif |
| #ifdef _WIN32 |
| |
| #endif |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_ICEB_CC_Connect_ToHost, (arg1 != NULL) ); |
| return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_ToHost); |
| } else { |
| return RDIError_UnimplementedMessage; |
| } |
| |
| case RDICommsChannel_FromHost: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_FromHost.\n"); |
| #endif |
| if ( angel_cc_exists() == RDIError_NoError ) { |
| |
| ccstate.fromhost = (RDICCProc_FromHost *)arg1; |
| ccstate.fromhostarg = arg2; |
| angel_check_DCC_handler( &ccstate ); |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_ICEB_CC_Connect_FromHost, (arg1 != NULL) ); |
| return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_FromHost); |
| } else { |
| return RDIError_UnimplementedMessage; |
| } |
| |
| case RDIProfile_Stop: |
| return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_Stop); |
| |
| case RDIProfile_ClearCounts: |
| return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_ClearCounts); |
| |
| case RDIProfile_Start: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Profile_Start %ld.\n", (long)*arg1); |
| #endif |
| return SendSubMessageWordAndCheckReply(ADP_Profile, ADP_Profile_Start, *arg1); |
| |
| case RDIProfile_WriteMap: |
| { RDI_ProfileMap *map = (RDI_ProfileMap *)arg1; |
| int32 maplen = map->len, |
| offset, |
| size; |
| int32 chunk = (Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_ProfileWriteHeaderSize) / sizeof(ARMword); |
| /* Maximum number of words sendable in one message */ |
| int oldrev = bytesex_reversing(); |
| int host_little = *(uint8 const *)&hostsex; |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Profile_WriteMap %ld.\n", maplen); |
| #endif |
| status = RDIError_NoError; |
| if (!host_little) { |
| bytesex_reverse(1); |
| for (offset = 0; offset < maplen; offset++) |
| map->map[offset] = bytesex_hostval(map->map[offset]); |
| } |
| for (offset = 0; offset < maplen; offset += size) { |
| unsigned hdrlen; |
| size = maplen - offset; |
| packet = (Packet *)DevSW_AllocatePacket(Armsd_LongBufSize); |
| if (size > chunk) size = chunk; |
| hdrlen = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", |
| ADP_Profile | HtoT, 0, ADP_HandleUnknown, |
| ADP_HandleUnknown, ADP_Profile_WriteMap, |
| maplen, size, offset); |
| |
| /* Copy the data into the packet. */ |
| memcpy(BUFFERDATA(packet->pk_buffer)+hdrlen, |
| &map->map[offset], (size_t)size * sizeof(ARMword)); |
| packet->pk_length = size * sizeof(ARMword) + hdrlen; |
| register_debug_message_handler(); |
| Adp_ChannelWrite(CI_HADP, packet); |
| reason = ADP_Profile | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err == RDIError_NoError) { |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status); |
| if (subreason != ADP_Profile_WriteMap) { |
| err = RDIError_Error; |
| } |
| DevSW_FreePacket(packet); |
| } |
| if (err != RDIError_NoError) { status = err; break; } |
| } |
| if (!host_little) { |
| for (offset = 0; offset < maplen; offset++) |
| map->map[offset] = bytesex_hostval(map->map[offset]); |
| bytesex_reverse(oldrev); |
| } |
| return status; |
| } |
| |
| case RDIProfile_ReadMap: |
| { int32 maplen = *(int32 *)arg1, |
| offset = 0, |
| size; |
| int32 chunk = (Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ProfileReadHeaderSize) / sizeof(ARMword); |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: ADP_Profile_ReadMap %ld.\n", maplen); |
| #endif |
| status = RDIError_NoError; |
| for (offset = 0; offset < maplen; offset += size) { |
| size = maplen - offset; |
| if (size > chunk) size = chunk; |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Profile | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Profile_ReadMap, offset, size); |
| reason = ADP_Profile | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) return err; |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status); |
| memcpy(&arg2[offset], BUFFERDATA(packet->pk_buffer)+ADP_ProfileReadHeaderSize, |
| size * sizeof(ARMword)); |
| DevSW_FreePacket(packet); |
| if (status != RDIError_NoError) break; |
| } |
| { int oldrev = bytesex_reversing(); |
| int host_little = *(uint8 const *)&hostsex; |
| if (!host_little) { |
| bytesex_reverse(1); |
| for (offset = 0; offset < maplen; offset++) |
| arg2[offset] = bytesex_hostval(arg2[offset]); |
| } |
| bytesex_reverse(oldrev); |
| } |
| return status; |
| } |
| |
| case RDIInfo_CanTargetExecute: |
| #ifdef DEBUG |
| printf("DEBUG: RDIInfo_CanTargetExecute.\n"); |
| #endif |
| return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CanTargetExecute); |
| |
| case RDIInfo_AgentEndianess: |
| return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_AgentEndianess); |
| |
| default: |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Fell through ADP_Info, default case taken.\n"); |
| angel_DebugPrint("DEBUG: type = 0x%x.\n", type); |
| #endif |
| if (type & RDIInfo_CapabilityRequest) { |
| switch (type & ~RDIInfo_CapabilityRequest) { |
| case RDISemiHosting_SetARMSWI: |
| return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_ChangeableSHSWI); |
| default: |
| #ifdef DEBUG |
| angel_DebugPrint( |
| "DEBUG: ADP_Info - Capability Request(%d) - reporting unimplemented \n", |
| type & ~RDIInfo_CapabilityRequest); |
| #endif |
| break; |
| } |
| } |
| return RDIError_UnimplementedMessage; |
| } |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_AddConfig------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Add a configuration: use ADP_ICEM_AddConfig. */ |
| int angel_RDI_AddConfig(unsigned long nbytes) { |
| Packet *packet = NULL; |
| int status, reason, subreason, debugID, OSinfo1, OSinfo2, err; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_AddConfig.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT, |
| 0, ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_ICEM_AddConfig, nbytes); |
| reason=ADP_ICEman | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return -1; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &subreason, &status); |
| DevSW_FreePacket(packet); |
| if ( subreason != ADP_ICEM_AddConfig ) |
| return RDIError_Error; |
| else |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_LoadConfigData-------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Load configuration data: use ADP_Ctrl_Download_Data. */ |
| int angel_RDI_LoadConfigData(unsigned long nbytes, char const *data) { |
| Packet *packet = NULL; |
| int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_LoadConfigData (%d bytes)\n", nbytes); |
| #endif |
| #if 0 |
| if (err = angel_RDI_AddConfig(nbytes) != RDIError_NoError) |
| return err; |
| #endif |
| packet = DevSW_AllocatePacket(Armsd_LongBufSize); |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", |
| ADP_Control | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Ctrl_Download_Data, nbytes); |
| memcpy(BUFFERDATA(packet->pk_buffer)+len, data, nbytes); |
| len += nbytes; |
| packet->pk_length = len; |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: packet len %d.\n", len); |
| #endif |
| register_debug_message_handler(); |
| Adp_ChannelWrite(CI_HADP, packet); |
| reason=ADP_Control | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return -1; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &subreason, &status); |
| DevSW_FreePacket(packet); |
| if ( subreason != ADP_Ctrl_Download_Data ) |
| return RDIError_Error; |
| else |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_SelectConfig---------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Select a configuration: use ADP_ICEM_SelecConfig.*/ |
| int angel_RDI_SelectConfig(RDI_ConfigAspect aspect, char const *name, |
| RDI_ConfigMatchType matchtype, unsigned versionreq, |
| unsigned *versionp) |
| { |
| Packet *packet = NULL; |
| int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err; |
| |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: Entered angel_RDI_SelectConfig.\n"); |
| #endif |
| packet = DevSW_AllocatePacket(Armsd_BufferSize); |
| len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b%b%b%w", |
| ADP_ICEman | HtoT, 0, |
| ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_ICEM_SelectConfig, aspect, strlen(name), |
| matchtype, versionreq); |
| /* copy the name into the buffer */ |
| memcpy(BUFFERDATA(packet->pk_buffer)+len, name, strlen(name)); |
| len += strlen(name); |
| packet->pk_length = len; |
| register_debug_message_handler(); |
| Adp_ChannelWrite(CI_HADP, packet); |
| reason=ADP_ICEman | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return err; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w", |
| &reason, &debugID, &OSinfo1, &OSinfo2, |
| &subreason, &status, versionp); |
| DevSW_FreePacket(packet); |
| if ( subreason != ADP_ICEM_SelectConfig ) |
| return RDIError_Error; |
| else |
| return status; |
| } |
| |
| |
| /*----------------------------------------------------------------------*/ |
| /*----angel_RDI_LoadAgent------------------------------------------------*/ |
| /*----------------------------------------------------------------------*/ |
| |
| /* Load a new debug agent: use ADP_Ctrl_Download_Agent. */ |
| int angel_RDI_LoadAgent(ARMword dest, unsigned long size, |
| getbufferproc *getb, void *getbarg) |
| { |
| Packet *packet = NULL; |
| int status, reason, subreason, debugID, OSinfo1, OSinfo2, err; |
| time_t t; |
| |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint("DEBUG: Entered angel_RDI_LoadAgent.\n"); |
| #endif |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Control | HtoT, |
| 0, ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Ctrl_Download_Agent, dest, size); |
| reason=ADP_Control | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return -1; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID, |
| &OSinfo1, &OSinfo2, &subreason, &status); |
| DevSW_FreePacket(packet); |
| if ( subreason != ADP_Ctrl_Download_Agent ) |
| return RDIError_Error; |
| if ( status != RDIError_NoError ) |
| return status; |
| |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint("DEBUG: starting agent data download.\n"); |
| #endif |
| { unsigned long pos = 0, segsize; |
| for (; pos < size; pos += segsize) { |
| char *b = getb(getbarg, &segsize); |
| if (b == NULL) return RDIError_NoError; |
| err = angel_RDI_LoadConfigData( segsize, b ); |
| if (err != RDIError_NoError) return err; |
| } |
| } |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint("DEBUG: finished downloading new agent.\n"); |
| #endif |
| |
| /* renegotiate back down */ |
| err = angel_negotiate_defaults(); |
| if (err != adp_ok) |
| return err; |
| |
| /* Output a message to tell the user what is going on. This is vital |
| * when switching from ADP EICE to ADP over JTAG, as then the user |
| * has to reset the target board ! |
| */ |
| { char msg[256]; |
| int len=angel_RDI_errmess(msg, 256, adp_new_agent_starting); |
| angel_hostif->write(angel_hostif->hostosarg, msg, len); |
| } |
| |
| /* get new image started */ |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint("DEBUG: sending start message for new agent.\n"); |
| #endif |
| |
| register_debug_message_handler(); |
| msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, |
| 0, ADP_HandleUnknown, ADP_HandleUnknown, |
| ADP_Ctrl_Start_Agent, dest); |
| reason=ADP_Control | TtoH; |
| err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2, |
| &status, &packet); |
| if (err != RDIError_NoError) { |
| DevSW_FreePacket(packet); |
| return -1; |
| } |
| unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, |
| &debugID, &OSinfo1, &OSinfo2, &subreason, &status); |
| DevSW_FreePacket(packet); |
| if ( subreason != ADP_Ctrl_Start_Agent ) |
| return RDIError_Error; |
| if ( status != RDIError_NoError ) |
| return status; |
| |
| /* wait for image to start up */ |
| heartbeat_enabled = FALSE; |
| t=time(NULL); |
| do { |
| Adp_AsynchronousProcessing(async_block_on_nothing); |
| if ((time(NULL)-t) > 2) { |
| #ifdef DEBUG |
| angel_DebugPrint("DEBUG: no booted message from new image yet.\n"); |
| #endif |
| break; |
| } |
| } while (booted_not_received); |
| booted_not_received=1; |
| |
| /* Give device driver a chance to do any necessary resyncing with new agent. |
| * Only used by etherdrv.c at the moment. |
| */ |
| (void)Adp_Ioctl( DC_RESYNC, NULL ); |
| |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint("DEBUG: reopening to new agent.\n"); |
| #endif |
| err = angel_RDI_open(0, NULL, NULL, NULL); |
| switch ( err ) |
| { |
| case RDIError_NoError: |
| { |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint( "LoadAgent: Open returned RDIError_NoError\n" ); |
| #endif |
| break; |
| } |
| |
| case RDIError_LittleEndian: |
| { |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint( "LoadAgent: Open returned RDIError_LittleEndian (OK)\n" ); |
| #endif |
| err = RDIError_NoError; |
| break; |
| } |
| |
| case RDIError_BigEndian: |
| { |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint( "LoadAgent: Open returned RDIError_BigEndian (OK)\n" ); |
| #endif |
| err = RDIError_NoError; |
| break; |
| } |
| |
| default: |
| { |
| #if defined(DEBUG) || defined(DEBUG_LOADAGENT) |
| angel_DebugPrint( "LoadAgent: Open returned %d - unexpected!\n", err ); |
| #endif |
| break; |
| } |
| } |
| #ifndef NO_HEARTBEAT |
| heartbeat_enabled = TRUE; |
| #endif |
| return err; |
| } |
| |
| static int angel_RDI_errmess(char *buf, int blen, int errnum) { |
| char *s=NULL; |
| int n; |
| |
| switch (errnum) { |
| case adp_malloc_failure: |
| s=AdpMess_MallocFailed; break; |
| case adp_illegal_args: |
| s=AdpMess_IllegalArgs; break; |
| case adp_device_not_found: |
| s=AdpMess_DeviceNotFound; break; |
| case adp_device_open_failed: |
| s=AdpMess_DeviceOpenFailed; break; |
| case adp_device_already_open: |
| s=AdpMess_DeviceAlreadyOpen; break; |
| case adp_device_not_open: |
| s=AdpMess_DeviceNotOpen; break; |
| case adp_bad_channel_id: |
| s=AdpMess_BadChannelId; break; |
| case adp_callback_already_registered: |
| s=AdpMess_CBAlreadyRegd; break; |
| case adp_write_busy: |
| s=AdpMess_WriteBusy; break; |
| case adp_bad_packet: |
| s=AdpMess_BadPacket; break; |
| case adp_seq_high: |
| s=AdpMess_SeqHigh; break; |
| case adp_seq_low: |
| s=AdpMess_SeqLow; break; |
| case adp_timeout_on_open: |
| s=AdpMess_TimeoutOnOpen; break; |
| case adp_failed: |
| s=AdpMess_Failed; break; |
| case adp_abandon_boot_wait: |
| s=AdpMess_AbandonBootWait; break; |
| case adp_late_startup: |
| s=AdpMess_LateStartup; break; |
| case adp_new_agent_starting: |
| s=AdpMess_NewAgentStarting; break; |
| default: return 0; |
| } |
| n=strlen(s); |
| if (n>blen-1) n=blen-1; |
| memcpy(buf, s, n); |
| buf[n++]=0; |
| return n; |
| } |
| |
| extern const struct RDIProcVec angel_rdi; |
| const struct RDIProcVec angel_rdi = { |
| "ADP", |
| angel_RDI_open, |
| angel_RDI_close, |
| angel_RDI_read, |
| angel_RDI_write, |
| angel_RDI_CPUread, |
| angel_RDI_CPUwrite, |
| angel_RDI_CPread, |
| angel_RDI_CPwrite, |
| angel_RDI_setbreak, |
| angel_RDI_clearbreak, |
| angel_RDI_setwatch, |
| angel_RDI_clearwatch, |
| angel_RDI_execute, |
| angel_RDI_step, |
| angel_RDI_info, |
| angel_RDI_pointinq, |
| |
| angel_RDI_AddConfig, |
| angel_RDI_LoadConfigData, |
| angel_RDI_SelectConfig, |
| |
| 0, /*angel_RDI_drivernames,*/ |
| 0, /* cpunames */ |
| |
| angel_RDI_errmess, |
| |
| angel_RDI_LoadAgent |
| }; |
| |
| /* EOF ardi.c */ |
| |
| /* Not strictly necessary, but allows linking this code into armsd. */ |
| |
| struct foo { |
| char *name; |
| int (*action)(); |
| char *syntax; |
| char **helpmessage; |
| int doafterend; |
| int dobeforestart; |
| int doinmidline; |
| } hostappl_CmdTable[1] = {{"", NULL}}; |
| |
| void |
| hostappl_Init() |
| { |
| } |
| |
| int |
| hostappl_Backstop() |
| { |
| return -30; |
| } |