URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
Compare Revisions
- This comparison shows the changes necessary to convert path
/or1k/trunk/gdb-5.0/gdb/29k-share
- from Rev 107 to Rev 1765
- ↔ Reverse comparison
Rev 107 → Rev 1765
/udi/udi2go32.c
0,0 → 1,607
/* |
|
Interface from UDI calls in 32-bit mode to go32 in 16-bit mode. |
Communication is done through a single interrupt vector, which passes |
data through two linear buffers. |
|
Call: |
AH = 0xfe |
AL = UDI function number |
ECX = IN length |
ESI = pointer to IN buffer |
EDI = pointer to OUT buffer |
|
Return: |
EAX = return value of UDI function |
|
Vector: |
0x21 |
|
*/ |
#ifdef __GO32__ |
|
#include <stdlib.h> |
#include "udiproc.h" |
#include "udisoc.h" |
|
char dfe_errmsg[500]; |
|
static char in_buffer[4096]; |
static char out_buffer[4096]; |
static char *in_ptr; |
static char *out_ptr; |
|
#define IN_INIT() in_ptr = in_buffer |
#define IN_VAL(t,v) *((t *)in_ptr)++ = v |
#define IN_DATA(ptr, cnt) memcpy(in_ptr, ptr, cnt), in_ptr += cnt |
|
#define OUT_INIT() out_ptr = out_buffer |
#define OUT_VAL(t) (*((t *)out_ptr)++) |
#define OUT_DATA(ptr, cnt) memcpy(ptr, out_ptr, cnt), out_ptr += cnt |
|
static int DO_CALL(int function) |
{ |
asm("pushl %esi"); |
asm("pushl %edi"); |
asm("movb %0, %%al" : : "g" (function)); |
asm("movl _in_ptr, %ecx"); |
asm("movl $_in_buffer, %esi"); |
asm("subl %esi, %ecx"); |
asm("movl $_out_buffer, %edi"); |
asm("movb $0xfe, %ah"); |
asm("int $0x21"); |
asm("popl %edi"); |
asm("popl %esi"); |
} |
|
/*----------------------------------------------------------------------*/ |
|
#ifdef TEST_UDI |
int main() |
{ |
int r; |
long p2; |
short p1; |
IN_INIT(); |
IN_VAL(long, 11111111); |
IN_VAL(short, 2222); |
IN_DATA("Hello, world\n", 17); |
|
r = DO_CALL(42); |
|
OUT_INIT(); |
p1 = OUT_VAL(short); |
p2 = OUT_VAL(long); |
printf("main: p1=%d p2=%d rv=%d\n", p1, p2, r); |
return r; |
} |
#endif |
|
/*----------------------------------------------------------------------*/ |
|
unsupported(char *s) |
{ |
printf("unsupported UDI host call %s\n", s); |
abort(); |
} |
|
UDIError UDIConnect ( |
char *Configuration, /* In */ |
UDISessionId *Session /* Out */ |
) |
{ |
int r; |
out_buffer[0] = 0; /* DJ - test */ |
IN_INIT(); |
IN_DATA(Configuration, strlen(Configuration)+1); |
|
r = DO_CALL(UDIConnect_c); |
|
OUT_INIT(); |
*Session = OUT_VAL(UDISessionId); |
return r; |
} |
|
UDIError UDIDisconnect ( |
UDISessionId Session, /* In */ |
UDIBool Terminate /* In */ |
) |
{ |
int r; |
IN_INIT(); |
IN_VAL(UDISessionId, Session); |
IN_VAL(UDIBool, Terminate); |
|
return DO_CALL(UDIDisconnect_c); |
} |
|
UDIError UDISetCurrentConnection ( |
UDISessionId Session /* In */ |
) |
{ |
IN_INIT(); |
IN_VAL(UDISessionId, Session); |
|
return DO_CALL(UDISetCurrentConnection_c); |
} |
|
UDIError UDICapabilities ( |
UDIUInt32 *TIPId, /* Out */ |
UDIUInt32 *TargetId, /* Out */ |
UDIUInt32 DFEId, /* In */ |
UDIUInt32 DFE, /* In */ |
UDIUInt32 *TIP, /* Out */ |
UDIUInt32 *DFEIPCId, /* Out */ |
UDIUInt32 *TIPIPCId, /* Out */ |
char *TIPString /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
IN_VAL(UDIUInt32, DFEId); |
IN_VAL(UDIUInt32, DFE); |
r = DO_CALL(UDICapabilities_c); |
OUT_INIT(); |
*TIPId = OUT_VAL(UDIUInt32); |
*TargetId = OUT_VAL(UDIUInt32); |
*TIP = OUT_VAL(UDIUInt32); |
*DFEIPCId = OUT_VAL(UDIUInt32); |
*TIPIPCId = OUT_VAL(UDIUInt32); |
strcpy(TIPString, out_ptr); |
return r; |
} |
|
UDIError UDIEnumerateTIPs ( |
UDIInt (*UDIETCallback) /* In */ |
( char *Configuration ) /* In to callback() */ |
) |
{ |
UDIETCallback("montip.exe"); |
} |
|
UDIError UDIGetErrorMsg ( |
UDIError ErrorCode, /* In */ |
UDISizeT MsgSize, /* In */ |
char *Msg, /* Out */ |
UDISizeT *CountDone /* Out */ |
) |
{ |
int r; |
if (MsgSize > 4000) |
MsgSize = 4000; |
IN_INIT(); |
IN_VAL(UDIError, ErrorCode); |
IN_VAL(UDISizeT, MsgSize); |
|
r = DO_CALL(UDIGetErrorMsg_c); |
|
OUT_INIT(); |
*CountDone = OUT_VAL(UDISizeT); |
OUT_DATA(Msg, *CountDone); |
return r; |
} |
|
UDIError UDIGetTargetConfig ( |
UDIMemoryRange KnownMemory[], /* Out */ |
UDIInt *NumberOfRanges, /* In/Out */ |
UDIUInt32 ChipVersions[], /* Out */ |
UDIInt *NumberOfChips /* In/Out */ |
) |
{ |
int r, i; |
int nr = *NumberOfRanges; |
int nc = *NumberOfChips; |
IN_INIT(); |
IN_VAL(UDIInt, *NumberOfRanges); |
IN_VAL(UDIInt, *NumberOfChips); |
r = DO_CALL(UDIGetTargetConfig_c); |
if (r == UDIErrorIncomplete) |
return r; |
OUT_INIT(); |
*NumberOfRanges = OUT_VAL(UDIInt); |
*NumberOfChips = OUT_VAL(UDIInt); |
for (i=0; i<nr; i++) |
{ |
KnownMemory[i].Space = OUT_VAL(short); |
KnownMemory[i].Offset = OUT_VAL(CPUOffset); |
KnownMemory[i].Size = OUT_VAL(CPUSizeT); |
} |
for (i=0; i<nc; i++) |
{ |
ChipVersions[i] = OUT_VAL(UDIUInt32); |
} |
return r; |
} |
|
UDIError UDICreateProcess ( |
UDIPId *PId /* Out */ |
) |
{ |
int r = DO_CALL(UDICreateProcess_c); |
|
OUT_INIT(); |
*PId = OUT_VAL(UDIPId); |
|
return r; |
} |
|
UDIError UDISetCurrentProcess ( |
UDIPId PId /* In */ |
) |
{ |
IN_INIT(); |
IN_VAL(UDIPId, PId); |
|
return DO_CALL(UDISetCurrentProcess_c); |
} |
|
UDIError UDIDestroyProcess ( |
UDIPId PId /* In */ |
) |
{ |
IN_INIT(); |
IN_VAL(UDIPId, PId); |
|
return DO_CALL(UDIDestroyProcess_c); |
} |
|
UDIError UDIInitializeProcess ( |
UDIMemoryRange ProcessMemory[], /* In */ |
UDIInt NumberOfRanges, /* In */ |
UDIResource EntryPoint, /* In */ |
CPUSizeT StackSizes[], /* In */ |
UDIInt NumberOfStacks, /* In */ |
char *ArgString /* In */ |
) |
{ |
int i, r; |
IN_INIT(); |
IN_VAL(UDIInt, NumberOfRanges); |
for (i=0; i<NumberOfRanges; i++) |
{ |
IN_VAL(short, ProcessMemory[i].Space); |
IN_VAL(CPUOffset, ProcessMemory[i].Offset); |
IN_VAL(CPUSizeT, ProcessMemory[i].Size); |
} |
IN_VAL(short, EntryPoint.Space); |
IN_VAL(CPUOffset, EntryPoint.Offset); |
IN_VAL(UDIInt, NumberOfStacks); |
for (i=0; i<NumberOfStacks; i++) |
IN_VAL(CPUSizeT, StackSizes[i]); |
IN_DATA(ArgString, strlen(ArgString)+1); |
|
return DO_CALL(UDIInitializeProcess_c); |
} |
|
UDIError UDIRead ( |
UDIResource From, /* In */ |
UDIHostMemPtr To, /* Out */ |
UDICount Count, /* In */ |
UDISizeT Size, /* In */ |
UDICount *CountDone, /* Out */ |
UDIBool HostEndian /* In */ |
) |
{ |
int cleft = Count, cthis, dthis; |
int cdone = 0, r, bsize=2048/Size; |
|
while (cleft) |
{ |
cthis = (cleft<bsize) ? cleft : bsize; |
IN_INIT(); |
IN_VAL(short, From.Space); |
IN_VAL(CPUOffset, From.Offset); |
IN_VAL(UDICount, cthis); |
IN_VAL(UDISizeT, Size); |
IN_VAL(UDIBool, HostEndian); |
|
r = DO_CALL(UDIRead_c); |
|
OUT_INIT(); |
dthis = OUT_VAL(UDICount); |
OUT_DATA(To, dthis*Size); |
cdone += dthis; |
To += dthis*Size; |
|
if (r != UDINoError) |
{ |
*CountDone = cdone; |
return r; |
} |
cleft -= cthis; |
} |
*CountDone = cdone; |
return UDINoError; |
} |
|
UDIError UDIWrite ( |
UDIHostMemPtr From, /* In */ |
UDIResource To, /* In */ |
UDICount Count, /* In */ |
UDISizeT Size, /* In */ |
UDICount *CountDone, /* Out */ |
UDIBool HostEndian /* In */ |
) |
{ |
int cleft = Count, cthis, dthis; |
int cdone = 0, r, bsize=2048/Size; |
|
while (cleft) |
{ |
cthis = (cleft<bsize) ? cleft : bsize; |
IN_INIT(); |
IN_VAL(short, To.Space); |
IN_VAL(CPUOffset, To.Offset); |
IN_VAL(UDICount, cthis); |
IN_VAL(UDISizeT, Size); |
IN_VAL(UDIBool, HostEndian); |
IN_DATA(From, cthis*Size); |
From += cthis*Size; |
|
r = DO_CALL(UDIWrite_c); |
|
OUT_INIT(); |
cdone += OUT_VAL(UDICount); |
|
if (r != UDINoError) |
{ |
*CountDone = cdone; |
return r; |
} |
cleft -= cthis; |
} |
*CountDone = cdone; |
return UDINoError; |
} |
|
UDIError UDICopy ( |
UDIResource From, /* In */ |
UDIResource To, /* In */ |
UDICount Count, /* In */ |
UDISizeT Size, /* In */ |
UDICount *CountDone, /* Out */ |
UDIBool Direction /* In */ |
) |
{ |
int r; |
IN_INIT(); |
IN_VAL(short, From.Space); |
IN_VAL(CPUOffset, From.Offset); |
IN_VAL(short, To.Space); |
IN_VAL(CPUOffset, To.Offset); |
IN_VAL(UDICount, Count); |
IN_VAL(UDISizeT, Size); |
IN_VAL(UDIBool, Direction); |
|
r = DO_CALL(UDICopy_c); |
|
OUT_INIT(); |
*CountDone = OUT_VAL(UDICount); |
|
return r; |
} |
|
UDIError UDIExecute ( |
void |
) |
{ |
return DO_CALL(UDIExecute_c); |
} |
|
UDIError UDIStep ( |
UDIUInt32 Steps, /* In */ |
UDIStepType StepType, /* In */ |
UDIRange Range /* In */ |
) |
{ |
IN_INIT(); |
IN_VAL(UDIUInt32, Steps); |
IN_VAL(UDIStepType, StepType); |
IN_VAL(UDIRange, Range); |
|
return DO_CALL(UDIStep_c); |
} |
|
UDIVoid UDIStop ( |
void |
) |
{ |
DO_CALL(UDIStop_c); |
} |
|
UDIError UDIWait ( |
UDIInt32 MaxTime, /* In */ |
UDIPId *PId, /* Out */ |
UDIUInt32 *StopReason /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
IN_VAL(UDIInt32, MaxTime); |
r = DO_CALL(UDIWait_c); |
OUT_INIT(); |
*PId = OUT_VAL(UDIPId); |
*StopReason = OUT_VAL(UDIUInt32); |
return r; |
} |
|
UDIError UDISetBreakpoint ( |
UDIResource Addr, /* In */ |
UDIInt32 PassCount, /* In */ |
UDIBreakType Type, /* In */ |
UDIBreakId *BreakId /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
IN_VAL(short, Addr.Space); |
IN_VAL(CPUOffset, Addr.Offset); |
IN_VAL(UDIInt32, PassCount); |
IN_VAL(UDIBreakType, Type); |
|
r = DO_CALL(UDISetBreakpoint_c); |
|
OUT_INIT(); |
*BreakId = OUT_VAL(UDIBreakId); |
return r; |
} |
|
UDIError UDIQueryBreakpoint ( |
UDIBreakId BreakId, /* In */ |
UDIResource *Addr, /* Out */ |
UDIInt32 *PassCount, /* Out */ |
UDIBreakType *Type, /* Out */ |
UDIInt32 *CurrentCount /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
IN_VAL(UDIBreakId, BreakId); |
|
r = DO_CALL(UDIQueryBreakpoint_c); |
|
OUT_INIT(); |
Addr->Space = OUT_VAL(short); |
Addr->Offset = OUT_VAL(CPUOffset); |
*PassCount = OUT_VAL(UDIInt32); |
*Type = OUT_VAL(UDIBreakType); |
*CurrentCount = OUT_VAL(UDIInt32); |
|
return r; |
} |
|
UDIError UDIClearBreakpoint ( |
UDIBreakId BreakId /* In */ |
) |
{ |
IN_INIT(); |
IN_VAL(UDIBreakId, BreakId); |
|
return DO_CALL(UDIClearBreakpoint_c); |
} |
|
UDIError UDIGetStdout ( |
UDIHostMemPtr Buf, /* Out */ |
UDISizeT BufSize, /* In */ |
UDISizeT *CountDone /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
if (BufSize > 4000) |
BufSize = 4000; |
IN_VAL(UDISizeT,BufSize); |
r = DO_CALL(UDIGetStdout_c); |
OUT_INIT(); |
*CountDone = OUT_VAL(UDISizeT); |
if (*CountDone <= BufSize) |
OUT_DATA(Buf, *CountDone); |
return r; |
} |
|
UDIError UDIGetStderr ( |
UDIHostMemPtr Buf, /* Out */ |
UDISizeT BufSize, /* In */ |
UDISizeT *CountDone /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
if (BufSize > 4000) |
BufSize = 4000; |
IN_VAL(UDISizeT,BufSize); |
r = DO_CALL(UDIGetStderr_c); |
OUT_INIT(); |
*CountDone = OUT_VAL(UDISizeT); |
OUT_DATA(Buf, *CountDone); |
return r; |
} |
|
UDIError UDIPutStdin ( |
UDIHostMemPtr Buf, /* In */ |
UDISizeT Count, /* In */ |
UDISizeT *CountDone /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
if (Count > 4000) |
Count = 4000; |
IN_VAL(UDISizeT,Count); |
IN_DATA(Buf, Count); |
r = DO_CALL(UDIPutStdin_c); |
OUT_INIT(); |
*CountDone = OUT_VAL(UDISizeT); |
return r; |
} |
|
UDIError UDIStdinMode ( |
UDIMode *Mode /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
r = DO_CALL(UDIStdinMode_c); |
OUT_INIT(); |
*Mode = OUT_VAL(UDIMode); |
return r; |
} |
|
UDIError UDIPutTrans ( |
UDIHostMemPtr Buf, /* In */ |
UDISizeT Count, /* In */ |
UDISizeT *CountDone /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
if (Count > 4000) |
Count = 4000; |
IN_VAL(UDISizeT,Count); |
IN_DATA(Buf, Count); |
r = DO_CALL(UDIPutTrans_c); |
OUT_INIT(); |
*CountDone = OUT_VAL(UDISizeT); |
return r; |
} |
|
UDIError UDIGetTrans ( |
UDIHostMemPtr Buf, /* Out */ |
UDISizeT BufSize, /* In */ |
UDISizeT *CountDone /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
if (BufSize > 4000) |
BufSize = 4000; |
IN_VAL(UDISizeT,BufSize); |
r = DO_CALL(UDIGetTrans_c); |
OUT_INIT(); |
*CountDone = OUT_VAL(UDISizeT); |
OUT_DATA(Buf, *CountDone); |
return r; |
} |
|
UDIError UDITransMode ( |
UDIMode *Mode /* Out */ |
) |
{ |
int r; |
IN_INIT(); |
r = DO_CALL(UDITransMode_c); |
OUT_INIT(); |
*Mode = OUT_VAL(UDIMode); |
return r; |
} |
|
#define DFEIPCIdCompany 0x0001 /* Company ID AMD */ |
#define DFEIPCIdProduct 0x1 /* Product ID 0 */ |
#define DFEIPCIdVersion 0x125 /* 1.2.5 */ |
|
unsigned UDIGetDFEIPCId () |
{ |
return((((UDIUInt32)DFEIPCIdCompany) << 16) |(DFEIPCIdProduct << 12) | DFEIPCIdVersion); |
} |
|
#endif /* __GO32__ */ |
/udi/udiphcfg.h
0,0 → 1,44
/* This file just picks the correct udiphxxx.h depending on the host. |
The two hosts that are now defined are UNIX and MSDOS. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
/* |
* For the moment, we will default to BSD_IPC; this might change if/when |
* another type of IPC (Mach? SysV?) is implemented. |
*/ |
|
#if 0 |
|
/* We don't seem to have a copy of udiphdos.h. Furthermore, all the |
things in udiphunix.h are pretty much generic 32-bit machine defines |
which don't have anything to do with IPC. */ |
|
#ifdef DOS_IPC |
#include "udiphdos.h" |
#else |
/*#ifdef BSD_IPC */ |
#include "udiphunix.h" |
#endif |
|
#else |
|
#include "udiphunix.h" |
|
#endif |
/udi/udipt29k.h
0,0 → 1,87
/* This file is to be used to reconfigure the UDI Procedural interface |
for a given target. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
/* This file should be placed so that it will be |
included from udiproc.h. Everything in here will probably need to |
be changed when you change the target processor. Nothing in here |
should need to change when you change hosts or compilers. |
*/ |
|
/* Select a target CPU Family */ |
#define TargetCPUFamily Am29K |
|
/* Enumerate the processor specific values for Space in a resource */ |
#define UDI29KDRAMSpace 0 |
#define UDI29KIOSpace 1 |
#define UDI29KCPSpace0 2 |
#define UDI29KCPSpace1 3 |
#define UDI29KIROMSpace 4 |
#define UDI29KIRAMSpace 5 |
#define UDI29KLocalRegs 8 |
#define UDI29KGlobalRegs 9 |
#define UDI29KRealRegs 10 |
#define UDI29KSpecialRegs 11 |
#define UDI29KTLBRegs 12 /* Not Am29005 */ |
#define UDI29KACCRegs 13 /* Am29050 only */ |
#define UDI29KICacheSpace 14 /* Am2903x only */ |
#define UDI29KAm29027Regs 15 /* When available */ |
#define UDI29KPC 16 |
#define UDI29KDCacheSpace 17 /* When available */ |
|
/* Enumerate the Co-processor registers */ |
#define UDI29KCP_F 0 |
#define UDI29KCP_Flag 8 |
#define UDI29KCP_I 12 |
#define UDI29KCP_ITmp 16 |
#define UDI29KCP_R 20 |
#define UDI29KCP_S 28 |
#define UDI29KCP_RTmp 36 |
#define UDI29KCP_STmp 44 |
#define UDI29KCP_Stat 52 |
#define UDI29KCP_Prec 56 |
#define UDI29KCP_Reg0 60 |
#define UDI29KCP_Reg1 68 |
#define UDI29KCP_Reg2 76 |
#define UDI29KCP_Reg3 84 |
#define UDI29KCP_Reg4 92 |
#define UDI29KCP_Reg5 100 |
#define UDI29KCP_Reg6 108 |
#define UDI29KCP_Reg7 116 |
#define UDI29KCP_Mode 124 |
|
/* Enumerate the stacks in StackSizes array */ |
#define UDI29KMemoryStack 0 |
#define UDI29KRegisterStack 1 |
|
/* Enumerate the chips for ChipVersions array */ |
#define UDI29K29KVersion 0 |
#define UDI29K29027Version 1 |
|
/* Define special value for elements of ChipVersions array for |
* chips not present */ |
#define UDI29KChipNotPresent -1 |
|
typedef UDIInt32 UDICount; |
typedef UDIUInt32 UDISize; |
|
typedef UDIInt CPUSpace; |
typedef UDIUInt32 CPUOffset; |
typedef UDIUInt32 CPUSizeT; |
/udi/udiphunix.h
0,0 → 1,81
/* Originally called "udiphsun.h", however it was not very |
Sun-specific; now it is used for generic-unix-with-bsd-ipc. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
/* This file is to be used to reconfigure the UDI Procedural interface |
for a given host. This file should be placed so that it will be |
included from udiproc.h. Everything in here may need to be changed |
when you change either the host CPU or its compiler. Nothing in |
here should change to support different targets. There are multiple |
versions of this file, one for each of the different host/compiler |
combinations in use. |
*/ |
|
#define UDIStruct struct /* _packed not needed on unix */ |
/* First, we need some types */ |
/* Types with at least the specified number of bits */ |
typedef double UDIReal64; /* 64-bit real value */ |
typedef float UDIReal32; /* 32-bit real value */ |
|
typedef unsigned long UDIUInt32; /* unsigned integers */ |
typedef unsigned short UDIUInt16; |
typedef unsigned char UDIUInt8; |
|
typedef long UDIInt32; /* 32-bit integer */ |
typedef short UDIInt16; /* 16-bit integer */ |
typedef char UDIInt8; /* unreliable signedness */ |
|
/* To aid in supporting environments where the DFE and TIP use |
different compilers or hosts (like DOS 386 on one side, 286 on the |
other, or different Unix machines connected by sockets), we define |
two abstract types - UDIInt and UDISizeT. |
UDIInt should be defined to be int except for host/compiler combinations |
that are intended to talk to existing UDI components that have a different |
sized int. Similarly for UDISizeT. |
*/ |
typedef int UDIInt; |
typedef unsigned int UDIUInt; |
|
typedef unsigned int UDISizeT; |
|
/* Now two void types. The first is for function return types, |
the other for pointers to no particular type. Since these types |
are used solely for documentational clarity, if your host/compiler |
doesn't support either one, replace them with int and char * |
respectively. |
*/ |
typedef void UDIVoid; /* void type */ |
typedef void * UDIVoidPtr; /* void pointer type */ |
typedef void * UDIHostMemPtr; /* Arbitrary memory pointer */ |
|
/* Now we want a type optimized for boolean values. Normally this |
would be int, but on some machines (Z80s, 8051s, etc) it might |
be better to map it onto a char |
*/ |
typedef int UDIBool; |
|
/* Now indicate whether your compiler support full ANSI style |
prototypes. If so, use #if 1. If not use #if 0. |
*/ |
#if 0 |
#define UDIParams(x) x |
#else |
#define UDIParams(x) () |
#endif |
/udi/udiids.h
0,0 → 1,48
/* This file contains the DFE and TIP IDs to be used by AMD products for |
the UDICapabilities call. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
/* Company Codes -- AMD assigns these */ |
#define UDICompanyCode_AMD 1 |
|
/* Build a UDIID given a CompanyProdCode and 3 version pieces */ |
#define UDIID(CompanyProdCode, v1,v2,v3) ((((CompanyProdCode) & 0xfffff)<<12)+\ |
(((v1)&0xf)<<8) + (((v2)&0xf)<<4) + ((v3)&0xf)) |
|
|
/* Extract a CompanyProdCode or a Version from a UDIID */ |
#define UDIID_CompanyProdCode(id) (((id)>>12) & 0xfffff) |
#define UDIID_Version(id) ((id)&0xfff) |
|
|
#define UDIAMDProduct(ProdCode) ((UDICompanyCode_AMD<<4) + (ProdCode&0xf)) |
|
/* AMD DFE Product Codes */ |
#define UDIProductCode_Mondfe UDIAMDProduct(0) |
#define UDIProductCode_XRAY UDIAMDProduct(1) |
#define UDIProductCode_TIPTester UDIAMDProduct(2) |
|
/* AMD TIP Product Codes (need not be distinct from DFE Product Codes) */ |
#define UDIProductCode_Montip UDIAMDProduct(0) |
#define UDIProductCode_Isstip UDIAMDProduct(1) |
|
|
#define UDILatestVersion 0x120 /* UDI 1.2.0, can be used in DFE and TIP desired UDI params */ |
|
/udi/udip2soc.c
0,0 → 1,1250
/* Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
static char udip2soc_c[]="@(#)udip2soc.c 2.11 Daniel Mann"; |
static char udip2soc_c_AMD[]="@(#)udip2soc.c 2.8, AMD"; |
/* |
* This module converts UDI Procedural calls into |
* UDI socket messages for UNIX. |
* It is used by DFE client processes |
********************************************************************** HISTORY |
*/ |
/* This is all unneeded on DOS machines. */ |
#ifndef __GO32__ |
|
#include <stdio.h> |
#include <string.h> |
|
/* Before sys/file.h for Unixware. */ |
#include <sys/types.h> |
|
#include <sys/file.h> |
|
/* This used to say sys/fcntl.h, but the only systems I know of that |
require that are old (pre-4.3, at least) BSD systems, which we |
probably don't need to worry about. */ |
#include <fcntl.h> |
|
#include <sys/wait.h> |
#include <sys/time.h> |
#include <sys/resource.h> |
#include <sys/socket.h> |
#include <netinet/in.h> |
#include <netdb.h> |
#include <signal.h> |
#include <sys/errno.h> |
#include "udiproc.h" |
#include "udisoc.h" |
|
extern int errno; |
extern int sys_nerr; |
extern int udr_errno; |
extern char* getenv(); |
|
/* local type decs. and macro defs. not in a .h file ************* MACRO/TYPE |
*/ |
#define version_c 0x121 /* DFE-IPC version id */ |
#define TRUE -1 |
#define FALSE 0 |
#define PORT_NUM 7000 |
#define MAX_SESSIONS 5 /* maximum DFE-TIP connections */ |
#define SOC_BUF_SIZE 4* 1024 /* size of socket comms buffer */ |
#define SBUF_SIZE 500 /* size of string buffer */ |
#define ERRMSG_SIZE 500 /* size of error message buffer */ |
|
typedef struct connection_str /* record of connect session */ |
{ |
int in_use; |
char connect_id[20]; /* connection identifier */ |
char domain_string[20]; /* dommaing for conection */ |
char tip_string[30]; /* TIP host name for AF_INET */ |
char tip_exe[80]; /* TIP exe name */ |
int dfe_sd; /* associated DFE socket */ |
int tip_pid; /* pid of TIP process */ |
struct sockaddr_in dfe_sockaddr; |
struct sockaddr_in tip_sockaddr_in; |
struct sockaddr tip_sockaddr; |
} connection_t; |
|
typedef struct session_str |
{ |
int in_use; |
connection_t* soc_con_p; /* associated connection */ |
UDISessionId tip_id; /* associated TIP session ID */ |
} session_t; |
|
/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS |
*/ |
UDIError dfe_errno; |
char dfe_errmsg[ERRMSG_SIZE];/* error string */ |
|
/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS |
*/ |
LOCAL connection_t soc_con[MAX_SESSIONS]; |
LOCAL session_t session[MAX_SESSIONS]; |
LOCAL UDR udr; |
LOCAL UDR* udrs = &udr; /* UDR for current session */ |
LOCAL int current; /* int-id for current session */ |
LOCAL char sbuf[SBUF_SIZE]; /* String handler buffer */ |
LOCAL char config_file[80]; /* path/name for config file */ |
|
/***************************************************************** UDI_CONNECT |
* Establish a new FDE to TIP conection. The file "./udi_soc" or |
* "/etc/udi_soc" may be examined to obtain the conection information |
* if the "Config" parameter is not a completd "line entry". |
* |
* NOTE: the Session string must not start whith white-space characters. |
* Format of string is: |
* <session> <domain> <soc_name|host_name> <tip_exe|port> <pass to UDIconnect> |
* soc2cayman AF_INET cayman 7000 <not supported> |
* soc2tip AF_UNIX astring tip.exe ... |
*/ |
UDIError |
UDIConnect(Config, Session) |
char *Config; /* in -- identification string */ |
UDISessionId *Session; /* out -- session ID */ |
{ |
UDIInt32 service_id = UDIConnect_c; |
int domain; |
int cnt=0; |
int rcnt, pos, params_pos=0; |
char *tip_main_string; |
char *env_p; |
struct hostent *tip_info_p; |
FILE *fd; |
#if 0 |
FILE *f_p; |
#endif |
UDIUInt32 TIPIPCId; |
UDIUInt32 DFEIPCId; |
|
#if 0 /* This is crap. It assumes that udi_soc is executable! */ |
sprintf(sbuf, "which udi_soc"); |
f_p = popen(sbuf, "r"); |
if(f_p) |
{ while( (sbuf[cnt++]=getc(f_p)) != EOF); |
sbuf[cnt-2]=0; |
} |
pclose(f_p); |
#endif |
|
for (rcnt=0; |
rcnt < MAX_SESSIONS && session[rcnt].in_use; |
rcnt++); |
|
if (rcnt >= MAX_SESSIONS) |
{ |
sprintf(dfe_errmsg, "DFE-ipc ERROR: Too many sessions already open"); |
return UDIErrorIPCLimitation; |
} |
|
/* One connection can be multiplexed between several sessions. */ |
|
for (cnt=0; |
cnt < MAX_SESSIONS && soc_con[cnt].in_use; |
cnt++); |
|
if (cnt >= MAX_SESSIONS) |
{ |
sprintf(dfe_errmsg, |
"DFE-ipc ERROR: Too many connections already open"); |
return UDIErrorIPCLimitation; |
} |
|
*Session = rcnt; |
session[rcnt].soc_con_p = &soc_con[cnt]; |
|
if (strchr(Config, ' ')) /* test if file entry given */ |
{ |
soc_con[cnt].in_use = TRUE; |
sscanf(Config, "%s %s %s %s %n", |
soc_con[cnt].connect_id, |
soc_con[cnt].domain_string, |
soc_con[cnt].tip_string, |
soc_con[cnt].tip_exe, |
¶ms_pos); |
tip_main_string = Config + params_pos; |
} |
else /* here if need to read udi_soc file */ |
{ |
strcpy(config_file, "udi_soc"); |
env_p = getenv("UDICONF"); |
if (env_p) |
strcpy(config_file, env_p); |
|
fd = fopen(config_file, "r"); |
|
if (!fd) |
{ |
sprintf(dfe_errmsg, "UDIConnect, can't open udi_soc file:\n%s ", |
strerror(errno)); |
dfe_errno = UDIErrorCantOpenConfigFile; |
goto tip_failure; |
} |
|
while (1) |
{ |
if (fscanf(fd, "%s %s %s %s %[^\n]\n", |
soc_con[cnt].connect_id, |
soc_con[cnt].domain_string, |
soc_con[cnt].tip_string, |
soc_con[cnt].tip_exe, |
sbuf) == EOF) |
break; |
|
if (strcmp(Config, soc_con[cnt].connect_id) != 0) |
continue; |
|
soc_con[cnt].in_use = TRUE; /* here if entry found */ |
|
tip_main_string = sbuf; |
break; |
} |
|
fclose(fd); |
if (!soc_con[cnt].in_use) |
{ |
sprintf(dfe_errmsg, |
"UDIConnect, can't find `%s' entry in udi_soc file", |
Config); |
dfe_errno = UDIErrorNoSuchConfiguration; |
goto tip_failure; |
} |
} |
/*----------------------------------------------------------- SELECT DOMAIN */ |
if (strcmp(soc_con[cnt].domain_string, "AF_UNIX") == 0) |
domain = AF_UNIX; |
else if (strcmp(soc_con[cnt].domain_string, "AF_INET") == 0) |
domain = AF_INET; |
else |
{ |
sprintf(dfe_errmsg, "DFE-ipc ERROR: socket address family not known"); |
dfe_errno = UDIErrorBadConfigFileEntry; |
goto tip_failure; |
} |
|
/*---------------------------------------------------- MULTIPLEXED SOCKET ? */ |
/* If the requested session requires communication with |
a TIP which already has a socket connection established, |
then we do not create a new socket but multiplex the |
existing one. A TIP is said to use the same socket if |
socket-name/host-name and the domain are the same. |
*/ |
for (rcnt=0; rcnt < MAX_SESSIONS; rcnt++) |
{ |
if (soc_con[rcnt].in_use |
&& rcnt != cnt |
&& strcmp(soc_con[cnt].domain_string, |
soc_con[rcnt].domain_string) == 0 |
&& strcmp(soc_con[cnt].tip_string, |
soc_con[rcnt].tip_string) == 0) |
{ |
session[*Session].soc_con_p = &soc_con[rcnt]; |
soc_con[cnt].in_use = FALSE; /* don't need new connect */ |
goto tip_connect; |
} |
} |
/*------------------------------------------------------------------ SOCKET */ |
soc_con[cnt].dfe_sd = socket(domain, SOCK_STREAM, 0); |
if (soc_con[cnt].dfe_sd == -1) |
{ |
sprintf(dfe_errmsg, "DFE-ipc ERROR, socket() call failed %s ", |
strerror (errno)); |
dfe_errno = UDIErrorUnknownError; |
goto tip_failure; |
} |
|
/*--------------------------------------------------------- AF_UNIX CONNECT */ |
if (domain == AF_UNIX) |
{ |
if (strcmp(soc_con[cnt].tip_string, "*") == 0) |
{ |
for (pos = 0; pos < 20; pos++) |
{ |
int f; |
|
sprintf(soc_con[cnt].tip_string,"/tmp/U%d", getpid() + pos); |
f = open(soc_con[cnt].tip_string, O_CREAT); |
if (f == -1) |
continue; |
|
close(f); |
unlink(soc_con[cnt].tip_string); |
break; |
} |
|
if (pos >= 20) |
{ |
sprintf(dfe_errmsg, |
"DFE-ipc ERROR, can't create random socket name"); |
dfe_errno = UDIErrorCantConnect; |
goto tip_failure; |
} |
} |
|
soc_con[cnt].tip_sockaddr.sa_family = domain; |
memcpy(soc_con[cnt].tip_sockaddr.sa_data, |
soc_con[cnt].tip_string, |
sizeof(soc_con[cnt].tip_sockaddr.sa_data)); |
if (connect(soc_con[cnt].dfe_sd, |
&soc_con[cnt].tip_sockaddr, |
sizeof(soc_con[cnt].tip_sockaddr))) |
{ /* if connect() fails assume TIP not yet started */ |
/*------------------------------------------------------------ AF_UNIX EXEC */ |
int pid; |
int statusp; |
char *arg0; |
|
arg0 = strrchr(soc_con[cnt].tip_exe,'/'); |
|
if (arg0) |
arg0++; |
else |
arg0 = soc_con[cnt].tip_exe; |
|
pid = vfork(); |
|
if (pid == 0) /* Child */ |
{ |
execlp(soc_con[cnt].tip_exe, |
arg0, |
soc_con[cnt].domain_string, |
soc_con[cnt].tip_string, |
NULL); |
_exit(1); |
} |
|
if (waitpid(pid, &statusp, WNOHANG)) |
{ |
sprintf(dfe_errmsg, "DFE-ipc ERROR: can't exec the TIP"); |
dfe_errno = UDIErrorCantStartTIP; |
goto tip_failure; |
} |
|
pos = 3; |
for (pos = 3; pos > 0; pos--) |
{ |
if (!connect(soc_con[cnt].dfe_sd, |
&soc_con[cnt].tip_sockaddr, |
sizeof(soc_con[cnt].tip_sockaddr))) |
break; |
sleep(1); |
} |
|
if (pos == 0) |
{ |
sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed: %s", |
strerror (errno)); |
dfe_errno = UDIErrorCantConnect; |
goto tip_failure; |
} |
} |
} |
/*--------------------------------------------------------- AF_INET CONNECT */ |
else if (domain == AF_INET) |
{ |
fprintf(stderr, |
"DFE-ipc WARNING, need to have first started remote TIP"); |
|
soc_con[cnt].tip_sockaddr_in.sin_family = domain; |
soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr = |
inet_addr(soc_con[cnt].tip_string); |
if (soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr == -1) |
{ |
tip_info_p = gethostbyname(soc_con[cnt].tip_string); |
if (tip_info_p == NULL) |
{ |
sprintf(dfe_errmsg,"DFE-ipc ERROR, No such host %s", |
soc_con[cnt].tip_string); |
dfe_errno = UDIErrorNoSuchConnection; |
goto tip_failure; |
} |
memcpy((char *)&soc_con[cnt].tip_sockaddr_in.sin_addr, |
tip_info_p->h_addr, |
tip_info_p->h_length); |
} |
soc_con[cnt].tip_sockaddr_in.sin_port |
= htons(atoi(soc_con[cnt].tip_exe)); |
|
if (connect(soc_con[cnt].dfe_sd, |
(struct sockaddr *) &soc_con[cnt].tip_sockaddr_in, |
sizeof(soc_con[cnt].tip_sockaddr_in))) |
{ |
sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed %s ", |
strerror (errno)); |
dfe_errno = UDIErrorCantConnect; |
goto tip_failure; |
} |
} |
/*------------------------------------------------------------- TIP CONNECT */ |
if (cnt == 0) udr_create(udrs, soc_con[cnt].dfe_sd, SOC_BUF_SIZE); |
|
tip_connect: |
current = cnt; |
session[*Session].in_use = TRUE; /* session id is now in use */ |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
|
DFEIPCId = (company_c << 16) + (product_c << 12) + version_c; |
udr_UDIUInt32(udrs, &DFEIPCId); |
|
udr_string(udrs, tip_main_string); |
|
udr_sendnow(udrs); |
|
udrs->udr_op = UDR_DECODE; /* recv all "out" parameters */ |
udr_UDIUInt32(udrs, &TIPIPCId); |
if ((TIPIPCId & 0xfff) < version_c) |
sprintf(dfe_errmsg, "DFE-ipc: Obsolete TIP Specified"); |
|
udr_UDIInt32(udrs, &soc_con[cnt].tip_pid); |
|
udr_UDISessionId(udrs, &session[*Session].tip_id); |
|
udr_UDIError(udrs, &dfe_errno); |
if (dfe_errno > 0) UDIKill(*Session, 0); |
|
return dfe_errno; |
|
tip_failure: |
|
soc_con[cnt].in_use = FALSE; |
session[*Session].in_use = FALSE; |
/* XXX - Should also close dfe_sd, but not sure what to do if muxed */ |
return dfe_errno; |
} |
|
/************************************************************** UDI_Disconnect |
* UDIDisconnect() should be called before exiting the |
* DFE to ensure proper shut down of the TIP. |
*/ |
UDIError UDIDisconnect(Session, Terminate) |
UDISessionId Session; |
UDIBool Terminate; |
{ |
int cnt; |
UDIInt32 service_id = UDIDisconnect_c; |
if(Session < 0 || Session > MAX_SESSIONS) |
{ |
sprintf(dfe_errmsg," SessionId not valid (%d)", Session); |
return UDIErrorNoSuchConfiguration; |
} |
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISessionId(udrs, &session[Session].tip_id); |
udr_UDIBool(udrs, &Terminate); |
udr_sendnow(udrs); |
|
session[Session].in_use = FALSE; /* session id is now free */ |
for (cnt=0; cnt < MAX_SESSIONS; cnt++) |
if(session[cnt].in_use |
&& session[cnt].soc_con_p == session[Session].soc_con_p |
) break; |
if(cnt >= MAX_SESSIONS) /* test if socket not multiplexed */ |
if(shutdown(session[Session].soc_con_p->dfe_sd, 2)) |
{ |
sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed"); |
return UDIErrorIPCInternal; |
} |
else |
session[Session].soc_con_p->in_use = 0; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/******************************************************************** UDI_KILL |
* UDIKill() is used to send a signal to the TIP. |
* This is a private IPC call. |
*/ |
UDIError UDIKill(Session, Signal) |
UDISessionId Session; |
UDIInt32 Signal; |
{ |
int cnt; |
UDIInt32 service_id = UDIKill_c; |
if(Session < 0 || Session > MAX_SESSIONS) |
{ |
sprintf(dfe_errmsg," SessionId not valid (%d)", Session); |
return UDIErrorNoSuchConfiguration; |
} |
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISessionId(udrs, &session[Session].tip_id); |
udr_UDIInt32(udrs, &Signal); |
udr_sendnow(udrs); |
|
session[Session].in_use = FALSE; /* session id is now free */ |
for (cnt=0; cnt < MAX_SESSIONS; cnt++) |
if(session[cnt].in_use |
&& session[cnt].soc_con_p == session[Session].soc_con_p |
) break; |
if(cnt < MAX_SESSIONS) /* test if socket not multiplexed */ |
if(shutdown(session[Session].soc_con_p->dfe_sd, 2)) |
{ |
sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed"); |
return UDIErrorIPCInternal; |
} |
else |
session[Session].soc_con_p->in_use = 0; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/************************************************** UDI_Set_Current_Connection |
* If you are connected to multiple TIPs, you can change |
* TIPs using UDISetCurrentConnection(). |
*/ |
UDIError UDISetCurrentConnection(Session) |
UDISessionId Session; |
{ |
UDIInt32 service_id = UDISetCurrentConnection_c; |
|
if(Session < 0 || Session > MAX_SESSIONS) |
return UDIErrorNoSuchConfiguration; |
if(!session[Session].in_use) /* test if not in use yet */ |
return UDIErrorNoSuchConnection; |
|
current = Session; |
/* change socket or multiplex the same socket */ |
udrs->sd = session[Session].soc_con_p->dfe_sd; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISessionId(udrs, &session[Session].tip_id); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/************************************************************ UDI_Capabilities |
* The DFE uses UDICapabilities() to both inform the TIP |
* of what services the DFE offers and to inquire of the |
* TIP what services the TIP offers. |
*/ |
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 */ |
{ |
UDIInt32 service_id = UDICapabilities_c; |
int size; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIInt32(udrs, &DFEId); |
udr_UDIInt32(udrs, &DFE); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ |
udr_UDIInt32(udrs, TIPId); |
udr_UDIInt32(udrs, TargetId); |
udr_UDIInt32(udrs, TIP); |
udr_UDIInt32(udrs, DFEIPCId); |
*DFEIPCId = (company_c << 16) + (product_c << 12) + version_c; |
udr_UDIInt32(udrs, TIPIPCId); |
udr_string(udrs, sbuf); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
size = strlen(sbuf); |
if(size +1 > 80) return -1; /* test if sufficient space */ |
strcpy(TIPString, sbuf); |
return dfe_errno; |
} |
|
/********************************************************** UDI_Enumerate_TIPs |
* Used by the DFE to enquire about available TIP |
* connections. |
*/ |
UDIError UDIEnumerateTIPs(UDIETCallback) |
int (*UDIETCallback)(); /* In -- function to callback */ |
{ |
FILE *fp; |
|
fp = fopen(config_file, "r"); |
if(fp == NULL) |
return UDIErrorCantOpenConfigFile; |
while(fgets( sbuf, SBUF_SIZE, fp)) |
if(UDIETCallback( sbuf) == UDITerminateEnumeration) |
break; |
fclose( fp); |
return UDINoError; /* return success */ |
} |
|
/*********************************************************** UDI_GET_ERROR_MSG |
* Some errors are target specific. They are indicated |
* by a negative error return value. The DFE uses |
* UDIGetErrorMsg() to get the descriptive text for |
* the error message which can then be displayed to |
* the user. |
*/ |
UDIError UDIGetErrorMsg(error_code, msg_len, msg, CountDone) |
UDIError error_code; /* In */ |
UDISizeT msg_len; /* In -- allowed message space */ |
char* msg; /* Out -- length of message*/ |
UDISizeT *CountDone; /* Out -- number of characters */ |
{ |
UDIInt32 service_id = UDIGetErrorMsg_c; |
int size; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIError(udrs, &error_code); |
udr_UDISizeT(udrs, &msg_len); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_string(udrs, sbuf); |
udr_UDISizeT(udrs, CountDone); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
size = strlen(sbuf); |
if(size +1 > msg_len) return -1; /* test if sufficient space */ |
strcpy(msg, sbuf); |
return dfe_errno; |
} |
|
/******************************************************* UDI_GET_TARGET_CONFIG |
* UDIGetTargetConfig() gets information about the target. |
*/ |
UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions, |
NumberOfChips) |
UDIMemoryRange KnownMemory[]; /* Out */ |
UDIInt *NumberOfRanges; /* In and Out */ |
UDIUInt32 ChipVersions[]; /* Out */ |
UDIInt *NumberOfChips; /* In and Out */ |
{ |
UDIInt32 service_id = UDIGetTargetConfig_c; |
int cnt; |
int MaxOfRanges = *NumberOfRanges; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIInt(udrs, NumberOfRanges); |
udr_UDIInt(udrs, NumberOfChips); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ |
for(cnt=1; cnt <= MaxOfRanges; cnt++) |
udr_UDIMemoryRange(udrs, &KnownMemory[cnt-1]); |
udr_UDIInt(udrs, NumberOfRanges); |
udr_UDIInt(udrs, NumberOfChips); |
for(cnt=1; cnt <= *NumberOfChips; cnt++) |
udr_UDIUInt32(udrs, &ChipVersions[cnt -1]); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/********************************************************** UDI_CREATE_PRCOESS |
* UDICreateProcess() tells the target OS that a |
* process is to be created and gets a PID back unless |
* there is some error. |
*/ |
UDIError UDICreateProcess(pid) |
UDIPId *pid; /* out */ |
{ |
UDIInt32 service_id = UDICreateProcess_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIPId(udrs, pid); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/***************************************************** UDI_Set_Current_Process |
* UDISetCurrentProcess uses a pid supplied by |
* UDICreateProcess and sets it as the default for all |
* udi calls until a new one is set. A user of a |
*/ |
UDIError UDISetCurrentProcess (pid) |
UDIPId pid; /* In */ |
{ |
UDIInt32 service_id = UDISetCurrentProcess_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIPId(udrs, &pid); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/****************************************************** UDI_INITIALISE_PROCESS |
* UDIInitializeProcess() prepare process for |
* execution. (Reset processor if process os processor). |
*/ |
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 */ |
{ |
UDIInt32 service_id = UDIInitializeProcess_c; |
int cnt; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIInt(udrs, &NumberOfRanges); |
for(cnt = 0; cnt < NumberOfRanges; cnt++) |
udr_UDIMemoryRange(udrs, &ProcessMemory[cnt] ); |
udr_UDIResource(udrs, &EntryPoint); |
udr_UDIInt(udrs, &NumberOfStacks); |
for(cnt = 0; cnt < NumberOfStacks; cnt++) |
udr_CPUSizeT(udrs, &StackSizes[cnt]); |
udr_string(udrs, ArgString); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/********************************************************* UDI_DESTROY_PROCESS |
* UDIDestroyProcess() frees a process resource |
* previously created by UDICreateProcess(). |
*/ |
UDIError UDIDestroyProcess(pid) |
UDIPId pid; /* in */ |
{ |
UDIInt32 service_id = UDIDestroyProcess_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIPId(udrs, &pid); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/****************************************************************** UDI_READ |
* UDIRead() reads a block of objects from a target |
* address space to host space. |
*/ |
|
UDIError UDIRead (from, to, count, size, count_done, host_endian) |
UDIResource from; /* in - source address on target */ |
UDIHostMemPtr to; /* out - destination address on host */ |
UDICount count; /* in -- count of objects to be transferred */ |
UDISizeT size; /* in -- size of each object */ |
UDICount *count_done; /* out - count actually transferred */ |
UDIBool host_endian; /* in -- flag for endian information */ |
{ |
UDIInt32 service_id = UDIRead_c; |
int byte_count; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIResource(udrs, &from); |
udr_UDICount(udrs, &count); |
udr_UDISizeT(udrs, &size); |
udr_UDIBool(udrs, &host_endian); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ |
udr_UDICount(udrs, count_done); |
byte_count = (*count_done) * size; |
if(*count_done > 0 && *count_done <= count) |
udr_bytes(udrs, to, byte_count); |
if(udr_errno) return udr_errno; |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/****************************************************************** UDI_WRITE |
* UDIWrite() writes a block of objects from host |
* space to a target address+space. |
*/ |
UDIError UDIWrite( from, to, count, size, count_done, host_endian ) |
UDIHostMemPtr from; /* in -- source address on host */ |
UDIResource to; /* in -- destination address on target */ |
UDICount count; /* in -- count of objects to be transferred */ |
UDISizeT size; /* in -- size of each object */ |
UDICount *count_done; /* out - count actually transferred */ |
UDIBool host_endian; /* in -- flag for endian information */ |
{ |
UDIInt32 service_id = UDIWrite_c; |
int byte_count = count * size; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIResource(udrs, &to); |
udr_UDICount(udrs, &count); |
udr_UDISizeT(udrs, &size); |
udr_UDIBool(udrs, &host_endian); |
udr_bytes(udrs, from, byte_count); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */ |
udr_UDICount(udrs, count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/******************************************************************** UDI_COPY |
* UDICopy() copies a block of objects from one target |
* get address/space to another target address/space. |
*/ |
UDIError UDICopy(from, to, count, size, count_done, direction ) |
UDIResource from; /* in -- destination address on target */ |
UDIResource to; /* in -- source address on target */ |
UDICount count; /* in -- count of objects to be transferred */ |
UDISizeT size; /* in -- size of each object */ |
UDICount *count_done; /* out - count actually transferred */ |
UDIBool direction; /* in -- high-to-low or reverse */ |
{ |
UDIInt32 service_id = UDICopy_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIResource(udrs, &from); |
udr_UDIResource(udrs, &to); |
udr_UDICount(udrs, &count); |
udr_UDISizeT(udrs, &size); |
udr_UDIBool(udrs, &direction); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDICount(udrs, count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/***************************************************************** UDI_EXECUTE |
* UDIExecute() continues execution of the default |
* process from the current PC. |
*/ |
UDIError UDIExecute() |
{ |
UDIInt32 service_id = UDIExecute_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/******************************************************************** UDI_STEP |
* UDIStep() specifies a number of "instruction" |
* steps to make. |
*/ |
UDIError UDIStep(steps, steptype, range) |
UDIUInt32 steps; /* in -- number of steps */ |
UDIStepType steptype; /* in -- type of stepping to be done */ |
UDIRange range; /* in -- range if StepInRange is TRUE */ |
{ |
UDIInt32 service_id = UDIStep_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIInt32(udrs, &steps); |
udr_UDIStepType(udrs, &steptype); |
udr_UDIRange(udrs, &range); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/******************************************************************** UDI_STOP |
* UDIStop() stops the default process |
*/ |
UDIVoid UDIStop() |
{ |
if (strcmp(session[current].soc_con_p->domain_string, "AF_UNIX") == 0) |
kill(session[current].soc_con_p->tip_pid, SIGINT); |
else |
udr_signal(udrs); |
|
/* XXX - should clean up session[] and soc_con[] structs here as well... */ |
|
return; |
} |
|
/******************************************************************** UDI_WAIT |
* UDIWait() returns the state of the target procesor. |
*/ |
UDIError UDIWait(maxtime, pid, stop_reason) |
UDIInt32 maxtime; /* in -- maximum time to wait for completion */ |
UDIPId *pid; /* out -- pid of process which stopped if any */ |
UDIUInt32 *stop_reason; /* out -- PC where process stopped */ |
{ |
UDIInt32 service_id = UDIWait_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIInt32(udrs, &maxtime); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIPId(udrs, pid); |
udr_UDIUInt32(udrs, stop_reason); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/********************************************************** UDI_SET_BREAKPOINT |
* UDISetBreakpoint() sets a breakpoint at an adress |
* and uses the passcount to state how many |
* times that instruction should be hit before the |
* break occurs. |
*/ |
UDIError UDISetBreakpoint (addr, passcount, type, break_id) |
UDIResource addr; /* in -- where breakpoint gets set */ |
UDIInt32 passcount; /* in -- passcount for breakpoint */ |
UDIBreakType type; /* in -- breakpoint type */ |
UDIBreakId *break_id; /* out - assigned break id */ |
{ |
UDIInt32 service_id = UDISetBreakpoint_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIResource(udrs, &addr); |
udr_UDIInt32(udrs, &passcount); |
udr_UDIBreakType(udrs, &type); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIBreakId(udrs, break_id); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/******************************************************** UDI_QUERY_BREAKPOINT |
*/ |
UDIError UDIQueryBreakpoint (break_id, addr, passcount, type, current_count) |
UDIBreakId break_id; /* in -- assigned break id */ |
UDIResource *addr; /* out - where breakpoint was set */ |
UDIInt32 *passcount; /* out - trigger passcount for breakpoint */ |
UDIBreakType *type; /* out - breakpoint type */ |
UDIInt32 *current_count; /* out - current count for breakpoint */ |
{ |
UDIInt32 service_id = UDIQueryBreakpoint_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIBreakId(udrs, &break_id); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIResource(udrs, addr); |
udr_UDIInt32(udrs, passcount); |
udr_UDIBreakType(udrs, type); |
udr_UDIInt32(udrs, current_count); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/******************************************************** UDI_CLEAR_BREAKPOINT |
* UDIClearBreakpoint() is used to clear a breakpoint. |
*/ |
UDIError UDIClearBreakpoint (break_id) |
UDIBreakId break_id; /* in -- assigned break id */ |
{ |
UDIInt32 service_id = UDIClearBreakpoint_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIBreakId(udrs, &break_id); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/************************************************************** UDI_GET_STDOUT |
* UDIGetStdout() is called when a call to |
* UDIWait() indicates there is STD output data ready. |
*/ |
UDIError UDIGetStdout(buf, bufsize, count_done) |
UDIHostMemPtr buf; /* out -- buffer to be filled */ |
UDISizeT bufsize; /* in -- buffer size in bytes */ |
UDISizeT *count_done; /* out -- number of bytes written to buf */ |
{ |
UDIInt32 service_id = UDIGetStdout_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISizeT(udrs, &bufsize); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDISizeT(udrs, count_done); |
udr_bytes(udrs, buf, *count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/************************************************************** UDI_GET_STDERR |
* UDIGetStderr() is called when a call to |
* UDIWait() indicates there is STDERR output data ready |
*/ |
UDIError UDIGetStderr(buf, bufsize, count_done) |
UDIHostMemPtr buf; /* out -- buffer to be filled */ |
UDISizeT bufsize; /* in -- buffer size in bytes */ |
UDISizeT *count_done; /* out -- number of bytes written to buf */ |
{ |
UDIInt32 service_id = UDIGetStderr_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISizeT(udrs, &bufsize); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDISizeT(udrs, count_done); |
udr_bytes(udrs, buf, *count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/*************************************************************** UDI_PUT_STDIN |
* UDIPutStdin() is called whenever the DFE wants to |
* deliver an input character to the TIP. |
*/ |
UDIError UDIPutStdin (buf, count, count_done) |
UDIHostMemPtr buf; /* in -- buffer to be filled */ |
UDISizeT count; /* in -- buffer size in bytes */ |
UDISizeT *count_done; /* out - number of bytes written to buf */ |
{ |
UDIInt32 service_id = UDIPutStdin_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISizeT(udrs, &count); |
udr_bytes(udrs, buf, count); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDISizeT(udrs, count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/************************************************************** UDI_STDIN_MODE |
* UDIStdinMode() is used to change the mode that chazcters |
* are fetched from the user. |
*/ |
UDIError UDIStdinMode(mode) |
UDIMode *mode; /* out - */ |
{ |
UDIInt32 service_id = UDIStdinMode_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIMode(udrs, mode); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/*************************************************************** UDI_PUT_TRANS |
* UDIPutTrans() is used to feed input to the passthru mode. |
*/ |
UDIError UDIPutTrans (buf, count, count_done) |
UDIHostMemPtr buf; /* in -- buffer address containing input data */ |
UDISizeT count; /* in -- number of bytes in buf */ |
UDISizeT *count_done; /* out-- number of bytes transfered */ |
{ |
UDIInt32 service_id = UDIPutTrans_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISizeT(udrs, &count); |
udr_bytes(udrs, buf, count); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDISizeT(udrs, count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/*************************************************************** UDI_GET_TRANS |
* UDIGetTrans() is used to get output lines from the |
* passthru mode. |
*/ |
UDIError UDIGetTrans (buf, bufsize, count_done) |
UDIHostMemPtr buf; /* out -- buffer to be filled */ |
UDISizeT bufsize; /* in -- size of buf */ |
UDISizeT *count_done; /* out -- number of bytes in buf */ |
{ |
UDIInt32 service_id = UDIGetTrans_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDISizeT(udrs, &bufsize); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDISizeT(udrs, count_done); |
udr_bytes(udrs, buf, *count_done); |
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */ |
return dfe_errno; |
} |
|
/************************************************************** UDI_Trans_Mode |
* UDITransMode() is used to change the mode that the |
* transparent routines operate in. |
*/ |
UDIError UDITransMode(mode) |
UDIMode *mode; /* out -- selected mode */ |
{ |
UDIInt32 service_id = UDITransMode_c; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
udr_UDIMode(udrs, mode); |
udr_sendnow(udrs); |
if(udr_errno) return udr_errno; |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
udr_UDIError(udrs, &dfe_errno); |
return dfe_errno; |
} |
|
/******************************************************************** UDI_TEST |
*/ |
UDIError UDITest( cnt, str_p, array) |
UDISizeT cnt; |
UDIHostMemPtr str_p; |
UDIInt32 array[]; |
{ |
UDIInt32 service_id = UDITest_c; |
UDIInt16 scnt = cnt; |
UDISizeT r_cnt; |
char buf[256]; |
|
udr_errno = 0; |
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */ |
udr_UDIInt32(udrs, &service_id); |
|
printf("send cnt=%d scnt=%d\n", cnt, scnt); |
udr_UDISizeT(udrs, &cnt); |
udr_UDIInt16(udrs, &scnt); |
printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n", |
array[0], array[1], array[2], array[3]); |
udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32)); |
printf(" string=%s\n", str_p); |
udr_string(udrs, str_p); |
udr_sendnow(udrs); |
if(udr_errno) |
{ fprintf(stderr, " DFE-ipc Send ERROR\n"); |
return udr_errno; |
} |
|
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */ |
printf("recv "); |
udr_UDISizeT(udrs, &r_cnt); |
udr_UDIInt16(udrs, &scnt); |
printf(" rcnt=%d scnt=%d\n", r_cnt, scnt); |
udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32)); |
|
printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n", |
array[0], array[1], array[2], array[3]); |
udr_string(udrs, str_p); |
printf(" string=%s\n", str_p); |
|
udr_UDIError(udrs, &dfe_errno); |
return dfe_errno; |
} |
|
|
|
UDIUInt32 UDIGetDFEIPCId() |
{ |
return ((company_c << 16) + (product_c << 12) + version_c); |
} |
#endif /* __GO32__ */ |
/udi/udr.c
0,0 → 1,427
/* This module supports sending and receiving data objects over a |
socket conection. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
static char udr_c[]="@(#)udr.c 2.8 Daniel Mann"; |
static char udr_c_AMD[]="@(#)udr.c 2.3, AMD"; |
/* |
* All data is serialised into a character stream, |
* and de-serialised back into the approproiate objects. |
********************************************************************** HISTORY |
*/ |
/* This is all unneeded on DOS machines. */ |
#ifndef __GO32__ |
|
#include <stdio.h> |
#include <sys/types.h> |
|
/* This used to say sys/fcntl.h, but the only systems I know of that |
require that are old (pre-4.3, at least) BSD systems, which we |
probably don't need to worry about. */ |
#include <fcntl.h> |
|
#include <sys/socket.h> |
#include "udiproc.h" |
#include "udisoc.h" |
|
extern int errno; |
extern char* malloc(); |
|
/* local type decs. and macro defs. not in a .h file ************* MACRO/TYPE |
*/ |
|
/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS |
*/ |
int udr_errno; /* error occurs during UDR service */ |
|
/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS |
*/ |
|
/****************************************************************** UDR_CREATE |
* Build UDR structure for character stream processing. |
*/ |
int udr_create(udrs, sd, size) |
UDR* udrs; |
int sd; |
int size; |
{ |
udrs->sd = sd; |
if(!udrs->buff) udrs->buff = malloc(size); |
udrs->getbytes = udrs->buff; /* set the buffer to the start */ |
udrs->putbytes = udrs->buff; |
udrs->putend = udrs->buff; |
udrs->udr_op = -1; /* don't know the direction */ |
udrs->previous_op = -1; /* don't know the direction */ |
udrs->bufsize = size; |
return 0; |
} |
|
/******************************************************************** UDR_FREE |
* Free USR structure and close socket. |
*/ |
int udr_free(udrs) |
UDR* udrs; |
{ |
close(udrs->sd); |
free(udrs->buff); |
return 0; |
} |
|
/****************************************************************** UDR_SIGNAL |
* Send a signal to the process at the other end of the socket, |
* indicating that it should expect to recieve a new message shortly. |
*/ |
int udr_signal(udrs) |
UDR* udrs; |
{ |
if(send(udrs->sd, "I", 1, MSG_OOB) == -1) |
{ perror("ERROR, udr_signal(), send(...MSG_OOB)"); |
udr_errno = UDIErrorIPCInternal; |
return -1; /* return error code */ |
} |
return 0; |
} |
|
/***************************************************************** UDR_SENDNOW |
* used to flush the current character stream buffer to |
* the associated socket. */ |
int udr_sendnow(udrs) |
UDR* udrs; |
{ |
int size = (UDIUInt32)(udrs->putend) - (UDIUInt32)(udrs->buff); |
if(udrs->previous_op == 0) |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
udrs->putbytes = udrs->buff; |
udrs->putend = udrs->buff; |
if (write(udrs->sd, udrs->buff, size) == -1) |
{ perror("ERROR, udr_sendnow(), write() call: "); |
udr_errno = UDIErrorIPCInternal; |
return -1; /* return error code */ |
} |
return 0; |
} |
|
/******************************************************************** UDR_WORK |
* Function to send or recieve data from the buffers supporting |
* socket communication. The buffer contains serialised objects |
* sent/recieved over a socket connection. |
*/ |
int udr_work(udrs, object_p, size) |
UDR* udrs; |
void* object_p; |
int size; |
{ |
int cnt, remain; |
|
if(udrs->udr_op != udrs->previous_op) |
{ if(udrs->previous_op == 0) |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
udrs->previous_op= udrs->udr_op; |
udrs->putbytes = udrs->buff; |
udrs->getbytes = udrs->buff; |
} |
|
if(udrs->udr_op == UDR_ENCODE) |
{ /* write data into character stream buffer */ |
if( (UDIUInt32)(udrs->putbytes) + size > |
(UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize) ) |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
memcpy(udrs->putbytes, (char*)object_p, size); |
udrs->putbytes += size; |
if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes; |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) |
{ /* need more data in character stream buffer */ |
remain = (UDIUInt32)(udrs->bufsize) - |
( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) ); |
if( ((UDIUInt32)(udrs->bufsize) + (UDIUInt32)(udrs->buff) |
- (UDIUInt32)(udrs->getbytes)) < size) |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
cnt = read(udrs->sd, (char*)udrs->putbytes, remain); |
if(cnt == -1) perror("ERROR udr_work(), read() failure: "); |
udrs->putbytes += cnt; |
if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) |
{ udr_errno = UDIErrorIPCInternal; |
return -1; /* return error code */ |
} |
} /* read data from character stream buffer */ |
memcpy((char*)object_p, udrs->getbytes, size); |
udrs->getbytes += size; |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
return 0; |
} |
|
/************************************************************* UDR_UDIResource |
*/ |
int udr_UDIResource(udrs, object_p) |
UDR* udrs; |
UDIResource* object_p; |
{ |
int retval; |
|
retval = udr_CPUSpace(udrs, &object_p->Space); |
retval = retval | udr_CPUOffset(udrs, &object_p->Offset); |
return retval; |
} |
|
/**************************************************************** UDR_UDIRange |
*/ |
int udr_UDIRange(udrs, object_p) |
UDR* udrs; |
UDIRange* object_p; |
{ |
int retval; |
|
retval = udr_CPUOffset(udrs, &object_p->Low); |
retval = retval | udr_CPUOffset(udrs, &object_p->High); |
return retval; |
} |
|
/********************************************************** UDR_UDIMemoryRange |
*/ |
int udr_UDIMemoryRange(udrs, object_p) |
UDR* udrs; |
UDIMemoryRange* object_p; |
{ |
int retval; |
|
retval = udr_CPUSpace(udrs, &object_p->Space); |
retval = retval | udr_CPUOffset(udrs, &object_p->Offset); |
retval = retval | udr_CPUSizeT(udrs, &object_p->Size); |
return retval; |
} |
|
/****************************************************************** UDR_string |
*/ |
int udr_string(udrs, sp) |
UDR* udrs; |
char* sp; |
{ |
int len, retval; |
|
if(udrs->udr_op == UDR_ENCODE) |
{ |
if(sp) |
{ len = strlen(sp) + 1; |
retval = udr_UDIInt32(udrs, &len); |
retval = retval | udr_work(udrs, sp, len); |
} |
else /* deal with NULL pointer */ |
{ len = 0; |
retval = udr_UDIInt32(udrs, &len); |
} |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
retval = udr_UDIInt32(udrs, &len); |
if(len) |
retval = retval | udr_work(udrs, sp, len); |
else *sp = '\0'; /* terminate string */ |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
return retval; |
} |
|
/******************************************************************* UDR_BYTES |
*/ |
int udr_bytes(udrs, ptr, len) |
UDR* udrs; |
char* ptr; |
int len; |
{ |
return udr_work(udrs, ptr, len); |
} |
|
/********************************************************************* UDR_INT |
*/ |
int udr_int(udrs, int_p) |
UDR* udrs; |
int* int_p; |
{ |
int ret_val; |
UDIInt32 udr_obj; /* object of know size */ |
|
if(udrs->udr_op == UDR_ENCODE) |
{ |
udr_obj = *int_p; /* copy into know object size */ |
return udr_UDIInt32(udrs, &udr_obj); |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
ret_val = udr_UDIInt32(udrs, &udr_obj); /* get object of known size */ |
*int_p = udr_obj; |
return ret_val; |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
} |
|
/****************************************************************** UDR_INLINE |
*/ |
char* udr_inline(udrs, size) |
UDR* udrs; |
int size; |
{ |
if(udrs->udr_op != udrs->previous_op) |
{ if(udrs->previous_op == 0) |
{ udr_errno = UDIErrorIPCInternal; |
return 0; |
} |
udrs->previous_op= udrs->udr_op; |
udrs->putbytes = udrs->buff; |
udrs->getbytes = udrs->buff; |
} |
if(udrs->udr_op == UDR_ENCODE) |
{ |
if(udrs->putbytes + size > udrs->bufsize + udrs->buff) |
return 0; |
udrs->putbytes += size; |
return udrs->putbytes - size; |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
if(udrs->getbytes + size > udrs->bufsize + udrs->buff) |
return 0; |
udrs->getbytes += size; |
return udrs->getbytes - size; |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return 0; |
} |
} |
|
/****************************************************************** UDR_GETPOS |
*/ |
char* udr_getpos(udrs) |
UDR* udrs; |
{ |
if(udrs->udr_op == UDR_ENCODE) |
{ |
return udrs->putbytes; |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
return udrs->getbytes; |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return 0; |
} |
} |
|
/****************************************************************** UDR_SETPOS |
*/ |
int udr_setpos(udrs, pos) |
UDR* udrs; |
char* pos; |
{ |
if( ((UDIUInt32)pos > (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize)) |
|| ((UDIUInt32)pos < (UDIUInt32)(udrs->buff) ) ) |
{ udr_errno = UDIErrorIPCInternal; |
return 0; |
} |
if(udrs->udr_op == UDR_ENCODE) |
{ |
udrs->putbytes = pos; |
return 1; |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
udrs->getbytes = pos; |
return 1; |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return 0; |
} |
} |
|
/***************************************************************** UDR_READNOW |
* Try and ensure "size" bytes are available in the |
* receive buffer character stream. |
*/ |
int udr_readnow(udrs, size) |
UDR* udrs; |
int size; |
{ |
int cnt, remain; |
|
if(udrs->udr_op == UDR_ENCODE) |
{ |
udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
else if(udrs->udr_op == UDR_DECODE) |
{ |
if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) |
{ /* need more data in character stream buffer */ |
remain = (UDIUInt32)(udrs->bufsize) - |
( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) ); |
cnt = read(udrs->sd, (char*)udrs->putbytes, remain); |
if(cnt == -1) perror("ERROR udr_work(), read() failure: "); |
udrs->putbytes += cnt; |
if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size ) |
{ fprintf(stderr,"ERROR, udr_readnow() too few bytes in stream\n"); |
return -1; /* return error code */ |
} |
} |
} |
else |
{ udr_errno = UDIErrorIPCInternal; |
return -1; |
} |
return 0; |
} |
|
/******************************************************************* UDR_ALIGN |
*/ |
int udr_align(udrs, size) |
UDR* udrs; |
int size; |
{ |
char* align; |
int offset; |
|
align = udr_getpos(udrs); |
offset = size - ((int)align & (size -1)); |
offset = offset & (size -1); |
if(offset) udr_setpos(udrs, align + offset); |
} |
#endif /* __GO32__ */ |
/udi/udiproc.h
0,0 → 1,308
/* local type decs. and macro defs. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
#include "udiphcfg.h" /* Get host specific configuration */ |
#include "udiptcfg.h" /* Get target specific configuration */ |
|
/* Here are all of the CPU Families for which UDI is currently defined */ |
#define Am29K 1 /* AMD's Am290xx and Am292xx parts */ |
|
typedef UDIInt UDIError; |
typedef UDIInt UDISessionId; |
typedef UDIInt UDIPId; |
typedef UDIInt UDIStepType; |
typedef UDIInt UDIBreakType; |
typedef UDIUInt UDIBreakId; |
typedef UDIUInt UDIMode; |
|
typedef UDIStruct |
{ |
CPUSpace Space; |
CPUOffset Offset; |
} UDIResource; |
|
typedef UDIStruct |
{ |
CPUOffset Low; |
CPUOffset High; |
} UDIRange; |
|
typedef UDIStruct |
{ |
CPUSpace Space; |
CPUOffset Offset; |
CPUSizeT Size; |
} UDIMemoryRange; |
|
/* Values for UDIStepType parameters */ |
#define UDIStepNatural 0x0000 |
#define UDIStepOverTraps 0x0001 |
#define UDIStepOverCalls 0x0002 |
#define UDIStepInRange 0x0004 |
#define UDIStepNatural 0x0000 |
|
/* Values for UDIBreakType parameters */ |
#define UDIBreakFlagExecute 0x0001 |
#define UDIBreakFlagRead 0x0002 |
#define UDIBreakFlagWrite 0x0004 |
#define UDIBreakFlagFetch 0x0008 |
|
/* Special values for UDIWait MaxTime parameter */ |
#define UDIWaitForever (UDIInt32) -1 /* Infinite time delay */ |
|
/* Special values for PId */ |
#define UDIProcessProcessor -1 /* Raw Hardware, if possible */ |
|
/* Values for UDIWait StopReason */ |
#define UDIGrossState 0xff |
#define UDITrapped 0 /* Fine state - which trap */ |
#define UDINotExecuting 1 |
#define UDIRunning 2 |
#define UDIStopped 3 |
#define UDIWarned 4 |
#define UDIStepped 5 |
#define UDIWaiting 6 |
#define UDIHalted 7 |
#define UDIStdoutReady 8 /* fine state - size */ |
#define UDIStderrReady 9 /* fine state - size */ |
#define UDIStdinNeeded 10 /* fine state - size */ |
#define UDIStdinModeX 11 /* fine state - mode */ |
#define UDIBreak 12 /* Fine state - Breakpoint Id */ |
#define UDIExited 13 /* Fine state - exit code */ |
|
/* Enumerate the return values from the callback function |
for UDIEnumerateTIPs. |
*/ |
#define UDITerminateEnumeration 0 |
#define UDIContinueEnumeration 1 |
|
/* Enumerate values for Terminate parameter to UDIDisconnect */ |
#define UDITerminateSession 1 |
#define UDIContinueSession 0 |
|
/* Error codes */ |
#define UDINoError 0 /* No error occured */ |
#define UDIErrorNoSuchConfiguration 1 |
#define UDIErrorCantHappen 2 |
#define UDIErrorCantConnect 3 |
#define UDIErrorNoSuchConnection 4 |
#define UDIErrorNoConnection 5 |
#define UDIErrorCantOpenConfigFile 6 |
#define UDIErrorCantStartTIP 7 |
#define UDIErrorConnectionUnavailable 8 |
#define UDIErrorTryAnotherTIP 9 |
#define UDIErrorExecutableNotTIP 10 |
#define UDIErrorInvalidTIPOption 11 |
#define UDIErrorCantDisconnect 12 |
#define UDIErrorUnknownError 13 |
#define UDIErrorCantCreateProcess 14 |
#define UDIErrorNoSuchProcess 15 |
#define UDIErrorUnknownResourceSpace 16 |
#define UDIErrorInvalidResource 17 |
#define UDIErrorUnsupportedStepType 18 |
#define UDIErrorCantSetBreakpoint 19 |
#define UDIErrorTooManyBreakpoints 20 |
#define UDIErrorInvalidBreakId 21 |
#define UDIErrorNoMoreBreakIds 22 |
#define UDIErrorUnsupportedService 23 |
#define UDIErrorTryAgain 24 |
#define UDIErrorIPCLimitation 25 |
#define UDIErrorIncomplete 26 |
#define UDIErrorAborted 27 |
#define UDIErrorTransDone 28 |
#define UDIErrorCantAccept 29 |
#define UDIErrorTransInputNeeded 30 |
#define UDIErrorTransModeX 31 |
#define UDIErrorInvalidSize 32 |
#define UDIErrorBadConfigFileEntry 33 |
#define UDIErrorIPCInternal 34 |
/* TBD */ |
|
/****************************************************************** PROCEDURES |
*/ |
|
UDIError UDIConnect UDIParams(( |
char *Configuration, /* In */ |
UDISessionId *Session /* Out */ |
)); |
|
UDIError UDIDisconnect UDIParams(( |
UDISessionId Session, /* In */ |
UDIBool Terminate /* In */ |
)); |
|
UDIError UDISetCurrentConnection UDIParams(( |
UDISessionId Session /* In */ |
)); |
|
UDIError UDICapabilities UDIParams(( |
UDIUInt32 *TIPId, /* Out */ |
UDIUInt32 *TargetId, /* Out */ |
UDIUInt32 DFEId, /* In */ |
UDIUInt32 DFE, /* In */ |
UDIUInt32 *TIP, /* Out */ |
UDIUInt32 *DFEIPCId, /* Out */ |
UDIUInt32 *TIPIPCId, /* Out */ |
char *TIPString /* Out */ |
)); |
|
UDIError UDIEnumerateTIPs UDIParams(( |
UDIInt (*UDIETCallback) /* In */ |
UDIParams(( char *Configuration )) /* In to callback() */ |
)); |
|
UDIError UDIGetErrorMsg UDIParams(( |
UDIError ErrorCode, /* In */ |
UDISizeT MsgSize, /* In */ |
char *Msg, /* Out */ |
UDISizeT *CountDone /* Out */ |
)); |
|
UDIError UDIGetTargetConfig UDIParams(( |
UDIMemoryRange KnownMemory[], /* Out */ |
UDIInt *NumberOfRanges, /* In/Out */ |
UDIUInt32 ChipVersions[], /* Out */ |
UDIInt *NumberOfChips /* In/Out */ |
)); |
|
UDIError UDICreateProcess UDIParams(( |
UDIPId *PId /* Out */ |
)); |
|
UDIError UDISetCurrentProcess UDIParams(( |
UDIPId PId /* In */ |
)); |
|
UDIError UDIDestroyProcess UDIParams(( |
UDIPId PId /* In */ |
)); |
|
UDIError UDIInitializeProcess UDIParams(( |
UDIMemoryRange ProcessMemory[], /* In */ |
UDIInt NumberOfRanges, /* In */ |
UDIResource EntryPoint, /* In */ |
CPUSizeT StackSizes[], /* In */ |
UDIInt NumberOfStacks, /* In */ |
char *ArgString /* In */ |
)); |
|
UDIError UDIRead UDIParams(( |
UDIResource From, /* In */ |
UDIHostMemPtr To, /* Out */ |
UDICount Count, /* In */ |
UDISizeT Size, /* In */ |
UDICount *CountDone, /* Out */ |
UDIBool HostEndian /* In */ |
)); |
|
UDIError UDIWrite UDIParams(( |
UDIHostMemPtr From, /* In */ |
UDIResource To, /* In */ |
UDICount Count, /* In */ |
UDISizeT Size, /* In */ |
UDICount *CountDone, /* Out */ |
UDIBool HostEndian /* In */ |
)); |
|
UDIError UDICopy UDIParams(( |
UDIResource From, /* In */ |
UDIResource To, /* In */ |
UDICount Count, /* In */ |
UDISizeT Size, /* In */ |
UDICount *CountDone, /* Out */ |
UDIBool Direction /* In */ |
)); |
|
UDIError UDIExecute UDIParams(( |
void |
)); |
|
UDIError UDIStep UDIParams(( |
UDIUInt32 Steps, /* In */ |
UDIStepType StepType, /* In */ |
UDIRange Range /* In */ |
)); |
|
UDIVoid UDIStop UDIParams(( |
void |
)); |
|
UDIError UDIWait UDIParams(( |
UDIInt32 MaxTime, /* In */ |
UDIPId *PId, /* Out */ |
UDIUInt32 *StopReason /* Out */ |
)); |
|
UDIError UDISetBreakpoint UDIParams(( |
UDIResource Addr, /* In */ |
UDIInt32 PassCount, /* In */ |
UDIBreakType Type, /* In */ |
UDIBreakId *BreakId /* Out */ |
)); |
|
UDIError UDIQueryBreakpoint UDIParams(( |
UDIBreakId BreakId, /* In */ |
UDIResource *Addr, /* Out */ |
UDIInt32 *PassCount, /* Out */ |
UDIBreakType *Type, /* Out */ |
UDIInt32 *CurrentCount /* Out */ |
)); |
|
UDIError UDIClearBreakpoint UDIParams(( |
UDIBreakId BreakId /* In */ |
)); |
|
UDIError UDIGetStdout UDIParams(( |
UDIHostMemPtr Buf, /* Out */ |
UDISizeT BufSize, /* In */ |
UDISizeT *CountDone /* Out */ |
)); |
|
UDIError UDIGetStderr UDIParams(( |
UDIHostMemPtr Buf, /* Out */ |
UDISizeT BufSize, /* In */ |
UDISizeT *CountDone /* Out */ |
)); |
|
UDIError UDIPutStdin UDIParams(( |
UDIHostMemPtr Buf, /* In */ |
UDISizeT Count, /* In */ |
UDISizeT *CountDone /* Out */ |
)); |
|
UDIError UDIStdinMode UDIParams(( |
UDIMode *Mode /* Out */ |
)); |
|
UDIError UDIPutTrans UDIParams(( |
UDIHostMemPtr Buf, /* In */ |
UDISizeT Count, /* In */ |
UDISizeT *CountDone /* Out */ |
)); |
|
UDIError UDIGetTrans UDIParams(( |
UDIHostMemPtr Buf, /* Out */ |
UDISizeT BufSize, /* In */ |
UDISizeT *CountDone /* Out */ |
)); |
|
UDIError UDITransMode UDIParams(( |
UDIMode *Mode /* Out */ |
)); |
/udi/udiptcfg.h
0,0 → 1,19
/* Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
#include "udipt29k.h" |
/udi/udisoc.h
0,0 → 1,184
/* This module defines constants used in the UDI IPC modules. |
|
Copyright 1993 Free Software Foundation, Inc. |
|
This file is part of GDB. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
static char udisoc_h[]="@(#)udisoc.h 2.6 Daniel Mann"; |
static char udisoc_h_AMD[]="@(#)udisoc.h 2.4, AMD"; |
|
#define LOCAL static |
#define company_c 1 /* AMD Company id */ |
#define product_c 1 /* socket IPC id */ |
|
/* Enumerate the UDI procedure services |
*/ |
#define UDIConnect_c 0 |
#define UDIDisconnect_c 1 |
#define UDISetCurrentConnection_c 2 |
#define UDICapabilities_c 3 |
#define UDIEnumerateTIPs_c 4 |
#define UDIGetErrorMsg_c 5 |
#define UDIGetTargetConfig_c 6 |
#define UDICreateProcess_c 7 |
#define UDISetCurrentProcess_c 8 |
#define UDIDestroyProcess_c 9 |
#define UDIInitializeProcess_c 10 |
#define UDIRead_c 11 |
#define UDIWrite_c 12 |
#define UDICopy_c 13 |
#define UDIExecute_c 14 |
#define UDIStep_c 15 |
#define UDIStop_c 16 |
#define UDIWait_c 17 |
#define UDISetBreakpoint_c 18 |
#define UDIQueryBreakpoint_c 19 |
#define UDIClearBreakpoint_c 20 |
#define UDIGetStdout_c 21 |
#define UDIGetStderr_c 22 |
#define UDIPutStdin_c 23 |
#define UDIStdinMode_c 24 |
#define UDIPutTrans_c 25 |
#define UDIGetTrans_c 26 |
#define UDITransMode_c 27 |
#define UDITest_c 28 |
#define UDIKill_c 29 |
|
#define udr_UDIInt8(udrs, obj) udr_work(udrs, obj, 1) |
#define udr_UDIInt16(udrs, obj) udr_work(udrs, obj, 2) |
#define udr_UDIInt32(udrs, obj) udr_work(udrs, obj, 4) |
#define udr_UDIInt(udrs, obj) udr_work(udrs, obj, 4) |
|
#define udr_UDIUInt8(udrs, obj) udr_work(udrs, obj, 1) |
#define udr_UDIUInt16(udrs, obj) udr_work(udrs, obj, 2) |
#define udr_UDIUInt32(udrs, obj) udr_work(udrs, obj, 4) |
#define udr_UDIUInt(udrs, obj) udr_work(udrs, obj, 4) |
|
#define udr_UDIBool(udrs, obj) udr_UDIInt32(udrs, obj) |
#define udr_UDICount(udrs, obj) udr_UDIInt32(udrs, obj) |
#define udr_UDISize(udrs, obj) udr_UDIUInt32(udrs, obj) |
#define udr_CPUSpace(udrs, obj) udr_UDIInt32(udrs, obj) |
#define udr_CPUOffset(udrs, obj) udr_UDIUInt32(udrs, obj) |
#define udr_CPUSizeT(udrs, obj) udr_UDIUInt32(udrs, obj) |
#define udr_UDIBreakId(udrs,obj) udr_UDIUInt(udrs, obj) |
#define udr_UDISizeT(udrs, obj) udr_UDIUInt(udrs, obj) |
#define udr_UDIMode(udrs, obj) udr_UDIUInt(udrs, obj) |
|
#define udr_UDIHostMemPtr(udrs, obj) udr_UDIUInt32(udrs, obj) |
#define udr_UDIVoidPtr(udrs, obj) udr_UDIUInt32(udrs, obj) |
#define udr_UDIPId(udrs, obj) udr_UDIUInt(udrs, obj) |
#define udr_UDISessionId(udrs, obj) udr_UDIInt32(udrs, obj) |
#define udr_UDIError(udrs, obj) udr_UDIInt32(udrs, obj) |
#define udr_UDIStepType(udrs, obj) udr_UDIInt32(udrs, obj) |
#define udr_UDIBreakType(udrs, obj) udr_UDIInt32(udrs, obj) |
|
|
#define UDR_ENCODE 1 |
#define UDR_DECODE 2 |
|
typedef struct UDR_str |
{ |
int udr_op; /* UDR operation */ |
int previous_op; |
int sd; |
int bufsize; |
char* buff; |
char* getbytes; |
char* putbytes; |
char* putend; |
int domain; |
char* soc_name; |
} UDR; |
|
/******************************************* Declare UDR suport functions */ |
int udr_create UDIParams(( |
UDR* udrs, |
int sd, |
int size |
)); |
|
int udr_free UDIParams(( |
UDR* udrs, |
)); |
|
int udr_signal UDIParams(( |
UDR* udrs, |
)); |
|
int udr_sendnow UDIParams(( |
UDR* udrs |
)); |
|
int udr_work UDIParams(( |
UDR* udrs, |
void* object_p, |
int size |
)); |
|
int udr_UDIResource UDIParams(( |
UDR* udrs, |
UDIResource* object_p |
)); |
|
int udr_UDIRange UDIParams(( |
UDR* udrs, |
UDIRange* object_p |
)); |
|
int udr_UDIMemoryRange UDIParams(( |
UDR* udrs, |
UDIMemoryRange* object_p |
)); |
|
int udr_UDIMemoryRange UDIParams(( |
UDR* udrs, |
UDIMemoryRange* object_p |
)); |
|
int udr_int UDIParams(( |
UDR* udrs, |
int* int_p |
)); |
|
int udr_bytes UDIParams(( |
UDR* udrs, |
char* ptr, |
int len |
)); |
|
char* udr_inline UDIParams(( |
UDR* udrs, |
int size |
)); |
|
char* udr_getpos UDIParams(( |
UDR* udrs |
)); |
int udr_setpos UDIParams(( |
UDR* udrs, |
char* pos |
)); |
|
int udr_readnow UDIParams(( |
UDR* udrs, |
int size |
)); |
|
int udr_align UDIParams(( |
UDR* udrs, |
int size, |
)); |
/udi_soc
0,0 → 1,9
# @(#)udi_soc 2.1 Daniel Mann |
# NOTE: the Session string must not start whith white-space characters. |
# Format of string is: |
# <session> <domain> <soc_name|host_name> <tip_exe> <pass to UDIconnect> |
soc2cayman AF_INET cayman /bin/udi_tip ... |
soc2tip AF_UNIX astring tip.exe ... |
cuba AF_UNIX soc_name ../bin.68020/udi_tip stuff to pass |
cayman AF_INET cayman this_entry_not_matter stuff to pass |
iss AF_UNIX * sun4/isstip -r osboot |
/README
0,0 → 1,9
The files in this directory are shared with other debuggers and |
debug interfaces that use Advanced Micro Devices' UDI (universal debug |
interface) protocol. The protocol provides a common interface among |
debuggers, logic analyzers, emulators, and embedded systems that use |
AMD 29000 family processors. |
|
Do not change these files without coordinating with Advanced Micro |
Devices, Embedded Processor Division, 5204 E. Ben White Blvd, Austin, TX 78741. |
Maybe postmaster@cayman.amd.com can direct you to the current maintainers. |