URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [utils/] [amd-udi/] [montip/] [udi2mtip.c] - Blame information for rev 1775

Go to most recent revision | Details | Compare with Previous | 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;
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [utils/] [amd-udi/] [montip/] [udi2mtip.c] - Blame information for rev 1775

Line No.	Rev	Author	Line
1	106	markom	`static char _[] = "@(#)udi2mtip.c 5.31 93/11/03 08:34:07, Srini, AMD.";`
2			`/******************************************************************************`
3			`* Copyright 1991 Advanced Micro Devices, Inc.`
4			`*`
5			`* This software is the property of Advanced Micro Devices, Inc (AMD) which`
6			`* specifically grants the user the right to modify, use and distribute this`
7			`* software provided this notice is not removed or altered. All other rights`
8			`* are reserved by AMD.`
9			`*`
10			`* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS`
11			`* SOFTWARE. IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL`
12			`* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR`
13			`* USE OF THIS SOFTWARE.`
14			`*`
15			`* So that all may benefit from your experience, please report any problems`
16			`* or suggestions about this software to the 29K Technical Support Center at`
17			`* 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131 in the UK, or`
18			`* 0031-11-1129 in Japan, toll free. The direct dial number is 512-462-4118.`
19			`*`
20			`* Advanced Micro Devices, Inc.`
21			`* 29K Support Products`
22			`* Mail Stop 573`
23			`* 5900 E. Ben White Blvd.`
24			`* Austin, TX 78741`
25			`* 800-292-9263`
26			`*****************************************************************************`
27			`* Engineers: Srini Subramanian.`
28			`*****************************************************************************`
29			`* This module implements the UDI procedural interface routines of MONTIP`
30			`* for both the Dos and Unix environments.`
31			`*****************************************************************************`
32			`*/`
33			`#include <stdio.h>`
34			`#include <signal.h>`
35
36			`#ifdef MSDOS`
37			`#include <stdlib.h>`
38			`#include <conio.h>`
39			`#else`
40			`#include <malloc.h>`