rik/jlibusb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- blackbox files added

Browse Source 
git-svn-id: https://svn.code.sf.net/p/libusbjava/code/trunk@96 94ad28fe-ef68-46b1-9651-e7ae4fcf1c4c
This commit is contained in:
schlaepfer
2006-01-19 07:17:20 +00:00
parent 6c6effa5b6
commit 2d735a5092
15 changed files with 5771 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
blackbox/!DevTools.otd Normal file
View File

@@ -0,0 +1,76 @@
(* USB Dev Tool *)
(* NOTE: writing permission is needed in this directory to create the files JavaOut.txt and JavaErr.txt! *)
(* MC68332 & MPC555 *)
<EFBFBD><EFBFBD>CXdeCmdsDev.CompileThis
UsbBDIDll
UsbBDI
UsbBDI555
UsbBDI332
UsbTargLog
<EFBFBD><EFBFBD>E
<EFBFBD><EFBFBD>CDevDebug.UnloadThis
UsbTargLog
UsbBDI555
UsbBDI332
UsbBDI
UsbBDIDll
<EFBFBD><EFBFBD>E
(* MPC555 only (start BB555) *)
<EFBFBD><EFBFBD>CXdeCmdsDev.CompileThis
XoppcTrgtRegDict
XoppcAmdFlashs
XoppcSystem
<EFBFBD><EFBFBD>E
<EFBFBD><EFBFBD>CDevDebug.UnloadThis
XoppcSystem
XoppcAmdFlashs
XoppcTrgtRegDict
<EFBFBD><EFBFBD>E
(* MC68332 only (start BB332) *)
<EFBFBD><EFBFBD>CXdeCmdsDev.CompileThis
Xo68x32AmdFlashs
Xo68x32System
<EFBFBD><EFBFBD>E
<EFBFBD><EFBFBD>CDevDebug.UnloadThis
Xo68x32System
Xo68x32AmdFlashs
<EFBFBD><EFBFBD>E
(* MC68332 & MPC555 *)
files of directory: Usb\Mod\ files: *
Usb\Mod\BDI.otd
Usb\Mod\BDI332.otd
Usb\Mod\BDI555.otd
Usb\Mod\BDIDll.otd
Usb\Mod\TargLog.otd
files of directory: Usb\Rsrc\ files: *
Usb\Rsrc\usbpdi.jar
files of directory: files: *
BDI.dll
(* MPC555 only *)
files of directory: Xoppc\Mod\ files: *
Xoppc\Mod\AmdFlashs.otd
Xoppc\Mod\System.otd
Xoppc\Mod\TrgtRegDict.otd
files of directory: Toppc\Docu\ files: *
Toppc\Docu\!NTBTargetPpcDemoTool.odc
(* MC68332 only *)
files of directory: Xo68x32\Mod\ files: *
Xo68x32\Mod\AmdFlashs.otd
Xo68x32\Mod\System.otd
files of directory: To68x32\Docu\ files: *
To68x32\Docu\!NTBTarget332DemoTool.odc

BIN
blackbox/BDI.dll Normal file
View File

Binary file not shown.

BIN
blackbox/To68x32/Docu/!NTBTarget332DemoTool.odc Normal file
View File

Binary file not shown.

BIN
blackbox/Toppc/Docu/!NTBTargetPpcDemoTool.odc Normal file
View File

Binary file not shown.

413
blackbox/Usb/Mod/BDI.otd Normal file
View File

@@ -0,0 +1,413 @@
MODULE UsbBDI;
IMPORT SYS := SYSTEM, BDI := UsbBDIDll, Log := StdLog, ComTools, WinApi, Services, TextModels, Ports,
Files, HostFiles;
CONST
ttDefaultPeriod = 500; (*500 ms*) ttPipeHandDisconnected = -1;
nul = 0X;
ascLf = 0AX; ascCr = 0DX;
CONST
FALSE_ = 0;
PATH_LENGTH* = 512;
CONST
JAVA_OUT_FILENAME = "JavaOut.txt";
JAVA_ERR_FILENAME = "JavaErr.txt";
INVALID_HANDLE_VALUE = -1;
STD_OUT_COLOR = Ports.green;
STD_ERR_COLOR = Ports.grey50;
JAVA_OUT_COLOR = Ports.blue;
JAVA_ERR_COLOR = Ports.red;
CONST
MAX_UART_DATA_LENGTH* = BDI.MAX_UART_DATA_LENGTH;
CONST
PATH_SEPERATOR = "\";
CLASSPATH = "Usb\Rsrc\usbpdi.jar";
TYPE
StdReaderWriter = POINTER TO ABSTRACT RECORD (Services.Action)
stdIoText: TextModels.Model; stdIoTextPos: INTEGER;
time, endTime: LONGINT; period: INTEGER;
hStdOut, hStdErr: WinApi.HANDLE;
connected, running: BOOLEAN; prevChar: SHORTCHAR
END;
JvmReaderWriter = POINTER TO EXTENSIBLE RECORD (StdReaderWriter)
errText: TextModels.Model; stdIoWriter, stdErrWriter: TextModels.Writer;
hJavaOut, hJavaErr: WinApi.HANDLE;
END;
VAR
bool: BDI.BOOL;
Done-, deviceOpen, jvmCreated: BOOLEAN; (** previous operation successfully completed *)
readerWriter: JvmReaderWriter;
(* ----------- Standard-IO / Java ReaderWriter --------------- *)
PROCEDURE (task: StdReaderWriter) Clear, NEW, EXTENSIBLE;
BEGIN
task.stdIoText := NIL; task.stdIoTextPos := 0;
task.hStdOut := ttPipeHandDisconnected; task.hStdErr := ttPipeHandDisconnected;
task.time := 0; task.endTime := 0; task.period := 0;
task.connected := FALSE; task.running := FALSE;
task.prevChar := nul;
END Clear;
PROCEDURE (task: StdReaderWriter) Stop, NEW, EXTENSIBLE;
VAR done: WinApi.BOOL;
BEGIN
Services.RemoveAction(task); task.running := FALSE;
IF task.connected THEN
done := WinApi.CloseHandle(task.hStdOut);
done := WinApi.CloseHandle(task.hStdErr);
END;
task.Clear
END Stop;
PROCEDURE (task: StdReaderWriter) SetTime (startFromNow, period, timeOut: INTEGER), NEW;
BEGIN
task.time := Services.Ticks() + startFromNow;
IF timeOut <= 0 THEN timeOut := MAX(INTEGER) END;
task.endTime := task.time + LONG(timeOut) * Services.resolution DIV 1000;
task.period := period
END SetTime;
PROCEDURE (task: StdReaderWriter) ConnectStdOutPipe (hStdOut: WinApi.HANDLE), NEW;
VAR done: WinApi.BOOL;
BEGIN
IF task.connected & (task.hStdOut # hStdOut) THEN done := WinApi.CloseHandle(task.hStdOut) END;
task.hStdOut := hStdOut; task.connected := TRUE
END ConnectStdOutPipe;
PROCEDURE (task: StdReaderWriter) ConnectStdErrPipe (hStdErr: WinApi.HANDLE), NEW;
VAR done: WinApi.BOOL;
BEGIN
IF task.connected & (task.hStdErr # hStdErr) THEN done := WinApi.CloseHandle(task.hStdErr) END;
task.hStdErr := hStdErr; task.connected := TRUE
END ConnectStdErrPipe;
PROCEDURE (task: StdReaderWriter) Start, NEW, ABSTRACT;
PROCEDURE NewJvmReaderWriter ( ): JvmReaderWriter;
VAR rec: JvmReaderWriter;
BEGIN
NEW(rec); rec.Clear; RETURN rec
END NewJvmReaderWriter;
PROCEDURE (rec: JvmReaderWriter) Clear, EXTENSIBLE;
VAR done: WinApi.BOOL;
BEGIN
rec.Clear^;
rec.errText := NIL; rec.stdIoWriter := NIL; rec.stdErrWriter := NIL;
rec.hJavaOut := ttPipeHandDisconnected; rec.hJavaErr := ttPipeHandDisconnected;
END Clear;
PROCEDURE (rec: JvmReaderWriter) Stop, EXTENSIBLE;
VAR done: WinApi.BOOL;
BEGIN
IF rec.connected THEN
rec.Stop^; done := WinApi.CloseHandle(rec.hJavaErr); done := WinApi.CloseHandle(rec.hJavaOut)
END;
rec.Clear
END Stop;
PROCEDURE (rec: JvmReaderWriter) ConnectJavaOutPipe (hJavaOut: WinApi.HANDLE), NEW;
VAR done: WinApi.BOOL;
BEGIN
IF rec.connected & (rec.hJavaOut # hJavaOut) THEN done := WinApi.CloseHandle(rec.hJavaOut) END;
rec.hJavaOut := hJavaOut; rec.connected := TRUE
END ConnectJavaOutPipe;
PROCEDURE (rec: JvmReaderWriter) ConnectJavaErrPipe (hJavaErr: WinApi.HANDLE), NEW;
VAR done: WinApi.BOOL;
BEGIN
IF rec.connected & (rec.hJavaErr # hJavaErr) THEN done := WinApi.CloseHandle(rec.hJavaErr) END;
rec.hJavaErr := hJavaErr; rec.connected := TRUE
END ConnectJavaErrPipe;
PROCEDURE (rec: JvmReaderWriter) Start;
VAR handle, stdOutHandle, stdErrHandle: WinApi.HANDLE;
BEGIN
IF rec.running THEN rec.Stop END;
IF rec.stdIoText = NIL THEN rec.stdIoText := TextModels.dir.New(); END;
IF rec.stdIoWriter = NIL THEN rec.stdIoWriter := rec.stdIoText.NewWriter(NIL) END;
rec.stdIoWriter.SetPos(rec.stdIoTextPos);
IF rec.errText = NIL THEN rec.errText := TextModels.dir.New(); END;
IF rec.stdErrWriter = NIL THEN rec.stdErrWriter := rec.errText.NewWriter(NIL) END;
rec.stdErrWriter.SetPos(rec.errText.Length());
(* Connect Std pipes *)
(*
stdOutHandle := BDI.getOutPipeHandle();
stdErrHandle := BDI.getErrPipeHandle();
Log.String("stdOutHandle: "); Log.Int(stdOutHandle); Log.Ln;
Log.String("stdErrHandle: "); Log.Int(stdErrHandle); Log.Ln;
*)
rec.ConnectStdOutPipe(BDI.getOutPipeHandle());
rec.ConnectStdErrPipe(BDI.getErrPipeHandle());
(* Connect Java pipes *)
handle := WinApi.CreateFile(JAVA_OUT_FILENAME, WinApi.GENERIC_READ + WinApi.GENERIC_WRITE,
WinApi.FILE_SHARE_WRITE, NIL, WinApi.OPEN_EXISTING, {}, 0);
IF (handle = INVALID_HANDLE_VALUE) THEN
Log.String("Error opening JAVA_OUT_FILENAME"); Log.Ln;
ELSE
rec.ConnectJavaOutPipe(handle)
END;
handle := WinApi.CreateFile(JAVA_ERR_FILENAME, WinApi.GENERIC_READ + WinApi.GENERIC_WRITE,
WinApi.FILE_SHARE_WRITE, NIL, WinApi.OPEN_EXISTING, {}, 0);
IF (handle = INVALID_HANDLE_VALUE) THEN
Log.String("Error opening JAVA_ERR_FILENAME"); Log.Ln;
ELSE
rec.ConnectJavaErrPipe(handle)
END;
rec.running := TRUE; Services.DoLater(rec, rec.time)
END Start;
PROCEDURE (rec: JvmReaderWriter) Do;
VAR
outModel: TextModels.Model;
n, ioDone, errDone, nofBytesRead, ioBytesAvail, errBytesAvail, exitCode: INTEGER;
ch: SHORTCHAR;
strSC: ARRAY 512 OF SHORTCHAR;
success: WinApi.BOOL;
BEGIN
IF rec.running THEN
(* STD OUT *)
IF rec.hStdOut > 0 THEN
nofBytesRead := 0; ioBytesAvail := 0;
ioDone := WinApi.PeekNamedPipe(
rec.hStdOut, (*//handle to pipe to copy from *)
SYS.ADR(strSC), (*//pointer to data buffer*)
LEN(strSC), (*//size, in bytes, of data buffer*)
nofBytesRead, (*nofBytesRead,*) (*//pointer to number of bytes read*)
ioBytesAvail, (*//pointer to total number of bytes available*)
NIL (*//pointer to unread bytes in this message*)
);
IF (ioDone # 0) & (ioBytesAvail > 0) THEN
ioDone := WinApi.ReadFile(rec.hStdOut, SYS.ADR(strSC), LEN(strSC), nofBytesRead, NIL);
IF (ioDone # 0) & (nofBytesRead > 0) THEN
FOR n := 0 TO nofBytesRead - 1 DO
ch := strSC[n];
IF (ch = ascLf) & (rec.prevChar # ascCr) THEN ch := TextModels.line END;
rec.stdIoWriter.WriteChar(ch);
rec.prevChar := ch;
END
END;
rec.stdIoText.SetAttr(0, rec.stdIoText.Length(),
TextModels.NewColor(TextModels.dir.attr, STD_OUT_COLOR));
Log.text.Append(rec.stdIoText)
END;
END;
(* STD ERR *)
IF rec.hStdErr > 0 THEN
nofBytesRead := 0; errBytesAvail := 0;
ioDone := WinApi.PeekNamedPipe(
rec.hStdErr, (*//handle to pipe to copy from *)
SYS.ADR(strSC), (*//pointer to data buffer*)
LEN(strSC), (*//size, in bytes, of data buffer*)
nofBytesRead, (*nofBytesRead,*) (*//pointer to number of bytes read*)
errBytesAvail, (*//pointer to total number of bytes available*)
NIL (*//pointer to unread bytes in this message*)
);
IF (ioDone # 0) & (errBytesAvail > 0) THEN
errDone := WinApi.ReadFile(rec.hStdErr, SYS.ADR(strSC), LEN(strSC), nofBytesRead, NIL);
IF (errDone # 0) & (nofBytesRead > 0) THEN
FOR n := 0 TO nofBytesRead - 1 DO
ch := strSC[n];
IF (ch = ascLf) & (rec.prevChar # ascCr) THEN ch := TextModels.line END;
rec.stdErrWriter.WriteChar(ch); rec.prevChar := ch
END
END;
rec.errText.SetAttr(0, rec.errText.Length(),
TextModels.NewColor(TextModels.dir.attr, STD_ERR_COLOR));
Log.text.Append(rec.errText)
END
END;
(* JAVA OUT *)
IF rec.hJavaOut > 0 THEN
ioDone := WinApi.ReadFile(rec.hJavaOut, SYS.ADR(strSC), LEN(strSC), nofBytesRead, NIL);
IF (ioDone # 0) & (nofBytesRead > 0) THEN
FOR n := 0 TO nofBytesRead - 1 DO
ch := strSC[n];
IF (ch = ascLf) & (rec.prevChar # ascCr) THEN ch := TextModels.line END;
rec.stdIoWriter.WriteChar(ch);
rec.prevChar := ch;
END
END;
rec.stdIoText.SetAttr(0, rec.stdIoText.Length(),
TextModels.NewColor(TextModels.dir.attr, JAVA_OUT_COLOR));
Log.text.Append(rec.stdIoText)
END;
(* JAVA ERR *)
IF rec.hJavaErr > 0 THEN
errDone := WinApi.ReadFile(rec.hJavaErr, SYS.ADR(strSC), LEN(strSC), nofBytesRead, NIL);
IF (errDone # 0) & (nofBytesRead > 0) THEN
FOR n := 0 TO nofBytesRead - 1 DO
ch := strSC[n];
IF (ch = ascLf) & (rec.prevChar # ascCr) THEN ch := TextModels.line END;
rec.stdErrWriter.WriteChar(ch); rec.prevChar := ch
END
END;
rec.errText.SetAttr(0, rec.errText.Length(),
TextModels.NewColor(TextModels.dir.attr, JAVA_ERR_COLOR));
Log.text.Append(rec.errText)
END;
INC( rec.time, rec.period ); Services.DoLater(rec, rec.time )
END;
END Do;
(* ----------- JVM --------------- *)
PROCEDURE CreateJVM (classpath: ARRAY OF SHORTCHAR);
VAR string: WinApi.PtrSTR;
BEGIN
string := ComTools.NewSString(classpath);
bool := BDI.createJVM(string);
IF bool = FALSE_ THEN
Done := FALSE;
Log.String("creating JVM failed"); Log.Ln;
ELSE
Done := TRUE;
Log.String("JVM successfully created"); Log.Ln;
jvmCreated := TRUE;
END;
(* We need to create the jvm before opening the ReaderWriter.
The javaout, javaerr can only be opened after creating the jvm! *)
IF readerWriter = NIL THEN
readerWriter := NewJvmReaderWriter();
readerWriter.Start();
END;
ComTools.FreeSString(string);
END CreateJVM;
PROCEDURE DestroyJVM ;
BEGIN
bool := BDI.destroyJVM();
IF bool = FALSE_ THEN
Done := FALSE;
Log.String("destroying JVM failed"); Log.Ln;
ELSE
Done := TRUE;
Log.String("JVM destroyed"); Log.Ln;
END;
jvmCreated := FALSE;
END DestroyJVM;
PROCEDURE CheckForExceptions * (): BOOLEAN;
BEGIN
RETURN (BDI.checkForExceptions() # FALSE_)
END CheckForExceptions;
(* ----------- USB --------------- *)
PROCEDURE USB_Device_open ;
BEGIN
BDI.USB_Device_open;
Done := ~CheckForExceptions();
IF Done THEN
deviceOpen := TRUE;
END
END USB_Device_open;
PROCEDURE USB_Device_close ;
BEGIN
BDI.USB_Device_close;
Done := ~CheckForExceptions();
deviceOpen := FALSE;
END USB_Device_close;
PROCEDURE USB_Device_reset * ;
BEGIN
BDI.USB_Device_reset;
Done := ~CheckForExceptions();
deviceOpen := FALSE;
END USB_Device_reset;
(* --------- UART0 ----------------- *)
PROCEDURE UART0_read * (VAR data: ARRAY OF SHORTCHAR; VAR length: INTEGER): BOOLEAN;
BEGIN
length := BDI.UART0_read(data);
RETURN length # FALSE_;
END UART0_read;
PROCEDURE UART0_write * (VAR data: ARRAY OF SHORTCHAR; length: INTEGER): BOOLEAN;
VAR
result: INTEGER;
BEGIN
RETURN BDI.UART0_write(SYS.ADR(data[0]), length) # FALSE_;
END UART0_write;
(* -------------- Helper Functions ------------------*)
PROCEDURE GetUserStartUpPath (VAR startupPath: ARRAY OF SHORTCHAR);
VAR
userStartUpLocator: Files.Locator; userStartUpHostLoc: HostFiles.Locator;
startupPathChar: ARRAY PATH_LENGTH OF CHAR;
i: INTEGER;
BEGIN
userStartUpLocator := Files.dir.This(""); userStartUpHostLoc := userStartUpLocator(HostFiles.Locator);
startupPathChar := userStartUpHostLoc.path$;
FOR i := 0 TO LEN(startupPathChar) - 1 DO
startupPath[i] := SYS.VAL(SHORTCHAR, startupPathChar[i]);
END
END GetUserStartUpPath;
PROCEDURE ConnectDevice * ;
VAR
startupPath: ARRAY PATH_LENGTH OF SHORTCHAR;
BEGIN
IF ~deviceOpen THEN
IF ~jvmCreated THEN
GetUserStartUpPath(startupPath);
Log.String("Startup Path: " + startupPath); Log.Ln;
CreateJVM(startupPath + PATH_SEPERATOR + CLASSPATH);
(*
CreateJVM("D:\work\USB\eclipse\mcdp\bin\");
*)
IF ~Done THEN HALT(77) END;
jvmCreated := TRUE;
END;
BDI.USB_Device_open;
IF ~Done THEN HALT(78) END;
END
END ConnectDevice;
PROCEDURE DeviceOpen * (): BOOLEAN ;
BEGIN
RETURN deviceOpen
END DeviceOpen;
(* Close and reopen the device *)
PROCEDURE ReopenDevice * ;
BEGIN
USB_Device_close;
USB_Device_open;
IF Done THEN
Log.String("Device opened successfully"); Log.Ln;
ELSE
Log.String("Error while opening Device"); Log.Ln;
END
END ReopenDevice;
BEGIN
deviceOpen := FALSE;
jvmCreated := FALSE;
CLOSE
IF readerWriter # NIL THEN
readerWriter.Stop;
END;
IF deviceOpen THEN
USB_Device_close;
END;
IF jvmCreated THEN
DestroyJVM
END
END UsbBDI.

109
blackbox/Usb/Mod/BDI332.otd Normal file
View File

@@ -0,0 +1,109 @@
MODULE UsbBDI332;
IMPORT SYS := SYSTEM, BDI := UsbBDIDll, BDIMain := UsbBDI, WinApi;
CONST
FALSE_ = 0;
VAR
Done-: BOOLEAN;
(* --------- 332 ----------------- *)
PROCEDURE nopsToLegalCmd * ;
BEGIN
BDI.BDI332_nopsToLegalCmd;
Done := ~BDIMain.CheckForExceptions()
END nopsToLegalCmd;
PROCEDURE go * ;
BEGIN
BDI.BDI332_go;
Done := ~BDIMain.CheckForExceptions()
END go;
PROCEDURE break_ * ;
BEGIN
BDI.BDI332_break_;
Done := ~BDIMain.CheckForExceptions()
END break_;
PROCEDURE reset_target * ;
BEGIN
BDI.BDI332_reset_target;
Done := ~BDIMain.CheckForExceptions()
END reset_target;
PROCEDURE reset_peripherals * ;
BEGIN
BDI.BDI332_reset_peripherals;
Done := ~BDIMain.CheckForExceptions()
END reset_peripherals;
PROCEDURE isFreezeAsserted * (): BOOLEAN;
VAR result: WinApi.BOOL;
BEGIN
result := BDI.BDI332_isFreezeAsserted();
Done := ~BDIMain.CheckForExceptions();
RETURN result # FALSE_
END isFreezeAsserted;
PROCEDURE fillMem * (downloadData: ARRAY OF INTEGER; dataLength: INTEGER);
BEGIN
BDI.BDI332_fillMem(SYS.ADR(downloadData[0]), dataLength);
Done := ~BDIMain.CheckForExceptions()
END fillMem;
PROCEDURE dumpMem * (nofData: INTEGER; VAR result: ARRAY OF INTEGER; VAR length: INTEGER);
BEGIN
length := BDI.BDI332_dumpMem(nofData, result);
Done := ~BDIMain.CheckForExceptions()
END dumpMem;
PROCEDURE writeMem * (addr, value, size: INTEGER);
BEGIN
BDI.BDI332_writeMem(addr, value, size);
Done := ~BDIMain.CheckForExceptions()
END writeMem;
PROCEDURE readMem * (addr, size: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI332_readMem(addr, size);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readMem;
PROCEDURE readUserReg * (reg: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI332_readUserReg(reg);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readUserReg;
PROCEDURE writeUserReg * (reg, value: INTEGER);
BEGIN
BDI.BDI332_writeUserReg(reg, value);
Done := ~BDIMain.CheckForExceptions()
END writeUserReg;
PROCEDURE readSysReg * (reg: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI332_readSysReg(reg);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readSysReg;
PROCEDURE writeSysReg * (reg, value: INTEGER);
BEGIN
BDI.BDI332_writeSysReg(reg, value);
Done := ~BDIMain.CheckForExceptions()
END writeSysReg;
PROCEDURE isTargetInDebugMode * (): BOOLEAN;
BEGIN
RETURN BDI.BDI332_isTargetInDebugMode() # FALSE_;
END isTargetInDebugMode;
END UsbBDI332.

189
blackbox/Usb/Mod/BDI555.otd Normal file
View File

@@ -0,0 +1,189 @@
MODULE UsbBDI555;
IMPORT SYS := SYSTEM, BDI := UsbBDIDll, BDIMain := UsbBDI, WinApi;
CONST
FALSE_ = 0;
CONST
MAX_NOF_LONGS_FILL* = BDI.MAX_NOF_LONGS_FILL;
VAR
Done-: BOOLEAN;
(* ----------- 555 --------------- *)
PROCEDURE go * ;
BEGIN
BDI.BDI555_go;
Done := ~BDIMain.CheckForExceptions()
END go;
PROCEDURE break_ * ;
BEGIN
BDI.BDI555_break_;
Done := ~BDIMain.CheckForExceptions()
END break_;
PROCEDURE reset_target * ;
BEGIN
BDI.BDI555_reset_target;
Done := ~BDIMain.CheckForExceptions()
END reset_target;
PROCEDURE isFreezeAsserted * (): BOOLEAN;
VAR result: WinApi.BOOL;
BEGIN
result := BDI.BDI555_isFreezeAsserted();
Done := ~BDIMain.CheckForExceptions();
RETURN result # FALSE_
END isFreezeAsserted;
PROCEDURE startFastDownload * (addr: INTEGER);
BEGIN
BDI.BDI555_startFastDownload(addr);
Done := ~BDIMain.CheckForExceptions()
END startFastDownload;
PROCEDURE fastDownload * (downloadData: ARRAY OF INTEGER; dataLength: INTEGER);
(*VAR i: INTEGER;*)
BEGIN
(*
Log.String("BDI555_fastDownload: length = "); Log.Int(dataLength); Log.Ln;
FOR i := 0 TO dataLength - 1 DO
Log.Int(downloadData[i]); Log.Tab;
END;
Log.Ln;
*)
BDI.BDI555_fastDownload(SYS.ADR(downloadData[0]), dataLength);
Done := ~BDIMain.CheckForExceptions()
END fastDownload;
PROCEDURE stopFastDownload * ;
BEGIN
BDI.BDI555_stopFastDownload;
Done := ~BDIMain.CheckForExceptions()
END stopFastDownload;
PROCEDURE writeMem * (addr, value, size: INTEGER);
BEGIN
BDI.BDI555_writeMem(addr, value, size);
Done := ~BDIMain.CheckForExceptions()
END writeMem;
PROCEDURE readMem * (addr, size: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readMem(addr, size);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readMem;
PROCEDURE writeMemSeq * (value, size: INTEGER);
BEGIN
BDI.BDI555_writeMemSeq(value, size);
Done := ~BDIMain.CheckForExceptions()
END writeMemSeq;
PROCEDURE readMemSeq * (size: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readMemSeq(size);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readMemSeq;
PROCEDURE readGPR * (gpr: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readGPR(gpr);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readGPR;
PROCEDURE writeGPR * (gpr, value: INTEGER);
BEGIN
BDI.BDI555_writeGPR(gpr, value);
Done := ~BDIMain.CheckForExceptions()
END writeGPR;
PROCEDURE readSPR * (spr: INTEGER): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readSPR(spr);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readSPR;
PROCEDURE writeSPR * (spr, value: INTEGER);
BEGIN
BDI.BDI555_writeSPR(spr, value);
Done := ~BDIMain.CheckForExceptions()
END writeSPR;
PROCEDURE readMSR * (): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readMSR();
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readMSR;
PROCEDURE writeMSR * (value: INTEGER);
BEGIN
BDI.BDI555_writeMSR(value);
Done := ~BDIMain.CheckForExceptions()
END writeMSR;
PROCEDURE readFPR * (fpr, tmpMemAddr: INTEGER): LONGINT;
VAR result: LONGINT;
BEGIN
result := BDI.BDI555_readFPR(fpr, tmpMemAddr);
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readFPR;
PROCEDURE writeFPR * (fpr, tmpMemAddr: INTEGER; value: LONGINT);
BEGIN
BDI.BDI555_writeFPR(fpr, tmpMemAddr, value);
Done := ~BDIMain.CheckForExceptions()
END writeFPR;
PROCEDURE readCR * (): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readCR();
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readCR;
PROCEDURE writeCR * (value: INTEGER);
BEGIN
BDI.BDI555_writeCR(value);
Done := ~BDIMain.CheckForExceptions()
END writeCR;
PROCEDURE readFPSCR * (): INTEGER;
VAR result: INTEGER;
BEGIN
result := BDI.BDI555_readFPSCR();
Done := ~BDIMain.CheckForExceptions();
RETURN result
END readFPSCR;
PROCEDURE writeFPSCR * (value: INTEGER);
BEGIN
BDI.BDI555_writeFPSCR(value);
Done := ~BDIMain.CheckForExceptions()
END writeFPSCR;
PROCEDURE isTargetInDebugMode * (): BOOLEAN;
BEGIN
RETURN BDI.BDI555_isTargetInDebugMode() # FALSE_;
END isTargetInDebugMode;
PROCEDURE setGpr31 * (gpr31: INTEGER);
BEGIN
BDI.BDI555_setGpr31(gpr31);
END setGpr31;
END UsbBDI555.

175
blackbox/Usb/Mod/BDIDll.otd Normal file
View File

@@ -0,0 +1,175 @@
MODULE UsbBDIDll ["BDI.dll"];
IMPORT SYSTEM;
CONST
MAX_NOF_LONGS_FILL* = 84;
MAX_UART_DATA_LENGTH* = 128;
TYPE
PtrSTR* = POINTER TO ARRAY [untagged] OF SHORTCHAR;
BOOL* = INTEGER;
(* -------JVM--------- *)
PROCEDURE getErrPipeHandle* (): INTEGER;
(*END getErrPipeHandle; *)
PROCEDURE getOutPipeHandle* (): INTEGER;
(*END getOutPipeHandle; *)
PROCEDURE createJVM* (classpath: PtrSTR): BOOL;
(*END createJVM; *)
PROCEDURE destroyJVM* (): INTEGER;
(*END destroyJVM; *)
PROCEDURE checkForExceptions* (): BOOL;
(*END checkForExceptions; *)
(* -------USB--------- *)
PROCEDURE USB_Device_open*;
(*END USB_Device_open; *)
PROCEDURE USB_Device_close*;
(*END USB_Device_close; *)
PROCEDURE USB_Device_reset*;
(*END USB_Device_reset; *)
(* -------555--------- *)
PROCEDURE BDI555_go*;
(*END BDI555_go; *)
PROCEDURE BDI555_break_*;
(*END BDI555_break_; *)
PROCEDURE BDI555_reset_target*;
(*END BDI555_reset_target; *)
PROCEDURE BDI555_isFreezeAsserted* (): BOOL;
(*END BDI555_isFreezeAsserted; *)
PROCEDURE BDI555_startFastDownload* (adr: INTEGER);
(*END BDI555_startFastDownload; *)
PROCEDURE BDI555_fastDownload* (downloadData: (* ARRAY OF *) INTEGER; dataLength: INTEGER);
(*END BDI555_fastDownload; *)
PROCEDURE BDI555_stopFastDownload*;
(*END BDI555_stopFastDownload; *)
PROCEDURE BDI555_writeMem* (addr, value, size: INTEGER);
(*END BDI555_writeMem; *)
PROCEDURE BDI555_readMem* (addr, size: INTEGER): INTEGER;
(*END BDI555_readMem; *)
PROCEDURE BDI555_writeMemSeq* (value, size: INTEGER);
(*END BDI555_writeMemSeq; *)
PROCEDURE BDI555_readMemSeq* (size: INTEGER): INTEGER;
(*END BDI555_readMemSeq; *)
PROCEDURE BDI555_readGPR* (gpr: INTEGER): INTEGER;
(*END BDI555_readGPR; *)
PROCEDURE BDI555_writeGPR* (gpr, value: INTEGER);
(*END BDI555_writeGPR; *)
PROCEDURE BDI555_readSPR* (spr: INTEGER): INTEGER;
(*END BDI555_readSPR; *)
PROCEDURE BDI555_writeSPR* (spr, value: INTEGER);
(*END BDI555_writeSPR; *)
PROCEDURE BDI555_readMSR* (): INTEGER;
(*END BDI555_readMSR; *)
PROCEDURE BDI555_writeMSR* (value: INTEGER);
(*END BDI555_writeMSR; *)
PROCEDURE BDI555_readFPR* (fpr, tmpMemAddr: INTEGER): LONGINT;
(*END BDI555_readFPR; *)
PROCEDURE BDI555_writeFPR* (fpr, tmpMemAddr: INTEGER; value: LONGINT);
(*END BDI555_writeFPR; *)
PROCEDURE BDI555_readCR* (): INTEGER;
(*END BDI555_readCR; *)
PROCEDURE BDI555_writeCR* (value: INTEGER);
(*END BDI555_writeCR; *)
PROCEDURE BDI555_readFPSCR* (): INTEGER;
(*END BDI555_readFPSCR; *)
PROCEDURE BDI555_writeFPSCR* (value: INTEGER);
(*END BDI555_writeFPSCR; *)
PROCEDURE BDI555_isTargetInDebugMode* (): BOOL;
(*END BDI555_isTargetInDebugMode; *)
PROCEDURE BDI555_setGpr31* (gpr31: INTEGER);
(*END BDI555_setGpr31; *)
(* -------332--------- *)
PROCEDURE BDI332_nopsToLegalCmd*;
(*END BDI332_nopsToLegalCmd; *)
PROCEDURE BDI332_go*;
(*END BDI332_go; *)
PROCEDURE BDI332_break_*;
(*END BDI332_break_; *)
PROCEDURE BDI332_reset_target*;
(*END BDI332_reset_target; *)
PROCEDURE BDI332_reset_peripherals*;
(*END BDI332_reset_peripherals; *)
PROCEDURE BDI332_isFreezeAsserted* (): BOOL;
(*END BDI332_isFreezeAsserted; *)
PROCEDURE BDI332_fillMem* (downloadData: (* ARRAY OF *) INTEGER; dataLength: INTEGER);
(*END BDI332_fillMem; *)
PROCEDURE BDI332_dumpMem* (nofData: INTEGER; VAR result: ARRAY OF INTEGER): INTEGER;
(*
PROCEDURE BDI332_dumpMem* (nofData: INTEGER; VAR result: ARRAY [untagged] MAX_NOF_LONGS_FILL OF INTEGER): INTEGER;
*)
(*END BDI332_dumpMem; *)
PROCEDURE BDI332_writeMem* (addr, value, size: INTEGER);
(*END BDI332_writeMem; *)
PROCEDURE BDI332_readMem* (addr, size: INTEGER): INTEGER;
(*END BDI332_readMem; *)
PROCEDURE BDI332_readUserReg* (reg: INTEGER): INTEGER;
(*END BDI332_readUserReg; *)
PROCEDURE BDI332_writeUserReg* (reg, value: INTEGER);
(*END BDI332_writeUserReg; *)
PROCEDURE BDI332_readSysReg* (reg: INTEGER): INTEGER;
(*END BDI332_readSysReg; *)
PROCEDURE BDI332_writeSysReg* (reg, value: INTEGER);
(*END BDI332_writeSysReg; *)
PROCEDURE BDI332_isTargetInDebugMode* (): BOOL;
(*END BDI332_isTargetInDebugMode; *)
(* ------ UART0 ------ *)
PROCEDURE UART0_read* (VAR data: ARRAY [untagged] OF SHORTCHAR): INTEGER;
(*END UART0_read; *)
PROCEDURE UART0_write* (data: (* ARRAY OF SHORTCHAR *) INTEGER; length: INTEGER): BOOL;
(*END UART0_write; *)
END UsbBDIDll.

110
blackbox/Usb/Mod/TargLog.otd Normal file
View File

@@ -0,0 +1,110 @@
MODULE UsbTargLog;
(** <20> NTB/AS 12.01.2006 *)
(**
Changes:
*)
IMPORT
USB := UsbBDI, Log := StdLog, Services, TextModels, XUT := XdeUtilities;
CONST
logTitle = "USB Target Log";
PERIOD = 200;
TYPE
Receiver = POINTER TO RECORD (Services.Action)
time: LONGINT; period: INTEGER
END;
VAR
receiver: Receiver;
logTextModel: TextModels.Model; logWriter: TextModels.Writer;
PROCEDURE (receiver: Receiver) Do;
VAR
length, i: INTEGER; done: BOOLEAN;
data: ARRAY USB.MAX_UART_DATA_LENGTH OF SHORTCHAR;
BEGIN
done := USB.UART0_read(data, length);
IF done THEN
FOR i := 0 TO length - 1 DO
logWriter.WriteChar(data[i])
END
END;
INC( receiver.time, receiver.period ); Services.DoLater(receiver, receiver.time )
END Do;
PROCEDURE Stop * ;
BEGIN
IF receiver # NIL THEN Services.RemoveAction(receiver ); receiver := NIL END;
logWriter := NIL; logTextModel := NIL
END Stop;
PROCEDURE StartReceiver;
BEGIN
IF receiver # NIL THEN Services.RemoveAction(receiver ); receiver := NIL END;
NEW(receiver);
receiver.time := Services.Ticks(); receiver.period := PERIOD;
Services.DoLater(receiver, receiver.time)
END StartReceiver;
PROCEDURE Start * ;
VAR beg, end: INTEGER;
BEGIN
IF ~USB.DeviceOpen() THEN
USB.ConnectDevice;
END;
Stop;
Log.String("opening USB target log"); Log.Ln;
XUT.GetTextModel("", logTextModel, beg, end); logWriter := logTextModel.NewWriter(NIL);
XUT.ShowTextView(logTextModel, logTitle);
StartReceiver;
END Start;
PROCEDURE SendSelToTarget * ;
(** send all visible char of the current selection to the target
*)
VAR
reader: TextModels.Reader; textModel: TextModels.Model; beg, end, currentLen: INTEGER; ch: CHAR;
data: ARRAY USB.MAX_UART_DATA_LENGTH OF SHORTCHAR; done, error: BOOLEAN;
BEGIN
XUT.GetTextModel("@", textModel, beg, end);
IF textModel # NIL THEN
reader := textModel.NewReader(NIL); reader.SetPos(beg);
currentLen := 0; error := FALSE;
WHILE reader.Pos() < end DO
reader.ReadChar(ch);
data[currentLen] := SHORT(ch);
INC(currentLen);
IF currentLen >= USB.MAX_UART_DATA_LENGTH THEN
done := USB.UART0_write(data, currentLen);
IF ~done THEN
error := TRUE;
Log.String("Sending data failed"); Log.Ln;
END;
currentLen := 0;
END
END;
IF currentLen > 0 THEN
done := USB.UART0_write(data, currentLen);
IF ~done THEN
error := TRUE;
Log.String("Sending data failed"); Log.Ln;
END
END;
IF ~error THEN
Log.String("Data sent successfully"); Log.Ln;
END
END
END SendSelToTarget;
PROCEDURE ClearText * ;
BEGIN
IF logTextModel # NIL THEN
logTextModel.Delete(0, logTextModel.Length()); logWriter.SetPos(0)
END
END ClearText;
CLOSE
Stop
END UsbTargLog .

BIN
blackbox/Usb/Rsrc/usbpdi.jar Normal file
View File

Binary file not shown.

369
blackbox/Xo68x32/Mod/AmdFlashs.otd Normal file
View File

@@ -0,0 +1,369 @@
MODULE Xo68x32AmdFlashs;
(** <20> ProXon/ED 7.10.97 / 20.10.98 / wm 9.00 / ED 18.12.00 / 27.6.02 | *)
(* Updated for 29F800 Bottom Boot Sector. Changes in dark-green. wm, 9.2000 *)
IMPORT
Log := StdLog, Dialog, Services,
UT := XdeUtilities, XE := XdeErrors, FlM := Xo68x32FlashMemories, BDI := UsbBDI332,
BDIMain := UsbBDI;
CONST
errPrefix = "Amd_";
TargetDefineMem = "Xo68x32ImcTarget.DefineMemory";
TargetInit = "Xo68x32ImcTarget.Init";
(*
thisMod="XdeAmdFlashs";
*)
CONST
nul = 0X; cr = 0DX; eol = cr; ht = 9X;
imageFileExt = ".Tim"; (** target image file extension: ".Tim" *)
VAR
Done-: BOOLEAN; eof-: BOOLEAN;
(** Done=TRUE: vorangegangene Operation wurde erfolgreich beendet.
eof = TRUE: das Ende des Files ist nun erreicht, oder ein ENDrecord wurde gelesen.
Done=TRUE und eot = TRUE: ENDrecord konnte noch erfolgreich gelesen werden.
*)
firstErr-: INTEGER; (** error list see CrossErrors.Text, search for Xo68x32AmdFlashs *)
PROCEDURE Error (errNr: SHORTINT);
BEGIN
IF Done THEN firstErr := firstErr; Done := FALSE END;
XE.Error("", errPrefix, errNr, TRUE)
END Error;
PROCEDURE LogHex (val: INTEGER);
BEGIN
Log.Char('0'); Log.IntForm(val, Log.hexadecimal, 1, ' ', Log.hideBase); Log.Char('H')
END LogHex;
PROCEDURE PutWord (adr, data: INTEGER);
BEGIN
data := data MOD 10000H; BDI.writeMem(adr, data, 2)
END PutWord;
PROCEDURE WaitByDataPoll (adr, expData: INTEGER);
VAR endTime: LONGINT; data: INTEGER;
BEGIN
endTime := Services.Ticks() + 5000;
REPEAT data := BDI.readMem(adr, 2) UNTIL (data = expData) OR (endTime < Services.Ticks());
IF data # expData THEN
Error(3); Log.Tab; Log.String("at loc "); LogHex(adr); Log.Ln
END
END WaitByDataPoll;
PROCEDURE LogWord (data: INTEGER; comment: ARRAY OF CHAR);
BEGIN
Log.Tab; Log.String(comment); Log.String(":"); Log.Tab; LogHex(data MOD 10000H); Log.Ln
END LogWord;
PROCEDURE InDeviceAdr (VAR devAdr: INTEGER);
VAR adr: INTEGER; scnr: UT.Scanner;
BEGIN
UT.GetScanner("!", scnr);
IF scnr.done THEN scnr.Int(adr) END;
IF ~scnr.done THEN
Error(1); devAdr := 0
ELSE
devAdr := adr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize
END
END InDeviceAdr;
PROCEDURE InSectorAdr (VAR sectorAdr: INTEGER);
VAR adr: INTEGER; scnr: UT.Scanner;
BEGIN
UT.GetScanner("!", scnr);
IF scnr.done THEN scnr.Int(adr) END;
IF ~scnr.done THEN
Error(1); sectorAdr := 0
ELSE
sectorAdr := adr DIV FlM.memDevice.sectorSize * FlM.memDevice.sectorSize
END
END InSectorAdr;
PROCEDURE GetChipIDsAm29F800 (devAdr: INTEGER);
VAR data: INTEGER; res, sector: INTEGER;
PROCEDURE GetSectorProtection (sector, sectAdr, sectSize: INTEGER);
BEGIN
data := BDI.readMem(sectAdr + 4, 2);
Log.Tab; Log.String("sector "); Log.Int(sector); Log.Tab; Log.String("adr: ");
Log.Tab; LogHex(sectAdr); Log.String("..."); LogHex(sectAdr + sectSize - 1);
Log.Tab;
IF data = 0 THEN Log.String("un") END; Log.String("protected")
END GetSectorProtection;
BEGIN
devAdr := devAdr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize;
Dialog.Call(TargetInit, "error calling " + TargetInit, res);
IF res # 0 THEN Error(2) END;
Log.Ln; Log.String("getting Am29F800B chip IDs:"); Log.Ln; Log.Tab; Log.String("address area:");
LogHex(devAdr); Log.String(" .. "); LogHex(devAdr + FlM.memDevice.deviceSize - 1); Log.Ln;
PutWord(devAdr + 0AAAH, 0AAAAH);
PutWord(devAdr + 0554H, 5555H);
PutWord(devAdr + 0AAAH, 9090H);
data := BDI.readMem(devAdr + 0, 2); LogWord(data, "manufacturer id");
data := BDI.readMem(devAdr + 2, 2); LogWord(data, "device id");
(* device id = 22D6h: top boot block, device id = 2258H: bottom boot block *)
Log.Tab; Log.String("sector protection:"); Log.Ln;
IF data = 22D6H THEN
FOR sector := 0 TO 14 DO
GetSectorProtection(sector, devAdr, FlM.memDevice.sectorSize);
INC(devAdr, FlM.memDevice.sectorSize); Log.Ln
END;
GetSectorProtection(15, devAdr, FlM.memDevice.sectorSize DIV 2);
INC(devAdr, FlM.memDevice.sectorSize DIV 2); Log.Ln;
GetSectorProtection(16, devAdr, FlM.memDevice.sectorSize DIV 8);
INC(devAdr, FlM.memDevice.sectorSize DIV 8); Log.Ln;
GetSectorProtection(17, devAdr, FlM.memDevice.sectorSize DIV 8);
INC(devAdr, FlM.memDevice.sectorSize DIV 8); Log.Ln;
GetSectorProtection(18, devAdr, FlM.memDevice.sectorSize DIV 4);
ELSIF data = 2258H THEN
GetSectorProtection(0, devAdr, FlM.memDevice.sectorSize DIV 4);
INC(devAdr, FlM.memDevice.sectorSize DIV 4); Log.Ln;
GetSectorProtection(1, devAdr, FlM.memDevice.sectorSize DIV 8);
INC(devAdr, FlM.memDevice.sectorSize DIV 8); Log.Ln;
GetSectorProtection(2, devAdr, FlM.memDevice.sectorSize DIV 8);
INC(devAdr, FlM.memDevice.sectorSize DIV 8); Log.Ln;
GetSectorProtection(3, devAdr, FlM.memDevice.sectorSize DIV 2);
INC(devAdr, FlM.memDevice.sectorSize DIV 2); Log.Ln;
FOR sector := 4 TO 18 DO
GetSectorProtection(sector, devAdr, FlM.memDevice.sectorSize);
INC(devAdr, FlM.memDevice.sectorSize); Log.Ln
END
ELSE Error(4) (* wrong device id *)
END;
PutWord(devAdr, 0F0F0H); Log.Ln
END GetChipIDsAm29F800;
PROCEDURE GetChipIDsAm29F040 (devAdr: INTEGER);
VAR data: INTEGER; res, sector: INTEGER;
PROCEDURE GetSectorProtection (sector, sectAdr, sectSize: INTEGER);
BEGIN
data := BDI.readMem(sectAdr + 4, 2);
Log.Tab; Log.String("sector "); Log.Int(sector); Log.Tab; Log.String("adr: ");
Log.Tab; LogHex(sectAdr); Log.String("..."); LogHex(sectAdr + sectSize - 1);
Log.Tab;
IF data = 0 THEN Log.String("un") END; Log.String("protected")
END GetSectorProtection;
BEGIN
devAdr := devAdr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize;
Dialog.Call(TargetInit, "error calling " + TargetInit, res);
IF res # 0 THEN Error(2) END;
Log.Ln; Log.String("getting Am29F040B chip IDs:"); Log.Tab; Log.String("address area:");
Log.Tab; LogHex(devAdr); Log.String(" .. "); LogHex(devAdr + FlM.memDevice.deviceSize - 1); Log.Ln;
PutWord(devAdr + 0AAAH, 0AAAAH);
PutWord(devAdr + 0554H, 5555H);
PutWord(devAdr + 0AAAH, 9090H);
data := BDI.readMem(devAdr + 0, 2); LogWord(data, "manufacturer id");
data := BDI.readMem(devAdr + 2, 2); LogWord(data, "device id");
(* device id = 22D6h: top boot block, device id = 2258H: bottom boot block *)
Log.Tab; Log.String("sector protection:"); Log.Ln;
FOR sector := 0 TO 7 DO
GetSectorProtection(sector, devAdr, FlM.memDevice.sectorSize);
INC(devAdr, FlM.memDevice.sectorSize); Log.Ln
END;
Log.Ln;
DEC(devAdr, FlM.memDevice.sectorSize);
PutWord(devAdr, 0F0F0H); Log.Ln
END GetChipIDsAm29F040;
PROCEDURE EraseDevice (adr: INTEGER);
CONST expData = 0FFFFH;
VAR devAdr: INTEGER;
BEGIN
devAdr := adr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize;
Log.Ln; Log.Tab; Log.String("erasing device(s): ");
LogHex(devAdr); Log.String(" .. "); LogHex(devAdr + FlM.memDevice.deviceSize - 1); Log.Ln;
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(devAdr + 0AAAAH, 8080H);
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(devAdr + 0AAAAH, 1010H);
WaitByDataPoll(devAdr, expData)
END EraseDevice;
PROCEDURE EraseSector (sectorAdr: INTEGER);
VAR devAdr: INTEGER;
BEGIN
sectorAdr := sectorAdr DIV FlM.memDevice.sectorSize * FlM.memDevice.sectorSize;
devAdr := sectorAdr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize;
Log.Ln; Log.Tab; Log.String("erasing sector: ");
LogHex(sectorAdr); Log.String(" .. "); LogHex(sectorAdr + FlM.memDevice.sectorSize - 1);
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(devAdr + 0AAAAH, 8080H);
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(sectorAdr, 3030H);
WaitByDataPoll(sectorAdr, 0FFFFH)
END EraseSector;
PROCEDURE EraseSectorAm29F800 (sectorAdr: INTEGER);
VAR devAdr: INTEGER;
PROCEDURE SetEraseMode;
BEGIN
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(devAdr + 0AAAAH, 8080H);
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H)
END SetEraseMode;
BEGIN
sectorAdr := sectorAdr DIV FlM.memDevice.sectorSize * FlM.memDevice.sectorSize;
devAdr := sectorAdr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize;
Log.Ln; Log.Tab; Log.String("erasing sector: ");
LogHex(sectorAdr); Log.String(" .. "); LogHex(sectorAdr + FlM.memDevice.sectorSize - 1);
SetEraseMode;
PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
IF sectorAdr - devAdr <= 0FFFFH THEN (* erase bottom boot block *)
INC(sectorAdr, FlM.memDevice.sectorSize DIV 4);
SetEraseMode; PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
INC(sectorAdr, FlM.memDevice.sectorSize DIV 8);
SetEraseMode; PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
INC(sectorAdr, FlM.memDevice.sectorSize DIV 8);
SetEraseMode; PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
ELSIF sectorAdr - devAdr >= 0F0000H THEN (* erase top boot block *)
INC(sectorAdr, FlM.memDevice.sectorSize DIV 2);
SetEraseMode; PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
INC(sectorAdr, FlM.memDevice.sectorSize DIV 8);
SetEraseMode; PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
INC(sectorAdr, FlM.memDevice.sectorSize DIV 8);
SetEraseMode; PutWord(sectorAdr, 3030H); WaitByDataPoll(sectorAdr, 0FFFFH);
END
END EraseSectorAm29F800;
PROCEDURE ProgramLong (adr, data: INTEGER);
(* program one long at adr *)
VAR devAdr, word: INTEGER;
BEGIN
devAdr := adr DIV FlM.memDevice.deviceSize * FlM.memDevice.deviceSize;
(* high word *)
word := data DIV 10000H MOD 10000H;
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(devAdr + 0AAAAH, 0A0A0H);
PutWord(adr, word);
WaitByDataPoll(adr, word);
(* low word *)
word := data MOD 10000H; INC(adr, 2);
PutWord(devAdr + 0AAAAH, 0AAAAH);
PutWord(devAdr + 05554H, 5555H);
PutWord(devAdr + 0AAAAH, 0A0A0H);
PutWord(adr, word);
WaitByDataPoll(adr, word)
END ProgramLong;
PROCEDURE ShowChipIDsAm29F040 * ;
(**
Syntax: XdeAmdFlashs.ShowChipIDsAm29F040B deviceAddress
Preconditions: Target.DefineMemory defines the memory device Am29F040B
target connected via BDI
Description: shows: manufacturer id, device id and sector protection
Postconditions: the device(s) is in normal reading array mode.
*)
VAR devAdr: INTEGER;
BEGIN
BDIMain.ConnectDevice;
FlM.LoadMemDevPar("Am29F040"); InDeviceAdr(devAdr); GetChipIDsAm29F040(devAdr)
END ShowChipIDsAm29F040;
PROCEDURE ShowChipIDsAm29F800 * ;
(**
Syntax: XdeAmdFlashs.ShowChipIDsAm29F800B deviceAddress
Preconditions: Target.DefineMemory defines the memory device Am29F800B
target connected via BDI
Description: shows: manufacturer id, device id and sector protection
Postconditions: the device(s) is in normal reading array mode.
*)
VAR devAdr: INTEGER;
BEGIN
BDIMain.ConnectDevice;
FlM.LoadMemDevPar("Am29F800"); InDeviceAdr(devAdr); GetChipIDsAm29F800(devAdr)
END ShowChipIDsAm29F800;
PROCEDURE EraseSectAm29F800 * ;
VAR sectAdr: INTEGER;
BEGIN
BDIMain.ConnectDevice;
FlM.LoadMemDevPar("Am29F800"); InSectorAdr(sectAdr); EraseSectorAm29F800(sectAdr)
END EraseSectAm29F800;
PROCEDURE LoadAm29F010 * ;
(** Preconditions: there is an image file Am29F010.Tim
if neccessary, click on CRSystem.Build to update all images
Description: the image in file Am29F010.Tim is loaded to the targets flash memory devices.
Postconditions: all flash memory device sectors, touched by the records in the imagefile,
are first erased and then programed.
*)
BEGIN
BDIMain.ConnectDevice;
Done := TRUE;
FlM.InstallDeviceProc(EraseDevice, EraseSector, ProgramLong);
FlM.Program("Am29F010", FALSE)
END LoadAm29F010;
PROCEDURE LoadAm29F040 * ;
(** Preconditions: there is an image file Am29F040.Tim
if neccessary, click on CRSystem.Build to update all images
Description: the image in file Am29F040.Tim is loaded to the targets flash memory devices.
Postconditions: all flash memory device sectors, touched by the records in the imagefile,
are first erased and then programed.
*)
BEGIN
BDIMain.ConnectDevice;
Done := TRUE;
FlM.InstallDeviceProc(EraseDevice, EraseSector, ProgramLong);
FlM.Program("Am29F040", FALSE)
END LoadAm29F040;
PROCEDURE LoadAm29F800 * ;
(** Preconditions: there is an image file Am29F800B.Tim
if neccessary, click on CRSystem.Build to update all images
Description: the image in file Am29F800B.Tim is loaded to the targets flash memory devices.
Postconditions: all flash memory device sectors, touched by the records in the imagefile,
are first erased and then programed.
*)
BEGIN
BDIMain.ConnectDevice;
Done := TRUE;
FlM.InstallDeviceProc(EraseDevice, EraseSectorAm29F800, ProgramLong);
FlM.Program("Am29F800", FALSE)
END LoadAm29F800;
BEGIN
END Xo68x32AmdFlashs.

1932
blackbox/Xo68x32/Mod/System.otd Normal file
View File

File diff suppressed because it is too large Load Diff

369
blackbox/Xoppc/Mod/AmdFlashs.otd Normal file
View File

@@ -0,0 +1,369 @@
MODULE XoppcAmdFlashs;
(** <20> ProXon/ED 7.10.97 / 20.10.98 / wm 9.00 / ED 18.12.00 / 27.6.02 | *)
(* changes:
22.10.04 UG adapted for ppc
*)
IMPORT
Log := StdLog, Dialog, Services,
UT := XdeUtilities, XE := XdeErrors, FlM := XoppcFlashMemories , BDI := UsbBDI555, TMAM := XoppcTargetMemAndMods,
S := SYSTEM, XSYS := XoppcSystem, TextModels;
CONST
errPrefix = "Amd_";
TargetDefineMem = "Xo68x32ImcTarget.DefineMemory";
TargetInit = "Xo68x32ImcTarget.Init";
(*
thisMod="XdeAmdFlashs";
*)
CONST
nul = 0X; cr = 0DX; eol = cr; ht = 9X;
nyd = "<>"; (*not yet defined (number)*)
imageFileExt = ".Tim"; (** target image file extension: ".Tim" *)
VAR
Done-: BOOLEAN; eof-: BOOLEAN;
(** Done=TRUE: vorangegangene Operation wurde erfolgreich beendet.
eof = TRUE: das Ende des Files ist nun erreicht, oder ein ENDrecord wurde gelesen.
Done=TRUE und eot = TRUE: ENDrecord konnte noch erfolgreich gelesen werden.
*)
firstErr-: INTEGER; (** error list see CrossErrors.Text, search for Xo68x32AmdFlashs *)
(*cs*)
VAR
Am29LV160DSegment : TMAM.Segment;
Am29LV160DDevice: TMAM.Device;
configT: TextModels.Model;
CONST
configText = "TargetConfig.odc";
PROCEDURE Error (errNr: SHORTINT);
BEGIN
IF Done THEN firstErr := firstErr; Done := FALSE END;
XE.Error("", errPrefix, errNr, TRUE)
END Error;
PROCEDURE LogHex (val: INTEGER);
BEGIN
Log.Char('0'); Log.IntForm(val, Log.hexadecimal, 1, ' ', Log.hideBase); Log.Char('H')
END LogHex;
PROCEDURE LogWord (data: INTEGER; comment: ARRAY OF CHAR);
BEGIN
Log.Tab; Log.String(comment); Log.String(":"); Log.Tab; LogHex(data MOD 10000H); Log.Ln
END LogWord;
PROCEDURE PutInt (adr, data: INTEGER);
BEGIN
BDI.writeMem(adr, data, 4);
END PutInt;
PROCEDURE mirrorReadIntData (data : INTEGER): INTEGER;
VAR i: INTEGER;
ds, datas: SET;
BEGIN
ds := {};
datas := S.VAL(SET, data);
FOR i := 0 TO 31 DO
IF i IN datas THEN
INCL(ds, 31 - i)
END;
END;
RETURN S.VAL(INTEGER, ds);
END mirrorReadIntData;
PROCEDURE InDeviceAdr (VAR devAdr: INTEGER);
VAR adr: INTEGER; scnr: UT.Scanner;
BEGIN
UT.GetScanner("!", scnr);
IF scnr.done THEN scnr.Int(adr) END;
IF ~scnr.done THEN
Error(1); devAdr := 0
ELSE
devAdr := adr DIV Am29LV160DSegment.size * Am29LV160DSegment.size ;
END
END InDeviceAdr;
PROCEDURE GetChipIDsAm29LV160D (devAdr: INTEGER);
VAR data: INTEGER; res, sector: INTEGER;
VAR locSgmt: TMAM.Segment; locSgmtNr: INTEGER;
PROCEDURE GetSectorProtection (sector, sectAdr, sectSize: INTEGER);
BEGIN
data := BDI.readMem(sectAdr + 2 * 4, 4);
Log.Tab; Log.String("adr: ");
Log.Tab; LogHex(sectAdr); Log.String("..."); LogHex(sectAdr + sectSize - 1);
Log.Tab;
IF mirrorReadIntData(data) = 0 THEN Log.String("un") END; Log.String("protected")
END GetSectorProtection;
BEGIN
devAdr := devAdr DIV Am29LV160DSegment.size * Am29LV160DSegment.size ;
Log.Ln; Log.String("getting Am29LV160D chip IDs:"); Log.Tab; Log.String("address area:");
Log.Tab; LogHex(devAdr); Log.String(" .. "); LogHex(devAdr + Am29LV160DSegment.size - 1); Log.Ln;
PutInt(devAdr + 01554H, 055005500H);
PutInt(devAdr + 0AA8H, 0AA00AA00H);
PutInt(devAdr + 01554H, 009000900H);
data := BDI.readMem(devAdr + 0, 4); LogWord(mirrorReadIntData(data), "manufacturer id"); (*01*)
data := BDI.readMem(devAdr + 4, 4); LogWord(mirrorReadIntData(data), "device id");
Log.String("Sectorname:"); Log.Tab;
Log.String("Sectorbaseadress:"); Log.Tab;
Log.String("Sectorsize:"); Log.Tab;
Log.String("Sectorused:"); Log.Tab;
Log.String("Sectorattributs:"); Log.Tab;
Log.String("Sectoradressrange:"); Log.Tab;
Log.Tab; Log.String("sector protection:");
Log.Ln;
locSgmt := Am29LV160DSegment.local; locSgmtNr := 0;
WHILE locSgmt # NIL DO
IF locSgmt.name = "" THEN Log.Int(locSgmtNr) ELSE Log.String(locSgmt.name) END;
Log.Tab;
Log.Tab; IF locSgmt.base < 0 THEN Log.String(nyd) ELSE LogHex(locSgmt.base) END;
Log.Tab; IF locSgmt.size < 0 THEN Log.String(nyd) ELSE LogHex(locSgmt.size) END;
Log.Tab; LogHex(locSgmt.used);
Log.Tab; Log.Set(locSgmt.attrs);
GetSectorProtection(locSgmtNr, devAdr, locSgmt.size);
INC(devAdr, locSgmt.size DIV Am29LV160DSegment.width); Log.Ln;
locSgmt := locSgmt.next; INC(locSgmtNr)
END;
PutInt(devAdr + 01554H, 0F000F00H); Log.Ln (*Reset*)
END GetChipIDsAm29LV160D;
PROCEDURE ShowChipIDsAm29LV160D * ;
(**
Syntax: XdeAmdFlashs.ShowChipIDsAm29LV160D deviceAddress
Preconditions: Target.DefineMemory defines the memory device Am29FLV160DB
target connected via BDI
Description: shows: manufacturer id, device id and sector protection
Postconditions: the device(s) is in normal reading array mode.
*)
VAR devAdr: INTEGER;
BEGIN
InDeviceAdr(devAdr);
GetChipIDsAm29LV160D(devAdr);
END ShowChipIDsAm29LV160D;
PROCEDURE GetSectorAdress (sectName : TMAM.Name; VAR sectSize : INTEGER ): INTEGER;
VAR locSgmt: TMAM.Segment; locSgmtNr, adr: INTEGER;
BEGIN
locSgmt := Am29LV160DSegment.local; locSgmtNr := 0; adr := 0;
WHILE locSgmt # NIL DO
adr := adr DIV locSgmt.size * locSgmt.size;
IF locSgmt.name = "" THEN Log.Int(locSgmtNr) ELSE Log.String(locSgmt.name) END;
IF locSgmt.name = sectName THEN
sectSize := locSgmt.size DIV Am29LV160DSegment.width ; RETURN adr
ELSE
adr := adr + locSgmt.size DIV Am29LV160DSegment.width;
END;
locSgmt := locSgmt.next; INC(locSgmtNr)
END;
END GetSectorAdress;
PROCEDURE InSectorAdr (VAR sectorAdr, sectSize : INTEGER);
VAR scnr: UT.Scanner;
sectName : TMAM.Name;
BEGIN
UT.GetScanner("!", scnr);
IF scnr.done THEN scnr.CharSequence(sectName) END;
Log.String("Readed sector name: "); Log.String(sectName); Log.Tab;
IF ~scnr.done THEN
Error(1); sectorAdr := 0
ELSE
sectorAdr := GetSectorAdress(sectName, sectSize);
Log.String("Sectoradress: "); LogHex(sectorAdr); Log.Ln;
END
END InSectorAdr;
PROCEDURE InDumpStartAndEndAdr (VAR startAdr, endAdr: INTEGER);
VAR adr: INTEGER; scnr: UT.Scanner;
BEGIN
UT.GetScanner("!", scnr);
IF scnr.done THEN scnr.Int(adr) END;
IF ~scnr.done THEN
Error(1); startAdr := 0
ELSE
startAdr := adr
END;
Log.Ln; Log.String("read start adress to dump: "); LogHex(startAdr);
IF scnr.done THEN scnr.Int(adr) END;
IF ~scnr.done THEN
Error(1); endAdr := 0
ELSE
endAdr := adr
END;
Log.Ln; Log.String("read end adress to dump: "); LogHex(endAdr); Log.Ln;
END InDumpStartAndEndAdr;
PROCEDURE InSectorAdr2 (VAR sectorAdr: INTEGER);
VAR adr: INTEGER; scnr: UT.Scanner;
BEGIN
UT.GetScanner("!", scnr);
IF scnr.done THEN scnr.Int(adr) END;
IF ~scnr.done THEN
Error(1); sectorAdr := 0
ELSE
sectorAdr := adr
END;
LogHex(sectorAdr);
END InSectorAdr2;
PROCEDURE WaitByDataPollInt (adr, expData, timeOut: INTEGER);
VAR endTime: LONGINT; data: INTEGER;
BEGIN
endTime := Services.Ticks() + timeOut;
REPEAT data := BDI.readMem(adr, 4) UNTIL (data = expData) OR (endTime < Services.Ticks());
IF data # expData THEN
Error(3); Log.Tab; Log.String("at loc "); LogHex(adr); Log.Ln
END
END WaitByDataPollInt;
PROCEDURE EraseSectorAm29LV160D (sectorAdr: INTEGER);
VAR devAdr: INTEGER;
PROCEDURE SetEraseMode;
BEGIN
PutInt(devAdr + 01554H, 055005500H);
PutInt(devAdr + 0AA8H, 0AA00AA00H);
PutInt(devAdr + 01554H, 01000100H);
PutInt(devAdr + 01554H, 055005500H);
PutInt(devAdr + 0AA8H, 0AA00AA00H)
END SetEraseMode;
BEGIN
(* Log.String("AmdFlashs-Erase, sector adress ");
LogHex(sectorAdr); Log.Tab;*)
devAdr := Am29LV160DSegment.base ;
(* LogHex(devAdr);*)
sectorAdr := sectorAdr - devAdr;
(* Log.Ln; Log.Tab; Log.String("erasing sector: ");
LogHex(devAdr + sectorAdr); Log.String(" .. ");*)
SetEraseMode;
PutInt(devAdr + sectorAdr , 0C000C00H); WaitByDataPollInt(devAdr + sectorAdr , 0FFFFFFFFH, 5000);
END EraseSectorAm29LV160D;
PROCEDURE EraseSectAm29LV160D * ;
VAR sectAdr, sectSize: INTEGER;
BEGIN
InSectorAdr2(sectAdr);
EraseSectorAm29LV160D(sectAdr);
END EraseSectAm29LV160D;
PROCEDURE EraseDeviceAm29LV160D * (adr: INTEGER);
CONST expData = 0FFFFFFFFH;
VAR devAdr: INTEGER;
BEGIN
devAdr := Am29LV160DSegment.base ;
adr := adr - devAdr;
Log.Ln; Log.Tab; Log.String("erasing device(s): ");
LogHex(devAdr); Log.String(" .. "); LogHex(devAdr + Am29LV160DDevice.size - 1); Log.Ln;
PutInt(devAdr + 01554H, 055005500H);
PutInt(devAdr + 0AA8H, 0AA00AA00H);
PutInt(devAdr + 01554H, 01000100H);
PutInt(devAdr + 01554H, 055005500H);
PutInt(devAdr + 0AA8H, 0AA00AA00H);
PutInt(devAdr + 01554H, 08000800H);
WaitByDataPollInt(devAdr, expData, 30000);
Log.Tab; Log.String("device erased! ");
END EraseDeviceAm29LV160D;
PROCEDURE EraseDeviceAm29LV160DCmd * ;
VAR sectAdr, sectSize: INTEGER;
BEGIN
InDeviceAdr(sectAdr);
EraseDeviceAm29LV160D(sectAdr);
END EraseDeviceAm29LV160DCmd;
PROCEDURE ProgramIntAm29LV160D (adr, data: INTEGER);
(* program one int at adr *)
VAR
devAdr: INTEGER;
BEGIN
devAdr := Am29LV160DSegment.base ;
PutInt(devAdr + 01554H, 055005500H);
PutInt(devAdr + 0AA8H, 0AA00AA00H);
PutInt(devAdr + 01554H, 05000500H);
PutInt(adr, data);
WaitByDataPollInt(adr , data, 5000);
END ProgramIntAm29LV160D;
PROCEDURE LoadAm29LV160D * ;
(** Preconditions: there is an image fileAm29LV160DB.Tim
if neccessary, click on XoppcSystem.Build to update all images
Description: the image in file fileAm29LV160DB.Tim is loaded to the targets flash memory devices.
Postconditions: all flash memory device sectors, touched by the records in the imagefile,
are first erased and then programed.
*)
BEGIN
Done := TRUE;
Am29LV160DSegment := TMAM.GetSegment(NIL, "ExternalFlashAm29LV160D");
Am29LV160DDevice := TMAM.GetDevice("Am29LV160D");
FlM.LoadMemDevPar(Am29LV160DDevice, Am29LV160DSegment);
FlM.InstallDeviceProc(EraseDeviceAm29LV160D, EraseSectorAm29LV160D, ProgramIntAm29LV160D);
XSYS.ResetTarget; IF ~BDI.Done THEN Error(40); RETURN END;
FlM.Program("Am29LV160D", FALSE)
END LoadAm29LV160D;
PROCEDURE DumpIntAm29LV160D * ;
VAR
startAdr, endAdr : INTEGER;
data, i : INTEGER;
BEGIN
InDumpStartAndEndAdr(startAdr, endAdr);
FOR i := startAdr TO (endAdr) BY 4 DO
data := BDI.readMem(i , 4);
Log.String("Readed INT value at Adress "); LogHex(i); Log.String(" : ");
LogHex(data); Log.Ln;
END;
END DumpIntAm29LV160D;
PROCEDURE Init * ;
BEGIN
XSYS.ResetTarget;
IF ~BDI.Done THEN Error(40); RETURN END;
Log.Tab; Log.String("controller reset and initialised"); Log.Ln;
TMAM.InitRegs;
END Init;
BEGIN
Init;
END XoppcAmdFlashs.

1839
blackbox/Xoppc/Mod/System.otd Normal file
View File

File diff suppressed because it is too large Load Diff

190
blackbox/Xoppc/Mod/TrgtRegDict.otd Normal file
View File

@@ -0,0 +1,190 @@
MODULE XoppcTrgtRegDict;
(** <20> ProXon/ED 3.9.94 / 22.11.98 / 4.12.00 / 14.2.02 | *)
(** target register operations*)
IMPORT
XE := XdeErrors, XU := XdeUtilities, BDI := UsbBDI555, Log := StdLog;
CONST
errPrefix = "RegDir_"; regDictPath = "Xoppc/Rsrc/RegisterDictionary.odc";
TYPE
RegName* = ARRAY 8 OF CHAR;
RegDesc = RECORD
type: RegName;
size: INTEGER;
END;
VAR
Done-: BOOLEAN; (** previous operation successfully completed *)
firstErr-: SHORTINT; (** first error occured, see error list at the end of this module *)
regTypeTab: ARRAY 8 OF RegDesc;
curReg, curRegCode, regTextPos: INTEGER; curRegName: RegName; curRegType: RegName;
regScn: XU.Scanner;
fprMoveAddr*: INTEGER;
PROCEDURE ClearRegAttr;
BEGIN
curReg := 0; curRegCode := 0; regTextPos := 0;
curRegType := regTypeTab[0].type; curRegName := ""
END ClearRegAttr;
PROCEDURE Error (errNr: SHORTINT);
BEGIN
IF Done THEN firstErr := errNr; Done := FALSE END;
XE.Error("", errPrefix, errNr, TRUE);
ClearRegAttr
END Error;
PROCEDURE LogInt (val: INTEGER);
BEGIN
Log.Int(val)
END LogInt;
PROCEDURE LogHex (val: INTEGER);
BEGIN
Log.Char('0'); Log.IntForm(val MOD 100000000L, Log.hexadecimal, 1, ' ', Log.hideBase); Log.Char('H')
END LogHex;
PROCEDURE SelectRegEntry;
BEGIN
curReg := 0;
WHILE (curReg < LEN(regTypeTab)) & (regTypeTab[curReg].type # curRegType) DO
INC(curReg)
END;
IF curReg >= LEN(regTypeTab) THEN Error(6) END
END SelectRegEntry;
PROCEDURE SelectNextReg * ;
VAR ch: CHAR;
BEGIN
regScn.Ident(curRegName); regTextPos := regScn.start;
regScn.Ident(curRegType);
regScn.Int(curRegCode); regScn.Char(ch);
IF ~regScn.done THEN
IF regScn.eot THEN
Done := FALSE; ClearRegAttr
ELSE
Error(8)
END
ELSIF ch # ';' THEN
Error(8)
ELSE
SelectRegEntry
END
END SelectNextReg;
PROCEDURE SelectFirstReg * ;
BEGIN
IF ~Done THEN
XU.GetScanner(regDictPath, regScn); Done := TRUE;
END;
regScn.SetPos(0); SelectNextReg
END SelectFirstReg;
PROCEDURE SelectReg * (IN name: ARRAY OF CHAR; OUT found: BOOLEAN);
BEGIN
SelectFirstReg;
WHILE Done & (name # curRegName) DO SelectNextReg END;
found := Done
END SelectReg;
PROCEDURE LogRegs * ;
BEGIN
SelectFirstReg;
WHILE Done DO
SelectNextReg;
Log.String(curRegName); Log.Tab; Log.String(curRegType); Log.Tab;
Log.Int(curRegCode); Log.Tab; Log.Int(regTextPos); Log.Ln
END
END LogRegs;
PROCEDURE ReadReg * (IN regName: ARRAY OF CHAR; OUT regVal: LONGINT; OUT size: INTEGER; OUT done: BOOLEAN);
BEGIN
Done := TRUE; done := TRUE;
IF curRegName # regName THEN SelectReg(regName, done) END;
IF done THEN
size := regTypeTab[curReg].size;
CASE curReg OF
| 0:
regVal := BDI.readGPR(curRegCode);
| 1:
regVal := BDI.readGPR(curRegCode);
| 2:
regVal := BDI.readSPR(curRegCode);
| 3:
regVal := BDI.readMSR();
| 4:
regVal := BDI.readFPR(curRegCode, fprMoveAddr);
| 5:
regVal := BDI.readCR();
| 6:
regVal := BDI.readFPSCR();
| 7:
regVal := BDI.readMem(curRegCode, 4);
END;
done := BDI.Done
END
END ReadReg;
PROCEDURE WriteReg * (IN regName: ARRAY OF CHAR; regVal: INTEGER; OUT done: BOOLEAN);
BEGIN
Done := TRUE; done := TRUE;
IF curRegName # regName THEN SelectReg(regName, done) END;
IF done THEN
CASE curReg OF
| 0:
BDI.writeGPR(curRegCode, regVal);
| 1:
BDI.writeGPR(curRegCode, regVal);
| 2:
BDI.writeSPR(curRegCode, regVal);
| 3:
BDI.writeMSR(regVal);
| 4:
BDI.writeFPR(curRegCode, fprMoveAddr, regVal);
| 5:
BDI.writeCR(regVal);
| 6:
BDI.writeFPSCR(regVal);
| 7:
BDI.writeMem(curRegCode, regVal, 4);
END;
done := BDI.Done
END
END WriteReg;
PROCEDURE Clear * ;
VAR n: INTEGER;
BEGIN
Done := TRUE; firstErr := 0;
FOR n := 0 TO LEN(regTypeTab) - 1 DO
regTypeTab[0].type := "???"; regTypeTab[0].size := 4;
END
END Clear;
PROCEDURE Init;
BEGIN
Clear;
(*__ setup stub reg type *)
regTypeTab[0].type := "???"; regTypeTab[0].size := 4;
ClearRegAttr;
(*__ setup register types *)
regTypeTab[1].type := "GPR"; regTypeTab[1].size := 4;
regTypeTab[2].type := "SPR"; regTypeTab[2].size := 4;
regTypeTab[3].type := "MSR"; regTypeTab[3].size := 4;
regTypeTab[4].type := "FPR"; regTypeTab[4].size := 8;
regTypeTab[5].type := "CR"; regTypeTab[5].size := 4;
regTypeTab[6].type := "FPSCR"; regTypeTab[6].size := 4;
regTypeTab[7].type := "CtrlReg"; regTypeTab[7].size := 4;
XU.GetScanner(regDictPath, regScn);
IF ~regScn.done THEN Error(3) END
END Init;
BEGIN
Init
END XoppcTrgtRegDict.