*  Function: RDI_InfoProc(mh, RDIInfo_Modifiable, arg1, arg2)
 *   Version: RDI 1.5
 *   Purpose: Query whether Processor status can be modified
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_Modifiable
 *
 *   Returns:   RDIError_NoError        Status can be modified
 *              RDIError_ReadOnly       Status cannot be modified
 */
#define RDIInfo_Modifiable        29


/*
 *  Function: RDI_InfoProc(mh, RDIInfo_GetClockSpeed, arg1, arg2)
 *   Version: RDI 1.5
 *   Purpose: Query the target clock speed
 *
 *    Params:
 *       Input: mh  handle identifies processor
 *
 *              type    RDIInfo_Modifiable
 *
 *       Output:arg1    uint32 *clock_speed.  Returns the clock
 *                      speed of the specified processor in ns.
 *
 *   Returns:   RDIError_NoError
 *              RDIError_UnimplmentedMessage - don't know the speed!
 */
#define RDIInfo_GetClockSpeed     30


/*
 *  Function: RDI_InfoProc(mh, RDIInfo_MovableVectors, arg1, arg2)
 *   Purpose: Query whether Processor has movable vectors
 *            (a WinCE requirement).  If this is supported (returns
 *            RDIError_NoError) then RDIInfo_{Get,Set}VectorAddress
 *            is also supported.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_MovableVectors
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError        Status can be modified
 *              RDIError_ReadOnly       Status cannot be modified
 */
#define RDIInfo_MovableVectors   31


/*
 *  Function: RDI_InfoProc(mh, RDIInfo_CP15CacheSelection, arg1, arg2)
 *   Purpose: Query whether Processor supports cache manipulation
 *            via CP15, and if it does whether a variable to determine
 *            which cache (I/D/Joint) will be manipulated via CP15.
 *            If this is supported (returns RDIError_NoError) then
 *            RDIInfo_{Get,Set}CP15CacheSelection is also supported.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_CP15CacheSelection
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError        Status can be modified
 *              RDIError_ReadOnly       Status cannot be modified
 */
#define RDIInfo_CP15CacheSelection   32


/*
 *  Function: RDI_InfoProc(mh, RDIInfo_CP15CurrentMemoryArea, arg1, arg2)
 *   Purpose: Query whether Processor supports memory area protection
 *            setup manipulation via CP15, and if it does whether a variable
 *            to determine the current mrmory area being manipulated is to
 *            be supported.
 *            If this is supported (returns RDIError_NoError) then
 *            RDIInfo_{Get,Set}CP15CurrentMemoryArea is also supported.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_CP15CurrentMemoryArea
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError        Status can be modified
 *              RDIError_ReadOnly       Status cannot be modified
 */
#define RDIInfo_CP15CurrentMemoryArea   33


/*
 *  Function: RDI_InfoProc(mh, RDIInfo_SafeNonVectorAddress, arg1, arg2)
 *   Purpose: Query whether the denug agent needs to be told of a safe
 *            non vector address to set the PC to prior to performing
 *            memory reads and writes.  This is only relevent to JTAG
 *            debug based systems.
 *            If this is supported (returns RDIError_NoError) then
 *            RDIInfo_{Get,Set}SafeNonVectorAddress is also supported.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_SafeNonVectorAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError        Status can be modified
 *              RDIError_ReadOnly       Status cannot be modified
 */
#define RDIInfo_SafeNonVectorAddress   34

/*  Function: RDI_InfoProc(mh, RDIInfo_CanForceSystemReset, arg1, arg2)
 *   Purpose: Query whether the target board can be forced to reset
 *            by setting System Reset via the debug agent.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_CanForceSystemReset
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError               System resetting is supported
 *              RDIError_UnimplementedMessage  System resetting not supported
 */
#define RDIInfo_CanForceSystemReset   35

/*  Function: RDI_InfoProc(mh, RDIInfo_ForceSystemReset, arg1, arg2)
 *   Purpose: Actually perform a system reset of the target.  This will only
 *            be supported if RDIInfo_CanForceSystemReset returned
 *            RDIError_NoError.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_ForceSystemReset
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError               System reset performed
 *              RDIError_UnimplementedMessage  System resetting not supported
 */
#define RDIInfo_ForceSystemReset   36

/*  Function: RDI_InfoProc(mh, RDIInfo_IOBitsSupported, arg1, arg2)
 *   Purpose: Query whether the debug agent supports I/O bit writing
 *            (such as the Multi-ICE User Input/Ouput bits).
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_IOBitsSupported
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError               I/O bits are supported
 *              RDIError_UnimplementedMessage  I/O bits are not supported
 */
#define RDIInfo_IOBitsSupported   37


#  define RDIInfo_IOBits_Output1  1
#  define RDIInfo_IOBits_Output2  2
#  define RDIInfo_IOBits_Input1   3
#  define RDIInfo_IOBits_Input2   4
 
/*  Function: RDI_InfoProc(mh, RDIInfo_SetIOBits, arg1, arg2)
 *   Purpose: Set the specified I/O Bit
 *
 *    Params:
 *       Input: mh              handle identifies processor
 *       Input: type            RDIInfo_SetIOBits
 *       Input: unsigned *arg1  Indicates the identity of the I/O bit
 *                              to be written.  For Multi-ICE see the
 *                              RDIInfo_IOBits_* definitions above.
 *       Input: unsigned *arg2  0=> set it low, 1=> set it high
 *               
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError               Request performed OK
 *              RDIError_UnimplementedMessage  I/O bits are not supported
 *                                             or invalid I/O bit specified
 */
#define RDIInfo_SetIOBits   38

/*  Function: RDI_InfoProc(mh, RDIInfo_GetIOBits, arg1, arg2)
 *   Purpose: Get the status of the specified I/O Bit
 *
 *    Params:
 *       Input: mh              handle identifies processor
 *       Input: type            RDIInfo_GetIOBits
 *       Input: unsigned *arg1  Indicates the identity of the I/O bit
 *                              to be read.  For Multi-ICE see the
 *                              RDIInfo_IOBits_* definitions above.
 *       Output: unsigned *arg2 Set to 0=> it was low, 1=> it was high
 *               
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError               Request performed OK
 *              RDIError_UnimplementedMessage  I/O bits are not supported
 *                                             or invalid I/O bit specified
 */
#define RDIInfo_GetIOBits   39

/*  Function: RDI_InfoProc(mh, RDISemiHosting_DCC, arg1, arg2)
 *   Purpose: Query whether the debug agent supports debug comms channel
 *            based semihosting.  If it does then it will be possible
 *            to get and set the address of the SWI & DCC handler used
 *            for DCC based semihosting.  The info calls which do
 *            this are: RDIInfo_{Get,Set}SHDCCHandlerAddress.
 *            a return value of RDIError_NoError indicates DCC semihosting
 *            is supported.  RDIError_UnimplementedMessage indicates it
 *            is not supported.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDISemiHosting_DCC
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError               Request performed OK
 *              RDIError_UnimplementedMessage  DCC semihosting is not supported
 */
#define RDISemiHosting_DCC   40

/*  Function: RDI_InfoProc(ah, RDIInfo_SynchronizationControl, arg1, arg2)
 *   Purpose: Determine the sequence of "stop_others" flags to pass to
 *            the debug target to perform synchronous execution in
 *            multiprocessor systems. Normally, this will be "always
 *            TRUE" for asynchronous, "always FALSE" for
 *            synchronous. However some targets--e.g. in the presence
 *            of multiple controllers--may instead wish the controller
 *            to use "occasionally FALSE" in the second time. For
 *            instance, a controller may generate a sequence of
 *            steps/gos for a single user request to step or go, and
 *            the target will need to be told "FALSE" for only one of
 *            these (typically, the last).
 *            The controller may abort before reaching the "user" request,
 *            for example, if it hits a breakpoint.
 *
 *   Params:
 *      Input: ah          handle identifies controller
 *      Input: type        RDIInfo_SynchronizationControl
 *      Input: char *arg1  Pointer to an array of four bytes to be filled
 *                         in as below
 *
 *   The array pointed to by (arg1) is filled in with:
 *      arg1[0] => boolean value to pass for stop_others for controller
 *                 generated requests for synchronous execution
 *      arg1[1] => boolean value to pass for stop_others for user
 *                 generated requests for synchronous execution
 *      arg1[2] => boolean value to pass for stop_others for controller
 *                 generated requests for asynchronous execution
 *      arg1[3] => boolean value to pass for stop_others for user
 *                 generated requests for asynchronous execution
 *
 *   Returns:   RDIError_NoError               Request performed OK
 *              RDIError_UnimplementedMessage  Target ignores "stop_others"
 */
#define RDIInfo_SynchronizationControl  41

/*
 *        Function: RDIInfo_AllowStopping
 *         Purpose: Indicate whether the target processor is permitted to stop
 *          Handle: Module
 *            XRef: Also defined in rdi_info.h
 *
 *  Pre-conditions: Only call if processor is in non-stopping mode
 *
 *          Params:
 *                   In: *((bool *)arg1): If TRUE, the target processor may
 *                       be stopped in order to service RDI requests.  If
 *                       FALSE, the target processor must never be stopped, and
 *                       impossible RDI requests must be faulted (with
 *                       RDIError_NotAllowedWhilstExecuting)
 *
 *         Returns: RDIError_OK
 *                  RDIError_UnimplementedMessage:  Target can not switch from
 *                  non-stopping to stopping mode, or vice versa. The
 *                  controller needs to close the connection and attempt to
 *                  re-open in the other mode.
 */
#define RDIInfo_AllowStopping           42


/*
 *        Function: RDIInfo_ReleaseControl
 *         Purpose: Return host execution thread to debug controller
 *          Handle: Module
 *
 *  Pre-conditions: Should be in RDI_Execute
 *
 *          Params: none
 *
 *         Returns: RDIError_NoError    The debug target will return from
 *                                     Execute as soon as possible, with
 *                                     return code Executing.
 *
 *                  RDIError_Executing  Target is currently executing, but