*                                     is unable to release control to the
 *                                     debug controller for some reason.
 *
 *                  RDIError_UnimplementedMessage
 *                                     Target is not currently in Execute.
 */
#define RDISignal_ReleaseControl        43

/*
 * RDI 1.51rt/tx
 */

typedef enum RDIProxyFlags
{
  RDIProxyFlag_SetExecuteProxy = 0,
  RDIProxyFlag_ClearExecuteProxy = 1
} RDIProxyFlags;

/*
 *        Function: RDIInfo_SetProxy
 *         Purpose: An RDI proxy allows a debug controller to re-use the
 *                  functions of a debug target. The debug target provides
 *                  most of the debug functions, but is instructed to use a
 *                  different RDI target for certain basic operations.
 * 
 *                  Only the following entry points are proxy-able
 *                    CPURead/CPUWrite
 *                    CPRead/CPWrite
 *                    Read/Write
 *                    SetBreak/ClearBreak
 *                    SetWatch/ClearWatch
 *                    Execute/Step
 *
 *          Handle: Module
 *
 *          Params:
 *                   In: *((RDI_ModuleDesc *)arg1): Module descriptoin to pass
 *                       to proxy
 *                   In: *((enum RDIProxyFlags *)arg2): Flags indicating when
 *                       to proxy
 *
 *         Returns: RDIError_NoError: Proxy set up
 *                  RDIError_UnimplementedMessage: Proxies not accepted
 *
 * Post-conditions: If a proxy was (successfully) registered, the debug
 *                  target will call any non-NULL entry points within the
 *                  proxy, rather than using its own implementations.
 */
#define RDIInfo_SetProxy                45


/*
 *        Function: RDIInfo_SetInfoProxy
 *         Purpose: An RDI proxy allows a debug controller to re-use the
 *                  functions of a debug target. The debug target provides
 *                  most of the debug functions, but is instructed to use a
 *                  different RDI target for certain basic operations.
 * 
 *                  This call allows subsets of RDIInfo to be proxied.
 *
 *  Pre-conditions: RDIInfo_Proxy must have been called previously, with a
 *                  valid info entry point, for the specified flags (arg2).
 *
 *          Handle: Module
 *
 *          Params:
 *                   In: *((uint32 *)arg1): An info "capability request" code
 *                       indicating a subset of info calls to proxy
 *                   In: *((enum RDIProxyFlags *)arg2): Flags indicating when
 *                       to proxy
 *
 *         Returns: RDIError_NoError: Info proxy set up
 *                  RDIError_NoSuchHandle: No appropriate proxy registered
 *                  RDIError_UnimplementedMessage: Info proxy not accepted
 *
 * Post-conditions: If a proxy was (successfully) registered, the debug
 *                  target will call info calls as indicated by arg1, until
 *                  either RDIInfo_SetInfoProxy is used to deregister the
 *                  info proxy, or RDIInfo_SetProxy is used to deregister the
 *                  entire proxy.
 *
 * Valid values of *((uint32 *)arg1) are:
 *
 * RDIInfo_Target         RDIInfo_CP15CacheSelection    RDIInfo_Log
 * RDIInfo_Points         RDIInfo_CP15CurrentMemoryArea RDIInfo_SetLog
 * RDIInfo_MMU            RDIInfo_CanForceSystemReset   RDIInfo_SetProcessID
 * RDIInfo_DownLoad       RDIInfo_IOBitsSupported       RDIInfo_Icebreaker
 * RDIInfo_SemiHosting    RDICycles                RDIInfo_SafeNonVectorAddress
 * RDIInfo_CoPro          RDIInfo_CustomLoad            RDISemihosting_DCC
 * RDIInfo_SetMemoryMap   RDIInfo_CanDoGeneralPurpose   RDIInfo_Properties
 * RDIInfo_GetMemoryMap   RDIInfo_Modifiable            RDIInfo_Trace
 * RDIInfo_ReadClock      RDIVector_Catch               RDIInfo_TraceRun
 * RDIInfo_MovableVectors RDISet_CmdLine                RDIInfo_TraceBuffer
 * RDIInfo_CodeSequenceInquiry
 */
#define RDIInfo_SetInfoProxy            46

/* ARMulator formerly used 45,46,47,48,49,59 before it got its own range. */

/*
 *        Function: RDIInfo_AllowedWhilstExecuting
 *         Version: Introduced by RDI 1.5.1tx/rt
 *         Purpose: Determine which RDI calls are available during execution
 *
 *          Handle: either
 *
 *          Params:
 *                  Out: arg1.  (RDI_ProcVec const *)(*arg1) is a procvec
 *                       where each entry is either NULL (not available during
 *                       execution, or takes the value as per the module/agents
 *                       real procvec (available during execution).
 *
 *         Returns: RDIError_NoError: ok
 *                  RDIError_UnimplementedMessage: nothing available during
 *                       execution, except RDISignal_[Stop/ReleaseControl]
 *
 */
#define RDIInfo_AllowedWhilstExecuting 50

/*
 *        Function: RDIInfo_InfoAllowedWhilstExecuting
 *         Version: Introduced by RDI 1.5.1tx/rt
 *         Purpose: Determine which info RDI calls are available during
 *                  execution
 *                  Only to be called if RDIInfo_AllowedWhilstExecuting
 *                  indicated that info was available during execute.
 *
 *          Handle: either
 *
 *          Params:
 *                   In: arg1.  Info code in question. Only use one of:
 * RDIInfo_Target              
 * RDIInfo_CustomLoad   
 * RDIInfo_Points       
 * RDIInfo_CanDoGeneralPurpose  
 * RDIInfo_MMU          
 * RDIInfo_Modifiable   
 * RDIInfo_Download             
 * RDIVector_Catch      
 * RDIInfo_Semihosting          
 * RDISet_CmdLine       
 * RDIInfo_CoPro                
 * RDIInfo_Log  
 * RDIInfo_SetMemoryMap         
 * RDIInfo_SetLog       
 * RDIInfo_GetMemoryMap         
 * RDIInfo_SetProcessID 
 * RDIInfo_ReadClock            
 * RDIInfo_Icebreaker   
 * RDIInfo_MoveableVectors              
 * RDIInfo_SafeNonVectorAddress 
 * RDIInfo_CP15CacheSelection           
 * RDISemihosting_DCC   
 * RDIInfo_CP15CurrentMemoryArea                
 * RDIInfo_CanForceSystemReset          
 * RDIInfo_IOBitsSupported              
 * RDICycles            
 * RDIInfo_Properties   
 * RDIInfo_Trace        
 * RDIInfo_TraceRun     
 * RDIInfo_TraceBuffer  
 *
 *                  Out: arg2. If arg1 is RDIInfo_Target, or RDIInfo_Points,
 *                             arg2 gives the respective capabilities during
 *                             execution
 *
 *         Returns: RDIError_NoError: ok
 *                  RDIError_UnimplementedMessage: no info available during
 *                       execution, except RDISignal_[Stop/ReleaseControl]
 *
 */
#define RDIInfo_InfoAllowedWhilstExecuting 51

/*
 *        Function: RDIInfo_SubModules
 *         Purpose: Obtain module hierarchy
 *          Handle: Module or Agent
 *
 *  Pre-conditions: RDI_OpenAgentProc has been called
 *
 *          Params:
 *               In/Out: nMods = (unsigned *)arg1
 *
 *                       On input, if (*nMods)==0, this is a request for total
 *                       number of modules that are children of this
 *                       module/agent. Output is the total number of modules
 *                       that are children of this module/agent.
 *                       On input, if (*nMods)!=0, request for description of
 *                       up to nMods registers to be returned in array.  Output
 *                       is the actual number of modules returned in array,
 *                       which can be 0 or more.
 *
 *                  Out: array = (RDI_ModuleHandle *)arg2
 *
 *                       Return an array of RDI_ModuleHandle in this
 *                       pointer.  The number of elements in array is
 *                       the smaller of the number of modules that are
 *                       children of this module/agent and nMods.  If
 *                       nMods is zero on input, then array may be
 *                       NULL.
 *
 *         Returns: RDIError_NoError    OK
 *                  RDIError_UnimplementedMessage
 *                                Module: Module does not have any sub-modules
 *                                Agent: Target has no hierarchy
 *
 */
#define RDIInfo_SubModules                 56

/*
 *        Function: RDIInfo_ProcessorType
 *         Purpose: Get information about the processor.  Only to
 *                  be called after a successful OpenProc.
 *
 *          Handle: Module
 *  Pre-conditions: RDI_OpenProc(module) successful
 *
 *          Params: Either arg can be NULL, which means that the caller is
 *                  not interested in this information.  If non-NULL, the
 *                  target should supply the relevant information, or -1
 *                  if the answer is not known.
 *
 *                  Out: *((uint32 *)arg1) = type.  A numeral indicating
 *                       the processor type, if available, or -1 if not
 *                       available.  For ARM processors, this will be
 *                       e.g., 7, 720, 740, 1020, etc.
 *
 *                  Out: *((uint32 *)arg2) = revision.  The numeric chip
 *                       revision, or -1 if this is not known.
 *
 *         Returns: RDIError_NoError - info returned OK
 *                  RDIError_UnimplementedMessage - no info available
 *
 * Post-conditions: none
 *                                  
 */
#define RDIInfo_ProcessorType 57

/*
 *        Function: RDIInfo_ErrorSeverity
 *         Purpose: Find out severity of a target specific error
 *
 *  Pre-conditions: The error in question has been returned from a previous
 *                  RDI call, and no other target specific errors have been
 *                  reported since
 *
 *          Params:
 *                   In: *((uint32 *)arg1) = errnum
 *                  Out: *((uint32 *)arg2) = severity (RDIErrorSeverity_*)
 *
 *         Returns: RDIError_NoError
 *                  RDIError_UnimplementedMessage
 */
#define RDIErrorSeverity_Fatal 0
#define RDIErrorSeverity_NonFatal 1
#define RDIErrorSeverity_Unknown 2

#define RDIInfo_ErrorSeverity 58


/* ARMulator formerly used 45,46,47,48,49,59 before it got its own range. */



/* The next two are only to be used if the value returned by            */
/* RDIInfo_Points has RDIPointCapability_Status set.                    */
#define RDIPointStatus_Watch    0x80
#define RDIPointStatus_Break    0x81
/* rdi: inout ARMword * (in handle, out hwresource), out ARMword *type  */
/* rdp: in word handle, out word hwresource, word type, byte status     */

#define RDISignal_Stop          0x100
/* Requests that the debuggee stop                                      */
/* No arguments, no return value                                        */
/* rdp: no reply (when the debuggee stops, there will be a reply to the */
/*      step or execute request which started it)                       */

#define RDIVector_Catch         0x180
/* rdi: in ARMword *bitmap                                              */
/* rdp: int word bitmap, out byte status                                */
/* bit i in bitmap set to cause vector i to cause entry to debugger     */

/* The next four are only to be used if RDIInfo_Semihosting returned    */
/* no error                                                             */
#define RDISemiHosting_SetState 0x181
/* rdi: in ARMword *semihostingstate                                    */
/* rdp: in word semihostingstate, out byte status                       */
#define RDISemiHosting_GetState 0x182
/* rdi: out ARMword *semihostingstate                                   */
/* rdp: in none, out word semihostingstate, byte status                 */
#define RDISemiHosting_SetVector 0x183
/* rdi: in ARMword *semihostingvector                                   */
/* rdp: in word semihostingvector, out byte status                      */
#define RDISemiHosting_GetVector 0x184
/* rdi: out ARMword *semihostingvector                                  */
/* rdp: in none, out word semihostingvector, byte status                */

/* The next two are only to be used if RDIInfo_Icebreaker returned      */
/* no error                                                             */
#define RDIIcebreaker_GetLocks  0x185
/* rdi: out ARMword *lockedstate                                        */
/* rdp: in none, out word lockedstate, byte status                      */

#define RDIIcebreaker_SetLocks  0x186
/* rdi: in ARMword *lockedstate                                         */
/* rdp: in word lockedstate, out byte status                            */