mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
e9110f4f31
From Grant Edwards <grante@visi.com> This keeps the GUI alive while running an RDI target and lets the STOP button be used to stop the target. * remote-rdi.c (arm_rdi_stop): New function. Implements target_stop. (init_rdi_ops): Set to_stop target vector entry to the above. * rdi-share/ardi.c (stop_request): New variable. Tells when a stop has been requested. (angel_RDI_stop_request): New function. Registers that a stop has been requested. (angel_RDI_ExecuteOrStep): Add call to ui_loop_hook() in loop that waits while target is executing. Initialize and reset stop_request. * rdi-share/ardi.h: Add declaration of angel_RDI_stop_request().
2694 lines
85 KiB
C
2694 lines
85 KiB
C
/*
|
|
* 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;
|
|
}
|