@X @~
~V7 56 2 -5
~D10
~H                    MUSS
~
~
~D10
~H            SYM021
~D10
~MMANCHESTER UNIVERSITY  -  CONFIDENTIAL~
~
~
                                                             ISSUE 11~
~V9 -1
~P
~V9 1
~YSYM021
~S1~M~OSYM IMPLEMENTATION DESCRIPTION
~S1~M~OSection 2 Version 1
~S1~OSection 2.1 ROM Tools
~S1~O1. General Description
~BThis module contains the library procedure which takes
as input a binary file representing the required ROM content
and formats it for the INTEC ? EPROM programmer.
~S1~O2. Interfaces
~S1~O2.2 Software Interface
~
~
PREPARE.TAPE (II,[C],I,I,I)~
~BThis procedure takes the binary in the file specified by
P1 (in the current directory), and produces one or more INTEL format
tapes to the file(s) or device controler specified by P2 (e.g. PTP*).
Each tape will contain the data to program one complete EPROM. P3
specifies the number of EPROMs that will be connected in parallel,
and the routine will alternate bytes to the various tapes as is required.
The default, suitable for the 68000, is two. P4 specifies the size (in
bytes) of the EPROMs used (default 4096 for intel 2732s). P5 is used
to start the routine at a tape outher than the first, the tape number is
specified (note that the first tape is number ~Wzero). The routine
punches sufficient tapes to output the complete compiled program from the
position specified. With the default settings, the first tape will contain
bytes 0, 2, 4, ... 8188, 8190, the second will contain bytes 1, 3, 5, ...
8189, 8190. If the complete program has not been output, further tapes are
prepared, the next will contain addresses 8192, 8194 etc. and the next
addresses 8193, 8195 etc. If four EPROMs are to be connected in parallel,
the first tape will contain bytes 0, 4, 8 etc., the next bytes 1, 5, 9 etc.,
the next bytes 2, 6, 10 and so on. Each tape is produced for an EPROM that
is assumed to be ~Wone ~Wbyte wide. However, the STAG programmer can
accept such a tape to program two 4 bit wide EPROMS.
~S1~O4. Compile Jobs
~X%`
~S1~O4.1 Compile Job for MKROM ~
~
::BEGIN MKROM ~
DO 0 MKROMLOG %200~
OUT.FN SYM021~
FLIP MU6S:SYM021 1~
SYM02~
DI 4~
OPENDIR MUSMS
MUSL 0 MKROM  5~
*INFORM %2400;~
**TLSEG 0 0 %600000 -1           *FOR MC5*~
**TLSEG 0 %000000 %180000 -1        *FOR MC3*~
**TLSEG 2 %010000 %500000 -3        *FOR MC5*~
**TLSEG 2 %010000 %140000 -3        *FOR MC3*~
**TLSEG 3 %010000 %500000 -3        *FOR MC5*~
**TLSEG 3 %010000 %140000 -3        *FOR MC3*~
**TLSEG 4 %010000 %000000 -3
**TLLOAD 2 2~
**TLLOAD 3 3~
**TLLOAD 4 4~
**SELECT.INPUT 4~
END.INPUT 4~
STOP~
::END MKROM~
~Y
~V9 -1
~P
~V9 -1
~D15
~HFLOWCHARTS
~
~
~H               SYM021
~V9 -1
~X%%
~F
@TITLE SYM02(1,11)
@COL 1S-2R-3R-4F
@FLOW 1-2-3-4
@BOX 1.0
MOTOROLA 68000 UTILITIES
@BOX 2.0
INPUT FILE TO SEGMENT 52.
@BOX 3.0
PROCEDURES IN MODULE
1) EXTERNALLY ACCESSIBLE.
      PREPARE.TAPE -        PRODUCE A BATCH OF TAPES TO PROGRAM EPROM.
                            (INTELLEC FORMAT)
2) INTERNAL.
      SIZE.INPUT.PROG       CALCULATE SIZE OF PROGRAM IN SEGMENT 52.
      PUT.HEX
@BOX 4.0
END
@BOX 1.1
MODULE SYM02 (PREPARE.TAPE);
@BOX 2.1
*GLOBAL 2;
LOGICAL32 [%4000] INPUT.PROG;
*GLOBAL 3;
LOGICAL8 [%4000] SOURCE.PROG;
*GLOBAL 4;
ADDR PW0, PW1, PW2, PW3, PW4, PW5, PW6;
@BOX 3.1
LSPEC PREPARE.TAPE (ADDR[$LO8], ADDR [LOGICAL8], INTEGER, INTEGER, INTEGER);
PSPEC SIZE.INPUT.PROG (INTEGER) /ADDR;
PSPEC PUT.HEX (LOGICAL32, INTEGER);
#SYM02.2
#SYM02.11
#SYM02.12

@BOX 4.1
*END
@END
@TITLE SYM02.2(1,11)
@COL 1S-2R-3R-4R-5R-6R-7F
@FLOW 1-2-3-4-5-6-7
@BOX 1.0
PREPARE BATCH OF TAPES FOR PROM PROGRAMMER.
@BOX 2.0
GIVE DEFAULT VALUES TO UNSPECIFIED PARAMETERS.
@BOX 3.0
GET INPUT PROGRAM.
@BOX 4.0
ADJUST START POINT TO ALLOW RESTART
GIVE BY TAPE NUMBER.
@BOX 5.0

OUTPUT TAPES
@BOX 6.0
FINISH LAST OUTPUT.
@BOX 7.0
END
@BOX 1.1
PROC PREPARE.TAPE (IN.FILE, OUT.DOC, NUM.IN.PAR, PROM.SIZE, TAPE.NO);
INTEGER PROG.SIZE, SIZE.DONE,J, I, LOOP.START.ADDR, CHECK.SUM, ISTR,
   NUM.LINES, P.ADDR, C.ADDR, BLOCK.START.TAPE.NO, BLOCK.NO, BYTE.OFFSET;
LITERAL   / ADDR[$LO8] NIL =;
@BOX 2.1
IF PROM.SIZE =< 0 THEN
   4096 => PROM.SIZE;
FI
IF NUM.IN.PAR =< 0 THEN
   2 => NUM.IN.PAR;
FI
@BOX 3.1
CAPTION (%"STARTING ......"); NEW.LINES (1);
OPEN.FILE (IN.FILE, 0, 20, %1E);
PW2 ->> 2 => PROG.SIZE ;
MAP (20, -1, 0);
SIZE.INPUT.PROG (PROG.SIZE) <<- 2 => PROG.SIZE;
CHANGE.SIZE (20, PROM.SIZE * NUM.IN.PAR + PROG.SIZE);
OUT.I (PROG.SIZE,10); CAPTION (%" bytes"); NEW.LINES (1);
@BOX 4.1
TAPE.NO * PROM.SIZE => SIZE.DONE;
TAPE.NO / NUM.IN.PAR => BLOCK.NO;
BLOCK.NO * NUM.IN.PAR => BLOCK.START.TAPE.NO;
TAPE.NO - BLOCK.START.TAPE.NO => BYTE.OFFSET;
BLOCK.START.TAPE.NO * PROM.SIZE + BYTE.OFFSET => LOOP.START.ADDR;
CAPTION (%"      Starting at address ");
OUT.HEX (LOOP.START.ADDR, 8);
NEW.LINES (1);
@BOX 5.1
DEFINE.OUTPUT (3, NIL, %200, 0);
SELECT.OUTPUT (3);
WHILE SIZE.DONE < PROG.SIZE DO
   WHILE BYTE.OFFSET < NUM.IN.PAR DO
      LOOP.START.ADDR => C.ADDR;
      PROM.SIZE / 32 => NUM.LINES;
      0 => P.ADDR;
      FOR NUM.LINES DO
         0 => CHECKSUM;
         OUT.CH (":");
         PUT.HEX (32, 8);
         32 -> CHECK.SUM;
         PUT.HEX (P.ADDR, 16);
         P.ADDR ->> 8 & %FF -> CHECK.SUM;
         P.ADDR & %FF -> CHECK.SUM;
         PUT.HEX (0, 8);
         FOR 32 DO
            PUT.HEX (SOURCE.PROG [C.ADDR], 8);
            SOURCE.PROG [C.ADDR] -> CHECK.SUM;
            NUM.IN.PAR +> C.ADDR;
      OD
         PUT.HEX (CHECKSUM, 8);
         NEW.LINES (1);
      32 +> P.ADDR;
      OD
      CAPTION (%":00000001FF");
      NEW.LINES (1);
FOR 200 DO
   OUTCH(0)
OD
      1 +> BYTE.OFFSET;
      1 +> LOOP.START.ADDR;
   OD
   0 => BYTE.OFFSET;
   NUM.IN.PAR -> LOOP.START.ADDR;
   NUM.IN.PAR * PROM.SIZE +> LOOP.START.ADDR;
   NUM.IN.PAR * PROM.SIZE +> SIZE.DONE;
OD
@BOX 6.1
RELEASE.SEGMENT (20);
SELECT.OUTPUT (0);
END.OUTPUT (3, 0);
DEFINE.INPUT (-1, NIL, 0)=>ISTR;
DEFINEOUTPUT (3,OUT.DOC,%200,0);
SELECTINPUT(ISTR);
SELECTOUTPUT(3);
FOR RSIZE() DO
INCH() => I => J;
WHILE I/=0 DO
   IF I&1 = 1 THEN
      %80 +> J
   FI
I ->> 1 => I
OD
OUTCH(J&%FF)
OD
SELECT.INPUT (0);
SELECT.OUTPUT (0);
END.OUTPUT (3,0);
END.INPUT (ISTR,0);

@BOX 7.1
END
@END
@TITLE SYM02.11(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
GIVE SIZE OF PROGRAM IN SEG 36 IN WORDS.
@BOX 2.0
GET SEGMENT SIZE.
FROM END OF SEGMENT WORK BAK 'TIL NONZERO WORD FOUND
@BOX 3.0
END
@BOX 1.1
PROC SIZE.INPUT.PROG (SEG.SIZE);
@BOX 2.1
WHILE SOURCE.PROG [1 -> SEG.SIZE] = 0 AND SEG.SIZE > 0 DO OD
SEG.SIZE + 1 => SIZE.INPUT.PROG;
@BOX 3.1
END
@END
@TITLE SYM02.12(1,10)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
OUTPUT LEAST SIGNIFICANT P2 BITS OF P1
@BOX 2.0
LOOP FOR EACH 4 BITS UNTIL P2 BITS OUTPUT
@BOX 3.0
END
@BOX 1.1
PROC PUT.HEX (VALUE, SHIFT);
DATAVEC HEX.DIG (LOGICAL8)
   "0123456789ABCDEF"
END
INTEGER TEMP;
@BOX 2.1
WHILE 4 -> SHIFT >= 0 DO
   VALUE ->> SHIFT & %F => TEMP;
   OUT.CH (HEX.DIG [TEMP]);
OD
@BOX 3.1
END
@END

