2529 lines
83 KiB
C
2529 lines
83 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.
|
|
*/
|
|
|
|
/* -*-C-*-
|
|
*
|
|
* $Revision$
|
|
* $Date$
|
|
*
|
|
*
|
|
*
|
|
* INTRODUCTION
|
|
* ------------
|
|
* The early RDP message definitions were held in an ARM Ltd "armdbg"
|
|
* source file. Since the relevant header files were not exported
|
|
* publicly as part of an ARM Ltd core tools release, it was a problem
|
|
* for developers manipulating the target side of the protocol.
|
|
*
|
|
* For Angel, this new (ANSI 'C' clean) header file defines the ADP
|
|
* protocol. The header should be useable by both host and target
|
|
* systems, thus avoiding problems that can arise from duplicate
|
|
* definitions. Care has been taken in the construction of this header
|
|
* file to avoid any host/target differences.
|
|
*
|
|
* MESSAGE FORMAT
|
|
* --------------
|
|
* Format of the "data" section of debug and boot agent messages. This is
|
|
* the standard ADP (Angel Debug Protocol) message format:
|
|
*
|
|
* unsigned32 reason - Main debug reason code.
|
|
* unsigned32 debugID - Information describing host debug world;
|
|
* - private to host and used in any target initiated
|
|
* messages.
|
|
* unsigned32 OSinfo1 \ Target OS information to identify process/thread
|
|
* unsigned32 OSinfo2 / memory/world, etc. These two fields are target
|
|
* defined.
|
|
* byte args[n] - Data for message "reason" code.
|
|
*
|
|
* NOTE: The message format is the same for single threaded debugging,
|
|
* except that the "OSinfo" fields should be -1 (0xFFFFFFFF). Even
|
|
* single-threaded debugging *MAY* have different host specified
|
|
* debugID values, so the Angel debug system will preserve the "debugID"
|
|
* information for replies, and the relevant asynchronous target-to-host
|
|
* messages. The "debugID" is defined by the host-end of the
|
|
* protocol, and is used by the host to ensure that messages are
|
|
* routed to the correct handler program/veneer.
|
|
*
|
|
* The reason there are two target specified "OSinfo" words is because
|
|
* thread identifiers may not be unique when processes/tasks have
|
|
* private virtual address spaces. It allows more flexibility when
|
|
* supporting multi-threaded or O/S aware debugging.
|
|
*
|
|
* NOTE: The reason that there is no "size" information, is that the
|
|
* message IDs themselves encode the format of any arguments. Also it
|
|
* would be a duplication of information used by the physical
|
|
* transport layer (which is distinct from this logical message
|
|
* layer). Any routing of messages through programs, hosts,
|
|
* etc. should be performed at the physical layer, or the boundaries
|
|
* between physical layers. i.e. packet received on socket in host,
|
|
* and transferred to serial packet for passing on down the line.
|
|
*
|
|
* NOTE: Pointers aren't passed in messages because they are dangerous in
|
|
* a multi-threaded environment.
|
|
*
|
|
* ADP REASON CODE
|
|
* ---------------
|
|
* The message reason codes contain some information that ties them to
|
|
* the channel and direction that the message will be used with. This
|
|
* will ensure that even if the message "#define name" is not
|
|
* completely descriptive, the message reason code is.
|
|
*
|
|
* b31 = direction. 0=Host-to-Target; 1=Target-to-Host;
|
|
* b30-28 = debug agent multi-threaded control (see below)
|
|
* b27-24 = reserved. should be zero.
|
|
* b23-16 = channelid. The fixed Angel channel number
|
|
* (see "channels.h").
|
|
* b15-0 = message reason code.
|
|
*
|
|
* It is unfortunate that to aid the error-checking capabilities of
|
|
* the Angel communications we have changed the message numbers from
|
|
* the original ARM Ltd RDP. However this also has benefits, in that
|
|
* the Angel work is meant to be a clean break.
|
|
*
|
|
* However, it isn't so bad since even though the numbers are
|
|
* different, the majority of the reason codes have exactly the same
|
|
* functionality as the original RDP messages.
|
|
*
|
|
* NOTES
|
|
* -----
|
|
* It would be ideal to use "rpcgen" (or some equivalent) to
|
|
* automatically maintain compatibility between the target and host
|
|
* ends of the protocol. However, ARM Ltd expressed that the message
|
|
* handling should be hand-coded, to avoid dependance on external
|
|
* tools.
|
|
*
|
|
* All other channels have undefined data formats and are purely
|
|
* application defined. The C library "_sys_" support will provide a
|
|
* veneer to perform message block operations as required.
|
|
*
|
|
* It is IMPLIED that all of the ADP messages will fit within the
|
|
* buffer DATASIZE. This has a minimum value, calculated from
|
|
* BUFFERMINSIZE.
|
|
*
|
|
* All messages are passed and received to the channel system in little
|
|
* endian order (ie. use little endian order when writing a word as
|
|
* a sequence of bytes within a message).
|
|
*
|
|
* A reply / acknowledgement to an ADP message is always sent and has the
|
|
* same reason code as the original except that the TtoH / HtoT bit is
|
|
* reversed. This makes it simple to check that the reply really
|
|
* is a reply to the message which was just sent! [Boot Channel messages
|
|
* also require that this protocol is used].
|
|
*/
|
|
|
|
#ifndef angel_adp_h
|
|
#define angel_adp_h
|
|
|
|
#include "chandefs.h"
|
|
|
|
|
|
/*
|
|
* Buffer minimum sizes
|
|
*/
|
|
|
|
/* the minimum target internal size */
|
|
#define ADP_BUFFER_MIN_SIZE (256)
|
|
|
|
/* a word is always reserved for internal use in the target */
|
|
#define ADP_BUFFER_MAX_INTERNAL (sizeof(word))
|
|
|
|
/* the minimum available data portion */
|
|
#define ADP_BUFFER_MIN_DATASIZE \
|
|
(ADP_BUFFER_MIN_SIZE - ADP_BUFFER_MAX_INTERNAL - CHAN_HEADER_SIZE)
|
|
|
|
/*
|
|
* the space taken up by the standard ADP header
|
|
* (reason, debugID, OSinfo1, OSinfo2)
|
|
*/
|
|
#define ADP_DEFAULT_HEADER_SIZE (4*sizeof(word))
|
|
|
|
|
|
/* 8bit ADP version identification */
|
|
#define ADPVSN (0x03)
|
|
/* This value can be used to identify the protocol version supported
|
|
* by target or host systems. This version number should only be
|
|
* changed if the protocol undergoes a non-backward compatible
|
|
* change. It should *NOT* be used to reflect extensions to the
|
|
* protocol. Such extensions can be added to the existing protocol
|
|
* version by allocating new reason codes, and by extending the
|
|
* ADP_Info message to identify new features.
|
|
*/
|
|
|
|
/* The following value is used in the OSinfo fields for
|
|
* single-threaded messages, or where the host wants to alter the
|
|
* global CPU state. NOTE: The "debugID" field should always be
|
|
* defined by the host, and returned in target initiated messages. The
|
|
* only exception to this rule is the ADP_Booted message at the
|
|
* start-of-day.
|
|
*/
|
|
#define ADP_HandleUnknown (-1)
|
|
|
|
/******************************************************************
|
|
*
|
|
* ADP reason code subfields
|
|
*
|
|
*/
|
|
|
|
/* The following bits are used to describe the basic direction of
|
|
* messages. This allows some extra checking of message validity to be
|
|
* performed, as well as providing a description of the message that
|
|
* may not be available in the "cpp" macro:
|
|
*/
|
|
#define HtoT ((unsigned)0 << 31) /* Host-to-Target message */
|
|
#define TtoH ((unsigned)1 << 31) /* Target-to-Host message */
|
|
|
|
/* The following bits are used to control how the target system
|
|
* executes whilst processing messages. This allows for O/S specific
|
|
* host-based debug programs to interrogate system structures whilst
|
|
* ensuring that the access is atomic within the constraints imposed
|
|
* by the target O/S.
|
|
*
|
|
* NOTE: That only the channel is inserted into the reason code
|
|
* automatically. Thus both direction and multi thread control bits
|
|
* must be added by the host / target.
|
|
*/
|
|
/* Disable FIQ whilst processing message */
|
|
#define DisableFIQ (1 << 30)
|
|
/* Disable IRQ whilst processing message */
|
|
#define DisableIRQ (1 << 29)
|
|
/* Disable O/S pre-emption whilst processing message */
|
|
#define DisablePreemption (1 << 28)
|
|
|
|
/* The channel identification number is held in the reason code as a
|
|
* check:
|
|
*/
|
|
#define ADPCHANNEL(b) (((b) & 0xFF) << 16)
|
|
|
|
/* The following macro constructs the reason code number, from the
|
|
* various fields - note that the direction is NOT inlcuded since
|
|
* this depends on whether the Host or Target system is including
|
|
* this file!
|
|
*/
|
|
#define ADPREASON(c,r) (ADPCHANNEL(c) | ((r) & 0xFFFF))
|
|
|
|
/* This macros is used when constructing manifests for sub-reason
|
|
* codes. At the moment it is identical to the main reason macro. If
|
|
* desired we could add a new bit that explicitly identifies the value
|
|
* as a sub-reason code, where the corresponding bit in the main
|
|
* message ID would be zero.
|
|
*/
|
|
#define ADPSUBREASON(c,r) (ADPCHANNEL(c) | ((r) & 0xFFFF))
|
|
|
|
/* All other undefined bits are reserved, and should be zero. */
|
|
|
|
|
|
|
|
/*****************************************************************
|
|
*
|
|
* channel_BOOT messages
|
|
*
|
|
*/
|
|
|
|
/* The BOOT agent only supports a few messages. They are used purely
|
|
* to control the "start-of-day" connection to a host program. All
|
|
* Angel systems with host communications *MUST* provide the BOOT
|
|
* agent, even if they don't have support for either the single- or
|
|
* multi-threaded debug agents.
|
|
*
|
|
* The way the BOOT channel will be used on startup will be as follows:
|
|
*
|
|
* a) Target board is powered up before host debugger is invoked
|
|
*
|
|
* After switching on the target and initialisation is completed the
|
|
* target will send an ADP_Booted or ADP_Reset message. The debugger
|
|
* has not been started yet so this message will not be received. In
|
|
* a serial world this makes it important that any buffers on the host
|
|
* side are flushed during initialisation of the debugger, and in an
|
|
* Ethernet world it makes it important that the target can cope with the
|
|
* message not being received.
|
|
*
|
|
* Eventually the Debugger will be started up and will send an
|
|
* ADP_Reboot or ADP_Reset request. The target will respond to this with
|
|
* an ADP_Reboot or ADP_Reset acknowldege and will then reboot, finally
|
|
* sending an ADP_Rebooted when it has done all it needs to do (very little
|
|
* in the case of ADP_Reset, but completely rebooting in the case of
|
|
* ADP_Reboot). Note that it is important that an ADP_Rebooted message is
|
|
* sent so that the Debugger does not attempt to send any data after it has
|
|
* made a request to ADP_Reboot and before it receives an ADP_Rebooted, as
|
|
* data can be lost be the target during this time.
|
|
*
|
|
* The target and host are now ready to start a debug session.
|
|
*
|
|
* b) Target board is powered up after host debugger is invoked
|
|
*
|
|
* The debugger will send an ADP_Reboot or ADP_Reset request, but will
|
|
* receive no reply until the target is powered up.
|
|
/ *
|
|
* When the target is powered up then it will send an ADP_Rebooted
|
|
* message to the debugger. The debugger should accept this message
|
|
* even though it has received no ADP_Reboot or ADP_Reset acknowldege message
|
|
* from the target.
|
|
*
|
|
* The target and host are now ready to start a debug session.
|
|
*
|
|
*
|
|
* If at any point during the bootup sequence and ADP messages are
|
|
* sent down the S_DBG channel then they should be responded to with a
|
|
* RDI_NotInitialised error. [This should never happen however].
|
|
*
|
|
* An ADP_Boot or ADP Rebooted message should be accepted at
|
|
* any point, since it is possible for a catastrophe to occur (such as
|
|
* disconnecteing the host and target during a debug message) which
|
|
* requires that one or other end be reset.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* A list of parameter types - for now just baud rate
|
|
*/
|
|
typedef enum ADP_Parameter {
|
|
AP_PARAMS_START = 0xC000,
|
|
AP_BAUD_RATE = AP_PARAMS_START,
|
|
/* extra parameters go in here */
|
|
#ifdef TEST_PARAMS
|
|
AP_CAFE_MENU, /* extra just for testing */
|
|
#endif
|
|
AP_PARAMS_END
|
|
} ADP_Parameter;
|
|
|
|
#define AP_NUM_PARAMS (AP_PARAMS_END - AP_PARAMS_START)
|
|
|
|
/*
|
|
* Parameter types should have associated semantics which can be represented
|
|
* within one word per parameter, or an associated enum for choices.
|
|
*
|
|
* AP_BAUD_RATE: the word contains the exact baud rate, eg. 9600, 38400.
|
|
*/
|
|
|
|
/* this is not strictly necessary, but it's an example */
|
|
typedef enum ADP_BaudRate {
|
|
AB_9600 = 9600,
|
|
AB_19200 = 19200,
|
|
AB_38400 = 38400,
|
|
AB_57600 = 57600,
|
|
AB_115200 = 115200
|
|
} ADP_BaudRate;
|
|
|
|
#define AB_NUM_BAUD_RATES 5 /* this is more useful, for sizing arrays */
|
|
|
|
/* This must be set to the max number of options per parameter type */
|
|
#define AP_MAX_OPTIONS (AB_NUM_BAUD_RATES)
|
|
|
|
|
|
#define ADP_Booted ADPREASON(CI_TBOOT,0)
|
|
/* This message is sent by the target after the Angel system has been
|
|
* initialised. This message also contains information describing the
|
|
* Angel world. The information can then be used to check that the
|
|
* target debug agent and source debugger are compatible.
|
|
*
|
|
* Message arguments:
|
|
* word Angel message default buffer size.
|
|
* word Angel message large buffer size (may be same as default)
|
|
* word Angel version ; inc. type (e.g. boot ROM) See (1)
|
|
* word ADP version. See (2)
|
|
* word ARM Architecture info See (3)
|
|
* word ARM CPU information ; including target endianness. See (4)
|
|
* word Target hardware status. See (5)
|
|
* word Number of bytes in banner message
|
|
* bytes Startup banner message (single-threaded readable
|
|
* descriptive text - NOT NULL terminated).
|
|
*
|
|
* Reply:
|
|
* word status
|
|
*
|
|
* 'status' returns RDIError_NoError for success, and otherwise
|
|
* indicates an error.
|
|
*/
|
|
|
|
/* Angel version word [Reference(1)] : */
|
|
/* Angel version number is a 16bit BCD value */
|
|
#define ADP_ANGELVSN_MASK (0x0000FFFF)
|
|
#define ADP_ANGELVSN_SHIFT (0)
|
|
|
|
/* Type of Angel system */
|
|
#define ADP_ANGELVSN_TYPE_MASK (0x00FF0000)
|
|
#define ADP_ANGELVSN_TYPE_SHIFT (16)
|
|
|
|
typedef enum {
|
|
ADP_AngelType_bootROM, /* Simple ROM system providing download capability */
|
|
ADP_AngelType_appROM, /* ROM based application */
|
|
ADP_AngelType_appDLOAD,/* Downloaded Angel based application */
|
|
ADP_AngelType_Last /* Unknown type. This typedef can be extended */
|
|
/* but if the host and target vsns differ */
|
|
/* Then one will spot that it dies not understand */
|
|
} ADP_Angel_Types ; /* this field and can whinge appropriately */
|
|
|
|
/* First unknown ADP_AngelType */
|
|
#define ADP_ANGELVSN_UNKTYPE_MASK (0xFF000000)
|
|
#define ADP_ANGELVSN_UNKYPE_SHIFT (24)
|
|
|
|
/* Currently only 8 bits are used in the word: */
|
|
/* ADP protocol supported by target [Reference (2)] */
|
|
#define ADP_ANGELVSN_ADP_MASK (0x000000FF)
|
|
#define ADP_ANGELVSN_ADP_SHIFT (0)
|
|
|
|
/* ARM Architecture info: [Reference (3)] */
|
|
/* ARM Architecture Verson of target CPU */
|
|
#define ADP_ARM_ARCH_VSN_MASK (0x000000FF)
|
|
#define ADP_ARM_ARCH_VSN_SHIFT (0)
|
|
/* Does the processor support the Thumb Instruction Set */
|
|
#define ADP_ARM_ARCH_THUMB (0x80000000)
|
|
/* Does the processor support Long Multiplies */
|
|
#define ADP_ARM_ARCH_LONGMUL (0x40000000)
|
|
/* All other flags are current undefined, and should be zero. */
|
|
|
|
/* The following flags describe the feature set of the processor: */
|
|
/* Set if cpu supports little-endian model [Reference (4)] */
|
|
#define ADP_CPU_LE (1 << 0)
|
|
/* Set if cpu supports big-endian model */
|
|
#define ADP_CPU_BE (1 << 1)
|
|
/* Set if processor has a cache */
|
|
#define ADP_CPU_CACHE (1 << 2)
|
|
/* Set if processor has a MMU */
|
|
#define ADP_CPU_MMU (1 << 3)
|
|
/* All other flags are current undefined, and should be zero. */
|
|
|
|
/* The following flags reflect current Target hardware status: */
|
|
/* [Reference (5)] */
|
|
/* 0 = no MMU or MMU off; 1 = MMU on */
|
|
#define ADP_CPU_MMUOn (1 << 29)
|
|
/* 0 = no cache or cache off; 1 = cache on */
|
|
#define ADP_CPU_CacheOn (1 << 30)
|
|
/* 0 = little-endian; 1 = big-endian */
|
|
#define ADP_CPU_BigEndian (1U << 31)
|
|
/* All other flags are current undefined, and should be zero. */
|
|
|
|
|
|
#ifdef LINK_RECOVERY
|
|
|
|
#define ADP_TargetResetIndication ADPREASON(CI_TBOOT, 1)
|
|
/*
|
|
* If parameter negotiation is enabled at the target, it configures itself
|
|
* to various likely parameter settings and sends this message at each
|
|
* configuration. The message describes the default settings, and after
|
|
* sending at each configuration the target sets itself to the defaults
|
|
* it has just broadcast, to await either an ack on TBOOT or a request
|
|
* or reset indication on HBOOT.
|
|
*
|
|
* If the host receives this message successfully, it should reset to the
|
|
* indicated parameters and send a reply.
|
|
*
|
|
* Message arguments:
|
|
* word status (always 0, makes body same as
|
|
* ADP_ParamNegotiate response)
|
|
* word n-parameters
|
|
* n-parameters * {
|
|
* word ADP_Parameter
|
|
* word parameter-value
|
|
* }
|
|
*
|
|
* Reply:
|
|
* - empty acknowledgement
|
|
*/
|
|
|
|
#endif /* def LINK_RECOVERY */
|
|
|
|
typedef enum ADP_Boot_Ack {
|
|
AB_NORMAL_ACK, /* will comply, immediate booted message */
|
|
AB_LATE_ACK, /* will comply, late startup */
|
|
AB_ERROR /* cannot comply */
|
|
} ADP_Boot_Ack;
|
|
|
|
/* If the host sets neither of these in the word sent on a Reset / Reboot
|
|
* then it doesn;t care about the endianess of the target
|
|
*/
|
|
#define ADP_BootHostFeature_LittleEnd 0x80000000
|
|
#define ADP_BootHostFeature_BigEnd 0x40000000
|
|
|
|
#define ADP_Reboot ADPREASON(CI_HBOOT,2)
|
|
/* This message is sent when the host wants the target system to be
|
|
* completely reset, back to the boot monitor Angel. This is the
|
|
* method of the host forcing a cold-reboot.
|
|
* Note that an acknowledgement message will be sent immediately and
|
|
* that this must be sent before the target can reset.
|
|
*
|
|
* The parameter to this function is a bitset of host supported
|
|
* features. (in fact the same as ADP_Reset below. This can be used by
|
|
* the target system to avoid using debug channel bandwidth raising
|
|
* messages that will be ignored by the host.
|
|
*
|
|
* Parameters:
|
|
* word host supported features (see above)
|
|
*
|
|
* Reply:
|
|
* word status, one of enum ADP_Boot_Ack above.
|
|
*
|
|
* Currently there are no such features defined, so the word indicating
|
|
* host supported features should be set to 0.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_Reset ADPREASON(CI_HBOOT,3)
|
|
/* This message is a request from the host, which should eventually
|
|
* result in the "ADP_Booted" message being sent by the target.
|
|
* Note that an acknowledgement message will be sent immediately and
|
|
* that this must be sent before the target can reset.
|
|
* This reset message is *ALWAYS* treated as a warm boot, with the target
|
|
* preserving as much state as possible.
|
|
*
|
|
* The parameter to this function is a bitset of host supported
|
|
* features. This can be used by the target system to avoid using
|
|
* debug channel bandwitdth raising messages that will be ignored by
|
|
* the host.
|
|
*
|
|
* Parameters:
|
|
* word host supported features (see above)
|
|
*
|
|
* Reply:
|
|
* word status, one of enum ADP_Boot_Ack above.
|
|
*
|
|
* Currently there are no such features defined, so the word indicating
|
|
* host supported features should be set to 0.
|
|
*/
|
|
|
|
|
|
#ifdef LINK_RECOVERY
|
|
|
|
#define ADP_HostResetIndication ADPREASON(CI_HBOOT, 4)
|
|
/*
|
|
* This is as for ADP_TargetResetIndication, but is sent by the host when
|
|
* it first starts up in case the target is listening at a non-default
|
|
* setting. Having sent at various configurations, the host then listens
|
|
* at the defaults it has just broadcast, to await either an ack on HBOOT
|
|
* or a reset indication on TBOOT.
|
|
*
|
|
* For arguments and reply, see ADP_TargetResetIndication.
|
|
*/
|
|
|
|
#endif /* def LINK_RECOVERY */
|
|
|
|
|
|
#define ADP_ParamNegotiate ADPREASON(CI_HBOOT, 5)
|
|
/*
|
|
* The host sends this messages to negotiate new parameters with the target.
|
|
* For each parameter the host specifies a range of possibilities, starting
|
|
* with the most favoured. All possible combinations of parameters
|
|
* must be valid.
|
|
*
|
|
* If the target can operate at a combination of the offered parameters,
|
|
* it will reply with the parameters it is willing to use. AFTER sending
|
|
* the reply, the target switches to this combination. On receiving the
|
|
* reply, the host will switch to the new combination and send a LinkCheck
|
|
* message (see below).
|
|
*
|
|
* If the target cannot operate at any combination of the offered parameters,
|
|
* it will reply with an error status.
|
|
*
|
|
* Message arguments:
|
|
* word n-parameter-blocks
|
|
* n-parameter-blocks * {
|
|
* word ADP_Parameter
|
|
* word n-options
|
|
* n-options * { word parameter-value }
|
|
* }
|
|
*
|
|
* Reply:
|
|
* word status
|
|
* if (status == RDIError_NoError) {
|
|
* word n-parameters
|
|
* n-parameters * {
|
|
* word ADP_Parameter
|
|
* word chosen-value
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
#define ADP_LinkCheck ADPREASON(CI_HBOOT, 6)
|
|
/*
|
|
* This should be the first message that the host sends after a successful
|
|
* parameter negotiation. It is really just a 'ping'.
|
|
*
|
|
* Message arguments:
|
|
* - empty message
|
|
*
|
|
* Reply:
|
|
* - empty acknowledgement
|
|
*/
|
|
|
|
|
|
/********************************************************************
|
|
*
|
|
* CI_HADP messages
|
|
*
|
|
*/
|
|
|
|
#define ADP_HADPUnrecognised ADPREASON(CI_HADP,0)
|
|
/* This message is unusual in that it is normally sent in reply to
|
|
* another message which is not understood. This is an exception
|
|
* to the normal protocol which says that a reply must have the
|
|
* same base reason code as the original. There is a single reply
|
|
* parameter which is the reason code which was not understood.
|
|
*
|
|
* As well as being a reply this message can also be sent and will
|
|
* return as if this message were unrecognised!
|
|
*
|
|
* Parameters:
|
|
* none
|
|
*
|
|
* Reply:
|
|
* word reason code which was not recognised
|
|
*/
|
|
|
|
|
|
#define ADP_Info ADPREASON(CI_HADP,1)
|
|
/* This is the new ADP information message. It is used to interrogate
|
|
* the target debug agent. It provides information on the processor,
|
|
* as well as the state of the debug world. This allows the host to
|
|
* configure itself to the capabilities of the target.
|
|
*
|
|
* We try not to use feature bitsets, since we could quickly run out
|
|
* of known bits. Thus when the feature set is extended, this can be
|
|
* done in a couple of supported ways:
|
|
*
|
|
* If an undivided reason code is to be added (no reason subcodes)
|
|
* then add a new ADP_Info code which responds with a flag indicating
|
|
* whether that feature is supported by the target. If this has not
|
|
* even been implemented then the reply will be ADP_HADPUnrecognised
|
|
*
|
|
* If a reason code which is subdivided into reason subcodes is
|
|
* added then reason subcode 0 should be set aside to indicate
|
|
* whether the functionality of that reason code is supported
|
|
* by the target. If it is not even implemented then the reply will
|
|
* be ADP_Unrecognised.
|
|
*
|
|
* The first parameter to ADP_Info is a reason subcode, and subsequent
|
|
* parameters are defined by that subcode
|
|
*
|
|
* Parameters:
|
|
* word reason subcode
|
|
* other arguments as reason subcode determines.
|
|
*
|
|
* Reply:
|
|
* word reason subcode
|
|
* other argument as reason subcode determines
|
|
*/
|
|
|
|
/* ADP_Info reason subcodes: */
|
|
|
|
|
|
|
|
#define ADP_Info_NOP ADPSUBREASON(CI_HADP,0)
|
|
/* ADP_Info_NOP
|
|
* ------------
|
|
* Summary: This message is used to check for ADP_Info being supported.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' returns RDIError_NoError for success, non-zero indicates an error.
|
|
* If an error is returned then there is no handler for the ADP_Info
|
|
* message. The normal action will be to return an OK status.
|
|
*/
|
|
|
|
|
|
#define ADP_Info_Target ADPSUBREASON(CI_HADP,1)
|
|
/* ADP_Info_Target
|
|
* ---------------
|
|
* Summary:
|
|
* This reason code is used to interrogate target system details.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word bitset, word model)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate OK, or non-zero to indicate
|
|
* some sort of error.
|
|
* 'bitset' is described in more detail below, and is mostly compatible
|
|
* with the old RDI/RDP system to avoid gratuitous changes to the debugger
|
|
* toolbox.
|
|
* 'model' is the target hardware ID word, as returned by the ADP_Booted
|
|
* message.
|
|
*
|
|
* NOTE: The minimum and maximum protocol levels are no longer supported.
|
|
* It is the Angel view that debugging complexity should be shifted to the
|
|
* host if at all possible. This means that the host debugger should
|
|
* always try to configure itself to the features available in the target
|
|
* debug agent. This can be done by checking individual messages, rather
|
|
* than by a blanket version number dictating the feature set.
|
|
*/
|
|
|
|
/* 'bitset':- */
|
|
/* Target speed in instructions per second = 10**(bits0..3). */
|
|
#define ADP_Info_Target_LogSpeedMask (0xF)
|
|
|
|
/* Target is running on [0 = emulator / 1 = hardware] */
|
|
#define ADP_Info_Target_HW (1 << 4)
|
|
|
|
/* Bits 5..10 are currently undefined and should be zero. */
|
|
/* Other bis are kept the same as the RDP in order to */
|
|
/* eliminate the need to change the position of some bits */
|
|
|
|
/* If set then the debug agent can be reloaded. */
|
|
#define ADP_Info_Target_CanReloadAgent (1 << 11)
|
|
|
|
/* Can request AngelBufferSize information. */
|
|
#define ADP_Info_Target_CanInquireBufferSize (1 << 12)
|
|
|
|
/* Bit 13 is no longer required as it inquired whether
|
|
* a special RDP Interrupt code was supported
|
|
*/
|
|
|
|
/* Debug agent can perform profiling. */
|
|
#define ADP_Info_Target_Profiling (1 << 14)
|
|
|
|
/* Debug agent can support Thumb code. */
|
|
#define ADP_Info_Target_Thumb (1 << 15)
|
|
|
|
/* Bit 16 was the communications channel check.
|
|
* This is always available on Angel systems.
|
|
*/
|
|
|
|
#define ADP_Info_Points ADPSUBREASON(CI_HADP,2)
|
|
/* ADP_Info_Points
|
|
* ---------------
|
|
* Summary: Returns a 32bit wide bitset of break- and watch-point
|
|
* features supported by the target debug agent.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word breakinfo)
|
|
*
|
|
* 'status' returns RDIError_NoError on success or non-zero to indicate
|
|
* some sort of error.
|
|
* 'breakinfo' is a 32bit wide bitset described in detail below. Note
|
|
* that only bits 1..12 are used.
|
|
*/
|
|
|
|
/* 'breakinfo':- */
|
|
/* Can trap on address equality. */
|
|
#define ADP_Info_Points_Comparison (1 << 0)
|
|
|
|
/* Can trap on address range. */
|
|
#define ADP_Info_Points_Range (1 << 1)
|
|
|
|
/* Can trap on 8bit memory reads. */
|
|
#define ADP_Info_Points_ReadByteWatch (1 << 2)
|
|
|
|
/* Can trap on 16bit memory reads. */
|
|
#define ADP_Info_Points_ReadHalfWatch (1 << 3)
|
|
|
|
/* Can trap on 32bit memory reads. */
|
|
#define ADP_Info_Points_ReadWordWatch (1 << 4)
|
|
|
|
/* Can trap on 8bit write accesses. */
|
|
#define ADP_Info_Points_WriteByteWatch (1 << 5)
|
|
|
|
/* Can trap on 16bit write accesses. */
|
|
#define ADP_Info_Points_WriteHalfWatch (1 << 6)
|
|
|
|
/* Can trap on 32bit write accesses. */
|
|
#define ADP_Info_Points_WriteWordWatch (1 << 7)
|
|
|
|
/* Like range, but based on address bitmask<. */
|
|
#define ADP_Info_Points_Mask (1 << 8)
|
|
|
|
/* Multi-threaded support only - thread specific breakpoints. */
|
|
#define ADP_Info_Points_ThreadBreak (1 << 9)
|
|
|
|
/* Multi-threaded support only - thread specific watchpoints. */
|
|
#define ADP_Info_Points_ThreadWatch (1 << 10)
|
|
|
|
/* Allows conditional breakpoints. */
|
|
#define ADP_Info_Points_Conditionals (1 << 11)
|
|
|
|
/* Break- and watch-points can be interrogated */
|
|
#define ADP_Info_Points_Status (1 << 12)
|
|
|
|
|
|
#define ADP_Info_Step ADPSUBREASON(CI_HADP,3)
|
|
/* ADP_Info_Step
|
|
* -------------
|
|
* Summary: Returns a 32bit wide bitmask of the single-stepping
|
|
* capabilities of the target debug agent.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word stepinfo)
|
|
*
|
|
* 'status' returns RDIError_NoError on success, or non-zero to indicate
|
|
* some kind of error.
|
|
* 'stepinfo' is a 32bit wide bitmask described in detail below. Note that
|
|
* only 3 bits are used.
|
|
*/
|
|
|
|
/* 'stepinfo':- */
|
|
/* Single-stepping of more than one instruction is possible. */
|
|
#define ADP_Info_Step_Multiple (1 << 0)
|
|
|
|
/* Single-stepping until next direct PC change is possible. */
|
|
#define ADP_Info_Step_PCChange (1 << 1)
|
|
|
|
/* Single-stepping of a single instruction is possible. */
|
|
#define ADP_Info_Step_Single (1 << 2)
|
|
|
|
|
|
#define ADP_Info_MMU ADPSUBREASON(CI_HADP,4)
|
|
/* ADP_Info_MMU
|
|
* ------------
|
|
* Summary: Returns information about the memory management system (if
|
|
* any).
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word meminfo)
|
|
*
|
|
* 'status' returns RDIError_NoError to indicate success or non-zero to
|
|
* indicate some kind of error.
|
|
* 'meminfo' should be a 32bit unique ID, or zero if there is no MMU
|
|
* support on the target.
|
|
*/
|
|
|
|
|
|
#define ADP_Info_SemiHosting ADPSUBREASON(CI_HADP,5)
|
|
/* ADP_Info_SemiHosting
|
|
* --------------------
|
|
* Summary: This message is used to check whether semi-hosting info calls
|
|
* are available on the target.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' returns RDIError_NoError if semi-hosting info calls are available,
|
|
* non-zero otherwise.
|
|
*/
|
|
|
|
|
|
#define ADP_Info_CoPro ADPSUBREASON(CI_HADP,6)
|
|
/* ADP_Info_CoPro
|
|
* --------------
|
|
* Summary: This message checks whether CoProcessor info calls are
|
|
* supported.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' returns RDIError_NoError to indicate these facilities
|
|
* are supported, non-zero otherwise.
|
|
*/
|
|
|
|
|
|
#define ADP_Info_Cycles ADPSUBREASON(CI_HADP,7)
|
|
/* ADP_Info_Cycles
|
|
* ---------------
|
|
* Summary: Returns the number of instructions and cycles executed since
|
|
* the target was initialised.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word ninstr, word Scycles, word Ncycles,
|
|
* word Icycles, word Ccycles, word Fcycles)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, or non-zero if there
|
|
* is no target support for gathering cycle count information.
|
|
* 'ninstr' is the number of instructions executed.
|
|
* 'Scycles' is the number of S-cycles executed.
|
|
* 'Ncycles' is the number of N-cycles executed.
|
|
* 'Icycles' is the number of I-cycles executed.
|
|
* 'Ccycles' is the number of C-cycles executed.
|
|
* 'Fcycles' is the number of F-cycles executed.
|
|
*/
|
|
|
|
|
|
#define ADP_Info_DescribeCoPro ADPSUBREASON(CI_HADP,8)
|
|
/* ADP_Info_DescribeCoPro
|
|
* ----------------------
|
|
* Summary: Describe the registers of a coprocessor. Use only if
|
|
* ADP_Info_CoPro return RDIError_NoError.
|
|
*
|
|
* Arguments:
|
|
* Send: Arguments of the form:
|
|
* (byte cpno, byte rmin, byte rmax, byte nbytes, byte access,
|
|
* byte cprt_r_b0, byte cprt_r_b1, byte cprt_w_b0, byte cprt_w_b1)
|
|
* And a terminating byte = 0xff. Must be within maximum buffer size.
|
|
* Return: (word status)
|
|
*
|
|
* 'cpno' is the number of the coprocessor to be described.
|
|
* 'rmin' is the bottom of a range of registers with the same description.
|
|
* 'rmax' is the top of a range of registers with the same description.
|
|
* 'nbytes' is the size of the register.
|
|
* 'access' describes access to the register and is described in more detail
|
|
* below.
|
|
*
|
|
* If bit 2 of access is set:-
|
|
* 'cprt_r0' provides bits 0 to 7, and
|
|
* 'cprt_r1' provides bits 16 to 23 of a CPRT instruction to read the
|
|
* register.
|
|
* 'cprt_w0' provides bits 0 to 7, and
|
|
* 'cprt_w1' provides bits 16 to 23 of a CPRT instruction to write the
|
|
* register.
|
|
*
|
|
* Otherwise, 'cprt_r0' provides bits 12 to 15, and 'cprt_r1' bit 22 of CPDT
|
|
* instructions to read and write the register ('cprt_w0' and 'cprt_w1' are
|
|
* junk).
|
|
*/
|
|
|
|
/* 'access':- */
|
|
/* Readable. */
|
|
#define ADP_Info_DescribeCoPro_Readable (1 << 0)
|
|
|
|
/* Writeable. */
|
|
#define ADP_Info_DescribeCoPro_Writeable (1 << 1)
|
|
|
|
/* Registers read or written via CPDT instructions (else CPRT) with this
|
|
bit set. */
|
|
#define ADP_Info_DescribeCoPro_CPDT (1 << 2)
|
|
|
|
#define ADP_Info_RequestCoProDesc ADPSUBREASON(CI_HADP,9)
|
|
/* ADP_Info_RequestCoProDesc
|
|
* -------------------------
|
|
* Summary: Requests a description of the registers of a coprocessor. Use
|
|
* only if ADP_Info_CoPro return RDIError_NoError.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte cpno)
|
|
* Return: Arguments of the form:-
|
|
* (word status, byte rmin, byte rmax, byte nbytes, byte access)
|
|
* Followed by a terminating byte = 0xFF. Must be within maximum
|
|
* buffer size.
|
|
* 'cpno' is the number of the coprocessor to describe.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'rmin' is the bottom of a range of registers with the same description.
|
|
* 'rmax' is the top of a range of registers with the same description.
|
|
* 'nbytes' is the size in bytes of the register(s).
|
|
* 'access' is as above in ADP_Info_DescribeCoPro.
|
|
*/
|
|
|
|
|
|
#define ADP_Info_AngelBufferSize ADPSUBREASON(CI_HADP,10)
|
|
/* ADP_Info_AngelBufferSize
|
|
* ------------------------
|
|
* Summary: Returns the Angel buffer sizes.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word defaultsize, word maxsize)
|
|
*
|
|
* 'status' returns RDIError_NoError to indicate success or non-zero to
|
|
* indicate some kind of error.
|
|
* 'defaultsize' is the default Angel ADP buffer size in bytes. This is
|
|
* at least 256 bytes.
|
|
* 'maxsize' is the largest Angel ADP buffer size in bytes. This will be
|
|
* greater than or equal to defaultsize. The target will accept ADP messages
|
|
* of up to this length for download, etc.
|
|
*
|
|
* Was DownLoadSize in RDP/RDI world. This is the amount that the target
|
|
* should transmit in a single operation. This should now be the Angel
|
|
* buffer size. This information is also given in the ADP_Booted message.
|
|
*
|
|
* NOTE: The value returned should be the DATASIZE and *NOT* BUFFERDEFSIZE.
|
|
* This is needed to ensure that the transport protocol information
|
|
* can be wrapped around the data.
|
|
*/
|
|
|
|
#define ADP_Info_ChangeableSHSWI ADPSUBREASON(CI_HADP,11)
|
|
/* ADP_Info_ChangeableSHSWI
|
|
* ------------------------
|
|
* Summary: This message is used to check whether it is possible to change
|
|
* which SWI's are used for semihosting.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' returns RDIError_NoError if semi-hosting info calls are available,
|
|
* non-zero otherwise.
|
|
*/
|
|
|
|
#define ADP_Info_CanTargetExecute ADPSUBREASON(CI_HADP,12)
|
|
/* ADP_Info_CanTargetExecute
|
|
* -------------------------
|
|
* Summary: This message is used to see if the target is currently in
|
|
* an executable state. Typically this is called after the debugger
|
|
* initialises. If a non-error statis is returned then the user is
|
|
* allowed to 'go' immediately.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' returns RDIError_NoError if target is ready to execute.
|
|
* other values indicate why it cannot execute.
|
|
*/
|
|
|
|
#define ADP_Info_AgentEndianess ADPSUBREASON(CI_HADP,13)
|
|
/* ADP_Info_AgentEndianess
|
|
* -------------------------
|
|
* Summary: This message is used to determine the endianess of the
|
|
* debug agent
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* status should be RDIError_LittleEndian or RDIError_BigEndian
|
|
* any other value indicates the target does not support this
|
|
* request, so the debugger will have to make a best guess, which
|
|
* probably means only allow little endian loadagenting.
|
|
*/
|
|
|
|
|
|
#define ADP_Control ADPREASON(CI_HADP,2)
|
|
/* This message allows for the state of the debug agent to be
|
|
* manipulated by the host.
|
|
*/
|
|
|
|
/* The following are sub reason codes to ADP control, the first parameter
|
|
* is the sub reason code which defines the format of subsequent parameters.
|
|
*
|
|
* word sub reason code
|
|
*/
|
|
|
|
#define ADP_Ctrl_NOP ADPSUBREASON(CI_HADP,0)
|
|
/* ADP_Ctrl_NOP
|
|
* ------------
|
|
* Summary: This message is used to check that ADP_Ctrl messages are
|
|
* supported.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate ADP_Ctrl messages are
|
|
* supported, non-zero otherwise.
|
|
*/
|
|
|
|
#define ADP_Ctrl_VectorCatch ADPSUBREASON(CI_HADP,1)
|
|
/* ADP_Ctrl_VectorCatch
|
|
* --------------------
|
|
* Summary: Specifies which hardware exceptions should be reported to the
|
|
* debugger.
|
|
*
|
|
* Arguments:
|
|
* Send: (word bitmap)
|
|
* Return: (word status)
|
|
*
|
|
* 'bitmap' is a bit-mask of exceptions to be reported, described in more
|
|
* detail below. A set bit indicates that the exception should be
|
|
* reported to the debugger, a clear bit indicates that the corresponding
|
|
* exception vector should be taken.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
/* 'bitmap':- */
|
|
/* Reset(branch through zero). */
|
|
#define ADP_Ctrl_VectorCatch_BranchThroughZero (1 << 0)
|
|
|
|
/* Undefined Instruction. */
|
|
#define ADP_Ctrl_VectorCatch_UndefinedInstr (1 << 1)
|
|
|
|
/* Software Interrupt. */
|
|
#define ADP_Ctrl_VectorCatch_SWI (1 << 2)
|
|
|
|
/* Prefetch Abort. */
|
|
#define ADP_Ctrl_VectorCatch_PrefetchAbort (1 << 3)
|
|
|
|
/* Data Abort. */
|
|
#define ADP_Ctrl_VectorCatch_DataAbort (1 << 4)
|
|
|
|
/* Address Exception. */
|
|
#define ADP_Ctrl_VectorCatch_AddressException (1 << 5)
|
|
|
|
/* Interrupt Request. */
|
|
#define ADP_Ctrl_VectorCatch_IRQ (1 << 6)
|
|
|
|
/* Fast Interrupt Request. */
|
|
#define ADP_Ctrl_VectorCatch_FIQ (1 << 7)
|
|
|
|
/* Error. */
|
|
#define ADP_Ctrl_VectorCatch_Error (1 << 8)
|
|
|
|
|
|
#define ADP_Ctrl_PointStatus_Watch ADPSUBREASON(CI_HADP,2)
|
|
/* ADP_Ctrl_PointStatus_Watch
|
|
* --------------------------
|
|
* Summary: Returns the hardware resource number and the type of that
|
|
* resource when given a watchpoint handle. Should only be called if
|
|
* the value returned by ADP_Info_Points had ADP_Info_Points_Status set.
|
|
*
|
|
* Arguments:
|
|
* Send: (word handle)
|
|
* Return: (word status, word hwresource, word type)
|
|
*
|
|
* 'handle' is a handle to a watchpoint.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'hwresource' is the hardware resource number. !!!!!
|
|
* 'type' is the type of the resource.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_PointStatus_Break ADPSUBREASON(CI_HADP,3)
|
|
/* ADP_Ctrl_PointStatus_Break
|
|
* --------------------------
|
|
* Summary: Returns the hardware resource number and the type of that
|
|
* resource when given a breakpoint handle. Should only be called if
|
|
* the value returned by ADP_Info_Points had ADP_Info_Points_Status set.
|
|
*
|
|
* Arguments:
|
|
* Send: (word handle)
|
|
* Return: (word status, word hwresource, word type)
|
|
*
|
|
* 'handle' is a handle to a breakpoint.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'hwresource' is the hardware resource number.
|
|
* 'type' is the type of the resource.
|
|
*/
|
|
|
|
#define ADP_Ctrl_SemiHosting_SetState ADPSUBREASON(CI_HADP,4)
|
|
/* ADP_Ctrl_SemiHosting_SetState
|
|
* -----------------------------
|
|
* Summary: Sets whether or not semi-hosting is enabled.
|
|
*
|
|
* Arguments:
|
|
* Send: (word semihostingstate)
|
|
* Return: (word status)
|
|
*
|
|
* 'semihostingstate' sets semi-hosting to enabled if zero, otherwise
|
|
* it disables semi-hosting.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_SemiHosting didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_SemiHosting_GetState ADPSUBREASON(CI_HADP,5)
|
|
/* ADP_Ctrl_SemiHosting_GetState
|
|
* -----------------------------
|
|
* Summary: Reads whether or not semi-hosting is enabled.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word semihostingstate)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'semihostingstate' is zero if semi-hosting is enabled, non-zero otherwise.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_SemiHosting didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_SemiHosting_SetVector ADPSUBREASON(CI_HADP,6)
|
|
/* ADP_Ctrl_SemiHosting_SetVector
|
|
* ------------------------------
|
|
* Summary: Sets the semi-hosting vector.
|
|
*
|
|
* Arguments:
|
|
* Send: (word semihostingvector)
|
|
* Return: (word status)
|
|
*
|
|
* 'semihostingvector' holds the value the vector is to be set to.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_SemiHosting didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_SemiHosting_GetVector ADPSUBREASON(CI_HADP,7)
|
|
/* ADP_Ctrl_SemiHosting_GetVector
|
|
* ------------------------------
|
|
* Summary: Gets the value of the semi-hosting vector.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word semihostingvector)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'semihostingvector' holds the value of the vector.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_SemiHosting didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_Log ADPSUBREASON(CI_HADP,8)
|
|
/* ADP_Ctrl_Log
|
|
* ------------
|
|
* Summary: Returns the logging state.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word logsetting)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'logsetting' is a bitmap specifying the level of logging desired,
|
|
* described in more detail below. The bits can be ORed together
|
|
*/
|
|
|
|
/* 'logsetting':- */
|
|
|
|
/* No logging. */
|
|
#define ADP_Ctrl_Log_NoLogging (0)
|
|
/* RDI level logging. */
|
|
#define ADP_Ctrl_Log_RDI (1 << 0)
|
|
/* ADP byte level logging. */
|
|
#define ADP_Ctrl_Log_ADP (1 << 1)
|
|
|
|
|
|
#define ADP_Ctrl_SetLog ADPSUBREASON(CI_HADP,9)
|
|
/* ADP_Ctrl_SetLog
|
|
* ---------------
|
|
* Summary: Sets the logging state.
|
|
*
|
|
* Arguments:
|
|
* Send: (word logsetting)
|
|
* Return: (word status)
|
|
*
|
|
* 'logsetting' is the same as in ADP_Ctrl_Log above.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
#define ADP_Ctrl_SemiHosting_SetARMSWI ADPSUBREASON(CI_HADP,10)
|
|
/* ADP_Ctrl_SemiHosting_SetARMSWI
|
|
* ------------------------------
|
|
* Summary: Sets the number of the ARM SWI used for semihosting
|
|
*
|
|
* Arguments:
|
|
* Send: (word ARM_SWI_number)
|
|
* Return: (word status)
|
|
*
|
|
* The debug agent will interpret ARM SWI's with the SWI number specified
|
|
* as semihosting SWI's.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_ChangeableSHSWI didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_SemiHosting_GetARMSWI ADPSUBREASON(CI_HADP,11)
|
|
/* ADP_Ctrl_SemiHosting_GetARMSWI
|
|
* ------------------------------
|
|
* Summary: Reads the number of the ARM SWI used for semihosting
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word ARM_SWI_number)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* ARM_SWI_number is the SWI number which is used for semihosting.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_SemiHosting didn't return
|
|
* an error.
|
|
*/
|
|
|
|
#define ADP_Ctrl_SemiHosting_SetThumbSWI ADPSUBREASON(CI_HADP,12)
|
|
/* ADP_Ctrl_SemiHosting_SetThumbSWI
|
|
* --------------------------------
|
|
* Summary: Sets the number of the Thumb SWI used for semihosting
|
|
*
|
|
* Arguments:
|
|
* Send: (word Thumb_SWI_number)
|
|
* Return: (word status)
|
|
*
|
|
* The debug agent will interpret Thumb SWI's with the SWI number specified
|
|
* as semihosting SWI's.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_ChangeableSHSWI didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_SemiHosting_GetThumbSWI ADPSUBREASON(CI_HADP,13)
|
|
/* ADP_Ctrl_SemiHosting_GetThumbSWI
|
|
* --------------------------------
|
|
* Summary: Reads the number of the Thumb SWI used for semihosting
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word ARM_Thumb_number)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* Thumb_SWI_number is the SWI number which is used for semihosting.
|
|
*
|
|
* NOTE: This should only be called if ADP_Info_SemiHosting didn't return
|
|
* an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_Download_Supported ADPSUBREASON(CI_HADP,14)
|
|
/* ADP_Ctrl_Download_Supported
|
|
* ---------------------------
|
|
* Summary: Can configuration be downloaded?
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError if the configuration can be downloaded,
|
|
* non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDIInfo_DownLoad.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_Download_Data ADPSUBREASON(CI_HADP,15)
|
|
/* ADP_Ctrl_Download_Data
|
|
* ----------------------
|
|
* Summary: Loads configuration data.
|
|
*
|
|
* Arguments:
|
|
* Send: (word nbytes, words data)
|
|
* Return: (word status)
|
|
*
|
|
* 'nbytes' is the number of *bytes* being sent.
|
|
* 'data' is the configuration data. NOTE: data must not cause the buffer
|
|
* size to exceed the maximum allowed buffer size.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDP_LoadConfigData. Should only be used if
|
|
* ADP_ICEM_AddConfig didn't return an error.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_Download_Agent ADPSUBREASON(CI_HADP,16)
|
|
/* ADP_Ctrl_Download_Agent
|
|
* -----------------------
|
|
* Summary: Prepares Debug Agent to receive configuration data which it
|
|
* should interpret as a new version of the Debug Agent code.
|
|
*
|
|
* Arguments:
|
|
* Send: (word loadaddress, word size)
|
|
* Return: (word status)
|
|
*
|
|
* 'loadaddress' is the address where the new Debug Agent code should be
|
|
* loaded.
|
|
* 'size' is the number of bytes of Debug Agent code to be loaded.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDP_LoadAgent. The data will be downloaded using
|
|
* ADP_Ctrl_Download_Data. The new agent is started with ADP_Ctrl_Start_Agent
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_Start_Agent ADPSUBREASON(CI_HADP,17)
|
|
/* ADP_Ctrl_Start_Agent
|
|
* -----------------------
|
|
* Summary: Instruct Debug Agent to begin execution of new agent,
|
|
* which has been downloaded by ADP_Ctrl_Download_Agent.
|
|
*
|
|
* Arguments:
|
|
* Send: (word startaddress)
|
|
* Return: (word status)
|
|
*
|
|
* 'startaddress' is the address where the new Debug Agent code should be
|
|
* entered, and must satisfy:
|
|
* (loadaddress <= startaddress <= (loadaddress + size))
|
|
* where 'loadaddress' and 'size' were specified in the
|
|
* ADP_Ctrl_Download_Agent message.
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
|
|
#define ADP_Ctrl_SetTopMem ADPSUBREASON(CI_HADP,18)
|
|
/* ADP_Ctrl_SetTopMem
|
|
* ------------------
|
|
* Summary: Sets the top of memory for ICEman2 systems, so that the C Library
|
|
* can allocate the stack in the correct place on startup.
|
|
*
|
|
* Arguments:
|
|
* Send: (word mem_top)
|
|
* Return: (word status)
|
|
*
|
|
* This request should only be supported by ICEman2. Standard Angel systems
|
|
* should return an error (unrecognised is fine).
|
|
*/
|
|
|
|
|
|
#define ADP_Read ADPREASON(CI_HADP,3)
|
|
#define ADP_ReadHeaderSize (ADP_DEFAULT_HEADER_SIZE + 2*sizeof(word))
|
|
|
|
/* ADP_Read
|
|
* --------
|
|
* Summary: Request for a transer of memory contents from the target to the
|
|
* debugger.
|
|
*
|
|
* Arguments:
|
|
* Send: (word address, word nbytes)
|
|
* Return: (word status, word rnbytes [, bytes data])
|
|
*
|
|
* 'address' is the address from which memory transer should start.
|
|
* 'nbytes' is the number of bytes to transfer.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'rnbytes' holds the number of requested bytes NOT read (i.e. zero
|
|
* indicates success, non-zero indicates an error).
|
|
* 'data' is the number of bytes requested minus 'rnbytes'.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_Write ADPREASON(CI_HADP,4)
|
|
#define ADP_WriteHeaderSize (ADP_DEFAULT_HEADER_SIZE + 2*sizeof(word))
|
|
|
|
/* ADP_Write
|
|
* ---------
|
|
* Summary: Request for a transfer of memory contents from the debugger to
|
|
* the target.
|
|
*
|
|
* Arguments:
|
|
* Send: (word address, word nbytes, bytes data)
|
|
* Return: (word status [, word rnbytes])
|
|
*
|
|
* 'address' is the address from which memory transer should start.
|
|
* 'nbytes' is the number of bytes to transfer.
|
|
* 'data' holds the bytes to be transferred.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'rnbytes' holds the number of requested bytes NOT written (i.e. zero
|
|
* indicates success, non-zero indicates an error) if status indicated an
|
|
* error.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_CPUread ADPREASON(CI_HADP,5)
|
|
/* ADP_CPUread
|
|
* -----------
|
|
* Summary: This is a request to read values in the CPU.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte mode, word mask)
|
|
* Return: (word status, words data)
|
|
*
|
|
* 'mode' defines the processor mode from which the transfer should be made.
|
|
* It is described in more detail below.
|
|
* 'mask' indicates which registers should be transferred. Setting a bit to
|
|
* one will cause the designated register to be transferred. The details
|
|
* of mask are specified below.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'data' holds the values of the registers on successful completion,
|
|
* otherwise it just holds rubbish. The lowest numbered register is
|
|
* transferred first. NOTE: data must not cause the buffer size to exceed
|
|
* the maximum allowed buffer size.
|
|
*/
|
|
|
|
/* 'mode':- */
|
|
/* The mode number is the same as the mode number used by an ARM; a value of
|
|
255 indicates the current mode. */
|
|
#define ADP_CPUmode_Current (255)
|
|
|
|
/* 26bit user mode. */
|
|
#define ADP_CPUread_26bitUser (0x0)
|
|
|
|
/* 26bit FIQ mode. */
|
|
#define ADP_CPUread_26bitFIQ (0x1)
|
|
|
|
/* 26bit IRQ mode. */
|
|
#define ADP_CPUread_26bitIRQ (0x2)
|
|
|
|
/* 26bit Supervisor mode. */
|
|
#define ADP_CPUread_26bitSVC (0x3)
|
|
|
|
/* 32bit user mode. */
|
|
#define ADP_CPUread_32bitUser (0x10)
|
|
|
|
/* 32bit FIQ mode. */
|
|
#define ADP_CPUread_32bitFIQ (0x11)
|
|
|
|
/* 32bit IRQ mode. */
|
|
#define ADP_CPUread_32bitIRQ (0x12)
|
|
|
|
/* 32bit Supervisor mode. */
|
|
#define ADP_CPUread_32bitSVC (0x13)
|
|
|
|
/* 32bit Abort mode. */
|
|
#define ADP_CPUread_32bitAbort (0x17)
|
|
|
|
/* 32bit Undefined mode. */
|
|
#define ADP_CPUread_32bitUndef (0x1B)
|
|
|
|
/* #32bit System mode - Added in Architecture 4 ARMs e.g.ARM7TDMI */
|
|
#define ADP_CPUread_32bitSystem (0x1F)
|
|
|
|
/* 'mask':- */
|
|
/* Request registers RO-R14. */
|
|
#define ADP_CPUread_RegsMask (0x7FFF)
|
|
|
|
/* Request Program Counter (including mode and flag bits in 26-bit modes. */
|
|
#define ADP_CPUread_PCmode (1 << 15)
|
|
|
|
/* Request Program Counter (without mode and flag bits in 26-bit modes. */
|
|
#define ADP_CPUread_PCnomode (1 << 16)
|
|
|
|
/* Requests the transfer of the CPSR */
|
|
#define ADP_CPUread_CPSR (1 << 17)
|
|
|
|
/* In processor modes with an SPSR(non-user modes), bit 19 requests its
|
|
transfer */
|
|
#define ADP_CPUread_SPSR (1 << 18)
|
|
|
|
|
|
|
|
#define ADP_CPUwrite ADPREASON(CI_HADP,6)
|
|
/* ADP_CPUwrite
|
|
* ------------
|
|
* Summary: This is a request to write values to the CPU.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte mode, word mask, words data)
|
|
* Return: (word status)
|
|
*
|
|
* 'mode' defines the processor mode to which the transfer should be made.
|
|
* The mode number is the same as the mode number used by ARM; a value of
|
|
* 255 indicates the current mode. See ADP_CPUread above for more detail.
|
|
* 'mask' indicates which registers should be transferred. Setting a bit to
|
|
* one will cause the designated register to be transferred. The details
|
|
* of mask are specified above in ADP_CPUread.
|
|
* 'data' holds the values of the registers to be transferred. The first
|
|
* value is written to the lowest numbered register. NOTE: data must not
|
|
* cause the buffer size to exceed the maximum allowed buffer size.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_CPread ADPREASON(CI_HADP,7)
|
|
/* ADP_CPread
|
|
* ----------
|
|
* Summary: This message requests a co-processors internal state.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte CPnum, word mask)
|
|
* Return: (word status, words data)
|
|
*
|
|
* 'CPnum' is the number of the co-processor to transfer values from.
|
|
* 'mask' specifies which registers to transfer and is co-processor
|
|
* specific.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'data' holds the registers specified in 'mask' if successful, otherwise
|
|
* just rubbish. The lowest numbered register is transferred first.
|
|
* NOTE: data must not cause the buffer size to exceed the maximum allowed
|
|
* buffer size.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_CPwrite ADPREASON(CI_HADP,8)
|
|
/* ADP_CPwrite
|
|
* -----------
|
|
* Summary: This message requests a write to a co-processors internal state.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte CPnum, word mask, words data)
|
|
* Return: (word status)
|
|
*
|
|
* 'CPnum' is the number of the co-processor to transfer values to.
|
|
* 'mask' specifies which registers to transfer and is co-processor
|
|
* specific.
|
|
* 'data' holds the values to transfer to the registers specified in 'mask'.
|
|
* The first value is written to the lowest numbered register.
|
|
* NOTE: data must not cause the buffer size to exceed the maximum allowed
|
|
* buffer size.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_SetBreak ADPREASON(CI_HADP,9)
|
|
/* ADP_SetBreak
|
|
* ------------
|
|
* Summary: Sets a breakpoint.
|
|
*
|
|
* Arguments:
|
|
* Send: (word address, byte type [, word bound])
|
|
* Return: (word status, word pointhandle, word raddress, word rbound)
|
|
*
|
|
* 'address' is the address of the instruction to set the breakpoint on.
|
|
* 'type' specifies the sort of breakpoint and is described in more detail
|
|
* below.
|
|
* 'bound' is included if the least significant 4 bits of type are set to
|
|
* 5 or above (see below for more detail).
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'pointhandle' returns a handle to the breakpoint, it will be valid if bit
|
|
* 7 of 'type' is set. See below for more detail.
|
|
* 'raddress' is valid depending on 'type', see below for more detail.
|
|
* 'rbound' is valid depending on 'type', see below for more detail.
|
|
*/
|
|
|
|
/* 'type':- */
|
|
/* The least significant 4 bits define the sort of breakpoint to set:- */
|
|
/* Halt if the pc is equal to 'address'. */
|
|
#define ADP_SetBreak_EqualsAddress (0)
|
|
|
|
/* Halt if the pc is greater than 'address'. */
|
|
#define ADP_SetBreak_GreaterAddress (1)
|
|
|
|
/* Halt if the pc is greater than or equal to 'address'. */
|
|
#define ADP_SetBreak_GEqualsAddress (2)
|
|
|
|
/* Halt if the pc is less than 'address'. */
|
|
#define ADP_SetBreak_LessAddress (3)
|
|
|
|
/* Halt if the pc is less than or equal to 'address'. */
|
|
#define ADP_SetBreak_LEqualsAddress (4)
|
|
|
|
/* Halt if the pc is in the range from 'address' to 'bound' inclusive. */
|
|
#define ADP_SetBreak_Range (5)
|
|
|
|
/* Halt if the pc is not in the range from 'address' to 'bound' inclusive. */
|
|
#define ADP_SetBreak_NotRange (6)
|
|
|
|
/* Halt if (pc & 'bound') = 'address'. */
|
|
#define ADP_SetBreak_AndBound (7)
|
|
|
|
/* Bits 5,6 and 7 are used as follows :- */
|
|
/* If set this indicates that the breakpoint is on a 16bit (Thumb)
|
|
instruction rather than a 32bit (ARM) instruction. */
|
|
#define ADP_SetBreak_Thumb (1 << 4)
|
|
|
|
/* This requests that the breakpoint should be conditional (execution halts
|
|
only if the breakpointed instruction is executed, not if it is
|
|
conditionally skipped). If bit 5 is not set, execution halts whenever
|
|
the breakpointed instruction is reached (whether executed or skipped). */
|
|
#define ADP_SetBreak_Cond (1 << 5)
|
|
|
|
/* This requests a dry run: the breakpoint is not set and the 'raddress', and
|
|
if appropriate the 'rbound', that would be used, are returned (for
|
|
comparison and range breakpoints the address and bound used need not be
|
|
exactly as requested). A RDIError_NoError 'status' byte indicates that
|
|
resources are currently available to set the breakpoint, non-zero
|
|
indicates an error. RDIError_NoMorePoints indicates that the required
|
|
breakpoint resources are not currently available. */
|
|
#define ADP_SetBreak_DryRun (1 << 6)
|
|
|
|
/* If the request is successful, but there are no more breakpoint registers
|
|
(of the requested type), then the value RDIError_NoMorePoints is
|
|
returned. */
|
|
|
|
/* If a breakpoint is set on a location which already has a breakpoint, the
|
|
first breakpoint will be removed before the new breakpoint is set. */
|
|
|
|
|
|
|
|
#define ADP_ClearBreak ADPREASON(CI_HADP,10)
|
|
/* ADP_ClearBreak
|
|
* --------------
|
|
* Summary: Clears a breakpoint.
|
|
*
|
|
* Arguments:
|
|
* Send: (word pointhandle)
|
|
* Return: (word status)
|
|
*
|
|
* 'pointhandle' is a handle returned by a previous ADP_SetBreak.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
|
|
#define ADP_SetWatch ADPREASON(CI_HADP,11)
|
|
/* ADP_SetWatch
|
|
* ------------
|
|
* Summary: Sets a watchpoint.
|
|
*
|
|
* Arguments:
|
|
* Send: (word address, byte type, byte datatype [,word bound])
|
|
* Return: (word status, word pointhandle, word raddress, word rbound)
|
|
*
|
|
* 'address' is the address at which to set the watchpoint.
|
|
* 'type' is the type of watchpoint to set and is described in detail below.
|
|
* 'datatype' defines the sort of data access to watch for and is described
|
|
* in more detail below.
|
|
* 'bound' is included depending on the value of type (see description of
|
|
* type below).
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'pointhandle' is valid depending on the value of type (see description
|
|
* of type below).
|
|
* 'raddress' is valid depending on the value of type (see description
|
|
* of type below).
|
|
* 'rbound' is valid depending on the value of type (see description
|
|
* of type below).
|
|
*/
|
|
|
|
/* 'type':- */
|
|
/* The least significant 4 bits of 'type' define the sort of watchpoint to
|
|
set:- */
|
|
/* Halt on a data access to the address equal to 'address'. */
|
|
#define ADP_SetWatch_EqualsAddress (0)
|
|
|
|
/* Halt on a data access to an address greater than 'address'. */
|
|
#define ADP_SetWatch_GreaterAddress (1)
|
|
|
|
/* Halt on a data access to an address greater than or equal to 'address'. */
|
|
#define ADP_SetWatch_GEqualsAddress (2)
|
|
|
|
/* Halt on a data access to an address less than 'address'. */
|
|
#define ADP_SetWatch_LessAddress (3)
|
|
|
|
/* Halt on a data access to an address less than or equal to 'address'. */
|
|
#define ADP_SetWatch_LEqualsAddress (4)
|
|
|
|
/* Halt on a data access to an address in the range from 'address' to
|
|
'bound' inclusive. */
|
|
#define ADP_SetWatch_Range (5)
|
|
|
|
/* Halt on a data access to an address not in the range from 'address' to
|
|
'bound' inclusive. */
|
|
#define ADP_SetWatch_NotRange (6)
|
|
|
|
/* Halt if (data-access-address & 'bound')='address'. */
|
|
#define ADP_SetWatch_AndBound (7)
|
|
|
|
/* Bits 6 and 7 of 'type' also have further significance:-
|
|
NOTE: they must not be simulataneously set. */
|
|
|
|
/* Bit 6 of 'type' set: Requests a dry run: the watchpoint is not set and
|
|
the 'address' and, if appropriate, the 'bound', that would be used are
|
|
returned (for range and comparison watchpoints, the 'address' and 'bound'
|
|
used need not be exactly as requested). A RDIError_NoError status byte
|
|
indicates that resources are currently available to set the watchpoint;
|
|
RDIError_NoMorePoints indicates that the required watchpoint resources
|
|
are not currently available. */
|
|
|
|
/* Bit 7 of 'type' set: Requests that a handle should be returned for the
|
|
watchpoint by which it will be identified subsequently. If bit 7 is
|
|
set, a handle will be returned ('pointhandle'), whether or not the
|
|
request succeeds or fails (but, obviously, it will only be meaningful
|
|
if the request succeesd). */
|
|
|
|
/* 'datatype':- */
|
|
/* The 'datatype' argument defines the sort of data access to watch for,
|
|
values can be summed or ORed together to halt on any set of sorts of
|
|
memory access. */
|
|
|
|
/* Watch for byte reads. */
|
|
#define ADP_SetWatch_ByteReads (1)
|
|
|
|
/* Watch for half-word reads. */
|
|
#define ADP_SetWatch_HalfWordReads (2)
|
|
|
|
/* Watch for word reads. */
|
|
#define ADP_SetWatch_WordReads (4)
|
|
|
|
/* Watch for half-word reads. */
|
|
#define ADP_SetWatch_ByteWrites (8)
|
|
|
|
/* Watch for half-word reads. */
|
|
#define ADP_SetWatch_HalfWordWrites (16)
|
|
|
|
/* Watch for half-word reads. */
|
|
#define ADP_SetWatch_WordWrites (32)
|
|
|
|
/* On successful completion a RDIError_NoError 'status' byte is returned. On
|
|
unsuccessful completion, a non-zero error code byte is returned. If the
|
|
request is successful, but there are now no more watchpoint registers
|
|
(of the requested type), then the value RDIError_NoMorePoints is
|
|
returned. */
|
|
|
|
/* If a watchpoint is set on a location which already has a watchpoint, the
|
|
first watchpoint will be removed before the new watchpoint is set. */
|
|
|
|
|
|
#define ADP_ClearWatch ADPREASON(CI_HADP,12)
|
|
/* ADP_ClearWatch
|
|
* --------------
|
|
* Summary: Clears a watchpoint.
|
|
*
|
|
* Arguments:
|
|
* Send: (word pointhandle)
|
|
* Return: (word status)
|
|
*
|
|
* 'pointhandle' is a handle to a watchpoint returned by a previous
|
|
* ADP_SetWatch.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_Execute ADPREASON(CI_HADP,13)
|
|
/* ADP_Execute
|
|
* -----------
|
|
* Summary: This message requests that the target starts executing from
|
|
* the stored CPU state.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* The message will *ALWAYS* respond immediately with an ACK (unlike the
|
|
* old RDI definition, which allowed asynchronous message replies).
|
|
*
|
|
* Execution will stop when allowed system events occur. The host will
|
|
* be notified via a ADP_Stopped message (described below).
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_Step ADPREASON(CI_HADP,14)
|
|
/* ADP_Step
|
|
* --------
|
|
* Summary: Execute 'ninstr' instructions.
|
|
*
|
|
* Arguments:
|
|
* Send: (word ninstr)
|
|
* Return: (word status)
|
|
*
|
|
* 'ninstr' is the number of instructions to execute, starting at the
|
|
* address currently loaded into the CPU program counter. If it is zero,
|
|
* the target should execute instructions upto the next instruction that
|
|
* explicitly alters the Program Counter. i.e. a branch or ALU operation
|
|
* with the PC as the destination.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* The ADP_Step function (unlike the earlier RDI system) will *ALWAYS*
|
|
* return an ACK immediately. A subsequent ADP_Stopped message will be
|
|
* delivered from the target to the host when the ADP_Step operation
|
|
* has completed.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_InterruptRequest ADPREASON(CI_HADP,15)
|
|
/* ADP_InterruptRequest
|
|
* --------------------
|
|
* Summary: Interrupt execution.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* On receiving this message the target should attempt to stop execution.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_HW_Emulation ADPREASON(CI_HADP,16)
|
|
/* ADP_HW_Emulation
|
|
* ----------------
|
|
* The first parameter to ADP_HW_Emulation is a Reason Subcode, and
|
|
* subsequent parameters are defined by that subcode
|
|
*
|
|
* word reason subcode
|
|
* other arguments as reason subcode determines
|
|
*
|
|
*/
|
|
|
|
/* ADP__HW_Emulation sub-reason codes: */
|
|
|
|
#define ADP_HW_Emul_Supported ADPSUBREASON(CI_HADP,0)
|
|
/* ADP_HW_Emul_Supported
|
|
* ---------------------
|
|
* Summary: Enquires whether calls to the next 4 messages are available
|
|
* (MemoryAccess, MemoryMap, Set_CPUspeed, ReadClock).
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate the messages are available,
|
|
* non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDI_Info_Memory_Stats.
|
|
*/
|
|
|
|
|
|
#define ADP_HW_Emul_MemoryAccess ADPSUBREASON(CI_HADP,1)
|
|
/* ADP_HW_Emul_MemoryAccess
|
|
* ------------------------
|
|
* Summary: Get memory access information for memory block with specified
|
|
* handle.
|
|
*
|
|
* Arguments:
|
|
* Send: (word handle)
|
|
* Return: (word status, word nreads, word nwrites, word sreads,
|
|
* word swrites, word ns, word s)
|
|
*
|
|
* 'handle' is a handle to a memory block.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'nreads' is the number of non-sequential reads.
|
|
* 'nwrites' is the number of non-sequential writes.
|
|
* 'sreads' is the number of sequential reads.
|
|
* 'swrites' is the number of sequential writes.
|
|
* 'ns' is time in nano seconds.
|
|
* 's' is time in seconds.
|
|
*
|
|
* NOTE: Equivalent to RDIMemory_Access.
|
|
*/
|
|
|
|
|
|
#define ADP_HW_Emul_MemoryMap ADPSUBREASON(CI_HADP,2)
|
|
/* ADP_HW_Emul_MemoryMap
|
|
* ---------------------
|
|
* Summary: Sets memory characteristics.
|
|
*
|
|
* Arguments:
|
|
* Send: (word n,
|
|
Then 'n' sets of arguments of the form:-
|
|
word handle, word start, word limit, byte width,
|
|
byte access, word Nread_ns, word Nwrite_ns, word Sread_ns,
|
|
word Swrite_ns)
|
|
* Return: (word status)
|
|
*
|
|
* 'n' is the number of sets of arguments.
|
|
* 'handle' is a handle to the region.
|
|
* 'start' is the start of this region.
|
|
* 'limit' is the limit of this region.
|
|
* 'width' is the memory width, described in detail below.
|
|
* 'access' is described in detail below.
|
|
* 'Nread_ns' is the access time for N read cycles in nano seconds.
|
|
* 'Nwrite_ns' is the access time for N write cycles in nano seconds.
|
|
* 'Sread_ns' is the access time for S read cycles in nano seconds.
|
|
* 'Swrite_ns' is the access time for S write cycles in nano seconds.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* NOTE: Equivalent to RDIMemory_Map.
|
|
*/
|
|
|
|
/* 'width':- */
|
|
/* 8 bit memory width. */
|
|
#define ADP_HW_Emul_MemoryMap_Width8 (0)
|
|
|
|
/* 16 bit memory width. */
|
|
#define ADP_HW_Emul_MemoryMap_Width16 (1)
|
|
|
|
/* 32 bit memory width. */
|
|
#define ADP_HW_Emul_MemoryMap_Width32 (2)
|
|
|
|
/* 'access':- */
|
|
/* Bit 0 - read access. */
|
|
#define ADP_HW_Emul_MemoryMap_Access_Read (1 << 0)
|
|
|
|
/* Bit 1 - write access. */
|
|
#define ADP_HW_Emul_MemoryMap_Access_Write (1 << 1)
|
|
|
|
/* Bit 2 - latched 32 bit memory. */
|
|
#define ADP_HW_Emul_MemoryMap_Access_Latched (1 << 2)
|
|
|
|
|
|
#define ADP_HW_Emul_SetCPUSpeed ADPSUBREASON(CI_HADP,3)
|
|
/* ADP_HW_Emul_SetCPUSpeed
|
|
* -----------------------
|
|
* Summary: Sets the speed of the CPU.
|
|
*
|
|
* Arguments:
|
|
* Send: (word speed)
|
|
* Return: (word status)
|
|
*
|
|
* 'speed' is the CPU speed in nano seconds.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDISet_CPUSpeed.
|
|
*/
|
|
|
|
|
|
#define ADP_HW_Emul_ReadClock ADPSUBREASON(CI_HADP,4)
|
|
/* ADP_HW_Emul_ReadClock
|
|
* ---------------------
|
|
* Summary: Reads simulated time.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word ns, word s)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'ns' is time in nano seconds.
|
|
* 's' is time in seconds.
|
|
*
|
|
* NOTE: Equivalent to RDIRead_Clock.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEbreakerHADP ADPREASON(CI_HADP,17)
|
|
|
|
/* The first parameter to ADP_ICEbreaker is a Reason Subcode, and
|
|
* subsequent parameters are defined by that subcode
|
|
*
|
|
* word reason subcode
|
|
* other arguments as reason subcode determines
|
|
*
|
|
*/
|
|
|
|
/* ADP_ICEbreaker sub-reason codes: */
|
|
|
|
#define ADP_ICEB_Exists ADPSUBREASON(CI_HADP,0)
|
|
/* ADP_ICEB_Exists
|
|
* ---------------
|
|
* Summary: Is there an ICEbreaker in the system?
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate there is an ICEbreaker,
|
|
* non-zero otherwise.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEB_GetLocks ADPSUBREASON(CI_HADP,1)
|
|
/* ADP_ICEB_GetLocks
|
|
* -----------------
|
|
* Summary: Returns which ICEbreaker registers are locked.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word lockedstate)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'lockedstate' is a bitmap if the ICEbreaker registers locked against use
|
|
* by IceMan (because explicitly written by the user). Bit n represents
|
|
* hardware breakpoint n, and if set the register is locked.
|
|
*
|
|
* NOTE: Equivalent to RDIIcebreaker_GetLocks. Should only be used if
|
|
* ADP_ICEB_Exists didn't return an error.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEB_SetLocks ADPSUBREASON(CI_HADP,2)
|
|
/* ADP_ICEB_SetLocks
|
|
* -----------------
|
|
* Summary: Sets which ICEbreaker registers are locked.
|
|
*
|
|
* Arguments:
|
|
* Send: (word lockedstate)
|
|
* Return: (word status)
|
|
*
|
|
* 'lockedstate' is the same as in ADP_ICEB_GetLocks above.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDIIcebreaker_SetLocks. Should only be used if
|
|
* ADP_ICEB_Exists didn't return an error.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEB_CC_Exists ADPSUBREASON(CI_HADP,3)
|
|
/* ADP_ICEB_CC_Exists
|
|
* ------------------
|
|
* Summary: Is there an ICEbreaker Comms Channel?
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate there is a Comms Channel,
|
|
* non-zero otherwise.
|
|
*
|
|
* NOTE: Should only be used if ADP_ICEB_Exists didn't return an error.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEB_CC_Connect_ToHost ADPSUBREASON(CI_HADP,4)
|
|
/* ADP_ICEB_CC_Connect_ToHost
|
|
* --------------------------
|
|
* Summary: Connect Comms Channel in ToHost direction.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte connect)
|
|
* Return: (word status)
|
|
*
|
|
* 'connect' !!!!!
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDICommsChannel_ToHost. Should only be used if
|
|
* ADP_ICEB_CC_Exists didn't return an error.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEB_CC_Connect_FromHost ADPSUBREASON(CI_HADP,5)
|
|
/* ADP_ICEB_CC_Connect_FromHost
|
|
* ----------------------------
|
|
* Summary: Connect Comms Channel in FromHost direction.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte connect)
|
|
* Return: (word status)
|
|
*
|
|
* 'connect' is the same as in ADP_ICEB_CC_Connect_ToHost above.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDICommsChannel_FromHost. Should only be used if
|
|
* ADP_ICEB_CC_Exists didn't return an error.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEman ADPREASON(CI_HADP,18)
|
|
|
|
/* The first parameter to ADP_ICEman is a Reason Subcode, and
|
|
* subsequent parameters are defined by that subcode
|
|
*
|
|
* word reason subcode
|
|
* other arguments as reason subcode determines
|
|
*
|
|
*/
|
|
|
|
/* ADP_ICEman sub-reason codes: */
|
|
|
|
|
|
#define ADP_ICEM_AddConfig ADPSUBREASON(CI_HADP,0)
|
|
/* ADP_ICEM_AddConfig
|
|
* ------------------
|
|
* Summary: Prepares target to receive configuration data block.
|
|
*
|
|
* Arguments:
|
|
* Send: (word nbytes)
|
|
* Return: (word status)
|
|
*
|
|
* 'nbytes' is the number of bytes in the configuration block.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero if a
|
|
* configuration block of this size can't be accepted.
|
|
*
|
|
* NOTE: Equivalent to RDP_AddConfig.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEM_SelectConfig ADPSUBREASON(CI_HADP,1)
|
|
/* ADP_ICEM_SelectConfig
|
|
* ---------------------
|
|
* Summary: Selects one of the sets of configuration data blocks and
|
|
* reinitialises to use the new configuration.
|
|
*
|
|
* Arguments:
|
|
* Send: (byte aspect, byte namelen, byte matchtype, word vsn_req,
|
|
bytes name)
|
|
* Return: (word status, word vsn_sel)
|
|
*
|
|
* 'aspect' is one of two values defined below.
|
|
* 'namelen' is the number of bytes in 'name'.
|
|
* 'matchtype' specifies how the selected version must match that specified,
|
|
* and takes one of the values defined below.
|
|
* 'vsn_req' is the requested version of the named configuration.
|
|
* 'name' is the name of the configuration.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'vsn_sel' is the version number of the configuration selected on success.
|
|
*
|
|
* NOTE: Equivalent to RDP_SelectConfig.
|
|
*/
|
|
|
|
/* 'aspect':- */
|
|
#define ADP_ICEM_SelectConfig_ConfigCPU (0)
|
|
#define ADP_ICEM_SelectConfig_ConfigSystem (1)
|
|
|
|
/* 'matchtype':- */
|
|
#define ADP_ICEM_SelectConfig_MatchAny (0)
|
|
#define ADP_ICEM_SelectConfig_MatchExactly (1)
|
|
#define ADP_ICEM_SelectConfig_MatchNoEarlier (2)
|
|
|
|
|
|
#define ADP_ICEM_ConfigCount ADPSUBREASON(CI_HADP,2)
|
|
/* ADP_ICEM_ConfigCount
|
|
* --------------------
|
|
* Summary: Return number of configurations.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status [, word count])
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'count' returns the number of configurations if status is zero.
|
|
*
|
|
* NOTE: Equivalent to RDIConfig_Count.
|
|
*/
|
|
|
|
|
|
#define ADP_ICEM_ConfigNth ADPSUBREASON(CI_HADP,3)
|
|
/* ADP_ICEM_ConfigNth
|
|
* ------------------
|
|
* Summary: Gets the nth configuration details.
|
|
*
|
|
* Arguments:
|
|
* Send: (word confign)
|
|
* Return: (word status, word version, byte namelen, bytes name)
|
|
*
|
|
* 'confign' is the number of the configuration.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'version' is the configuration version number.
|
|
* 'namelen' is the number of bytes in 'name'.
|
|
* 'name' is the name of the configuration.
|
|
*
|
|
* NOTE: Equivalent to RDIConfig_Nth.
|
|
*/
|
|
|
|
|
|
|
|
#define ADP_Profile ADPREASON(CI_HADP,19)
|
|
|
|
/* The first parameter to ADP_Profile is a Reason Subcode, and
|
|
* subsequent parameters are defined by that subcode
|
|
*
|
|
* word reason subcode
|
|
* other arguments as reason subcode determines
|
|
*
|
|
*/
|
|
|
|
/* ADP_Profile sub-reason codes: */
|
|
|
|
|
|
#define ADP_Profile_Supported ADPSUBREASON(CI_HADP,0)
|
|
/* ADP_Profile_Supported
|
|
* ---------------------
|
|
* Summary: Checks whether profiling is supported.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError if profiling is supported, non-zero otherwise.
|
|
*
|
|
* NOTE: Can also be determined using Info_Target.
|
|
*/
|
|
|
|
|
|
#define ADP_Profile_Stop ADPSUBREASON(CI_HADP,1)
|
|
/* ADP_Profile_Stop
|
|
* ----------------
|
|
* Summary: Stops profiling.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDIProfile_Stop.
|
|
*/
|
|
|
|
|
|
#define ADP_Profile_Start ADPSUBREASON(CI_HADP,2)
|
|
/* ADP_Profile_Start
|
|
* -----------------
|
|
* Summary: Starts profiling (PC sampling).
|
|
*
|
|
* Arguments:
|
|
* Send: (word interval)
|
|
* Return: (word status)
|
|
*
|
|
* 'interval' is the period of PC sampling in micro seconds.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDIProfile_Start.
|
|
*/
|
|
|
|
|
|
#define ADP_Profile_WriteMap ADPSUBREASON(CI_HADP,3)
|
|
#define ADP_ProfileWriteHeaderSize (ADP_DEFAULT_HEADER_SIZE + 4*sizeof(word))
|
|
|
|
/* ADP_Profile_WriteMap
|
|
* --------------------
|
|
* Summary: Downloads a map array, which describes the PC ranges for profiling.
|
|
*
|
|
* Arguments: A number of messages each of form:-
|
|
* Send: (word len, word size, word offset, words map_data)
|
|
* Return: (word status)
|
|
*
|
|
* 'len' is the number of elements in the entire map array being downloaded.
|
|
* 'size' is the number of words being downloaded in this message, i.e. the
|
|
* length of 'map_data'.
|
|
* 'offset' is the offset into the entire map array which this message starts
|
|
* from, in words.
|
|
* 'map_data' consists of 'size' words of map data.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDIProfile_WriteMap.
|
|
*/
|
|
|
|
|
|
#define ADP_Profile_ReadMap ADPSUBREASON(CI_HADP,4)
|
|
#define ADP_ProfileReadHeaderSize (ADP_DEFAULT_HEADER_SIZE + 2*sizeof(word))
|
|
|
|
/* ADP_Profile_ReadMap
|
|
* -------------------
|
|
* Summary: Uploads a set of profile counts which correspond to the current
|
|
* profile map.
|
|
*
|
|
* Arguments: A number of messages, each of the form:
|
|
* Send: (word offset, word size)
|
|
* Return: (word status, words counts)
|
|
*
|
|
* 'offset' is the offset in the entire array of counts that this message
|
|
* starts from, in words.
|
|
* 'size' is the number of words uploaded in this message (in counts).
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'counts' is 'size' words of profile counts.
|
|
*
|
|
* NOTE: Equivalent to RDIProfile_ReadMap.
|
|
*/
|
|
|
|
|
|
#define ADP_Profile_ClearCounts ADPSUBREASON(CI_HADP,5)
|
|
/* ADP_Profile_ClearCounts
|
|
* -----------------------
|
|
* Summary: Requests that PC sample counts be set to zero.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDIProfile_ClearCounts.
|
|
*/
|
|
|
|
#define ADP_InitialiseApplication ADPREASON(CI_HADP,20)
|
|
/* ADP_InitialiseApplication
|
|
* -------------------------
|
|
* Summary: Requests that OS setup up the thread/task so that it can be
|
|
* executed.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
#define ADP_End ADPREASON(CI_HADP,21)
|
|
/* ADP_End
|
|
* -------
|
|
* Summary: Sent by the host debugger to tell angel this debugging session
|
|
* is is finished
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status)
|
|
* status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*/
|
|
|
|
/******************************************************************
|
|
*
|
|
* CI_TADP messages
|
|
*
|
|
*/
|
|
|
|
#define ADP_TADPUnrecognised ADPREASON(CI_TADP,0)
|
|
/* This message is unusual in that it is normally sent in reply to
|
|
* another message which is not understood. This is an exception
|
|
* to the normal protocol which says that a reply must have the
|
|
* same base reason code as the original. There is a single reply
|
|
* parameter which is the reason code which was not understood.
|
|
*
|
|
* As well as being a reply this message can also be sent and will
|
|
* return as if this message were unrecognised!
|
|
*
|
|
* Parameters:
|
|
* none
|
|
*
|
|
* Reply:
|
|
* word reason code which was not recognised
|
|
*/
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
#define ADP_Stopped ADPREASON(CI_TADP,1)
|
|
/* ADP_Stopped
|
|
* -----------
|
|
* Summary: This message is sent to the host when the application stops,
|
|
* either naturally or due to an exception.
|
|
*
|
|
* Parameters:
|
|
* word reason subcode
|
|
* other arguments as reason subcode determines.
|
|
* Unless stated otherwise (below) there will be none.
|
|
*
|
|
* Reply:
|
|
* word status unless reason subcode says otherwise
|
|
*
|
|
* This message is sent to the host when execution has stopped. This
|
|
* can be when the end of the application has been reached, or as the
|
|
* result of an exception. It can also be the return from an ADP_Step
|
|
* process, when the requested number of instructions have been
|
|
* executed., or a breakpoint or watchpoint has been hit etc.
|
|
*/
|
|
|
|
/* The first set of Stopped subreason codes are for the ARM hardware
|
|
* vectors. These events will be raised if the
|
|
* ADP_Control_Vector_Catch allows, or if the target application has
|
|
* not provided its own handlers.
|
|
*/
|
|
#define ADP_Stopped_BranchThroughZero ADPSUBREASON(CI_TADP,0)
|
|
#define ADP_Stopped_UndefinedInstr ADPSUBREASON(CI_TADP,1)
|
|
#define ADP_Stopped_SoftwareInterrupt ADPSUBREASON(CI_TADP,2)
|
|
#define ADP_Stopped_PrefetchAbort ADPSUBREASON(CI_TADP,3)
|
|
#define ADP_Stopped_DataAbort ADPSUBREASON(CI_TADP,4)
|
|
#define ADP_Stopped_AddressException ADPSUBREASON(CI_TADP,5)
|
|
#define ADP_Stopped_IRQ ADPSUBREASON(CI_TADP,6)
|
|
#define ADP_Stopped_FIQ ADPSUBREASON(CI_TADP,7)
|
|
|
|
/* We leave the rest of what would be the bits in the VectorCatch
|
|
* bitmask free for future expansion.
|
|
*/
|
|
|
|
/* The following are software reasons for execution stopping: */
|
|
#define ADP_Stopped_BreakPoint ADPSUBREASON(CI_TADP,32)
|
|
/* Breakpoint was reached
|
|
* extra send parameter: word handle - indicates which breakpoint
|
|
*/
|
|
|
|
#define ADP_Stopped_WatchPoint ADPSUBREASON(CI_TADP,33)
|
|
/* Watchpoint was triggered
|
|
* extra send parameter: word handle - indicates which watchpoint
|
|
*/
|
|
|
|
#define ADP_Stopped_StepComplete ADPSUBREASON(CI_TADP,34)
|
|
/* End of ADP_Step request */
|
|
|
|
#define ADP_Stopped_RunTimeErrorUnknown ADPSUBREASON(CI_TADP,35)
|
|
/*
|
|
* non-specific fatal runtime support error
|
|
*/
|
|
|
|
#define ADP_Stopped_InternalError ADPSUBREASON(CI_TADP,36)
|
|
/* extra send parameter: word error - indicates the nature of the error
|
|
*
|
|
* An Angel internal error has happened. The error number should be
|
|
* displayed for the user to report to his software supplier. Once
|
|
* this error has been received the internal state of Angel can no longer
|
|
* be trusted.
|
|
*/
|
|
|
|
#define ADP_Stopped_UserInterruption ADPSUBREASON(CI_TADP,37)
|
|
/* Host requested interruption */
|
|
|
|
#define ADP_Stopped_ApplicationExit ADPSUBREASON(CI_TADP,38)
|
|
/* extra send parameter: word exitcode
|
|
* This indicates that the application has exited via exit(), an exitcode
|
|
* of zero indiactes successful termination.
|
|
*/
|
|
|
|
#define ADP_Stopped_StackOverflow ADPSUBREASON(CI_TADP, 39)
|
|
/*
|
|
* Software stack overflow has occurred
|
|
*/
|
|
|
|
#define ADP_Stopped_DivisionByZero ADPSUBREASON(CI_TADP, 40)
|
|
/*
|
|
* Division by zero has occurred
|
|
*/
|
|
|
|
#define ADP_Stopped_OSSpecific ADPSUBREASON(CI_TADP, 41)
|
|
/*
|
|
* The OS has requested that execution stops. The OS will know
|
|
* why this has happened.
|
|
*/
|
|
|
|
|
|
|
|
/******************************************************************
|
|
*
|
|
* CI_TTDCC messages (Target-initiated debug comms channel)
|
|
*
|
|
*/
|
|
|
|
#define ADP_TDCC_ToHost ADPREASON(CI_TTDCC,0)
|
|
/* ADP_TDCC_ToHost
|
|
* ------------------
|
|
* Summary: Send Data down Comms Channel in ToHost direction.
|
|
*
|
|
* Arguments:
|
|
* Send: (word nbytes, words data)
|
|
* Return: (word status)
|
|
*
|
|
* 'nbytes' is number of BYTES to be transferred from the target to the
|
|
* host via the Debug Comms channel.
|
|
* 'data' is (nbytes/sizeof(word)) WORDS of data to be transferred from
|
|
* the target to the host via the Debug Comms channel.
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
*
|
|
* NOTE: Equivalent to RDP_CCToHost and RDP_CCToHostReply (just set the
|
|
* direction bit).
|
|
* NOTE II: Current implementations only support single word transfers
|
|
* (nbytes = 4).
|
|
*/
|
|
|
|
|
|
#define ADP_TDCC_FromHost ADPREASON(CI_TTDCC,1)
|
|
/* ADP_TDCC_FromHost
|
|
* --------------------
|
|
* Summary: Send Data down Comms Channel in FromHost direction.
|
|
*
|
|
* Arguments:
|
|
* Send: ()
|
|
* Return: (word status, word nbytes, words data)
|
|
*
|
|
* 'status' is RDIError_NoError to indicate success, non-zero otherwise.
|
|
* 'nbytes' is number of BYTES to be transferred from the host to the
|
|
* target via the Debug Comms channel, or zero if the host has no data
|
|
* to transfer.
|
|
* 'data' is (nbytes/sizeof(word)) WORDS of transferred data.
|
|
*
|
|
* NOTE: Equivalent to RDP_CCFromHost and RDP_CCFromHostReply (just set the
|
|
* direction bit).
|
|
* NOTE II: Current implementations only support single word transfers
|
|
* (nbytes = 4).
|
|
*/
|
|
|
|
|
|
/*******************************************************************
|
|
*
|
|
* Error Codes
|
|
*
|
|
*/
|
|
|
|
#define RDIError_NoError 0
|
|
|
|
#define RDIError_Reset 1
|
|
#define RDIError_UndefinedInstruction 2
|
|
#define RDIError_SoftwareInterrupt 3
|
|
#define RDIError_PrefetchAbort 4
|
|
#define RDIError_DataAbort 5
|
|
#define RDIError_AddressException 6
|
|
#define RDIError_IRQ 7
|
|
#define RDIError_FIQ 8
|
|
#define RDIError_Error 9
|
|
#define RDIError_BranchThrough0 10
|
|
|
|
#define RDIError_NotInitialised 128
|
|
#define RDIError_UnableToInitialise 129
|
|
#define RDIError_WrongByteSex 130
|
|
#define RDIError_UnableToTerminate 131
|
|
#define RDIError_BadInstruction 132
|
|
#define RDIError_IllegalInstruction 133
|
|
#define RDIError_BadCPUStateSetting 134
|
|
#define RDIError_UnknownCoPro 135
|
|
#define RDIError_UnknownCoProState 136
|
|
#define RDIError_BadCoProState 137
|
|
#define RDIError_BadPointType 138
|
|
#define RDIError_UnimplementedType 139
|
|
#define RDIError_BadPointSize 140
|
|
#define RDIError_UnimplementedSize 141
|
|
#define RDIError_NoMorePoints 142
|
|
#define RDIError_BreakpointReached 143
|
|
#define RDIError_WatchpointAccessed 144
|
|
#define RDIError_NoSuchPoint 145
|
|
#define RDIError_ProgramFinishedInStep 146
|
|
#define RDIError_UserInterrupt 147
|
|
#define RDIError_CantSetPoint 148
|
|
#define RDIError_IncompatibleRDILevels 149
|
|
|
|
#define RDIError_CantLoadConfig 150
|
|
#define RDIError_BadConfigData 151
|
|
#define RDIError_NoSuchConfig 152
|
|
#define RDIError_BufferFull 153
|
|
#define RDIError_OutOfStore 154
|
|
#define RDIError_NotInDownload 155
|
|
#define RDIError_PointInUse 156
|
|
#define RDIError_BadImageFormat 157
|
|
#define RDIError_TargetRunning 158
|
|
#define RDIError_DeviceWouldNotOpen 159
|
|
#define RDIError_NoSuchHandle 160
|
|
#define RDIError_ConflictingPoint 161
|
|
|
|
#define RDIError_LittleEndian 240
|
|
#define RDIError_BigEndian 241
|
|
#define RDIError_SoftInitialiseError 242
|
|
|
|
#define RDIError_InsufficientPrivilege 253
|
|
#define RDIError_UnimplementedMessage 254
|
|
#define RDIError_UndefinedMessage 255
|
|
|
|
|
|
#endif
|
|
|
|
/* EOF adp_h */
|