udi2mtip.c

gdb for adsp develop

     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;