rdi_info.h

realview22.rar

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

/* lockedstate is a bitmap of the icebreaker registers locked against   */
/* use by IceMan (because explicitly written by the user)               */

#define RDIInfo_GetLoadSize     0x187
/* rdi: out ARMword *maxloadsize                                        */
/* rdp: in none, out word maxloadsize, byte status                      */
/* Inquires the maximum length of data transfer the agent is prepared   */
/* to receive                                                           */
/* Only usable if RDIInfo_Target returned RDITarget_CanInquireLoadSize  */
/* rdi: out ARMword *size                                               */

#ifdef armtypes_h /* ARMword is defined in clx/armtypes.h */
/* Only to be used if the value returned by RDIInfo_Target had          */
/* RDITarget_HasCommsChannel set                                        */
typedef void RDICCProc_ToHost(void *arg, ARMword data);
typedef void RDICCProc_FromHost(void *arg, ARMword *data, int *valid);
#endif

#define RDICommsChannel_ToHost  0x188
/* rdi: in RDICCProc_ToHost *, in void *arg                             */
/* rdp: in byte connect, out byte status                                */
#define RDICommsChannel_FromHost 0x189
/* rdi: in RDICCProc_FromHost *, in void *arg                           */
/* rdp: in byte connect, out byte status                                */


/*
 * Debug controller initialiated comms channel calls.
 * --------------------------------------------------
 *
 * An alternative mechanism to RDICommsChannel_ToHost and
 * RDICommsChannel_FromHost.  Intended for use when the debug target
 * is executing, but does not have the host execution thread.
 *
 * Two new calls are provided to give controller-side control over
 * debug comms channel communication. If these calls are being used,
 * the controller must not register the comms channel callback
 * procedures. A target should return RDIError_UnimplementedMessage to
 * both calls if either or both callbacks have been registered. (If a
 * callback has been registered in the past, but has since been
 * cleared, the controller is permitted to make these calls.)
 */

/*
 *        Function: RDICallCC_ToHost
 *         Purpose: Read some bytes to the host from the comms channel
 *          Handle: Module
 *
 *  Pre-conditions: There is not a callback currently registered through
 *                  RDICommsChannel_ToHost or RDICommsChannel_FromHost
 *
 *          Params:
 *             In/Out: (char *)arg1 = buffer
 *                        A pointer to the buffer where the bytes read from
 *                        the DCC will be placed by the target. May be NULL,
 *                        in which case (*nbytes) must be zero on entry.
 *
 *                 In: (uint32 *)arg2 = nbytes
 *                        (*nbytes) is the size of the buffer in bytes.
 *                        The target must not return more than (*nbytes) data.
 *                        May be zero.
 *                Out: (uint32 *)arg2 = nbytes
 *                        (*nbytes) is the number of bytes placed in to
 *                        'buffer', plus the number of bytes still buffered in
 *                         the target.
 *                     If, (*nbytes)_out is less than (*nbytes)_in, 'buffer'
 *                     has been filled with only (*nbytes)_out data, and the
 *                     target ran out of data to put into 'buffer' before it
 *                     was filled. There are no bytes remaining buffered on
 *                     the target.
 *
 *                     If (*nbytes)_out equals (*nbytes)_in, 'buffer' has been
 *                     filled completely, and no bytes are remaining buffered
 *                     on the target.
 *
 *                     If (*nbytes)_out is greater than (*nbytes)_in (as may
 *                     be the case if (*nbytes)_in was zero), then 'buffer'
 *                     has been filled (with (*nbytes)_in words), and
 *                     (*nbytes)_out - (*nbytes)_in words remain buffered on
 *                     the target.
 *
 *         Returns:  RDIError_NoError
 *                   RDIError_UnimplementedMessage  call not supported, or
 *                                       callback currently registered
 *                   Or a generic error (see RDI 1.5 doc) 
 */
#define RDICallCC_ToHost     0x18A


/*
 *        Function: RDICallCC_FromHost
 *         Purpose: Write some bytes from the host to the comms channel
 *          Handle: Module
 *
 *   Pre-conditions: There is not a callback currently registered through
 *                  RDICommsChannel_ToHost or RDICommsChannel_FromHost
 *
 *          Params:
 *                In: (char const *)arg1 = buffer
 *                       A pointer to the buffer containing the bytes to write
 *                       to the DCC.
 *               Out: arg1: Contents are unchanged.
 *
 *                In: (uint32 *)arg2 = nbytes
 *                       (*nbytes) is the number of bytes waiting in the buffer
 *               Out: (uint32 *)arg2 = nbytes
 *                       (*nbytes) is the number of bytes taken from the buffer
 *                       for writing to the target. These bytes may either have
 *                       been written, or else copied to the target's buffer
 *                       for writing later.
 *                    If (*nbytes)_out is less than (*nbytes)_in, then not
 *                    all the data has been takem from 'buffer' by the target.
 *
 *         Returns:  RDIError_NoError
 *                   RDIError_UnimplementedMessage  call not supported, or
 *                                       callback currently registered
 *                   Or a generic error (see RDI 1.5 doc)
 */
#define RDICallCC_FromHost   0x18B

/*
 *        Function: RDICallCC_Reset
 *         Purpose: Flush RDICallCC buffers, if any
 *          Handle: Module
 *
 *  Pre-conditions: There is not a callback currently registered through
 *                  RDICommsChannel_ToHost or RDICommsChannel_FromHost
 *
 *          Params:
 *               In:  (uint32 *)arg1 = bufid
 *                       If (*bufid) == 'RDICallCC_ToHost', the target->host
 *                       buffer (if implemented) is emptied.
 *                       (Any data in the buffer is lost.)
 *                       If (*bufid) == 'RDICallCC_FromHost', the host->target
 *                       buffer (if implemented) is emptied.
 *                       (Any data in the buffer is lost.)
 *                       If (*bufid) == 0, both buffers (if implemented)
 *                       are emptied.
 *
 *         Returns:  RDIError_NoError
 *                   RDIError_UnimplementedMessage  call not supported, or
 *                                       callback currently registered
 *                   Or a generic error (see RDI 1.5 doc)
 */
#define RDICallCC_Reset      0x18C

/* These 4 are only to be used if RDIInfo_Semihosting returns no error, or
 * the relevant RDIInfo_SemiHosting_... returns no error
 */
#define RDISemiHosting_SetARMSWI 0x190
/* rdi: in ARMword ARM_SWI_number                                       */
/* rdp: in ARMword ARM_SWI_number, out byte status                      */

#define RDISemiHosting_GetARMSWI 0x191
/* rdi: out ARMword ARM_SWI_number                                      */
/* rdp: out ARMword ARM_SWI_number, byte status                         */

#define RDISemiHosting_SetThumbSWI 0x192
/* rdi: in ARMword Thumb_SWI_number                                     */
/* rdp: in ARMword Thumb_SWI_number, out byte status                    */

#define RDISemiHosting_GetThumbSWI 0x193
/* rdi: out ARMword ARM_Thumb_number                                    */
/* rdp: out ARMword ARM_Thumb_number, byte status                       */

#define RDIInfo_SemiHostingSetARMSWI 0x8190
#define RDIInfo_SemiHostingGetARMSWI 0x8191
#define RDIInfo_SemiHostingSetThumbSWI 0x8192
#define RDIInfo_SemiHostingGetThumbSWI 0x8193
/*
 * Return RDIError_NoError if the function is servicable, or 
 * RDIError_UnimplementedMessage otherwise
 */

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_GetSafeNonVectorAddress, arg1, arg2)
 *   Purpose: Get the value of the SafeNonVectorAddress, ie. an address
 *            it is safe for JTAG based debug systems to set the PC to
 *            before performing a system speed access.
 *            This is only supported if RDIInfo_SafeNonVectorAddress returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_GetSafeNonVectorAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_GetSafeNonVectorAddress 0x194

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_SetSafeNonVectorAddress, arg1, arg2)
 *   Purpose: Set the value of the SafeNonVectorAddress, ie. an address
 *            it is safe for JTAG based debug systems to set the PC to
 *            before performing a system speed access.
 *            This is only supported if RDIInfo_SafeNonVectorAddress returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_SetSafeNonVectorAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_SetSafeNonVectorAddress 0x195

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_GetVectorAddress, arg1, arg2)
 *   Purpose: Get the value of the VectorAddress, ie. the location of
 *            the exception vectors.
 *            This is only supported if RDIInfo_VectorAddress returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_GetVectorAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_GetVectorAddress 0x196

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_SetVectorAddress, arg1, arg2)
 *   Purpose: Set the value of the VectorAddress, ie. the location of
 *            the exception vectors.
 *            This is only supported if RDIInfo_VectorAddress returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_SetVectorAddress
 *
 *   This is also supported in RDI1, in which case mh is left out.
 *
 *   Returns:   RDIError_NoError
 */
#define RDIInfo_SetVectorAddress 0x197

/*
 *  Function: RDI_InfoProc(mh, RDIInfo_GetCP15CacheSelected, arg1, arg2)
 *   Purpose: Get the identity of cache which has been selected for manipulation
 *            via CP15.  0=>D-Cache, 1=>I-Cache.
 *            This is only supported if RDIInfo_CP15CacheSelection returns
 *            RDIError_NoError
 *
 *    Params:
 *       Input: mh      handle identifies processor
 *
 *              type    RDIInfo_GetCP15CacheSelected