*    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_SetCP15CurrentMemoryArea
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_SetCP15CurrentMemoryArea 0x19B

/*
 *  Function: RDI_InfoProc(mh, RDISemiHosting_GetDCCHandlerAddress, arg1, arg2)
 *   Purpose: Get the value of the semihosting DCCHandler Address, ie. the
 *            address at which a SWI Handler is automatically loaded if
 *            Debug Comms Channel based semihosting is enabled.
 *            This is only supported if RDISemiHosting_DCC returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDISemiHosting_GetDCCHandlerAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDISemiHosting_GetDCCHandlerAddress 0x19C

/*
 *  Function: RDI_InfoProc(mh, RDISemiHosting_SetDCCHandlerAddress, arg1, arg2)
 *   Purpose: Get the value of the semihosting DCCHandler Address, ie. the
 *            address at which a SWI Handler is automatically loaded if
 *            Debug Comms Channel based semihosting is enabled.
 *            This is only supported if RDISemiHosting_DCC returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDISemiHosting_SetDCCHandlerAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDISemiHosting_SetDCCHandlerAddress 0x19D
/*
 *  Function: RDI_InfoProc(mh, RDIInfo_GetCPAccessCodeAddress, arg1, arg2)
 *   Purpose: Get the address of the area of memory (guarenteed at least
 *            40 bytes) which can be used by the Debug Agent (specifically
 *            Multi-ICE) to read / write coprocessor state.  The memory
 *            at this address must be RAM, and must be readable and writeable.
 *            This memory is however not corrupted, so the user may use this
 *            area of memory for other purposes too.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_GetCPAccessCodeAddress
 *
 *              *arg1   is used to return the address
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_GetCPAccessCodeAddress 0x19E

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_SetCPAccessCodeAddress, arg1, arg2)
 *   Purpose: Set the address of the area of memory (guarenteed at least
 *            40 bytes) which can be used by the Debug Agent (specifically
 *            Multi-ICE) to read / write coprocessor state.  The memory
 *            at this address must be RAM, and must be readable and writeable.
 *            This memory is however not corrupted, so the user may use this
 *            area of memory for other purposes too.
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_SetCPAccessCodeAddress
 *
 *              *arg1   is the new address
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_SetCPAccessCodeAddress 0x19F


/*
 *  Function: RDI_InfoProc(mh, RDIInfo_GetARM9RestartCodeAddress, arg1, arg2)
 *   Purpose: Get the address of the area of memory (guarenteed at least
 *            32 bytes) which can be used by the Debug Agent (specifically
 *            Multi-ICE) to restart the processor correctly.  The memory
 *            at this address must be RAM, and must be readable and writeable.
 *            This memory is dedicated to use by the Debug Agent, and cannot
 *            be used for any other purpose.
 *            In practice this will only be used for ARM9T rev 0 based targets.
 *            
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_GetARM9RestartCodeAddress
 *
 *              *arg1   is used to return the address
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_GetARM9RestartCodeAddress 0x1A0

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_SetARM9RestartCodeAddress, arg1, arg2)
 *   Purpose: Set the address of the area of memory (guarenteed at least
 *            32 bytes) which can be used by the Debug Agent (specifically
 *            Multi-ICE) to restart the processor correctly.  The memory
 *            at this address must be RAM, and must be readable and writeable.
 *            This memory is dedicated to use by the Debug Agent, and cannot
 *            be used for any other purpose.
 *            In practice this will only be used for ARM9T rev 0 based targets.
 *            
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_SetARM9RestartCodeAddress
 *
 *              *arg1   is the new address
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_SetARM9RestartCodeAddress 0x1A1

#define RDICycles               0x200
/* rdi: out ARMword cycles[n*2]                                         */
/* rdp: in none, out 6 words cycles, byte status                        */
/* the rdi result represents <n> big-endian doublewords; the rdp        */
/* results return values for the ls halves of 6 of these (n=6 for rdp)  */
/* For rdi the value of <n> depends on the return value of              */
/* RequestCyclesDesc, and defaults to 6.                                */
#  define RDICycles_Size        48


#define RDIErrorP               0x201
/* rdi: out ARMaddress *errorp                                          */
/* rdp: in none, out word errorp, byte status                           */
/* Returns the error pointer associated with the last return from step  */
/* or execute with status RDIError_Error.                               */

/*
 * Inquiry for RDIRequestCyclesDesc
 * RDIError_NoError => I support this
 * RDIError_UnimplementedMessage => I don't support this
 */
#define RDIInfo_RequestCyclesDesc 0x8202

#define RDIRequestCyclesDesc    0x202
/* rdi: in  int *size, RDI_CycleDesc *sd                                */
/*      out size modified, sd filled in                                 */
/* rdp: not supported                                                   */
/* target fills in a description of the statistics returned by          */
/* RDICycles. If this call is unsupported (as in rdp), RDICycles is     */
/* assumed to return:                                                   */
/* {"\014Instructions",                                                 */
/*  "\010S_Cycles",                                                     */
/*  "\010N_Cycles",                                                     */
/*  "\010I_Cycles",                                                     */
/*  "\010C_Cycles",                                                     */
/*  "\010F_Cycles"}                                                     */
/* Cycles are assumed to be monotonically increasing counters. All the  */
/* fields are treated as such, and the debugger uses this fact to       */
/* generate "increment" counters.                                       */
/* The size of the array "sd" is passed in in "size" (number of         */
/* entries), which the target should modify to indicate the number of   */
/* entries used.                                                        */


#define RDISet_Cmdline          0x300
/* rdi: in char *commandline (a null-terminated string)                 */
/* No corresponding RDP operation (cmdline is sent to the agent in      */
/* response to SWI_GetEnv)                                              */

#define RDISet_RDILevel         0x301
/* rdi: in ARMword *level                                               */
/* rdp: in word level, out byte status                                  */
/* Sets the RDI/RDP protocol level to be used (must lie between the     */
/* limits returned by RDIInfo_Target).                                  */

#define RDISet_Thread           0x302
/* rdi: in ARMword *threadhandle                                        */
/* rdp: in word threadhandle, out byte status                           */
/* Sets the thread context for subsequent thread-sensitive operations   */
/* (null value sets no thread)                                          */

/* To be used if RDI_read or RDI_write returned                         */
/* RDIError_LittleEndian or RDIError_BigEndian, to signify that the     */
/* debugger has noticed.                                                */
#define RDIInfo_AckByteSex     0x303


/* Read endian sex of module                                            */
#define RDIInfo_ByteSex        0x304
/* rdi: out ARMword *sex (RDISex_Little, RDISex_Big or RDISex_DontCare  */

/* Also used to inform a target driver what bytesex the target is after */
/* RDI_open                                                             */
#define RDISet_ByteSex          0x305
/* rdi: in ARMword *sex (RDISex_Little or RDISex_Big)                   */

/* The next two are only to be used if RDIInfo_CoPro returned no error  */
#define RDIInfo_DescribeCoPro   0x400
/* rdi: in int *cpno, Dbg_CoProDesc *cpd                                */
/* rdp: in byte cpno,                                                   */
/*         cpd->entries * {                                             */
/*           byte rmin, byte rmax, byte nbytes, byte access,            */
/*           byte cprt_r_b0, cprt_r_b1, cprt_w_b0, cprt_w_b1}           */
/*         byte = 255                                                   */
/*      out byte status                                                 */

#define RDIInfo_RequestCoProDesc 0x401
/* rdi: in int *cpno, out Dbg_CoProDesc *cpd                            */
/* rpd: in byte cpno                                                    */
/*      out nentries * {                                                */
/*            byte rmin, byte rmax, byte nbytes, byte access,           */
/*          }                                                           */
/*          byte = 255, byte status                                     */

#define RDIInfo_Log             0x800
/* rdi: out ARMword *logsetting                                         */
/* No corresponding RDP operation                                       */
#define RDIInfo_SetLog          0x801
/* rdi: in ARMword *logsetting                                          */
/* No corresponding RDP operation                                       */

#define RDIProfile_Stop         0x500
/* No arguments, no return value                                        */
/* rdp: in none, out byte status                                        */
/* Requests that pc sampling stop                                       */

#define RDIProfile_Start        0x501
/* rdi: in ARMword *interval                                            */
/* rdp: in word interval, out byte status                               */
/* Requests that pc sampling start, with period <interval> usec         */

#define RDIProfile_WriteMap     0x502
/* rdi: in ARMword map[]                                                */
/* map[0] is the length of the array, subsequent elements are sorted    */
/* and are the base of ranges for pc sampling (so if the sampled pc     */
/* lies between map[i] and map[i+1], count[i] is incremented).          */
/* rdp: a number of messages, each of form:                             */
/*        in word len, word size, word offset, <size> words map data    */
/*        out status                                                    */
/* len, size and offset are all word counts.                            */

#define RDIProfile_ReadMap      0x503
/* rdi: in ARMword *len, out ARMword counts[len]                        */
/* Requests that the counts array be set to the accumulated pc sample   */
/* counts                                                               */
/* rdp: a number of messages, each of form:                             */
/*        in word offset, word size                                     */
/*        out <size> words, status                                      */
/* len, size and offset are all word counts.                            */

#define RDIProfile_ClearCounts  0x504
/* No arguments, no return value                                        */
/* rdp: in none, out byte status                                        */
/* Requests that pc sample counts be set to zero                        */

/*
 * InfoProc: RDI_InfoProc(mh, RDIInfo_Trace, arg1, arg2)
 *
 * Purpose:  Inquire whether a processor on a Debug Target supports
 *           tracing. A Debug Controller should call this Info call
 *           before trying to use the other Trace calls.
 *
 * Base of RDITrace info calls - see rdi_rti.h for actual calls
 * RDIInfo_Trace -> RDIInfo_Trace + 0xff are reserved for trace.
 *
 * Params:   mh  handle identifies processor
 *
 * Return:   RDIError_NoError              Processor supports tracing.
 *           RDIError_UnimplementedMessage Processor does not support tracing.
 */
#define RDIInfo_Trace 0x600


/*
 * Function: RDI_InfoProc(mh, RDIInfo_Property, arg1, arg2)
 *
 *  Version: RDI 1.51
 *
 *  Purpose: Inquire whether RDI properties are supported by this target
 *
 *           This must be called before any other Property related info
 *           calls are made, and they will only be supported if this returns
 *           RDIError_NoError.
 *
 *  Base of RDIProperty calls - see rdi_prop.h for actual c