URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [insight/] [utils/] [amd-udi/] [montip/] [udi2mtip.c] - Rev 1765
Compare with Previous | Blame | View Log
static char _[] = "@(#)udi2mtip.c 5.31 93/11/03 08:34:07, Srini, AMD."; /****************************************************************************** * Copyright 1991 Advanced Micro Devices, Inc. * * This software is the property of Advanced Micro Devices, Inc (AMD) which * specifically grants the user the right to modify, use and distribute this * software provided this notice is not removed or altered. All other rights * are reserved by AMD. * * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS * SOFTWARE. IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR * USE OF THIS SOFTWARE. * * So that all may benefit from your experience, please report any problems * or suggestions about this software to the 29K Technical Support Center at * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131 in the UK, or * 0031-11-1129 in Japan, toll free. The direct dial number is 512-462-4118. * * Advanced Micro Devices, Inc. * 29K Support Products * Mail Stop 573 * 5900 E. Ben White Blvd. * Austin, TX 78741 * 800-292-9263 ***************************************************************************** * Engineers: Srini Subramanian. ***************************************************************************** * This module implements the UDI procedural interface routines of MONTIP * for both the Dos and Unix environments. ***************************************************************************** */ #include <stdio.h> #include <signal.h> #ifdef MSDOS #include <stdlib.h> #include <conio.h> #else #include <malloc.h> #endif #include <string.h> #include "coff.h" #include "messages.h" #include "memspcs.h" #include "macros.h" #include "udiproc.h" #include "udiids.h" #include "udiext.h" #include "mtip.h" #include "hif.h" #include "versions.h" /* * MsgCode halt1, halt2, halt3, halt4 are variables defined as INT32 * * inside the macro block * */ #define CLEAR_PENDING_STOP StopFlag=0; /* Stop signal handler / macro */ #define STOP_SIG_HDLR {\ INT32 MsgCode;\ INT32 halt1, halt2, halt3, halt4;\ StopFlag=0;\ Mini_build_break_msg();\ if (Mini_msg_send() != SUCCESS)\ return((-1) * MONErrCantSendMsg);\ SIGINT_POLL \ MsgCode = Wait_For_Ack();\ if (MsgCode == ABORT_FAILURE)\ return ((-1) * MONErrAbortAborted);\ if (MsgCode == FAILURE)\ return ((-1) * MONErrNoAck);\ else if (MsgCode != HALT)\ return ((-1) * MONErrCantRecvMsg);\ Mini_unpack_halt_msg(&halt1, &halt2, &halt3, &halt4);\ }; #define SEND_AND_WAIT_ACK(x) {\ INT32 MsgCode;\ if (Mini_msg_send() != SUCCESS)\ return((-1)*MONErrCantSendMsg);\ SIGINT_POLL \ MsgCode = Wait_For_Ack();\ if (MsgCode == ABORT_FAILURE)\ return (UDIErrorAborted);\ else if (MsgCode == FAILURE)\ return ((-1) * MONErrNoAck);\ else if (MsgCode == ERROR)\ ReturnedError = 1; \ else if (MsgCode != (INT32) (x))\ return ((-1) * MONErrCantRecvMsg);\ }; #define MONUDISession 1 static int AllSections=(STYP_ABS|STYP_TEXT|STYP_LIT|STYP_DATA|STYP_BSS); static UDIPId CurrentPID = (UDIPId) UDIProcessProcessor; static UDIUInt32 PreviousProcessorState; static UDIUInt32 ProcessorState; static int TipAlive = 0; static int NumberOfProcesses=0; static int ContinuingSession = 0; static char *TargetType; static char *SecondTarget; static char *CoreFile; static int CoreLoaded; static BreakIdType LastBreakId = 0; static UDIBool SupervisorMode; static UDIBool RealMode; static UDIBool ProtectedMode; static UDIBool VirtualMode; static int BreaksInPlace; /* EB29K */ static int StepCmdGiven = 0; static int ReturnedError=0; static int StopFlag=0; static int Interrupted=0; static int RemoteTarget=0; static int NoStepReqd=0; static int NoChan1Ack=0; static int SendACKFirst=0; static INT32 MsgAlreadyInBuffer = 0; static INT32 MsgAlreadyReceived = 0; static int Channel0Busy=0; unsigned long TimeOut; int MessageRetries; int BlockCount; int DelayFactor; unsigned int MaxMsgBufSize; extern int lpt_initialize; /* global */ extern int use_parport; /* global */ static UDISizeT ErrCntRemaining=(UDISizeT) 0; static FILE *coff_in; static char buffer[LOAD_BUFFER_SIZE]; /* used in input/output routines */ #define TIP_IO_BUFSIZE 1024 static char channel0_buffer[TIP_IO_BUFSIZE]; static UDISizeT Channel0_count=0; static char channel1_buffer[TIP_IO_BUFSIZE]; static UDISizeT Channel1_count=0; static char channel2_buffer[TIP_IO_BUFSIZE]; static UDISizeT Channel2_count=0; static UDIUInt32 Lr4_count; static UDIUInt32 TotalDone=(UDIUInt32) 0; static CPUOffset Lr3_addr; #define TIP_COOKED 0 /* default */ #define TIP_RAW 1 #define TIP_CBREAK 2 #define TIP_ECHO 4 #define TIP_ASYNC 8 #define TIP_NBLOCK 0x10 static UDIUInt32 PgmStdinMode=TIP_COOKED; /* default */ static UDIUInt32 StdinCharsNeeded=0; /* Cache register values */ static UDIUInt32 Glob_Regs[128], Loc_Regs[128]; static int RefreshRegs = 1; static int exitstat; static char ConnectString[512]; static char TempArgString[1024]; static struct tip_break_table *bp_table=NULL; /* Global variables */ TIP_TARGET_CONFIG tip_target_config; TIP_TARGET_STATUS tip_target_status; TIP_CONFIG tip_config; char *Msg_Logfile; FILE *MsgFile; /* ------------- Minimon TIP Specific Error Codes ------------ */ #define MONNoError 0 #define MONErrCantSendMsg 1 #define MONErrCantRecvMsg 2 #define MONErrCantLoadROMfile 3 #define MONErrCantInitMsgSystem 4 #define MONErrCantBreakInROM 5 #define MONErrCantResetComm 6 #define MONErrCantAllocBufs 7 #define MONErrUnknownBreakType 8 #define MONErrNoAck 9 #define MONErrNoSynch 10 #define MONErrCantOpenCoff 11 #define MONErrCantWriteToMem 12 #define MONErrAbortAborted 13 #define MONErrNullConfigString 14 #define MONErrNoTargetType 15 #define MONErrOutofMemory 16 #define MONErrErrorInit 17 #define MONErrErrorRead 18 #define MONErrErrorWrite 19 #define MONErrErrorCopy 20 #define MONErrErrorSetBreak 21 #define MONErrErrorStatBreak 22 #define MONErrErrorRmBreak 23 #define MONErrConfigInterrupt 24 #define MONErrNoConfig 25 #define MONErrMsgInBuf 26 #define MONErrUnknownTIPCmd 27 #define MAX_MONERR 28 static char *monerr_tip[] = { /* 0 */ "No Error.", /* 1 */ "Could not send message to target.", /* 2 */ "Did not receive the correct ACK from target.", /* 3 */ "Cant load ROM file.", /* 4 */ "Cant initialize the message system.", /* 5 */ "Cant set breakpoint in ROM.", /* 6 */ "Cant reset communication channel.", /* 7 */ "Cant reallocate message buffers.", /* 8 */ "Breakpoint type requested is not recognized.", /* 9 */ "No ACK from target - timed out.", /* 10 */ "Timed out synching. No response from target.", /* 11 */ "Cannot open ROM file.", /* 12 */ "Cannot write to memory while downloading ROM file.", /* 13 */ "Ctrl-C aborted previous Ctrl-C processing.", /* 14 */ "Null configuration string specified for connection.", /* 15 */ "No Target type specified for connection.", /* 16 */ "Out of memory.", /* 17 */ "Error on target - trying to initialize process.", /* 18 */ "Error on target - trying to read.", /* 19 */ "Error on target - trying to write.", /* 20 */ "Error on target - trying to do copy.", /* 21 */ "Error on target - trying to set breakpoint.", /* 22 */ "Error on target - trying to query breakpoint.", /* 23 */ "Error on target - trying to remove breakpoint.", /* 24 */ "User interrupt signal received - Aborting synch.", /* 25 */ "Couldn't get target config after reset. Try again.", /* 26 */ "Message received from target waiting in buffer.", /* 27 */ "Unknown Montip command, Exiting TIP mode." }; #define MAX_MONERR_SIZE 80 /* ---------------- Error Codes -------------------------------- */ /* Function declarations */ extern void IntHandler PARAMS((int num)); extern void print_recv_bytes PARAMS((void)); extern void set_lpt PARAMS((void)); extern void unset_lpt PARAMS((void)); static FILE *FindFile PARAMS((char *)); static char *GetTargetType PARAMS((char *, char *)); static INT32 SendConfigWait PARAMS((void)); extern void SendACK PARAMS((void)); static int parse_string PARAMS((char *string)); static int write_args PARAMS((char *argstr, ADDR32 argstart, ADDR32 * datahigh)); static int write_argv PARAMS((int arg_count, char *arg_ptr[], ADDR32 argstart, ADDR32 * hi_data)); static INT32 SpaceMap_udi2mm PARAMS((CPUSpace space)); static CPUSpace SpaceMap_mm2udi PARAMS((INT32 space)); static int Reset_Processor PARAMS((void)); static INT32 Wait_For_Ack PARAMS((void)); static void process_target_msg PARAMS((INT32 msgcode)); static void process_HALT_msg PARAMS((void)); static INT32 process_chan0_ack PARAMS((void)); static void process_CHAN1_msg PARAMS((void)); static void process_CHAN2_msg PARAMS((void)); static void process_stdin_needed_req PARAMS((void)); static void set_stdin_mode PARAMS((void)); static void process_ERR_msg PARAMS((void)); static void process_HIF_msg PARAMS((void)); static int PutAllBreakpoints PARAMS((void)); static int ResetAllBreakpoints PARAMS((void)); static int Write_Glob_Reg PARAMS((INT32 RegVal, int RegNum)); /* * these three functions are called from HIF/IO handlers to do terminal * input/output. */ extern void set_stdin_needed PARAMS((ADDR32 offset, UDICount count)); extern void set_stderr_ready PARAMS((ADDR32 offset, UDICount count)); extern void set_stdout_ready PARAMS((ADDR32 offset, UDICount count)); static INT32 Mini_load_coff PARAMS((char *fname, INT32 space, INT32 sym, INT32 sects, int msg)); static int update_breakpt_at PARAMS((INT32 space, ADDR32 addr, ADDR32 Inst)); static int is_breakpt_at PARAMS((INT32 space, ADDR32 addr)); static void add_to_bp_table PARAMS((BreakIdType * id, INT32 space, ADDR32 offset, INT32 count, INT32 type, ADDR32 inst)); static int get_from_bp_table PARAMS((BreakIdType id, INT32 * space, ADDR32 * offset, INT32 * count, INT32 * type, ADDR32 * inst)); static int remove_from_bp_table PARAMS((BreakIdType id)); extern INT32 CheckForMsg PARAMS((INT32 time)); extern int service_HIF PARAMS((UINT32 svcnm, UINT32 lr2, UINT32 lr3, UINT32 lr4, UINT32 * gr96, UINT32 * gr97, UINT32 * gr121)); /* ================================================================= */ /* UDI Procedure definitions */ UDIError UDIConnect(string, Session) char *string; UDISessionId *Session; { INT32 MsgCode; int retval; if (TipAlive) { /* already connected */ /* If same TargetType requested, return ConnectionUnavailable */ SecondTarget = NULL; if ((SecondTarget = GetTargetType (SecondTarget, string)) == NULL) return (UDIErrorInvalidTIPOption); if (strcmp (SecondTarget, TargetType) == 0) return (UDIErrorConnectionUnavailable); else return (UDIErrorTryAnotherTIP); } else { if (ContinuingSession) { ContinuingSession=0; /* reset */ *Session = (UDISessionId) MONUDISession; if ((int) (ProcessorState & 0xFF) != UDINotExecuting) {/* none active */ CurrentPID = (UDIPId) (UDIProcessProcessor+1); NumberOfProcesses=1; }; TipAlive = 1; return (UDINoError); } /* Initialize variables */ /* Take control of Ctrl-C until connect time */ signal (SIGINT, IntHandler); CoreFile = NULL; TargetType = NULL; Msg_Logfile = NULL; CoreLoaded = 0; CurrentPID = (UDIPId) UDIProcessProcessor; SupervisorMode = 0; RealMode = 0; ProtectedMode = 1; /* default */ VirtualMode = 0; BreaksInPlace = 0; /* EB29K */ TimeOut = (unsigned long) 10000; MessageRetries = (int) 1000; #ifdef MSDOS BlockCount = (int) 1000; #else BlockCount = (int) 40000; #endif DelayFactor = (int) 0; MaxMsgBufSize = (unsigned int) 0; Channel0_count = 0; Channel1_count = 0; Channel2_count = 0; Channel0Busy=0; *Session = (UDISessionId) MONUDISession; TipAlive = 1; /* no more positive error codes */ /* TIP_CONFIG initialization */ tip_config.PC_port_base = (INT32) - 1; /* default */ tip_config.PC_mem_seg = (INT32) - 1; /* default */ (void) strcpy(tip_config.baud_rate, DEFAULT_BAUD_RATE); (void) strcpy(tip_config.comm_port, DEFAULT_COMM_PORT); (void) strcpy(tip_config.par_port, DEFAULT_PAR_PORT); /* Get the CFG register value to find out 29kEndian */ tip_target_config.P29KEndian = BIG; /* default */ if ((retval = parse_string(string)) != (int) 0) return ((UDIError) retval); if (TargetType == NULL) return ((-1) * MONErrNoTargetType); /* Open Msg_Logfile if any */ if (Msg_Logfile) { if ((MsgFile = fopen(Msg_Logfile, "w")) == NULL) Msg_Logfile = NULL; } /* Initialize message system */ if (Mini_msg_init(TargetType) != SUCCESS) { *Session = (UDISessionId) MONUDISession; TipAlive = 1; return ((-1) * MONErrCantInitMsgSystem); } /* Reset communication channel */ Mini_reset_comm(); /* * Should we have different TIPS: one for shared memory & another for * serial connections? */ if (CoreFile) { if ((MsgCode = Mini_load_coff(CoreFile, (INT32) D_MEM, (INT32) 1, (INT32) AllSections, 0)) != SUCCESS) { *Session = (UDISessionId) MONUDISession; TipAlive = 1; return ((UDIError) MsgCode); } CoreLoaded = 1; /* True */ /* Reset communication channel */ Mini_reset_comm(); Mini_go_target(); /* RESET Target Processor */ } /* Define TIPs endianess */ #ifdef MSDOS tip_target_config.TipEndian = LITTLE; #else tip_target_config.TipEndian = BIG; #endif if (strcmp(TargetType, "serial") && strcmp(TargetType, "paral_1") && strcmp(TargetType, "pcserver")) { /* non-serial targets */ RemoteTarget = 0; /* not a remote target */ } else { RemoteTarget = 1; /* remote target */ SendACKFirst = 1; /* safe to send always */ } if (RemoteTarget == 0) { /* shared memory */ MsgCode = Wait_For_Ack(); if (MsgCode == ABORT_FAILURE) return (UDIErrorAborted); else if (MsgCode == FAILURE) return((-1) * MONErrNoSynch); } if (SendACKFirst) SendACK(); /* send a config msg to sync with target */ do { MsgCode = SendConfigWait(); } while (MsgCode == HALT); if (MsgCode == ABORT_FAILURE) return (UDIErrorAborted); else if (MsgCode == FAILURE) return ((-1) * MONErrNoSynch); else if (MsgCode != CONFIG) return ((-1) * MONErrCantRecvMsg); Mini_unpack_config_msg(&tip_target_config); /* Reallocate message buffers to the smallest, if necessary */ if ((MaxMsgBufSize != (unsigned int) 0) && (MaxMsgBufSize < (unsigned int) tip_target_config.max_msg_size)) tip_target_config.max_msg_size = (INT32) MaxMsgBufSize; if (Mini_alloc_msgbuf((int) tip_target_config.max_msg_size) != SUCCESS) return ((-1) * MONErrCantAllocBufs); ProcessorState = (UDIUInt32) UDINotExecuting; PreviousProcessorState = (UDIUInt32) UDINotExecuting; return (UDINoError); } } UDIError UDIDisconnect(Session, Terminate) UDISessionId Session; UDIBool Terminate; { if (Session != (UDISessionId) MONUDISession) return (UDIErrorNoSuchConnection); if (Terminate == (UDIBool) UDITerminateSession) { if (CoreFile) (void) free((char *) CoreFile); if (TargetType) (void) free((char *) TargetType); Mini_msg_exit(); /* clean up message buffers */ if (Msg_Logfile) (void) fclose(MsgFile); ProcessorState = (UDIUInt32) UDINotExecuting; PreviousProcessorState = (UDIUInt32) UDINotExecuting; } else { ContinuingSession=1; }; if ((int) (ProcessorState & 0xFF) == UDINotExecuting) {/* none active */ CurrentPID = (UDIPId) UDIProcessProcessor; NumberOfProcesses=0; } TipAlive = 0; return (UDINoError); } UDIError UDISetCurrentConnection(Session) UDISessionId Session; { if (Session != (UDISessionId) MONUDISession) return (UDIErrorNoSuchConnection); return (UDINoError); } UDIError UDICapabilities ( TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId, TIPIPCId, TIPString) UDIUInt32 *TIPId; /* Out */ UDIUInt32 *TargetId; /* Out */ UDIUInt32 DFEId; /* In */ UDIUInt32 DFE; /* In */ UDIUInt32 *TIP; /* Out */ UDIUInt32 *DFEIPCId; /* Out */ UDIUInt32 *TIPIPCId; /* Out */ char *TIPString; /* Out */ { *TIPId = (UDIUInt32) UDIID (UDIProductCode_Montip, MONTIPRev, MONTIPSubRev, MONTIPSubSubRev); *TargetId = (UDIUInt32) UDIID (UDIProductCode_Montip, MONTIPRev, MONTIPSubRev, MONTIPSubSubRev); if ((int) (DFE & 0x00000FFF) > (int) (MONTIPUDIVers)) { *TIP = (UDIUInt32) 0; } else if ((int) (DFE & 0x00000FFF) == (int) MONTIPUDIVers) { *TIP = (UDIUInt32) DFE; } else { *TIP = (UDIUInt32) MONTIPUDIVers; } *DFEIPCId = (UDIUInt32) 0; *TIPIPCId = (UDIUInt32) 0; (void) strcpy (TIPString, "UDI 1.2 Conformant Montip for 29K targets\0"); return (UDINoError); } UDIError UDIGetErrorMsg (ErrorCode, MsgSize, Msg, CountDone) UDIError ErrorCode; /* In */ UDISizeT MsgSize; /* In */ char *Msg; /* Out */ UDISizeT *CountDone; /* Out */ { int index; /* Continue Previous Error Message */ if (ErrCntRemaining != (UDISizeT) 0) { index = (int) (strlen(monerr_tip[-ErrorCode]) + 1 - ErrCntRemaining); if (MsgSize < (UDISizeT) ErrCntRemaining) { (void) strncpy((char *) Msg, (char *) (monerr_tip[-ErrorCode]+index), MsgSize); *CountDone = MsgSize; ErrCntRemaining = ErrCntRemaining - MsgSize; } else { (void) strcpy((char *) Msg, (char *) (monerr_tip[-ErrorCode]+index)); *CountDone = (UDISizeT) strlen(Msg) + 1; ErrCntRemaining = (UDISizeT) 0; } return (UDINoError); }; /* A New ErrorCode */ if ((ErrorCode <= 0) && (ErrorCode > (-1) * MAX_MONERR)) { if (MsgSize < (UDISizeT) MAX_MONERR_SIZE) { (void) strncpy((char *) Msg, monerr_tip[-ErrorCode], MsgSize); *CountDone = MsgSize; ErrCntRemaining = (UDISizeT) (strlen(monerr_tip[-ErrorCode])+1) - MsgSize; } else { (void) strcpy((char *) Msg, monerr_tip[-ErrorCode]); *CountDone = (UDISizeT) strlen(Msg) + 1; ErrCntRemaining = (UDISizeT) 0; } return (UDINoError); } else { return (UDIErrorUnknownError); }; } UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions, NumberOfChips) UDIMemoryRange KnownMemory[]; /* Out */ UDIInt *NumberOfRanges; /* In/Out */ UDIUInt32 ChipVersions[]; /* Out */ UDIInt *NumberOfChips; /* In/Out */ { UDIInt InRanges, InChips; int Incomplete; Incomplete = 0; InRanges = *NumberOfRanges; InChips = *NumberOfChips; if ((InRanges < (UDIInt) MONMaxMemRanges) || (InChips < (UDIInt) MONMaxChips)) Incomplete = 1; *NumberOfRanges = (UDIInt) 0; switch ((int) InRanges) { default: case 3 /* MONMaxMemRanges */: if (*NumberOfRanges == (UDIInt) 0) *NumberOfRanges = (UDIInt) 3; KnownMemory[2].Space = (CPUSpace) UDI29KIRAMSpace; KnownMemory[2].Offset = (CPUOffset) tip_target_config.I_mem_start; KnownMemory[2].Size = (CPUSizeT) tip_target_config.I_mem_size; case 2: if (*NumberOfRanges == (UDIInt) 0) *NumberOfRanges = (UDIInt) 2; KnownMemory[1].Space = (CPUSpace) UDI29KDRAMSpace; KnownMemory[1].Offset = (CPUOffset) tip_target_config.D_mem_start; KnownMemory[1].Size = (CPUSizeT) tip_target_config.D_mem_size; case 1: if (*NumberOfRanges == (UDIInt) 0) *NumberOfRanges = (UDIInt) 1; KnownMemory[0].Space = (CPUSpace) UDI29KIROMSpace; KnownMemory[0].Offset = (CPUOffset) tip_target_config.ROM_start; KnownMemory[0].Size = (CPUSizeT) tip_target_config.ROM_size; break; case 0: *NumberOfRanges = (UDIInt) 0; break; } *NumberOfChips = (UDIInt) 0; switch ((int) InChips) { default: case 2: /* MONMaxChips */ if (*NumberOfChips == (UDIInt) 0) *NumberOfChips = (UDIInt) 2; if (tip_target_config.coprocessor == (UINT32) -1) ChipVersions[1] = (UDIUInt32) UDI29KChipNotPresent; else ChipVersions[1] = (UDIUInt32) tip_target_config.coprocessor; case 1: if (*NumberOfChips == (UDIInt) 0) *NumberOfChips = (UDIInt) 1; ChipVersions[0] = (UDIUInt32) tip_target_config.processor_id; break; case 0: *NumberOfChips = (UDIInt) 0; break; } if (Incomplete) return (UDIErrorIncomplete); else return (UDINoError); } UDIError UDICreateProcess(pid) UDIPId *pid; { if (CurrentPID == (UDIPId) (UDIProcessProcessor + 1)) return (UDIErrorCantCreateProcess); CurrentPID = (UDIPId) (UDIProcessProcessor + 1); NumberOfProcesses=1; *pid = (UDIPId) CurrentPID; return (UDINoError); } UDIError UDISetCurrentProcess(pid) UDIPId pid; { if ((pid > (UDIPId) (UDIProcessProcessor + 1)) || (pid < (UDIPId) (UDIProcessProcessor))) return (UDIErrorNoSuchProcess); if ((NumberOfProcesses == (int) 0) && (pid != (UDIPId) UDIProcessProcessor)) return (UDIErrorNoSuchProcess); CurrentPID = pid; return (UDINoError); } UDIError UDIDestroyProcess(pid) UDIPId pid; { if ((pid > (UDIPId) (UDIProcessProcessor + 1)) || (pid < (UDIPId) (UDIProcessProcessor))) return (UDIErrorNoSuchProcess); CurrentPID = (UDIPId) UDIProcessProcessor; ProcessorState = (UDIUInt32) UDINotExecuting; PreviousProcessorState = (UDIUInt32) UDINotExecuting; NumberOfProcesses=0; return (UDINoError); } UDIError UDIInitializeProcess (ProcessMemory, NumberOfRanges, EntryPoint, StackSizes, NumberOfStacks, ArgString) UDIMemoryRange ProcessMemory[]; /* In */ UDIInt NumberOfRanges; /* In */ UDIResource EntryPoint; /* In */ CPUSizeT StackSizes[]; /* In */ UDIInt NumberOfStacks; /* In */ char *ArgString; /* In */ { UDIError ErrCode; UDIRange text_addr, data_addr; CPUSizeT mem_stack_size, reg_stack_size; ADDR32 arg_start; ADDR32 data_high; ADDR32 highmem; INT32 os_control; INT32 MsgCode; UDIInt i; exitstat = 0; /* reset */ PgmStdinMode=TIP_COOKED; /* revert to default mode */ CLEAR_PENDING_STOP if (CurrentPID == (UDIPId) UDIProcessProcessor) { if ((MsgCode = Reset_Processor()) != SUCCESS) return ((UDIError) MsgCode); do { MsgCode = SendConfigWait(); } while (MsgCode == HALT); if (MsgCode == ABORT_FAILURE) return (UDIErrorAborted); else if (MsgCode == FAILURE) return ((-1) * MONErrNoSynch); else if (MsgCode != CONFIG) return ((-1) * MONErrCantRecvMsg); Mini_unpack_config_msg(&tip_target_config); /* Reallocate message buffers */ if (Mini_alloc_msgbuf((int) tip_target_config.max_msg_size) != SUCCESS) return ((-1) * MONErrCantAllocBufs); ProcessorState = (UDIUInt32) UDINotExecuting; Channel0_count = 0; Channel1_count = 0; Channel2_count = 0; Channel0Busy = 0; PreviousProcessorState = (UDIUInt32) UDINotExecuting; return (UDINoError); }; /* For other processes */ /* Set Default Values */ mem_stack_size = (CPUSizeT) MONDefaultMemStackSize; reg_stack_size = (CPUSizeT) MONDefaultRegStackSize; text_addr.Low = (CPUOffset) tip_target_config.I_mem_start; text_addr.High = (CPUOffset) tip_target_config.I_mem_start + (CPUOffset) tip_target_config.I_mem_size - 1; data_addr.Low = (CPUOffset) tip_target_config.D_mem_start; data_addr.High = (CPUOffset) tip_target_config.D_mem_start + (CPUOffset) tip_target_config.D_mem_size - (CPUOffset) (mem_stack_size + reg_stack_size + 16) - 1; /* Get Memory Ranges */ if (NumberOfRanges != (UDIInt) 0) { for (;NumberOfRanges--;) { switch ((int) ProcessMemory[NumberOfRanges].Space) { case UDI29KIRAMSpace: text_addr.Low = ProcessMemory[NumberOfRanges].Offset; text_addr.High = ProcessMemory[NumberOfRanges].Offset + (CPUOffset) ProcessMemory[NumberOfRanges].Size; break; case UDI29KDRAMSpace: data_addr.Low = ProcessMemory[NumberOfRanges].Offset; data_addr.High = ProcessMemory[NumberOfRanges].Offset + (CPUOffset) ProcessMemory[NumberOfRanges].Size; break; default: /* don't care */ break; } /* switch */ } /* for */ } /* Get Stack Sizes */ for (i = (UDIInt) 0; i < NumberOfStacks; i=i+(UDIInt)1) { switch ((int) i) { case 0: /* register stack size */ if (StackSizes[0] != (CPUSizeT) 0) reg_stack_size = StackSizes[0]; break; case 1: /* memory stack size */ if (StackSizes[1] != (CPUSizeT) 0) mem_stack_size = StackSizes[1]; break; default: /* don't care */ break; } } if ((CPUOffset) text_addr.High > (CPUOffset) data_addr.High) data_addr.High = text_addr.High; /* when no data sections */ arg_start = (data_addr.High + 7) & ~0x7; /* word boundary */ if ((ErrCode = write_args(ArgString, arg_start, &data_high)) != UDINoError) return (ErrCode); data_addr.High = (data_high + 7) & ~0x7; /* double word bdry */ highmem = (ADDR32) 0; /* User programs run mode */ if (SupervisorMode) os_control = (INT32) 0x10000000; /* set bit 28 only */ else if (VirtualMode || ProtectedMode) os_control = (INT32) 0; else os_control = (INT32) 0x80000000; Mini_build_init_msg((ADDR32) text_addr.Low, (ADDR32) text_addr.High, (ADDR32) data_addr.Low, (ADDR32) data_addr.High, (ADDR32) EntryPoint.Offset, (INT32) mem_stack_size, (INT32) reg_stack_size, (ADDR32) highmem, (ADDR32) arg_start, (INT32) os_control); SEND_AND_WAIT_ACK(INIT_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorInit); } Mini_unpack_init_ack_msg(); ProcessorState = (UDIUInt32) UDINotExecuting; PreviousProcessorState = (UDIUInt32) UDINotExecuting; return (UDINoError); } UDIError UDIRead(from, to, count, size, count_done, host_endian) UDIResource from; UDIHostMemPtr to; UDICount count; UDISizeT size; UDICount *count_done; UDIBool host_endian; { INT32 space = SpaceMap_udi2mm(from.Space); INT32 done; INT32 ttl_count; INT32 msg_count; INT32 overhead; ADDR32 ack_addr; INT32 ack_space; BYTE *output; UDIError UDIretval; UDICount i; INT32 *Version; int Gr1_val; int Lrnum; int j; UDIResource temp_from; UDICount temp_done; UDIUInt32 start_offset, end_offset; BYTE *reg_data; CLEAR_PENDING_STOP if (count <= (UDICount) 0) { *count_done = (UDICount) 0; return (UDINoError); } if (space == (INT32) VERSION_SPACE) { /* minimon ver cmd */ Version = (INT32 *) to; *Version = (INT32) tip_target_config.version; *(Version+1) = (INT32) tip_target_config.os_version; /* TIPVERSION must be 11 chars or less */ strcpy((char *) (Version+2),TIPVERSION); /* TIPDATE must be 11 chars or less */ strcpy((char *) (Version+5),TIPDATE); /* max msg size */ *(Version + 8) = tip_target_config.max_msg_size; /* max bkpts */ *(Version + 9) = tip_target_config.max_bkpts; if ((host_endian) && (tip_target_config.TipEndian != tip_target_config.P29KEndian)) { output = (BYTE *) to; for (i = 0; i < count; i++) { if (size == 4) tip_convert32(output); else if (size == 2) tip_convert16(output); output = output + size; } } /* hostendian */ *count_done = (UDICount) count; return (UDINoError); }; if (space < (INT32) 0) { *count_done = (UDICount) 0; return (UDIErrorUnknownResourceSpace); } output = (BYTE *) to; switch (from.Space) { case UDI29KPC: from.Offset = 1; /* PC1 */ break; case UDI29KGlobalRegs: break; case UDI29KRealRegs: /* REAL REGS BEGIN */ /* get global and local reg values from target if target exec'ed */ if (RefreshRegs) { RefreshRegs = 0; /* reset */ temp_from.Offset = (CPUOffset) 0; temp_from.Space = UDI29KGlobalRegs; if ((UDIretval = UDIRead(temp_from, (UDIHostMemPtr) &Glob_Regs[0], (UDICount) 2, (UDISizeT) 4, (UDICount *) &temp_done, (UDIBool) TRUE)) != UDINoError) /* gr0, gr1 */ return (UDIretval); /* UDIRead (); gr64 to gr 127 */ temp_from.Offset = (CPUOffset) 64; temp_from.Space = UDI29KGlobalRegs; if ((UDIretval = UDIRead(temp_from, (UDIHostMemPtr) &Glob_Regs[64], (UDICount) 64, (UDISizeT) 4, (UDICount *) &temp_done, (UDIBool) TRUE)) != UDINoError) /* gr0, gr1 */ return (UDIretval); /* UDIRead (); lr0 to lr127 */ temp_from.Offset = (CPUOffset) 0; temp_from.Space = UDI29KLocalRegs; if ((UDIretval = UDIRead(temp_from, (UDIHostMemPtr) &Loc_Regs[0], (UDICount) 128, (UDISizeT) 4, (UDICount *) &temp_done, (UDIBool) TRUE)) != UDINoError) /* gr0, gr1 */ return (UDIretval); }; start_offset = from.Offset; end_offset = start_offset + count; output = (BYTE *) to; while (start_offset < end_offset) { /* do only if count is non zero */ if (start_offset <= (UDIUInt32) 127) { reg_data = (BYTE *) &Glob_Regs[(int) start_offset]; for (j = 0; j < 4 /* sizeof (UDIUInt32) */ ; j++) *output++ = *reg_data++; } else if ((start_offset >= (UDIUInt32) 128) && (start_offset <= (UDIUInt32) 255)) { Gr1_val = (int) (Glob_Regs[1] & 0x000001FC) >> 2; /* bits 2 to 8 */ Lrnum = (int) ((int) start_offset - Gr1_val) % 128; reg_data = (BYTE *) & Loc_Regs[(int) Lrnum]; for (j = 0; j < 4 /* sizeof (UDIUInt32) */ ; j++) *output++ = *reg_data++; } else return (UDIErrorUnknownResourceSpace); start_offset = start_offset + (UDIUInt32) 1; } /* end while */ *count_done = (UDICount) count; return (UDINoError); /* REAL REGS END */ default: break; } output = (BYTE *) to; if ( (RemoteTarget == 0) && ((from.Space == UDI29KDRAMSpace) || (from.Space == UDI29KIRAMSpace) || (from.Space == UDI29KIROMSpace))) { /* shared memory board */ Mini_read_memory(space, from.Offset, count * size, (BYTE *) output); } else { /* overhead = checksum + header + size rounding + bfr rounding + ? */ overhead = 32; ttl_count = count; output = (BYTE *) to; while (ttl_count > 0) { /* Check for user interrupt */ if (StopFlag) { STOP_SIG_HDLR ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = (UDIUInt32) UDIStopped; return (UDIErrorAborted); }; /* Check possible buffer overflow */ if ((ttl_count * size) + overhead > #ifdef MSDOS tip_target_config.max_msg_size) { msg_count = (tip_target_config.max_msg_size-overhead) >> (size >> 1); #else (INT32) 256) { /* SunOS has problems with higher numbers */ msg_count = (256 - overhead) >> (size >> 1); #endif ttl_count = ttl_count - msg_count; } else { msg_count = ttl_count; ttl_count = ttl_count - msg_count; } Mini_build_read_req_msg(space, (ADDR32) from.Offset, msg_count, size); SEND_AND_WAIT_ACK(READ_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorRead); } Mini_unpack_read_ack_msg((INT32 *) &ack_space, (ADDR32 *) &ack_addr, (INT32 *) &done, (BYTE *) output); output = output + (msg_count * size); if (ISMEM(space)) from.Offset = from.Offset + (CPUOffset) (msg_count * size); else from.Offset = from.Offset + (CPUOffset) msg_count; } } /* end while */ if ((host_endian) && (tip_target_config.TipEndian != tip_target_config.P29KEndian)) { output = (BYTE *) to; for (i = 0; i < count; i++) { if (size == 4) tip_convert32(output); else if (size == 2) tip_convert16(output); output = output + size; } } /* hostendian */ *count_done = (UDICount) count; return (UDINoError); } UDIError UDIWrite(from, to, count, size, count_done, HostEndian) UDIHostMemPtr from; UDIResource to; UDICount count; UDISizeT size; UDICount *count_done; UDIBool HostEndian; { INT32 space = SpaceMap_udi2mm(to.Space); INT32 done; INT32 ttl_count; INT32 msg_count; INT32 overhead; ADDR32 ack_addr; INT32 ack_space; BYTE *input; UDIError UDIretval; UDIUInt32 tmpbuf[2]; UDICount i; /* REAL REGS BEGIN */ UDIResource temp_to; UDICount temp_done; CPUOffset start_offset, end_offset; UDIUInt32 Gr1_val; /* REAL REGS END */ CLEAR_PENDING_STOP if (space < (INT32) 0) { *count_done = (UDICount) 0; return (UDIErrorUnknownResourceSpace); } if (count <= (UDICount) 0) { *count_done = (UDICount) 0; return (UDINoError); } if (to.Space == UDI29KPC) { /* when writing UDI29KPC, set both PC1 and PC0 */ /* NOTE: this assumes we are not in freeze mode */ /* this must all be done before doing the endian conversion below */ to.Offset = 0; /* start at PC0 */ count = (UDIInt32) 2; /* writing 2 4-byte quantities */ tmpbuf[1] = *((UDIUInt32 *) from); /* PC1 = PC */ if (!HostEndian && (tip_target_config.TipEndian != tip_target_config.P29KEndian)) { tmpbuf[0] = tmpbuf[1]; tip_convert32((BYTE *) &tmpbuf[0]); tmpbuf[0] = tmpbuf[0] + 4; /* PC0 = PC + 4 */ tip_convert32((BYTE *) &tmpbuf[0]); } else { tmpbuf[0] = tmpbuf[1] + 4; /* PC0 = PC + 4 */ } from = (UDIHostMemPtr) tmpbuf; /* set pointer to temporary (8-byte) * buffer */ } switch (to.Space) { case UDI29KLocalRegs: RefreshRegs = 1; break; case UDI29KPC: /* PC causes special regs(PC0,PC1) space */ break; case UDI29KGlobalRegs: RefreshRegs = 1; break; case UDI29KRealRegs: RefreshRegs = 1; /* REAL REGS BEGIN */ start_offset = to.Offset; end_offset = start_offset + count - 1; if ((end_offset <= 127)) { /* all globals asked */ temp_to.Offset = to.Offset; temp_to.Space = UDI29KGlobalRegs; if ((UDIretval = UDIWrite(from, temp_to, count, size, &temp_done, HostEndian)) != UDINoError) return (UDIretval); } else if (start_offset > 127) { /* all local regs */ /* read gr1 */ temp_to.Offset = (CPUOffset) 1; temp_to.Space = UDI29KGlobalRegs; if ((UDIretval = UDIRead(temp_to, (UDIHostMemPtr) &Gr1_val, (UDICount) 1, (UDISizeT) 4, (UDICount *) &temp_done, (UDIBool) TRUE)) != UDINoError) /* gr1 */ return (UDIretval); /* recompute start_offset and end_offset */ Gr1_val = (Gr1_val & 0x01FC) >> 2; start_offset = (start_offset - Gr1_val) % 128; end_offset = (end_offset - Gr1_val) % 128; input = (BYTE *) from; if (start_offset > end_offset) { /* wrap around */ temp_to.Offset = start_offset; temp_to.Space = UDI29KLocalRegs; if ((UDIretval = UDIWrite(input, temp_to, (UDICount) (128 - start_offset), size, &temp_done, HostEndian)) != UDINoError) return (UDIretval); input = input + (int) ((128 - start_offset) * size); temp_to.Offset = (CPUOffset) 0; /* from LR0 */ temp_to.Space = UDI29KLocalRegs; if ((UDIretval = UDIWrite(input, temp_to, (UDICount) (end_offset + 1 ), size, &temp_done, HostEndian)) != UDINoError) return (UDIretval); } else { /* no wrapping */ temp_to.Offset = start_offset; temp_to.Space = UDI29KLocalRegs; if ((UDIretval = UDIWrite(input, temp_to, count, size, &temp_done, HostEndian)) != UDINoError) return (UDIretval); } } else { /* overlap */ input = (BYTE *) from; /* write globals */ temp_to.Offset = start_offset; temp_to.Space = UDI29KGlobalRegs; if ((UDIretval = UDIWrite(input, temp_to, ((UDICount) 128 - (UDICount) start_offset), size, &temp_done, HostEndian)) != UDINoError) return (UDIretval); input = input + (int) (size) * ((UDICount) 128 - (UDICount) start_offset); /* write locals */ temp_to.Offset = (CPUOffset) 128; temp_to.Space = UDI29KRealRegs; if ((UDIretval = UDIWrite(input, temp_to, (UDICount) (count - 128 + start_offset), size, &temp_done, HostEndian)) != UDINoError) return (UDIretval); } *count_done = (UDICount) count; return (UDINoError); /* REAL REGS END */ default: break; } if (HostEndian && (tip_target_config.TipEndian != tip_target_config.P29KEndian)) { input = (BYTE *) from; for (i = 0; i < count; i++) { if (size == 4) tip_convert32(input); else if (size == 2) tip_convert16(input); input = input + size; } }; /* endian conversion done */ input = (BYTE *) from; if ((RemoteTarget == 0) && ((to.Space == UDI29KDRAMSpace) || (to.Space == UDI29KIRAMSpace) || (to.Space == UDI29KIROMSpace))) { Mini_write_memory(space, to.Offset, count * size, (BYTE *) input); *count_done = (UDICount) count; return (UDINoError); } else { /* remote */ /* overhead = checksum + header + size rounding + bfr rounding + ? */ overhead = 32; ttl_count = count; input = (BYTE *) from; while (ttl_count > 0) { /* Check for user interrupt */ if (StopFlag) { STOP_SIG_HDLR ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = (UDIUInt32) UDIStopped; return (UDIErrorAborted); }; /* Check possible buffer overflow */ if ((ttl_count * size) + overhead > tip_target_config.max_msg_size) { msg_count = (tip_target_config.max_msg_size-overhead) >> (size >> 1); ttl_count = ttl_count - msg_count; } else { msg_count = ttl_count; ttl_count = ttl_count - msg_count; } Mini_build_write_req_msg(space, (ADDR32) to.Offset, msg_count, size, (BYTE *) input); SEND_AND_WAIT_ACK(WRITE_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorWrite); } Mini_unpack_write_ack_msg((INT32 *) &ack_space, (ADDR32 *) &ack_addr, (INT32 *) &done); input = input + (msg_count * size); if (ISMEM(space)) to.Offset = to.Offset + (CPUOffset) (msg_count * size); else to.Offset = to.Offset + (CPUOffset) msg_count; } /* while */ } /* end remote */ *count_done = (to.Space == UDI29KPC) ? (UDICount) 1 : (UDICount) count; return (UDINoError); } UDIError UDICopy(from, to, count, size, count_done, direction) UDIResource from; UDIResource to; UDICount count; UDISizeT size; UDICount *count_done; UDIBool direction; { INT32 f_space = SpaceMap_udi2mm(from.Space); INT32 t_space = SpaceMap_udi2mm(to.Space); UDICount counter, maxcount,curcount; INT32 fill_count, fill_size; INT32 done; ADDR32 ack_saddr, ack_daddr; CLEAR_PENDING_STOP if ((t_space < 0) || (f_space < 0)) { *count_done = (UDICount) 0; return (UDIErrorUnknownResourceSpace); } if (count <= (UDICount) 0) { *count_done = (UDICount) 0; return (UDINoError); } RefreshRegs = 1; /* Split the copy to smaller copies based on the message size */ maxcount = (UDICount) (tip_target_config.max_msg_size / size); counter = (UDICount) count; while (counter > (UDICount) 0) { /* Check for user interrupt */ if (StopFlag) { STOP_SIG_HDLR ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = (UDIUInt32) UDIStopped; return (UDIErrorAborted); }; curcount = (maxcount < counter) ? maxcount : counter; counter = counter - curcount; if ((size > (UDISizeT) 4) && (t_space == (INT32) I_MEM)) { /* reduce it to 4, must be a multiple also for I_MEM */ fill_count = (INT32) (curcount * (size/4)); fill_size = (INT32) size; } else if ((size > (UDISizeT) 4) && (t_space != (INT32) I_MEM)) { /* copy as bytes */ fill_count = (INT32) (curcount * size); fill_size = (INT32) 1; /* bytes */ } else { fill_count = (INT32) curcount; fill_size = (INT32) size; }; Mini_build_copy_msg(f_space, (ADDR32) from.Offset, t_space, (ADDR32) to.Offset, fill_count, fill_size); SEND_AND_WAIT_ACK(COPY_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorCopy); } Mini_unpack_copy_ack_msg(&f_space, &ack_saddr, &t_space, &ack_daddr, &done); from.Offset = from.Offset + (CPUOffset) (curcount * size); to.Offset = to.Offset + (CPUOffset) (curcount * size); }; /* end while */ *count_done = (UDICount) count; return (UDINoError); } UDIError UDIExecute() { INT32 MsgCode; CLEAR_PENDING_STOP if (!NoStepReqd) { if (!StepCmdGiven) { /* Execute one instruction */ Mini_build_step_msg((INT32) 1); if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); /* process message received from target */ MsgCode = Wait_For_Ack(); if (MsgCode == ABORT_FAILURE) return (UDIErrorAborted); else if (MsgCode == FAILURE) return ((-1) * MONErrNoAck); process_target_msg(MsgCode); /* if processor state is stepped, set breakpoints, issue a GO */ if (ProcessorState != (UDIUInt32) UDIStepped) { RefreshRegs = 1; return (UDINoError); } PutAllBreakpoints(); BreaksInPlace = 1; } } Mini_build_go_msg(); if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); RefreshRegs = 1; ProcessorState = (UDIUInt32) UDIRunning; PreviousProcessorState = (UDIUInt32) UDIRunning; return (UDINoError); } /* * Stepping will NOT cause any breakpoints to be installed. It will step the * number requested. */ UDIError UDIStep(steps, steptype, range) UDIUInt32 steps; UDIStepType steptype; UDIRange range; { CLEAR_PENDING_STOP if (steps == (UDIUInt32) 0) return (UDINoError); if ((steptype & UDIStepOverCalls) || (steptype & UDIStepOverTraps) || (steptype & UDIStepInRange)) return (UDIErrorUnsupportedStepType); StepCmdGiven = 1; Mini_build_step_msg(steps); if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); RefreshRegs = 1; ProcessorState = (UDIUInt32) UDIRunning; PreviousProcessorState = (UDIUInt32) UDIRunning; return (UDINoError); } UDIVoid UDIStop() { int GrossState; GrossState = (int) (ProcessorState & 0xFF); if ((GrossState == UDINotExecuting) || (GrossState == UDIRunning) || (GrossState == UDIStdoutReady) || (GrossState == UDIStderrReady) || (GrossState == UDIStdinNeeded) ) { StopFlag = 1; /* This will be reset after its handled */ } /* Else ignored */ return; } UDIError UDIWait(maxtime, pid, stop_reason) UDIInt32 maxtime; UDIPId *pid; UDIUInt32 *stop_reason; { INT32 MsgCode; *pid = (UDIPId) CurrentPID; if (ProcessorState == (UDIUInt32) UDIRunning) { while (1) { /* handle messages as long as they are coming */ if (MsgAlreadyInBuffer==1) { MsgCode = MsgAlreadyReceived; MsgAlreadyInBuffer=0; } else { MsgCode = CheckForMsg(maxtime); } #if 0 MsgCode = CheckForMsg(maxtime); #endif if ((MsgCode == FAILURE) || (MsgCode == ABORT_FAILURE)) { /* no news */ *stop_reason = ProcessorState; return (UDINoError); } else { /* a message from target has arrived */ *stop_reason = ProcessorState; if (MsgCode == CHANNEL0_ACK) { process_chan0_ack(); return (UDINoError); } (void) process_target_msg(MsgCode); if (ProcessorState != (UDIUInt32) UDIRunning) return (UDINoError); }; } } else { *stop_reason = ProcessorState; return (UDINoError); } } UDIError UDISetBreakpoint(addr, pass_count, bk_type, break_id) UDIResource addr; UDIInt32 pass_count; UDIBreakType bk_type; BreakIdType *break_id; { INT32 space = SpaceMap_udi2mm(addr.Space); ADDR32 ack_addr; INT32 set_count, set_type; BreakIdType newid; UDIUInt32 BreakInst; /* EB29K */ UDIError UDIretval; /* EB29K */ CLEAR_PENDING_STOP if (space < 0) return (UDIErrorUnknownResourceSpace); /* * Minimon currently supports only two types of breakpoints * BKPT_29000 * and BKPT_29050 * */ if (bk_type & MONBreakFlagHardware) { if (bk_type & MONBreakTranslationEnabled) bk_type = BKPT_29050_BTE_1; else bk_type = BKPT_29050_BTE_0; /* default */ } else if ((bk_type & UDIBreakFlagRead) || (bk_type & UDIBreakFlagWrite)) return ((-1) * MONErrUnknownBreakType); else if (bk_type & UDIBreakFlagExecute) bk_type = BKPT_29000; /* Minimon uses this */ if (pass_count == (UDIInt32) 0) pass_count = (UDIInt32) -1; /* make it temporary */ Mini_build_bkpt_set_msg(space, (ADDR32) addr.Offset, (INT32) pass_count, (INT32) bk_type); SEND_AND_WAIT_ACK (BKPT_SET_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorSetBreak); } Mini_unpack_bkpt_set_ack_msg((INT32 *) &space, (ADDR32 *) &ack_addr, (INT32 *) &set_count, (INT32 *) &set_type); BreakInst = (ADDR32) - 1; if (!strcmp(TargetType, "eb29k")) { /* For EB29K */ /* UDIRead(); read instruction */ if ((UDIretval = UDIRead(addr, (UDIHostMemPtr) &BreakInst, (UDICount) 4, (UDISizeT) 1, (UDICount *) &ack_addr, (UDIBool) FALSE)) != UDINoError) /* 29K endian */ return (UDIretval); }; add_to_bp_table(&newid, space, addr.Offset, set_count, set_type, BreakInst); *break_id = (BreakIdType) newid; LastBreakId = newid + 1; /* ??? */ return (UDINoError); } UDIError UDIQueryBreakpoint(break_id, addr, pass_count, bk_type, current_count) BreakIdType break_id; UDIResource *addr; UDIInt32 *pass_count; UDIBreakType *bk_type; UDIInt32 *current_count; { INT32 space; ADDR32 offset; INT32 pcount; INT32 type; INT32 ccount; ADDR32 Inst; CLEAR_PENDING_STOP if (break_id >= LastBreakId) return (UDIErrorNoMoreBreakIds); if (get_from_bp_table(break_id, &space, &offset, &pcount, &type, &Inst) != 0) return (UDIErrorInvalidBreakId); Mini_build_bkpt_stat_msg(space, offset); SEND_AND_WAIT_ACK (BKPT_STAT_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorStatBreak); } Mini_unpack_bkpt_stat_ack_msg((INT32 *) &space, (ADDR32 *) &offset, (INT32 *) &ccount, (INT32 *) &type); addr->Space = SpaceMap_mm2udi(space); addr->Offset = (CPUOffset) offset; *pass_count = (UDIInt32) pcount; if (type == (INT32) BKPT_29000) type = UDIBreakFlagExecute; else if (type == BKPT_29050_BTE_0) type = (MONBreakFlagHardware | UDIBreakFlagExecute); else if (type == BKPT_29050_BTE_1) type = (MONBreakTranslationEnabled | MONBreakFlagHardware | UDIBreakFlagExecute); *bk_type = (UDIBreakType) type; *current_count = (UDIInt32) ccount; return (UDINoError); } UDIError UDIClearBreakpoint(break_id) BreakIdType break_id; { INT32 space; ADDR32 offset; INT32 count; INT32 type; ADDR32 Inst; UDIResource addr; /* EB29K */ UDIError UDIretval; /* EB29K */ CLEAR_PENDING_STOP /* should bkpt be removed from linked list ?? */ if (get_from_bp_table(break_id, &space, &offset, &count, &type, &Inst) != 0) return (UDIErrorInvalidBreakId); Mini_build_bkpt_rm_msg(space, offset); SEND_AND_WAIT_ACK (BKPT_RM_ACK); if (ReturnedError == (int) 1) { ReturnedError = 0; return ((-1) * MONErrErrorRmBreak); } Mini_unpack_bkpt_rm_ack_msg(&space, &offset); if (!strcmp(TargetType, "eb29k")) { /* For EB29K */ /* Write back the original instruction * UDIWrite(Inst); */ addr.Offset = offset; addr.Space = SpaceMap_mm2udi(space); if ((UDIretval = UDIWrite((UDIHostMemPtr) &Inst, addr, (UDICount) 4, (UDISizeT) 1, &offset, FALSE)) != UDINoError) return (UDIretval); }; remove_from_bp_table(break_id); return (UDINoError); } UDIError UDIGetStdout(buf, bufsize, count_done) UDIHostMemPtr buf; UDISizeT bufsize; UDISizeT *count_done; { static int chan1_indx = 0; UDISizeT mincount; UDISizeT i; char *temp; UDIUInt32 reg_val; UDIError UDIretval; if ((int) (ProcessorState & 0xFF) != (int) UDIStdoutReady) { *count_done = (UDISizeT) 0; return (UDINoError); }; temp = (char *) buf; /* used for copying */ i = (UDISizeT) chan1_indx; if (Channel1_count) { mincount = (Channel1_count < (UDISizeT) bufsize) ? Channel1_count : (UDISizeT) bufsize; for (i = 0; i < mincount; i++) { (char) *temp++ = (char) channel1_buffer[chan1_indx]; chan1_indx = (chan1_indx + 1) % TIP_IO_BUFSIZE; /* circular buffer */ } *count_done = (UDISizeT) mincount; Channel1_count = Channel1_count - mincount; TotalDone = TotalDone + (UDIUInt32) mincount; if (Channel1_count <= (UDISizeT) 0) { /* * The HIF kernel from MiniMON29K release 2.1 expects MONTIP * to send a HIF_CALL_RTN response for a HIF_CALL message, and * a CHANNEL1_ACK response for a CHANNEL1 message, and * a CHANNEL2_ACK response for a CHANNEL2 message, and * a CHANNEL0 message for a asynchronous input. * The HIF kernel version numbers 0x05 and above support these * features. */ if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */ if (!NoChan1Ack) { Mini_build_channel1_ack_msg(TotalDone); /* send gr96 value */ if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); } } else { /* old HIF kernel */ if ((UDIretval = Write_Glob_Reg(TotalDone, (int) 96)) != UDINoError) return (UDIretval); reg_val = (UDIUInt32) 0x80000000; if ((UDIretval = Write_Glob_Reg(reg_val, (int) 121)) != UDINoError) return (UDIretval); } TotalDone = (UDIUInt32) 0; Channel1_count = (UDISizeT) 0; chan1_indx = 0; } else { return (UDINoError); } } else { *count_done = (UDISizeT) 0; TotalDone = (UDIUInt32) 0; Channel1_count = (UDISizeT) 0; chan1_indx = 0; /* * The HIF kernel from MiniMON29K release 2.1 expects MONTIP * to send a HIF_CALL_RTN response for a HIF_CALL message, and * a CHANNEL1_ACK response for a CHANNEL1 message, and * a CHANNEL2_ACK response for a CHANNEL2 message, and * a CHANNEL0 message for a asynchronous input. * The HIF kernel version numbers 0x05 and above support these * features. */ if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */ Mini_build_channel1_ack_msg(TotalDone); /* send gr96 value */ if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); } else { /* old HIF kernel */ if ((UDIretval = Write_Glob_Reg(TotalDone, (int) 96)) != UDINoError) return (UDIretval); reg_val = (UDIUInt32) 0x80000000; if ((UDIretval = Write_Glob_Reg(reg_val, (int) 121)) != UDINoError) return (UDIretval); } } if (StepCmdGiven) { ProcessorState = UDIStepped; PreviousProcessorState = UDIStepped; StepCmdGiven = 0; } else { if (!BreaksInPlace) { PutAllBreakpoints(); BreaksInPlace = 1; } /* * The HIF kernel from MiniMON29K release 2.1 expects MONTIP * to send a HIF_CALL_RTN response for a HIF_CALL message, and * a CHANNEL1_ACK response for a CHANNEL1 message, and * a CHANNEL2_ACK response for a CHANNEL2 message, and * a CHANNEL0 message for a asynchronous input. * The HIF kernel version numbers 0x05 and above support these * features. */ if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */ ProcessorState = (UDIUInt32) UDIRunning; PreviousProcessorState = (UDIUInt32) UDIRunning; } else { /* old HIF kernel */ UDIExecute(); /* sends a GO to the Debugger to start application */ } } return (UDINoError); } #ifdef MSDOS UDIError OldHIFGetStderr( UDIHostMemPtr buf,UDISizeT bufsize,UDISizeT *count_done); #else UDIError OldHIFGetStderr(); #endif UDIError UDIGetStderr(buf, bufsize, count_done) UDIHostMemPtr buf; UDISizeT bufsize; UDISizeT *count_done; { static int chan2_indx = 0; UDISizeT mincount; UDISizeT i; char *temp; if ((int) (ProcessorState & 0xFF) != (int) UDIStderrReady) { *count_done = (UDISizeT) 0; return (UDINoError); }; /* * The HIF kernel from MiniMON29K release 2.1 expects MONTIP * to send a HIF_CALL_RTN response for a HIF_CALL message, and * a CHANNEL1_ACK response for a CHANNEL1 message, and * a CHANNEL2_ACK response for a CHANNEL2 message, and * a CHANNEL0 message for a asynchronous input. * The HIF kernel version numbers 0x05 and above support these * features. */ if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */ /* * From MiniMON29K release 2.1 all interactions with * stdin, stdout, stderr by the application is handled without * invoking the Debugger on the target. Thus, a write to stderr * is implemented by a CHANNEL2 message similar to the CHANNEL1 * message for stdout. */ temp = (char *) buf; /* used for copying */ i = (UDISizeT) chan2_indx; if (Channel2_count) { mincount = (Channel2_count < (UDISizeT) bufsize) ? Channel2_count : (UDISizeT) bufsize; for (i = 0; i < mincount; i++) { (char) *temp++ = (char) channel2_buffer[chan2_indx]; chan2_indx = (chan2_indx + 1) % TIP_IO_BUFSIZE;/* circular buffer */ } *count_done = (UDISizeT) mincount; Channel2_count = Channel2_count - mincount; TotalDone = TotalDone + (UDIUInt32) mincount; if (Channel2_count <= (UDISizeT) 0) { Mini_build_channel2_ack_msg(TotalDone); /* send gr96 value */ if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); TotalDone = (UDIUInt32) 0; Channel2_count = (UDISizeT) 0; chan2_indx = 0; } else { return (UDINoError); } } else { *count_done = (UDISizeT) 0; TotalDone = (UDIUInt32) 0; Channel2_count = (UDISizeT) 0; chan2_indx = 0; Mini_build_channel2_ack_msg(TotalDone); /* send gr96 value */ if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); } if (StepCmdGiven) { ProcessorState = UDIStepped; PreviousProcessorState = UDIStepped; StepCmdGiven = 0; } else { if (!BreaksInPlace) { PutAllBreakpoints(); BreaksInPlace = 1; } ProcessorState = (UDIUInt32) UDIRunning; PreviousProcessorState = (UDIUInt32) UDIRunning; } } else { /* old HIF kernel code */ return (OldHIFGetStderr(buf, bufsize, count_done)); } /* old kernel code */ return (UDINoError); } UDIError OldHIFGetStderr(buf, bufsize, count_done) UDIHostMemPtr buf; UDISizeT bufsize; UDISizeT *count_done; /* * For HIF kernel version 0x04 and lower. */ { UDIUInt32 count; UDIUInt32 done; UDIResource from; UDIBool host_endian; UDISizeT size; UDIError UDIretval; UDIUInt32 reg_val; /* Lr4_count gives the bytes to be written */ /* Lr3_addr gives the address in the target */ if (Lr4_count > (UDIUInt32) 0) { count = (Lr4_count < (UDIUInt32) bufsize) ? Lr4_count : (UDIUInt32) bufsize; /* read count bytes from Lr3_addr */ from.Offset = Lr3_addr; from.Space = UDI29KDRAMSpace; size = 1; host_endian = FALSE; if ((UDIretval = UDIRead(from, buf, count, size, &done, host_endian)) != UDINoError) { return (UDIretval); } *count_done = (UDISizeT) count; Lr4_count = Lr4_count - count; Lr3_addr = Lr3_addr + count; TotalDone = TotalDone + (UDIUInt32) count; if (Lr4_count <= (UDISizeT) 0) { if ((UDIretval = Write_Glob_Reg(TotalDone, (int) 96)) != UDINoError) return (UDIretval); reg_val = (UDIUInt32) 0x80000000; if ((UDIretval = Write_Glob_Reg(reg_val, (int) 121)) != UDINoError) return (UDIretval); TotalDone = (UDIUInt32) 0; Lr4_count = (UDIUInt32) 0; } else { return (UDINoError); } } else { *count_done = (UDISizeT) 0; TotalDone = (UDIUInt32) 0; if ((UDIretval = Write_Glob_Reg(TotalDone, (int) 96)) != UDINoError) return (UDIretval); reg_val = (UDIUInt32) 0x80000000; if ((UDIretval = Write_Glob_Reg(reg_val, (int) 121)) != UDINoError) return (UDIretval); Lr4_count = (UDIUInt32) 0; }; /* Resume execution UDIExecute()? */ if (StepCmdGiven) { ProcessorState = UDIStepped; PreviousProcessorState = UDIStepped; StepCmdGiven = 0; } else { if (!BreaksInPlace) { PutAllBreakpoints(); BreaksInPlace = 1; } UDIExecute(); } return (UDINoError); } #ifdef MSDOS UDIError OldHIFPutStdin( UDIHostMemPtr buf,UDISizeT count,UDISizeT *count_done); #else UDIError OldHIFPutStdin(); #endif UDIError UDIPutStdin(buf, count, count_done) UDIHostMemPtr buf; UDISizeT count; UDISizeT *count_done; { char *CharPtr; UINT32 MinCnt; INT32 Code; if ((tip_target_config.os_version & 0xf) > 0x6) { /* MiniMON29K 3.0 */ if ((int) (ProcessorState & 0xFF) != (int) UDIStdinNeeded) { /* non-blocking mode asynchronous mode */ /* if asynchronous mode, we sent a channel0 message for every character sent by DFE in this call. */ if (PgmStdinMode & TIP_NBLOCK) { if ((Code = Mini_msg_recv(NONBLOCK)) != FAILURE) { MsgAlreadyReceived=Code; MsgAlreadyInBuffer = 1; } CharPtr = buf; if (!Channel0Busy) { /* send one character and return to DFE */ Mini_build_channel0_msg(CharPtr, (INT32) 1); /* * Just send the message here, and wait for the ack later SEND_AND_WAIT_ACK(CHANNEL0_ACK); */ if (Mini_msg_send() != SUCCESS) return((-1) * MONErrCantSendMsg); #if 0 Channel0Busy = 1; /* never set */ #endif } else { /* save it in channel0_buffer */ channel0_buffer[Channel0_count] = (char) *CharPtr; Channel0_count=Channel0_count+1; } *count_done = (UDISizeT) 1; return (UDINoError); } else if (PgmStdinMode & TIP_ASYNC) { if ((Code = Mini_msg_recv(NONBLOCK)) != FAILURE) { MsgAlreadyReceived=Code; MsgAlreadyInBuffer = 1; /* check in UDIWait */ } CharPtr = buf; *count_done = (UDISizeT) 0; for ( ; count > 0; count--) { Mini_build_channel0_msg(CharPtr, (INT32) 1); /* * Just send the message here, and wait for the ack later SEND_AND_WAIT_ACK(CHANNEL0_ACK); */ if (Mini_msg_send() != SUCCESS) return((-1)*MONErrCantSendMsg); *count_done = (UDISizeT) (*count_done + (UDISizeT) 1); CharPtr++; } return (UDINoError); } } else { /* synchronous mode */ /* in synchronous mode, we send all the characters received using stdin_needed_ack_msg, when the processorstate becomes stdinneeded. This is line-buffered mode. So we clear variables after we send. What do we do when DFE sends more characters than we need now? The count_done return value gives number accepted. But who keeps the rest. Otherwise, what do we do??????? */ if (PgmStdinMode & TIP_NBLOCK) { /* send one character and return to DFE */ CharPtr = buf; if ((Code = Mini_msg_recv(NONBLOCK)) != FAILURE) { MsgAlreadyReceived=Code; MsgAlreadyInBuffer = 1; } *count_done = (UDISizeT) 1; Mini_build_channel0_msg(CharPtr, (INT32) 1); /* * Send the message now and wait for the ack later. SEND_AND_WAIT_ACK(CHANNEL0_ACK); */ if (Mini_msg_send() != SUCCESS) return ((-1)*MONErrCantSendMsg); return (UDINoError); }; MinCnt = ((UINT32) StdinCharsNeeded > (UINT32) count) ? (UINT32) count : (UINT32) StdinCharsNeeded; Mini_build_stdin_needed_ack_msg (MinCnt, buf); if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); *count_done = (UDISizeT) MinCnt; StdinCharsNeeded = 0; /* reset to zero ?? */ if (StepCmdGiven) { ProcessorState = UDIStepped; PreviousProcessorState = UDIStepped; StepCmdGiven = 0; } else { if (!BreaksInPlace) { PutAllBreakpoints(); BreaksInPlace = 1; } ProcessorState = UDIRunning; PreviousProcessorState = UDIRunning; } return (UDINoError); } } else if ((tip_target_config.os_version & 0xf) > 4) { /* pre-release */ /* * The HIF kernel from MiniMON29K release 2.1 expects MONTIP * to send a HIF_CALL_RTN response for a HIF_CALL message, and * a CHANNEL1_ACK response for a CHANNEL1 message, and * a CHANNEL2_ACK response for a CHANNEL2 message, and * a CHANNEL0 message for a asynchronous input. * The HIF kernel version numbers 0x05 and above support these * features. */ /* Send CHANNEL0 message depending on StdinMode. */ CharPtr = buf; if (PgmStdinMode == TIP_COOKED) { /* default line buffered */ /* * send a line of input using channel0 * Check for '\n' sent from DFE. */ if ((int) *CharPtr == (int) 8) {/* backspace */ Channel0_count=Channel0_count-1; } else if ((int) *CharPtr == (int) 127) {/* delete */ Channel0_count=Channel0_count-1; #ifdef MSDOS } else if ((int) *CharPtr == (int) 10) {/* \n */ /* simply return, no change. already padded. */ *count_done = count; return (UDINoError); } else if ((int) *CharPtr == (int) 13) {/* end of line */ channel0_buffer[Channel0_count] = (char) *CharPtr; Channel0_count=Channel0_count+1; channel0_buffer[Channel0_count] = (char) 10; /* add \n */ Channel0_count=Channel0_count+1; Mini_build_channel0_msg(channel0_buffer, Channel0_count); SEND_AND_WAIT_ACK(CHANNEL0_ACK); Channel0_count = 0; /* reset */ *count_done = count; #else /* MSDOS */ } else if ((int) *CharPtr == (int) 13) {/* end of line */ /* simply return, added on \n */ *count_done = count; return (UDINoError); } else if ((int) *CharPtr == (int) 10) {/* \n */ channel0_buffer[Channel0_count] = (char) 13; /* add \r */ Channel0_count=Channel0_count+1; channel0_buffer[Channel0_count] = (char) *CharPtr; Channel0_count=Channel0_count+1; Mini_build_channel0_msg(channel0_buffer, Channel0_count); SEND_AND_WAIT_ACK(CHANNEL0_ACK); Channel0_count = 0; /* reset */ #endif /* MSDOS */ } else { /* store it in buffer here */ channel0_buffer[Channel0_count] = (char) *CharPtr; Channel0_count=Channel0_count+1; *count_done = count; } return (UDINoError); } else if (PgmStdinMode == TIP_RAW) { /* for other modes of input */ channel0_buffer[Channel0_count] = (char) *CharPtr; Channel0_count=Channel0_count+1; Mini_build_channel0_msg(channel0_buffer, Channel0_count); SEND_AND_WAIT_ACK(CHANNEL0_ACK); Channel0_count = 0; /* reset */ *count_done = count; return (UDINoError); } else { /* for other modes of input */ /* NOT IMPLEMENTED */ return (UDINoError); } } else { /* old HIF kernel */ return(OldHIFPutStdin(buf, count, count_done)); } } UDIError OldHIFPutStdin(buf, count, count_done) UDIHostMemPtr buf; UDISizeT count; UDISizeT *count_done; { UDIResource to; UDIError retval; UDIBool hostendian; UDICount mincount, bytes_ret; UDIUInt32 reg_val; UDISizeT size; if ((int) (ProcessorState & 0xFF) != (int) UDIStdinNeeded) { *count_done = (UDISizeT) 0; return (UDINoError); }; /* Lr4_count has count requested */ /* Lr3_addr has the destination */ if (Lr4_count > (UDIUInt32) 0) { mincount = ((UDICount) count < (UDICount) Lr4_count) ? (UDICount) count : (UDICount) Lr4_count; to.Space = (CPUSpace) UDI29KDRAMSpace; to.Offset = (CPUOffset) Lr3_addr; size = (UDISizeT) 1; hostendian = FALSE; if ((retval = UDIWrite(buf, to, mincount, size, &bytes_ret, hostendian)) != UDINoError) { return ((UDIError) retval); }; Lr4_count = (UDIUInt32) 0; *count_done = (UDISizeT) bytes_ret; } else { Lr4_count = (UDIUInt32) 0; *count_done = (UDISizeT) 0; }; /* * ASSUMPTION: It's always a non-blocking read & this function is called * only when app. needs data. So, write the number of bytes read to gr96 on * the target. */ /* Write gr96 set above */ /* gr96 */ reg_val = (UDIUInt32) * count_done; /* same as mincount */ if ((retval = Write_Glob_Reg(reg_val, (int) 96)) != UDINoError) return (retval); /* Write Gr121 */ reg_val = (UDIUInt32) 0x80000000; if ((retval = Write_Glob_Reg(reg_val, (int) 121)) != UDINoError) return (retval); if (StopFlag) { STOP_SIG_HDLR ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = (UDIUInt32) UDIStopped; return (UDINoError); }; /* Resume execution UDIExecute()? */ if (StepCmdGiven) { ProcessorState = UDIStepped; PreviousProcessorState = UDIStepped; StepCmdGiven = 0; } else { if (!BreaksInPlace) { PutAllBreakpoints(); BreaksInPlace = 1; } UDIExecute(); } return (UDINoError); } UDIError UDIStdinMode(mode) UDIMode *mode; { *mode = (UDIMode) (PgmStdinMode); /* restore ProcessorState from saved value in PreviousState */ ProcessorState = PreviousProcessorState; return (UDINoError); } UDIError UDIPutTrans(buf, count, count_done) UDIHostMemPtr buf; UDISizeT count; UDISizeT *count_done; { char *tip_token; tip_token = strtok ((char *) buf, " \t,;\n\r"); if (tip_token == NULL) return ((-1) * MONErrUnknownTIPCmd); if (strcmp (tip_token, "tip") == 0) { tip_token = strtok ((char *) 0, " \t,;\n\r"); if (tip_token == NULL) return ((-1) * MONErrUnknownTIPCmd); else { if (strcmp(tip_token, "lpt=1") == 0) { #ifdef MSDOS set_lpt(); #endif use_parport = 1; } else if (strcmp(tip_token, "lpt=0") == 0) { #ifdef MSDOS unset_lpt(); #endif use_parport = 0; } else return ((-1) * MONErrUnknownTIPCmd); } return (UDINoError); } else { return ((-1) * MONErrUnknownTIPCmd); } } UDIError UDIGetTrans(buf, bufsize, count) UDIHostMemPtr buf; UDISizeT bufsize; UDISizeT *count; { CLEAR_PENDING_STOP return (UDIErrorUnsupportedService); } UDIError UDITransMode(mode) UDIMode *mode; { CLEAR_PENDING_STOP return (UDIErrorUnsupportedService); } /* Map Space conversion functions */ static INT32 SpaceMap_udi2mm(space) CPUSpace space; { switch (space) { case UDI29KDRAMSpace: return ((INT32) D_MEM); case UDI29KIOSpace: return ((INT32) I_O); case UDI29KCPSpace0: return ((INT32) SPECIAL_REG); case UDI29KCPSpace1: return ((INT32) SPECIAL_REG); case UDI29KIROMSpace: return ((INT32) I_ROM); case UDI29KIRAMSpace: return ((INT32) I_MEM); case UDI29KLocalRegs: return ((INT32) LOCAL_REG); case UDI29KGlobalRegs: return ((INT32) GLOBAL_REG); case UDI29KRealRegs: return ((INT32) GLOBAL_REG); case UDI29KSpecialRegs: return ((INT32) SPECIAL_REG); case UDI29KTLBRegs: return ((INT32) TLB_REG); case UDI29KACCRegs: return ((INT32) SPECIAL_REG); case UDI29KICacheSpace: return ((INT32) I_CACHE); case UDI29KAm29027Regs: return ((INT32) COPROC_REG); case UDI29KPC: return ((INT32) PC_SPACE); case UDI29KDCacheSpace: return ((INT32) D_CACHE); case VERSION_SPACE: return ((INT32) VERSION_SPACE); default: return (FAILURE); }; } static CPUSpace SpaceMap_mm2udi(space) INT32 space; { switch (space) { case LOCAL_REG: return ((CPUSpace) UDI29KLocalRegs); case ABSOLUTE_REG: return ((CPUSpace) UDI29KGlobalRegs); case GLOBAL_REG: return ((CPUSpace) UDI29KGlobalRegs); case SPECIAL_REG: return ((CPUSpace) UDI29KSpecialRegs); case TLB_REG: return ((CPUSpace) UDI29KTLBRegs); case COPROC_REG: return ((CPUSpace) UDI29KAm29027Regs); case I_MEM: return ((CPUSpace) UDI29KIRAMSpace); case D_MEM: return ((CPUSpace) UDI29KDRAMSpace); case I_ROM: return ((CPUSpace) UDI29KIROMSpace); case D_ROM: return ((CPUSpace) UDI29KIROMSpace); case I_O: return ((CPUSpace) UDI29KIOSpace); case I_CACHE: return ((CPUSpace) UDI29KICacheSpace); case D_CACHE: return ((CPUSpace) UDI29KDCacheSpace); case PC_SPACE: return ((CPUSpace) UDI29KPC); case A_SPCL_REG: return ((CPUSpace) UDI29KSpecialRegs); default: return (FAILURE); } } /* Miscellaneous UDI support functions */ static int Reset_Processor() { INT32 MsgCode; BreakIdType i; CLEAR_PENDING_STOP Mini_build_reset_msg(); if (Mini_msg_send() != SUCCESS) return ((-1) * MONErrCantSendMsg); MsgCode = Wait_For_Ack(); if (MsgCode == ABORT_FAILURE) return (UDIErrorAborted); else if (MsgCode == FAILURE) return ((-1) * MONErrNoSynch); RefreshRegs = 1; /* Clear all breakpoints */ BreaksInPlace = 0; for (i = 1; i < LastBreakId; i++) remove_from_bp_table(i); return (SUCCESS); } static int parse_string(string) char *string; { char *s; if ((string == NULL) || (strcmp(string,"") == 0)) return ((-1) * MONErrNullConfigString); (void) strcpy (&ConnectString[0], string); /* to preserve the original */ s = strtok(ConnectString, " "); while (s != NULL) { if ((s[0] == '-') && (s[1] != '\0') && (s[2] == '\0')) { /* single letter options */ switch (s[1]) { case 'S': /* -Supervisor Mode */ SupervisorMode = 1; /* always in real mode */ RealMode = 1; ProtectedMode = 0; VirtualMode = 0; s = strtok(NULL, " "); /* get next string */ break; case 'R': /* -Real Mode */ RealMode = 1; ProtectedMode = 0; VirtualMode = 0; s = strtok(NULL, " "); /* get next string */ break; case 'P': /* _Protected mode */ SupervisorMode = 0; /* SM mode not supported */ RealMode = 0; VirtualMode = 0; ProtectedMode = 1; s = strtok(NULL, " "); /* get next string */ break; case 'V': /* -Virtual mode */ SupervisorMode = 0; /* SM mode not supported */ RealMode = 0; ProtectedMode = 0; VirtualMode = 1; s = strtok(NULL, " "); /* get next string */ break; case 'r': /* core file */ s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if ((CoreFile = (char *) malloc(strlen(s) + 1)) == NULL) { return ((-1) * MONErrOutofMemory); /* EMALLOC ? */ }; (void) strcpy(CoreFile, s); }; s = strtok(NULL, " "); /* get next string */ break; case 't': /* target type */ s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if ((TargetType = (char *) malloc(strlen(s) + 1)) == NULL) { return ((-1) * MONErrOutofMemory); /* EMALLOC ? */ }; (void) strcpy(TargetType, s); }; s = strtok(NULL, " "); /* get next string */ break; case 'm': /* message log file */ s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if ((Msg_Logfile = (char *) malloc(strlen(s) + 1)) == NULL) { return ((-1) * MONErrOutofMemory); /* EMALLOC ? */ }; (void) strcpy(Msg_Logfile, s); }; s = strtok(NULL, " "); /* get next string */ break; default: /* unknown */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ }; /* end switch */ } else { /* multiple letter options */ if (strcmp(s, "-com") == 0) { s = strtok(NULL, " "); if (s == NULL) { return (UDIErrorInvalidTIPOption); } else { (void) strcpy(tip_config.comm_port, s); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-af") == 0) { SendACKFirst = 1; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-par") == 0) { s = strtok(NULL, " "); if (s == NULL) { return (UDIErrorInvalidTIPOption); } else { (void) strcpy(tip_config.par_port, s); lpt_initialize = 1; }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-le") == 0) { /* little endian target */ tip_target_config.P29KEndian = LITTLE; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-re") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%d", &MessageRetries) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-na") == 0) { /* no need to ack channel1 msg */ NoChan1Ack = 1; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-nt") == 0) { NoStepReqd = 1; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-mbuf") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%d", &MaxMsgBufSize) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-del") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%d", &DelayFactor) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-bl") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%d", &BlockCount) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-to") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%ld", &TimeOut) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-seg") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%lx", &tip_config.PC_mem_seg) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-nblock") == 0) { /* specify NBLOCK Stdin Mode */ PgmStdinMode = TIP_NBLOCK; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-port") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { if (sscanf(s, "%lx", &tip_config.PC_port_base) != 1) return (UDIErrorInvalidTIPOption); }; s = strtok(NULL, " "); /* get next string */ } else if (strcmp(s, "-baud") == 0) { s = strtok(NULL, " "); if (s == NULL) { /* error */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } else { (void) strcpy(tip_config.baud_rate, s); }; s = strtok(NULL, " "); /* get next string */ } else /* unknown option */ return (UDIErrorInvalidTIPOption); /* UNKNOWN */ } }; /* end while */ return ((int) 0); /* SUCCESS */ } static int write_args(argstring, argstart, datahigh) char *argstring; ADDR32 argstart; ADDR32 *datahigh; { char *argvstring[25]; int i; char *s; i = 0; if (argstring == NULL) { s = strtok(argstring, " \t\n\r"); argvstring[i] = s; } else { (void) strcpy (&TempArgString[0], argstring); s = strtok (&TempArgString[0], " \t\n\r"); argvstring[i] = s; if (s != NULL) { while ((s = strtok((char *) 0, " \t\n\r"))) { i++; argvstring[i] = s; (void) strcpy(argvstring[i], s); }; /* add the final NULL */ /* i is the argc count */ argvstring[++i] = NULL; } } return (write_argv(i, argvstring, argstart, datahigh)); } static int write_argv(arg_count, arg_ptr, argstart, hi_data) int arg_count; char *arg_ptr[]; ADDR32 argstart; ADDR32 *hi_data; { int i; UDIError retval; UDIResource to; UDIBool hostendian; UDICount count, bytes_ret; UDISizeT size; UDIUInt32 dataend; /* start address for heap */ UDIUInt32 tmp_dataend; /* start address for heap */ /* * * Write args to target */ /* Set init.data_end to start of arg string space */ /* (saving room for the array of pointers) */ dataend = argstart + (arg_count + 1) * sizeof(CPUOffset); for (i = 0; i < arg_count; i = i + 1) { /* Write arg_ptr[i] pointer (Am29000 address) to target */ tmp_dataend = dataend; /* We might have to change the endian of the address */ if (tip_target_config.P29KEndian != tip_target_config.TipEndian) { tip_convert32((BYTE *) &(tmp_dataend)); } to.Offset = argstart + (i * sizeof(CPUOffset)); to.Space = UDI29KDRAMSpace; count = (UDICount) 1; size = (UDISizeT) sizeof(CPUOffset); hostendian = FALSE; /* ???? */ if ((retval = UDIWrite((UDIHostMemPtr) &tmp_dataend, to, count, size, &bytes_ret, hostendian)) != UDINoError) { return (retval); }; /* Continue if SUCCESSful */ /* Write arg_ptr[i] to target */ to.Offset = dataend; to.Space = UDI29KDRAMSpace; count = (UDICount) strlen(arg_ptr[i]) + 1; size = (UDISizeT) 1; hostendian = FALSE; if ((retval = UDIWrite(arg_ptr[i], to, count, size, &bytes_ret, hostendian)) != UDINoError) { return (retval); }; dataend = dataend + strlen(arg_ptr[i]) + 1; } /* end for loop */ /* return dataend */ *hi_data = dataend; /* Write NULL pointer at end of argv array */ to.Offset = argstart + arg_count * sizeof(CPUOffset); to.Space = UDI29KDRAMSpace; count = (UDICount) sizeof(CPUOffset); size = (UDISizeT) 1; hostendian = FALSE; if ((retval = UDIWrite("\0\0\0", to, count, size, &bytes_ret, hostendian)) != UDINoError) { return (retval); }; return (UDINoError); } void set_stdin_needed(hif_lr3, hif_lr4) ADDR32 hif_lr3; UDICount hif_lr4; { Lr3_addr = (CPUOffset) hif_lr3; Lr4_count = (UDIUInt32) hif_lr4; ProcessorState = (UDIUInt32) UDIStdinNeeded; PreviousProcessorState = (UDIUInt32) UDIStdinNeeded; } void set_stdout_ready(hif_lr3, hif_lr4) ADDR32 hif_lr3; UDICount hif_lr4; { Lr3_addr = (CPUOffset) hif_lr3; Lr4_count = (UDIUInt32) hif_lr4; ProcessorState = (UDIUInt32) UDIStdoutReady; PreviousProcessorState = (UDIUInt32) UDIStdoutReady; } void set_stderr_ready(hif_lr3, hif_lr4) ADDR32 hif_lr3; UDICount hif_lr4; { Lr3_addr = (CPUOffset) hif_lr3; Lr4_count = (UDIUInt32) hif_lr4; ProcessorState = (UDIUInt32) UDIStderrReady; PreviousProcessorState = (UDIUInt32) UDIStderrReady; } static INT32 Wait_For_Ack( /* retries */ ) { INT32 code; UINT32 count; count=(UINT32) 1; code = FAILURE; while ((code == FAILURE) && (count < TimeOut)) { code = Mini_msg_recv(BLOCK); count = count + 10; /* Check for user interrupt */ SIGINT_POLL if (StopFlag) { STOP_SIG_HDLR ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = (UDIUInt32) UDIStopped; return (ABORT_FAILURE); }; }; return (code); } static INT32 CheckForMsg(time) INT32 time; { INT32 i; INT32 Code; int ForEver; ForEver = 0; if (time == (UDIInt32) UDIWaitForever) ForEver = 1; else if (RemoteTarget == 1) /* remote targets */ #ifdef MSDOS time = time*100; #else time = time; #endif i = 0; while ((i <= time) || ForEver) { /* Check for user interrupt */ SIGINT_POLL if (StopFlag) { STOP_SIG_HDLR ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = (UDIUInt32) UDIStopped; return (ABORT_FAILURE); }; if ((Code = Mini_msg_recv(NONBLOCK)) != FAILURE) return (Code); i = i + 1; } return (FAILURE); } static void process_target_msg(msgcode) INT32 msgcode; { switch (msgcode) { case HALT: if (BreaksInPlace) ResetAllBreakpoints(); BreaksInPlace = 0; process_HALT_msg(); break; case CHANNEL1: process_CHAN1_msg(); break; case CHANNEL2: process_CHAN2_msg(); break; case CHANNEL0_ACK: (void) process_chan0_ack(); break; case HIF_CALL: (void) process_HIF_msg(); break; case STDIN_NEEDED_REQ: (void) process_stdin_needed_req(); break; case STDIN_MODE_REQ: (void) set_stdin_mode(); break; case ERROR: if (BreaksInPlace) ResetAllBreakpoints(); BreaksInPlace = 0; process_ERR_msg(); break; default: if (BreaksInPlace) ResetAllBreakpoints(); BreaksInPlace = 0; ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = (UDIUInt32) UDIHalted; fprintf(stderr, "FATAL: a unknown msg 0x%lx\n", msgcode); (void)print_recv_bytes(); break; }; } static INT32 process_chan0_ack() { char nextchar; Channel0Busy = 0; if (Channel0_count > 0) { Channel0_count = Channel0_count - 1; nextchar = channel0_buffer[Channel0_count]; Mini_build_channel0_msg(&nextchar, (INT32) 1); if (Mini_msg_send() != SUCCESS) { return((-1) * MONErrCantSendMsg); } #if 0 Channel0Busy=1; /* never set */ #endif } return (UDINoError); } static void process_HALT_msg() { INT32 mspace; ADDR32 pc0, pc1; INT32 trap_number; INT32 type; ADDR32 Inst; BreakIdType break_id; INT32 count; Mini_unpack_halt_msg(&mspace, &pc0, &pc1, &trap_number); if (trap_number == (INT32) 0) { if ((break_id = (BreakIdType) is_breakpt_at(mspace, pc1)) > (BreakIdType) 0) { ProcessorState = (UDIUInt32) UDIBreak; PreviousProcessorState = (UDIUInt32) UDIBreak; if ((get_from_bp_table(break_id, &mspace, &pc1, &count, &type, &Inst) == 0) && (count < (INT32) 0)) remove_from_bp_table(break_id); } else ProcessorState = (UDIUInt32) UDITrapped; PreviousProcessorState = (UDIUInt32) UDITrapped; } else if (trap_number == 15) { /* Trace */ ProcessorState = (UDIUInt32) UDIStepped; PreviousProcessorState = (UDIUInt32) UDIStepped; StepCmdGiven = 0; /* step complete */ } else if (trap_number == 75) { ProcessorState = (UDIUInt32) UDIBreak; PreviousProcessorState = (UDIUInt32) UDIBreak; } else if (trap_number & 0x1000) { /* HIF specific reason */ if ((trap_number & 0xffff) == 0x1000) { /* HIF exit */ ProcessorState = (UDIUInt32) (UDIExited | ((trap_number & 0xffff0000)>>8)); PreviousProcessorState = ProcessorState; } else { /* HIF error */ ProcessorState = (UDIUInt32) (UDIHalted | (trap_number & 0xffff0000)); PreviousProcessorState = ProcessorState; } } else { ProcessorState = (UDIUInt32) (UDITrapped | (trap_number << 8)); PreviousProcessorState = ProcessorState; } } static void set_stdin_mode() { INT32 mode; Mini_unpack_stdin_mode_msg(&mode); Mini_build_stdin_mode_ack_msg(PgmStdinMode); PgmStdinMode = mode; PreviousProcessorState = ProcessorState; /* save current state */ ProcessorState = (UDIUInt32) (UDIStdinModeX); if (Mini_msg_send() != SUCCESS) { ProcessorState = (UDIUInt32) UDIHalted; } return; } static void process_stdin_needed_req() { Mini_unpack_stdin_needed_msg(&StdinCharsNeeded); /* upper 24 bits gives number needed */ ProcessorState = (UDIUInt32) (UDIStdinNeeded | (StdinCharsNeeded << 8)); PreviousProcessorState = ProcessorState; } static void process_CHAN1_msg() { INT32 count; Mini_unpack_channel1_msg((BYTE *) channel1_buffer, &count); Channel1_count = (UDISizeT) count; /* upper 24 bits gives number to output */ ProcessorState = (UDIUInt32) (UDIStdoutReady | (Channel1_count << 8)); PreviousProcessorState = ProcessorState; } static void process_CHAN2_msg() { INT32 count; Mini_unpack_channel2_msg((BYTE *) channel2_buffer, &count); Channel2_count = (UDISizeT) count; /* upper 24 bits gives number to output */ ProcessorState = (UDIUInt32) (UDIStderrReady | (Channel2_count << 8)); PreviousProcessorState = ProcessorState; } static void process_HIF_msg() { INT32 svc_nm, lr2, lr3, lr4, gr96, gr97, gr121; int retval; INT32 MsgCode; Mini_unpack_hif_msg(&svc_nm, &lr2, &lr3, &lr4); if ((svc_nm == (INT32) HIF_read) && (lr2 == (INT32) 0)) { /* stdin */ set_stdin_needed(lr3, lr4); return; } else if ((svc_nm == (INT32) HIF_write) && (lr2 == (INT32) 2)) { /* stderr */ set_stderr_ready(lr3, lr4); return; } else { retval = service_HIF(svc_nm, lr2, lr3, lr4, &gr96, &gr97, &gr121); if (retval == (INT32) -1) { /* service failed */ ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; return; } ; if (svc_nm == HIF_exit) { if (BreaksInPlace) { /* For EB29K */ BreaksInPlace = 0; ResetAllBreakpoints(); }; if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */ if ((tip_target_config.os_version & 0xf) > 0x6) { /* send hif rtn */ Mini_build_hif_rtn_msg(svc_nm, gr121, gr96, gr97); if (Mini_msg_send() != SUCCESS) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; return; } MsgCode = Wait_For_Ack(); /* debug core sends a HALT msg */ if (MsgCode == ABORT_FAILURE) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; } else if (MsgCode == FAILURE) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; } else { ProcessorState = (UDIUInt32) (UDIExited | (lr2 << 8)); PreviousProcessorState = ProcessorState; } return; } else { ProcessorState = (UDIUInt32) (UDIExited | (lr2 << 8)); PreviousProcessorState = ProcessorState; return; } } else { /* old HIF kernel */ exitstat = (int) lr2; if (Write_Glob_Reg(gr121, (int) 121) != UDINoError) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; return; } ProcessorState = (UDIUInt32) (UDIExited | (exitstat << 8)); PreviousProcessorState = ProcessorState; return; } } else { /* not a HIF exit */ if ((tip_target_config.os_version & 0xf) > 4) { /* new HIF kernel */ Mini_build_hif_rtn_msg(svc_nm, gr121, gr96, gr97); if (Mini_msg_send() != SUCCESS) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; return; } ProcessorState = (UDIUInt32) UDIRunning; PreviousProcessorState = ProcessorState; return; } else { /* old HIF kernel */ if (Write_Glob_Reg(gr96, (int) 96) != UDINoError) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; } if (svc_nm == (INT32) HIF_gettz) { if (Write_Glob_Reg(gr97, (int) 97) != UDINoError) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; } } if (Write_Glob_Reg(gr121, (int) 121) != UDINoError) { ProcessorState = (UDIUInt32) UDIHalted; PreviousProcessorState = ProcessorState; } /* UDIExecute()? */ if (StepCmdGiven) { ProcessorState = UDIStepped; PreviousProcessorState = ProcessorState; } else { if (!BreaksInPlace) { PutAllBreakpoints(); BreaksInPlace = 1; } UDIExecute(); } }; return; } } } static void process_ERR_msg() { ProcessorState = (UDIUInt32) UDIStopped; PreviousProcessorState = ProcessorState; } static int Write_Glob_Reg(RegVal, RegNum) INT32 RegVal; int RegNum; { UDIResource to; UDISizeT size; UDICount mincount; UDIBool hostendian; UDICount bytes_ret; UDIError retval; to.Space = (CPUSpace) UDI29KGlobalRegs; to.Offset = (CPUOffset) RegNum; size = (UDISizeT) 4; mincount = (UDICount) 1; hostendian = FALSE; if (tip_target_config.TipEndian != tip_target_config.P29KEndian) { tip_convert32((BYTE *) &RegVal); } if ((retval = UDIWrite((UDIHostMemPtr) &RegVal, to, mincount, size, &bytes_ret, hostendian)) != UDINoError) { return ((UDIError) retval); }; return (UDINoError); } static int PutAllBreakpoints() { UDIResource addr; UDIError UDIretval; UDICount count_done; BreakIdType break_id; ADDR32 offset; INT32 space; INT32 pcount; INT32 type; ADDR32 Inst; UDIUInt32 IllOp; if (strcmp (TargetType, "eb29k") == 0) { /* if EB29K */ for (break_id = 1; break_id < LastBreakId; break_id++) { if (get_from_bp_table(break_id, &space, &offset, &pcount, &type, &Inst) == 0) { addr.Offset = offset; addr.Space = SpaceMap_mm2udi(space); /* Read Instruction into Breaktable */ if (!strcmp(TargetType, "eb29k")) { if ((UDIretval = UDIRead(addr, (UDIHostMemPtr) &Inst, (UDICount) 1, (UDISizeT) 4, (UDICount *) &count_done, (UDIBool) FALSE)) != UDINoError) /* 29K endian */ return (UDIretval); }; (void) update_breakpt_at(space, offset, Inst); /* UDIWrite(Illop); write illegal opcode instruction */ IllOp = (UDIUInt32) 0x00ccbbaa; /* Illegal opcode */ if ((UDIretval = UDIWrite((UDIHostMemPtr) &IllOp, addr, (UDICount) 1, (UDISizeT) 4, &count_done, TRUE)) != UDINoError) return (UDIretval); } } } return (0); } static int ResetAllBreakpoints() { UDIResource addr; UDIError UDIretval; UDICount count_done; BreakIdType break_id; ADDR32 offset; INT32 space; INT32 pcount; INT32 type; ADDR32 Inst; if (strcmp (TargetType, "eb29k") == 0) { /* if EB29K */ for (break_id = 1; break_id < LastBreakId; break_id++) { if (get_from_bp_table(break_id, &space, &offset, &pcount, &type, &Inst) == 0) { /* UDIWrite(); write original instruction */ addr.Offset = offset; addr.Space = SpaceMap_mm2udi(space); if ((UDIretval = UDIWrite((UDIHostMemPtr) &Inst, addr, (UDICount) 1, (UDISizeT) 4, &count_done, FALSE)) != UDINoError) return (UDIretval); } } } return (0); } void TIPPrintUsage(s) char *s; { fprintf(stderr, "Minimon (UDI 1.2) TIP Version: %s Date: %s\n", TIPVERSION, TIPDATE); fprintf(stderr, "List of Valid MONTIP options are:\n"); fprintf(stderr, "-t <target_if_type> - the target interface type MUST be specified\n"); fprintf(stderr, "[-r <Minimon_OS_linked_object>] - ROM file to be downloaded, if any\n"); fprintf(stderr, "[-m <msg_log_filename>] - file to log messages between TIP and target\n"); fprintf(stderr, "[-com <serial_comm_port>] -communication port to use, ex: -com com1:\n"); fprintf(stderr, "[-par <paralle_port>] -parallel port for download , ex: -par lpt1:\n"); fprintf(stderr, "[-re <retries_for_a_msg>] - number of retries\n"); fprintf(stderr, "[-le] - specifies target is little endian\n"); fprintf(stderr, "[-mbuf <msg_bufsize_to_use>] - maximum message buffer size\n"); fprintf(stderr, "[-bl <msg_block_loopcount>] - block count while receiving\n"); fprintf(stderr, "[-to <timeout_loopcount>] - timeout while receiving\n"); fprintf(stderr, "[-seg <PC_mem_seg_addr_in_hex>] - PC memory segment base address, ex: -seg D800\n"); fprintf(stderr, "[-port <PC_port_base_addr_in_hex>] - PC i/o port base address, ex: -port 2A0\n"); fprintf(stderr, "[-baud <baudrate>] - baud rate for serial communications, ex: -baud 38400\n"); fprintf(stderr, "[-R/P] - physical or protected mode (ONLY with OSBOOT supplied)\n"); fprintf(stderr, "[-S] - run in supervisor mode (ONLY with OSBOOT supplied)\n"); exit(1); } static INT32 SendConfigWait() { INT32 MsgCode; int count; unsigned long time; count = (UINT32) 0; MsgCode = (INT32) FAILURE; do { #ifdef MSDOS if (RemoteTarget == 1) Mini_reset_comm(); /* reset communications channel */ #endif Mini_build_config_req_msg(); if (Mini_msg_send() != SUCCESS) { return ((-1) * MONErrCantSendMsg); } count = count + 1; time = (unsigned long) 1; do { time = time + 10; MsgCode = Mini_msg_recv(BLOCK); SIGINT_POLL if (Interrupted) { Interrupted = 0; return ((INT32) ABORT_FAILURE); } #ifndef MSDOS if ((MsgCode == FAILURE) && (RemoteTarget == 1)) Mini_reset_comm(); /* reset communications channel */ #endif } while ((MsgCode == FAILURE) && (time < TimeOut)); } while ((MsgCode == FAILURE) && (count < MessageRetries)); return (MsgCode); } static char * GetTargetType( Target, FromString) char *Target; char *FromString; { char *s; if (FromString == NULL) return (NULL); (void) strcpy (&ConnectString[0], FromString); /* to preserve the original */ s = strtok(ConnectString, " "); while (s != NULL) { if ((s[0] == '-') && (s[1] == 't') && (s[2] == '\0')) { /* -t option */ s = strtok (NULL, " "); /* continue search */ if (s == NULL) return (NULL); else { Target = s; return (s); } }; s = strtok (NULL, " "); /* continue search */ }; /* while */ return (NULL); } static INT32 Mini_load_coff(filename, mspace, sym, Section, quietmode) char *filename; int quietmode; INT32 sym; INT32 Section; INT32 mspace; { unsigned short COFF_sections; INT32 flags; INT32 memory_space; INT32 address; INT32 byte_count; INT32 write_count; INT32 temp_byte_count; struct filehdr COFF_header; struct aouthdr COFF_aout_header; struct scnhdr COFF_section_header; /* Open the COFF input file (if we can) */ if ((coff_in = FindFile(filename)) == NULL) return ((-1) * MONErrCantOpenCoff); /* Read in COFF header information */ if (fread((char *)&COFF_header, sizeof(struct filehdr), 1, coff_in) != 1) { fclose(coff_in); return ((-1) * MONErrCantLoadROMfile); }; /* Is it an Am29000 COFF File? */ if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x7a01) && (COFF_header.f_magic != 0x17b) && (COFF_header.f_magic != 0x7b01)) { fclose(coff_in); return ((-1) * MONErrCantLoadROMfile); } /* Get number of COFF sections */ if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x017b)) tip_convert16((BYTE *) &COFF_header.f_nscns); COFF_sections = (unsigned short) COFF_header.f_nscns; /* Read in COFF a.out header information (if we can) */ if (COFF_header.f_opthdr > 0) { if (fread((char *)&COFF_aout_header, sizeof(struct aouthdr), 1, coff_in) != 1) { fclose(coff_in); return ((-1) * MONErrCantLoadROMfile); }; if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x017b)) { tip_convert16((BYTE *) &COFF_header.f_opthdr); } } /* ** Process COFF section headers */ /* Process all sections */ while ((int) COFF_sections--) { fseek (coff_in, (long) (FILHSZ+(int)COFF_header.f_opthdr+ SCNHSZ*(COFF_header.f_nscns-COFF_sections-1)), FROM_BEGINNING); if (fread(&COFF_section_header, 1, SCNHSZ, coff_in) != SCNHSZ) { fclose(coff_in); return ((-1) * MONErrCantLoadROMfile); } if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x017b)) { tip_convert32((BYTE *) &(COFF_section_header.s_paddr)); tip_convert32((BYTE *) &(COFF_section_header.s_scnptr)); tip_convert32((BYTE *) &(COFF_section_header.s_size)); tip_convert32((BYTE *) &(COFF_section_header.s_flags)); } address = COFF_section_header.s_paddr; byte_count = COFF_section_header.s_size; flags = COFF_section_header.s_flags; /* Print downloading messages (if necessary) */ if ((flags == (INT32) STYP_TEXT) || (flags == (INT32) (STYP_TEXT | STYP_ABS))) { memory_space = I_MEM; } else if ((flags == (INT32) STYP_DATA) || (flags == (INT32) (STYP_DATA | STYP_ABS)) || (flags == (INT32) STYP_LIT) || (flags == (INT32) (STYP_LIT | STYP_ABS)) || (flags == (INT32) STYP_BSS) || (flags == (INT32) (STYP_BSS | STYP_ABS))) { memory_space = D_MEM; } else { flags = (INT32) 0; } if ((flags == (INT32) STYP_BSS) || (flags == (INT32) (STYP_BSS | STYP_ABS))) { /* Clear BSS section */ if (flags & Section) { (void) memset ((char *) buffer, (int) '\0', sizeof(buffer)); while (byte_count > 0) { write_count = (byte_count < (INT32) sizeof(buffer)) ? byte_count : (INT32) sizeof (buffer); if(Mini_write_memory ((INT32) memory_space, (ADDR32) address, (INT32) write_count, (BYTE *) buffer) != SUCCESS) { (void) fclose(coff_in); return((-1) * MONErrCantWriteToMem); } address = address + write_count; byte_count = byte_count - write_count; } } } else if (flags & Section) { /* not a BSS or COmment */ if (flags == (INT32) (flags & Section)) { fseek (coff_in, COFF_section_header.s_scnptr, FROM_BEGINNING); while (byte_count > 0) { temp_byte_count = MIN((INT32) byte_count, (INT32) sizeof(buffer)); if (fread((char *) buffer, (int) temp_byte_count, 1, coff_in) != 1) { fclose(coff_in); return ((-1) * MONErrCantLoadROMfile); }; /* Write to 29K memory*/ if (Mini_write_memory ((INT32) memory_space, (ADDR32) address, (INT32) temp_byte_count, (BYTE *) buffer) != SUCCESS) { (void) fclose(coff_in); return((-1) * MONErrCantWriteToMem); }; address = address + temp_byte_count; byte_count = byte_count - temp_byte_count; }; }; } } /* end while */ (void) fclose(coff_in); return (SUCCESS); } /* end Mini_loadcoff() */ /* ** Breakpoint code */ static void add_to_bp_table(id, space, offset, count, type, inst) BreakIdType *id; INT32 space; ADDR32 offset; INT32 count; INT32 type; ADDR32 inst; { static BreakIdType current_break_id=1; struct tip_break_table *temp, *temp2; if (bp_table == NULL) { /* first element */ bp_table = (struct tip_break_table *) malloc (sizeof(struct tip_break_table)); bp_table->id = current_break_id; bp_table->offset = offset; bp_table->space = space; bp_table->count = count; bp_table->type = type; bp_table->BreakInst = inst; bp_table->next = NULL; } else { temp2 = bp_table; temp = (struct tip_break_table *) malloc (sizeof(struct tip_break_table)); temp->id = current_break_id; temp->offset = offset; temp->space = space; temp->count = count; temp->type = type; temp->BreakInst = inst; temp->next = NULL; while (temp2->next != NULL) temp2 = temp2->next; temp2->next = temp; }; *id = current_break_id; current_break_id++; } static int get_from_bp_table(id, space, offset, count, type, inst) BreakIdType id; INT32 *space; ADDR32 *offset; INT32 *count; INT32 *type; ADDR32 *inst; { struct tip_break_table *temp; temp = bp_table; while (temp != NULL) { if (temp->id == id) { *offset = temp->offset; *space = temp->space; *count = temp->count; *type = temp->type; *inst = temp->BreakInst; return(0); } else { temp = temp->next; }; } return(-1); } static int remove_from_bp_table(id) BreakIdType id; { struct tip_break_table *temp, *temp2; if (bp_table == NULL) return (-1); else { temp = bp_table; if (temp->id == id) { /* head of list */ bp_table = bp_table->next; (void) free (temp); return (0); /* success */ } else { while (temp->next != NULL) { if (temp->next->id == id) { temp2 = temp->next; temp->next = temp->next->next; (void) free (temp2); return (0); /* success */ } else { temp = temp->next; } }; } }; return (-1); /* failed */ } static int update_breakpt_at(space, offset, Inst) INT32 space; ADDR32 offset; ADDR32 Inst; { struct tip_break_table *temp; temp = bp_table; while (temp != NULL) { if ((temp->space == space) && (temp->offset == offset)) { temp->BreakInst = Inst; return(0); } else { temp = temp->next; }; } return (-1); } static int is_breakpt_at(space, offset) INT32 space; ADDR32 offset; { struct tip_break_table *temp; temp = bp_table; while (temp != NULL) { if ((temp->space == space) && (temp->offset == offset)) { return((int) temp->id); /* TRUE */ } else { temp = temp->next; }; } return(0); /* FALSE */ } #ifdef MSDOS #define PATH_DELIM ";" #define DIR_SEP_CHAR (char) '\\' #define APPEND_PATH "\\lib\\" #else #define PATH_DELIM ":" #define DIR_SEP_CHAR (char) '/' #define APPEND_PATH "/lib/" #endif static FILE * FindFile(filename) char *filename; { char *path, *pathptr; char *trypath, *at; char *pathbuf; FILE *filep; /* is the filename given already complete? */ if ((filep = fopen(filename, FILE_OPEN_FLAG)) != NULL) { return(filep); }; /* get PATH */ if ((pathptr = (char *) getenv ("PATH")) == NULL) return ((FILE *) NULL); if ((path = (char *) malloc ((unsigned int)strlen(pathptr)+1))==NULL) return ((FILE *) NULL); (void) strcpy(path,pathptr); /* local copy */ /* alloc buffer */ if ((pathbuf = (char *) malloc((unsigned int) strlen(path)+ strlen("../lib/ ")+strlen(filename)+3)) == NULL) return ((FILE *) NULL); /* get first item */ if ((trypath = strtok(path, PATH_DELIM)) == NULL) { /* one item */ (void) strcpy(pathbuf,path); if ((at = strrchr (pathbuf, DIR_SEP_CHAR)) != NULL) { (void) strcpy (at, APPEND_PATH); (void) strcat (pathbuf, filename); if ((filep = fopen(pathbuf, FILE_OPEN_FLAG)) != NULL) return (filep); } else { /* just append filename */ (void) strcat (pathbuf, APPEND_PATH); (void) strcat (pathbuf, filename); if ((filep = fopen(pathbuf, FILE_OPEN_FLAG)) != NULL) return (filep); }; return ((FILE *) NULL); }; /* try all items */ while (trypath != NULL) { (void) strcpy (pathbuf, trypath); if ((at = strrchr (pathbuf, DIR_SEP_CHAR)) != NULL) { (void) strcpy (at, APPEND_PATH); (void) strcat (pathbuf, filename); if ((filep = fopen(pathbuf, FILE_OPEN_FLAG)) != NULL) return (filep); } else { /* just append filename */ (void) strcat (pathbuf, APPEND_PATH); (void) strcat (pathbuf, filename); if ((filep = fopen(pathbuf, FILE_OPEN_FLAG)) != NULL) return (filep); }; trypath = strtok((char *) 0, PATH_DELIM); } /* didn't succeed */ return ((FILE *) NULL); } void IntHandler(num) int num; { Interrupted = 1; return; }