| /* |
| * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved. |
| * |
| * This software may be freely used, copied, modified, and distributed |
| * provided that the above copyright notice is preserved in all copies of the |
| * software. |
| */ |
| |
| /* sys.h |
| *********************************************************************** |
| * Angel C Libary support channel protocol definitions |
| * |
| * $Revision$ |
| * $Date$ |
| * |
| * |
| * |
| * |
| * MESSAGE FORMAT |
| * -------------- |
| * Format of the "data" section of C Lib Support Channel Messages. |
| * You will notice that the format is much the same as the format |
| * of ADP messages - this is so that multi-threaded C Libraries can |
| * be supported. |
| * |
| * unsigned32 reason - Main C Library reason code. |
| * unsigned32 debugID - Info. describing host debug world; |
| * private to host and used in any target |
| * initiated messages. |
| * unsigned32 OSinfo1 \ Target OS information to identify process/thread |
| * unsigned32 OSinfo2 / world, etc. These two fields are target defined. |
| * byte args[n] - Data for message "reason" code. |
| * |
| * The "debugID" is defined by the host-end of the protocol, and is used |
| * by the host to ensure that messages are routed to the correct handler |
| * program/veneer (eg. imagine several threads having opened stdout and |
| * each writing to a different window in a windowed debugger). |
| * |
| * NOTE: The reason that there is no "size" information, is that the |
| * message IDs themselves encode the format of any arguments. |
| * |
| * For further discussion of the format see adp.h |
| * |
| * N.B. All streams are little endian. |
| * |
| * CLIB REASON CODE |
| * ---------------- |
| * The message reason codes contain some information that ties them to |
| * the channel and direction that the message will be used with. This |
| * will ensure that even if the message "#define name" is not |
| * completely descriptive, the message reason code is. |
| * |
| * b31 = direction. 0=Host-to-Target; 1=Target-to-Host; |
| * b30-16 = reserved. should be zero |
| * b15-0 = message reason code. |
| * |
| * Note that typically a request will be initiated by the target side, and |
| * that the host will then respond with either an acknowledgement or some |
| * data. In either case the same reason code will be used, but the direction |
| * bit will be reveresed. |
| */ |
| |
| #ifndef __sys_h |
| #define __sys_h |
| |
| #ifndef HtoT |
| #define HtoT ((unsigned)0 << 31) /* Host-to-Target message */ |
| #define TtoH ((unsigned)1 << 31) /* Target-to-Host message */ |
| #endif |
| |
| /* |
| * The following are error codes used in the status field returned on |
| * sending a message. 0 represents no error having occurred, non-zero |
| * represents a general error. More codes should be added as required. |
| */ |
| |
| #ifndef ErrCode |
| #define NoError 0x0 |
| #endif |
| |
| /*************************************************************************/ |
| /* The following are direct conversions of the DeMon SWI's */ |
| /* NB: nbytes is the number of bytes INCLUDING THE NULL character where */ |
| /* applicable. */ |
| |
| /* This message is used as a response to a packet whose message |
| * was not understood. The return parameter, code is the reason |
| * code which was not understood. Although intended for use as a |
| * default case on a received message switch it can also be used |
| * as a proper message*/ |
| #define CL_Unrecognised 0x00 |
| /* Unrecognised() |
| * return(word code) |
| */ |
| |
| /* Write a character to the terminal. |
| */ |
| #define CL_WriteC 0x01 |
| /* WriteC(byte data) |
| * return(word status) |
| */ |
| |
| /* Write a NULL terminated string of characters to the terminal. The length |
| * of the string excluding the NULL terminating character is passed in |
| * 'nbytes'. |
| */ |
| #define CL_Write0 0x02 |
| /* Write0(word nbytes, bytes data) |
| * return(word status) |
| */ |
| |
| /* Read a character from the terminal - probably the keyboard. |
| */ |
| #define CL_ReadC 0x04 |
| /* ReadC(void) |
| * return(word status, byte data) |
| */ |
| |
| /* Perform system call, pass NULL terminated string to host's command |
| * line interpreter(NOT AVAILABLE IN PC/DOS RELEASE). The data byte |
| * returned holds the return code from the system call. |
| */ |
| #define CL_System 0x05 |
| /* CLI(word nbytes, bytes data) |
| * return(word status, word data) |
| */ |
| |
| /* It returns the address of the null terminated command line string used to |
| * invoke the program. status will be set to NoError if the command line |
| * can be returned. Other status values will be treated as error conditions. |
| */ |
| #define CL_GetCmdLine 0x10 |
| /* GetCmdLine(void) |
| * return(word status, word nbytes, bytes argline) |
| */ |
| |
| /* Return the number of centi-seconds since the support code began |
| * execution. Only the difference between successive calls can be |
| * meaningful. |
| */ |
| #define CL_Clock 0x61 |
| /* Clock(void) |
| * return(word status, word clks) |
| */ |
| |
| /* Return the number of seconds since the beginning of 1970. |
| */ |
| #define CL_Time 0x63 |
| /* Time(void) |
| * return(word status, word time) |
| */ |
| |
| /* Delete(remove, un-link, wipe, destroy) the file named by the |
| * NULL-terminated string 'name'. |
| */ |
| #define CL_Remove 0x64 |
| /* Remove(word nbytes, bytes name) |
| * return(word status) |
| */ |
| |
| /* Rename the file specified by the NULL-terminated string 'oname' |
| * to 'nname'. |
| */ |
| #define CL_Rename 0x65 |
| /* Rename(word nbytes, bytes oname, word nbytes, bytes nname) |
| * return(word status) |
| */ |
| |
| /* 'name' specifies a NULL-terminated string containing a file name or a |
| * device name. Opens the file/device and returns a non-zero handle on |
| * success that can be quoted to CL_Close, CL_Read, CL_Write, CL_Seek, |
| * CL_Flen or CL_IsTTY. The mode is an integer in the range 0-11:- |
| * |
| * Mode: 0 1 2 3 4 5 6 7 8 9 10 11 |
| * ANSI C fopen mode: r rb r+ r+b w wb w+ w+b a ab a+ a+b |
| * |
| * Values 12-15 are illegal. If 'name' is ":tt" the stdin/stdout is |
| * opened depending on whether 'mode' is read or write. |
| */ |
| #define CL_Open 0x66 |
| /* Open(word nbytes, bytes name, word mode) |
| * return(word handle) |
| */ |
| |
| /* 'handle' is a file handle previously returned by CL_Open. CL_Close |
| * closes the file. |
| */ |
| #define CL_Close 0x68 |
| /* Close(word handle) |
| * return(word status) |
| */ |
| |
| /* Writes data of length nbytes to the file/device specified by |
| * handle. nbtotal represents the total number of bytes to be |
| * written, whereas nbytes is the number of bytes in this packet |
| * |
| * If nbtotal is <= DATASIZE - CL_Write message header size in the |
| * packet then nbytes = nbtotal and the number of bytes not written |
| * is returned. If nbtotal is > the packet size then the CL_Write |
| * must be followed by a number of CL_WriteX's to complete the write, |
| * the nbytes returned by CL_Write can be ignored |
| * If the status word returned is non zero, an error has occurred and |
| * the write request has been aborted. |
| * |
| */ |
| #define CL_Write 0x69 |
| /* Write(word handle, word nbtotal, word nbytes, bytes data) |
| * return(word status, word nbytes) |
| */ |
| |
| /* Write Extension is a reads a continuation of data from a CL_Write |
| * which was too big to fit in a single packet. |
| * nbytes is the number of bytes of data in this packet, the |
| * returned value of nbytes can be ignored except if it is the |
| * last packet, in which case it is the number of bytes that were NOT |
| * written |
| */ |
| #define CL_WriteX 0x6A |
| /* WriteX(word nbytes, bytes data) |
| * return(word status, word nbytes) |
| */ |
| |
| /* Reads 'nbytes' from the file/device specified by 'handle'. |
| * |
| * If nbytes <= DATASIZE then the read will occur in a single packet |
| * and the returned value of nbytes will be the number of bytes actually |
| * read and nbmore will be 0. If nbytes> DATASIZE then multiple packets |
| * will have to be used ie CL_Read followed by 1 or more CL_ReadX |
| * packets. In this case CL_Read will return nbytes read in the current |
| * packet and nbmore representing how many more bytes are expected to be |
| * read |
| * If the status word is non zero then the request has completed with an |
| * error. If the status word is 0xFFFFFFFF (-1) then an EOF condition |
| * has been reached. |
| */ |
| #define CL_Read 0x6B |
| /* Read(word handle, word nbytes) |
| * return(word status, word nbytes, word nbmore, bytes data) |
| */ |
| |
| /* Read eXtension returns a continuation of the data that was opened for |
| * read in the earlier CL_Read. The return value nbytes is the number of |
| * data bytes in the packet, nbmore is the number of bytes more that are |
| * expected to be read in subsequent packets. |
| */ |
| #define CL_ReadX 0x6C |
| /* ReadX() |
| * return(word status, word nbytes, word nbmore, bytes data) |
| */ |
| |
| /* Seeks to byte position 'posn' in the file/device specified by 'handle'. |
| */ |
| #define CL_Seek 0x6D |
| /* Seek(word handle, word posn) |
| * return(word status) |
| */ |
| |
| /* Returns the current length of the file specified by 'handle' in 'len'. |
| * If an error occurs 'len' is set to -1. |
| */ |
| #define CL_Flen 0x6E |
| /* Flen(word handle) |
| * return(word len) |
| */ |
| |
| /* Returns NoError if 'handle' specifies an interactive device, otherwise |
| * returns GenError |
| */ |
| #define CL_IsTTY 0x6F |
| /* IsTTY(word handle) |
| * return(word status) |
| */ |
| |
| /* Returns a temporary host file name. The maximum length of a file name |
| * is passed to the host. The TargetID is some identifier from the target |
| * for this particular temporary filename. This value is could be used |
| * directly in the generation of the filename. |
| * |
| * If the host cannot create a suitable name or the generated name is too |
| * long then status is non zero. status will be NoError if the host can create |
| * a name. |
| */ |
| #define CL_TmpNam 0x70 |
| /* TmpNam(word maxlength, word TargetID) |
| * return(word status, word nbytes, bytes fname) |
| */ |
| |
| /* Note there is no message for Exit, EnterOS, InstallHandler or |
| * GenerateError as these will be supported entirely at the host end, |
| * or by the underlying Operating system. |
| */ |
| |
| #define CL_UnknownReason (-1) |
| |
| extern unsigned int GetRaiseHandler( void ); |
| extern unsigned int SysLibraryHandler(unsigned int sysCode, unsigned int *args); |
| extern void angel_SysLibraryInit(void); |
| |
| /* |
| * Function: Angel_IsSysHandlerRunning |
| * Purpose: return whether or not SysLibraryHandler is running |
| * |
| * No paramaters |
| * |
| * Returns 1 if SysLibraryHandler is running |
| * 0 otherwise |
| */ |
| extern int Angel_IsSysHandlerRunning(void); |
| |
| #ifdef ICEMAN2 |
| /* This function exists in an ICEman2 system only, and can be called by |
| * debug support code when the debugger tells it how much memory the |
| * target has. This will then be used to deal with the HEAPINFO SWI |
| */ |
| extern void angel_SetTopMem(unsigned addr); |
| #endif |
| |
| #endif |
| |
