rdi_info.h

realview22.rar

  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_SubAgents
 *         Purpose: Obtain agent 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 agents that are children of this
 *                       module/agent. Output is the total number of agents
 *                       that are children of this module/agent.
 *                       On input, if (*nMods)!=0, request for description of
 *                       up to nMods agents to be returned in array.  Output
 *                       is the actual number of agents 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 agents that are
 *                       children of this module/agent and nMods.  If
 *                       nMods is zero on input, then array may be
 *                       NULL.
 *
 *         Returns: RDIError_NoError    OK
 */
#define RDIInfo_SubAgents 54


/*
 *        Function: RDIInfo_Parent
 *         Purpose: Obtain module or agent hierarchy
 *          Handle: Module or Agent
 *
 *  Pre-conditions: RDI_OpenAgentProc has been called
 *
 *          Params:
 *                  Out: parent = (RDI_DbgStateForSubagent *)arg1
 *
 *                     Module
 *                       A module will fill in parent->agent_desc with its
 *                       own agent, and parent->parent_desc will be
 *                       set to it's parent module if it has one, else NULL.
 *                     Agent
 *                       If an agent has no parent, then
 *                       parent->agent_desc and parent->parent_desc will be
 *                       set to NULL.
 *                       Otherwise parent will be filled in with the
 *                       RDI_DbgStateForSubagent passed to the (sub)agent
 *                       during OpenAgent.
 *
 *               Unused: arg2 must be NULL.
 *
 *         Returns: RDIError_NoError    OK
 */
#define RDIInfo_Parent 55



/*
 *        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