;;; -*- Mode:LISP; Package:LAMBDA; Base:8; Readtable:ZL -*-
;;; Memory diagnostic system, includes microcode and debugging function

;; for each test, we step through all memory locations doing a write followed by
;; an immediate read.  We then make a second pass of reads over the memory, verifying
;; that the pattern has been written as expected (the second phase catches 
;; refresh problems in memories and also address problems.  Address problems are noticed
;; when data is overwritten by a later part of the test, when the two writes should
;; have been to different addresses

(SETQ FPCM16 '(

 (DEF-DATA-FIELD OAL-MROT 5 0)				;MROT field of microinstruction

 (LOCALITY M-MEM)

M-GARBAGE	(0)
M-HUNOZ		(0)
M-ZERO		(0)
M-MINUS-ONE 
M-ONES		(0)

M-A		(0)
M-B		(0)
M-C		(0)
M-D		(0)
M-S		(0)
M-PAGE          (0)
M-PAIGE         (0)           ;variables used to update l2map
M-1	(0)
M-2	(0)
M-TOM   (0)
M-LOOP-COUNT	(0)
M-CURRENT-MEMORY-DATA	(0)
M-TEST	                (0)     ;Dispatch offset of current test
M-STARTING-POINT	(0)
M-CURRENT-MEMORY-LOC    (0)	;The memory location being hacked currently
M-WAB                   (0)     ;register for returned mode register data

 (LOCALITY A-MEM)

A-GARBAGE	(0)
A-HUNOZ		(0)
A-ZERO		(0)
A-ONES		(0)
A-A		(0)
A-B		(0)
A-C		(0)
A-D		(0)
A-S		(0)
A-PAGE          (0)
A-PAIGE         (0)    ;variables used to update l2map
A-1	(0)
A-2	(0)
A-TOM   (0)            ;top of map used to test for reload of map
A-LOOP-COUNT	(0)
A-CURRENT-MEMORY-DATA   (0)     ;The data that should be at VMA
A-TEST	                (0)     ;Dispatch offset of current test
A-STARTING-POINT	(0)	;Starting point of next pass over memory for certain tests
A-CURRENT-MEMORY-LOC    (0)	;The memory location being hacked currently
A-WAB                   (0)     ;returned from status-reg

 (LOC 40)

A-TEM1			(0)
A-TEM2			(0)
A-TEM3			(0)

A-MAIN-MEMORY-START	(0)     ;First memory loc of interest, mapped to vir adr 0
A-MAIN-MEMORY-SIZE      (0)     ;Size of memory under test
A-REPEAT-COUNT		(0)	;Number of times to do the main data loop (decremented til 0)

;Below registers used by test loop TL
A-WA1 (0)	;address for first cycle (write)
A-RA1 (0)	;address for 2nd cycle (read)
A-WA2 (0)	;  " 3rd cycle (write)
A-RA2 (0)       ;  " 4th cycle (read)
A-WD1 (0)       ;data for first write
A-WD2 (37777777777)  ;data for second write 

 (LOCALITY D-MEM)


 (START-DISPATCH 3 (PLUS INHIBIT-XCT-NEXT-BIT P-BIT))

MEMORY-DATA-TESTS-INIT-DATA
	(DATA-ZEROES-INIT)                              ;ZEROES
	(DATA-ONES-INIT)                                ;ONES
	(DATA-FLOATING-ZEROES-INIT)                     ;FLOATING ZEROES
	(DATA-FLOATING-ONES-INIT)                       ;FLOATING ONES
	(DATA-OFFSET-FLOATING-ZEROES-INIT)      	;FLOATING ZEROES, OFFSET PER ADR
	(DATA-OFFSET-FLOATING-ONES-INIT)		;FLOATING ONES, OFFSET PER ADR
	(DATA-FLOATING-ADDRESS-INIT)                    ;DATA IS FLOATING ADDRESS
	(DATA-FLOATING-ADDRESS-COM-INIT)		;DATA IS FLOATING COM OF ADDRESS

 (END-DISPATCH)


 (START-DISPATCH 3 (PLUS INHIBIT-XCT-NEXT-BIT P-BIT))

MEMORY-DATA-TESTS-INIT-ADDRESS
	(R-BIT)                                         ;ZEROES, DROP THROUGH
	(R-BIT)                                         ;ONES
	(DATA-OFFSET-FLOATING-ZEROES-ADR-INIT)          ;FLOATING ZEROES
	(SLEEP)                                         ;FLOATING KNAIZUK/REFRESH
	(DATA-OFFSET-FLOATING-ZEROES-ADR-INIT)          ;FLOATING ZEROES OFFSET
	(DATA-OFFSET-FLOATING-ONES-ADR-INIT)            ;FLOATING ONES OFFSET
	(R-BIT)                                         ;DATA IS ADDRESS
	(R-BIT)                                         ;DATA IS COMPLEMENT OF ADDRESS


 (END-DISPATCH)


 (START-DISPATCH 3 (PLUS INHIBIT-XCT-NEXT-BIT P-BIT))

MEMORY-DATA-TESTS-STEP-DATA
	(MEMORY-TEST-OK)                                ;ZEROES
	(MEMORY-TEST-OK)                                ;ONES
	(DATA-OFFSET-FLOATING-ZEROES-STEP)              ;ODD ADDRESS& ODDER DATA
	(MEMORY-TEST-OK)                                ;FLOATING ONES

	(MEMORY-TEST-OK)                                ;FLOATING ZEROES OFFSET
	(MEMORY-TEST-OK)                        	;FLOATING ONES OFFSET
	(DATA-FLOATING-ADDRESS-STEP)			;DATA IS ADDRESS
	(DATA-FLOATING-ADDRESS-COM-STEP)		;DATA IS COMPLEMENT OF ADDRESS

 (END-DISPATCH)


 (START-DISPATCH 3 (PLUS INHIBIT-XCT-NEXT-BIT P-BIT))

MEMORY-DATA-TESTS-STEP-ADDRESS
	(R-BIT)                                         ;ZEROES, DROP THROUGH
	(R-BIT)                                         ;ONES
	(DATA-WALKING-ZEROES-ODD-ADDR)                  ;GEE I DON'T KNOW
	(DATA-ALT-ADR-STEP)                             ;ALTERNATE ONES
	(DATA-OFFSET-FLOATING-ZEROES-ADR-STEP)          ;FLOATING ZEROES OFFSET
	(DATA-OFFSET-FLOATING-ONES-ADR-STEP)            ;FLOATING ONES OFFSET
	(DATA-FLOATING-ADDRESS-ADR-STEP)		;DATA IS ADDRESS
	(DATA-FLOATING-ADDRESS-COM-ADR-STEP)		;DATA IS COMPLEMENT OF ADDRESS

 (END-DISPATCH)


 (LOCALITY I-MEM)

 (LOC 0)

;;; Main diagnostic loop, data tests

INITIALIZE
	((M-ONES) SETO)				; - executed only once
	((M-ZERO) SETZ)
        (CALL MESS-L1-MAP)
        (CALL FLUSH-MAP-LOOP)
        ((MD) (A-CONSTANT 3776400))             ;code to shut off parity led
        ((L2-MAP-CONTROL) (A-CONSTANT 3400))    ;pkt size to byte op
        ((M-PAIGE) L2-MAP-PHYSICAL-PAGE)
        ((M-PAGE) DPB(BYTE-FIELD 2 12.) M-ONES A-PAIGE)
        ((M-PAGE) DPB(BYTE-FIELD 1 22.) M-ONES A-PAGE)  ;for byte op
        ((L2-MAP-PHYSICAL-PAGE) M-PAGE)
        ((VMA) (A-CONSTANT #x3FFDFF))
        ((MD-START-WRITE) M-ZERO)
        (JUMP-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)
        ((MD) (A-CONSTANT 3776400))
        ((L2-MAP-PHYSICAL-PAGE) M-PAIGE)
        ((L2-MAP-CONTROL) (A-CONSTANT 1400))    ;reset pkt size for word op
MEMORY-DATA-TEST				;perform init for the test
	((M-ONES) SETO)				; - executed only once
	((M-ZERO) SETZ)
	(DISPATCH MEMORY-DATA-TESTS-INIT-DATA (BYTE-FIELD 3 0) M-TEST)
						;set the value of a-repeat-count
	(NO-OP)


;; this is the the begining of the main loop, which is done until a-repeat-count
;; has been decremented to zero. 
MEMORY-DATA-TEST-1
	((M-CURRENT-MEMORY-LOC) A-MAIN-MEMORY-START)
						;start from the beginning memory loc
						;init the address for tests 4 and 5
						;drop through the dispatch for all others
	(DISPATCH MEMORY-DATA-TESTS-INIT-ADDRESS (BYTE-FIELD 3 0) M-TEST)
	(NO-OP)
	((M-LOOP-COUNT) SETZ)

MEMORY-DATA-LOOP-1
        (DISPATCH MEMORY-DATA-TESTS-STEP-ADDRESS (BYTE-FIELD 3 0) M-TEST)
        (NO-OP)
						;step the address for tests 4-7
						;drop through for tests 0-3
        (CALL-LESS-OR-EQUAL M-TOM A-CURRENT-MEMORY-LOC WR-MAP-LOOP)
        (JUMP-GREATER-THAN M-CURRENT-MEMORY-LOC A-MAIN-MEMORY-SIZE MEMORY-CHECK-LOOP-GJ)
	((VMA) M-CURRENT-MEMORY-LOC)
	((MD-START-WRITE) M-CURRENT-MEMORY-DATA)        ;WRITE APPROPRIATE DATA
	(JUMP-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)

MEMORY-DATA-IMMEDIATE-READBACK                 ;used to be readbak here
       ((M-LOOP-COUNT) M+A+1 M-LOOP-COUNT A-ZERO)
						;increment loop counter                              						
	(JUMP-LESS-THAN-XCT-NEXT M-LOOP-COUNT A-MAIN-MEMORY-SIZE MEMORY-DATA-LOOP-1)
						;jump to check data after resetting maps

	((M-CURRENT-MEMORY-LOC) M+A+1 M-CURRENT-MEMORY-LOC A-ZERO)
						;increment memory location counter	                              
        ;; NOW WE HAVE WRITTEN A DATA PATTERN, READ IT BACK AND INSURE IT IS CORRECT
	;; - identical to memory-data-loop except that we only read
MEMORY-CHECK-LOOP-GJ   ;routine to reset l2 map to bottom of 16M board
        (CALL FLUSH-MAP-LOOP)
        (DISPATCH MEMORY-DATA-TESTS-INIT-ADDRESS (BYTE-FIELD 3 0) M-TEST)
        (NO-OP) 
MEMORY-CHECK-LOOP
	((M-CURRENT-MEMORY-LOC) A-MAIN-MEMORY-START)
	(DISPATCH MEMORY-DATA-TESTS-INIT-ADDRESS (BYTE-FIELD 3 0) M-TEST)
        (NO-OP)
	((M-LOOP-COUNT) SETZ)

MEMORY-CHECK-LOOP-1
        (DISPATCH MEMORY-DATA-TESTS-STEP-ADDRESS (BYTE-FIELD 3 0) M-TEST)
        (NO-OP)
        (CALL-LESS-OR-EQUAL M-TOM A-CURRENT-MEMORY-LOC WR-MAP-LOOP)
        (JUMP-GREATER-THAN M-CURRENT-MEMORY-LOC A-MAIN-MEMORY-SIZE PROCEED)        
	((VMA-START-READ) M-CURRENT-MEMORY-LOC)
	(JUMP-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)

MEMORY-CHECK
	(CALL-NOT-EQUAL-XCT-NEXT MD A-CURRENT-MEMORY-DATA ERROR-WRONG-DATA)
       ((M-LOOP-COUNT) M+A+1 M-LOOP-COUNT A-ZERO)
	(JUMP-LESS-THAN-XCT-NEXT M-LOOP-COUNT A-MAIN-MEMORY-SIZE MEMORY-CHECK-LOOP-1)
       ((M-CURRENT-MEMORY-LOC) M+A+1 M-CURRENT-MEMORY-LOC A-ZERO)

PROCEED
        (CALL PARITY-CHECK)
        (CALL FLUSH-MAP-LOOP)  
        (DISPATCH MEMORY-DATA-TESTS-STEP-DATA (BYTE-FIELD 3 0) M-TEST)
        (NO-OP)
        (JUMP-LESS-THAN-XCT-NEXT M-ZERO A-REPEAT-COUNT MEMORY-DATA-TEST-1)
        ((A-REPEAT-COUNT) ADD M-MINUS-ONE A-REPEAT-COUNT)
                                                              


MEMORY-TEST-OK
       	(JUMP HALT-CONS MEMORY-TEST-OK)         
	(NO-OP)

ERROR-BAD-PAGE-FAULT
	(JUMP HALT-CONS ERROR-BAD-PAGE-FAULT)
	(NO-OP)
ERROR-PARITY-ERROR
        (JUMP HALT-CONS ERROR-PARITY-ERROR)
        (NO-OP)

ERROR-WRONG-DATA
	(NO-OP HALT-CONS)                               ;DATA ERROR, CONTINUABLE
	(POPJ)
	(NO-OP)		;SO PC SAYS ERROR-WRONG-DATA INSTEAD OF DATA-ZEROS WHEN IT STOPS

;;; Data tests

;;	the zeroes test writes 0 in all memory locations and then checks
DATA-ZEROES 

DATA-ZEROES-INIT
	(POPJ-AFTER-NEXT (A-REPEAT-COUNT) M+A+1 M-ZERO A-ZERO)
	((M-CURRENT-MEMORY-DATA) SETZ)

DATA-ONES
;;	the ones test writes -1 in all locations and then checks

DATA-ONES-INIT
	(POPJ-AFTER-NEXT (A-REPEAT-COUNT) M+A+1 M-ZERO A-ZERO)
	((M-CURRENT-MEMORY-DATA) SETO)


DATA-FLOATING-ZEROES
;;	the floating zeroes test inits current-memory-data to 17777777777
;;	and then rotates current-memory-data on each step.  we get a pattern in which
;;	the bits walk as the addresses increment

DATA-FLOATING-ZEROES-INIT
        ((M-STARTING-POINT) (BYTE-FIELD 37 0) M-ONES A-ZERO)
	(POPJ-AFTER-NEXT (A-REPEAT-COUNT) (A-CONSTANT 16.))
	((M-CURRENT-MEMORY-DATA) (BYTE-FIELD 37 0) M-ONES A-ZERO)

DATA-FLOATING-ZEROES-STEP
	((M-CURRENT-MEMORY-DATA) (BYTE-FIELD 40 1) M-CURRENT-MEMORY-DATA)
	(POPJ)


DATA-FLOATING-ONES
;;	the floating ones test is like the floating zeroes except that we init
;;	current-memory-data to 20000000000


SLEEP
        ((M-WAB) (A-CONSTANT 1_25))

SLEEP-1
        ((M-WAB) M-A-1 M-WAB A-ZERO)
        (JUMP-NOT-EQUAL M-WAB A-ZERO SLEEP-1) 

DATA-FLOATING-ONES-INIT
	(POPJ-AFTER-NEXT (A-REPEAT-COUNT) (A-CONSTANT 1.))
	((M-CURRENT-MEMORY-DATA) (A-CONSTANT 12525252525))

DATA-WALKING-ZEROES-ODD-ADDR
        ((M-CURRENT-MEMORY-LOC) ADD M-CURRENT-MEMORY-LOC (A-CONSTANT 2))
	((M-LOOP-COUNT) ADD M-LOOP-COUNT (A-CONSTANT 2))

DATA-FLOATING-ONES-STEP
	((M-CURRENT-MEMORY-DATA) (BYTE-FIELD 40 1) M-CURRENT-MEMORY-DATA)
	(POPJ)
DATA-ALT-ADR-STEP
        ((M-CURRENT-MEMORY-DATA) SUB M-CURRENT-MEMORY-DATA (A-CONSTANT #x55555555))
        (POPJ-NOT-EQUAL M-CURRENT-MEMORY-DATA A-ZERO)
        ((M-CURRENT-MEMORY-DATA) A-ONES)
        (POPJ)

DATA-OFFSET-FLOATING-ZEROES
;;	the diference between the floating tests and the offset floating tests
;;	is that m-starting-point is initialized by the same al

DATA-OFFSET-FLOATING-ZEROES-INIT
	(POPJ-AFTER-NEXT M-STARTING-POINT (BYTE-FIELD 37 0) M-ONES A-ZERO)
	((A-REPEAT-COUNT) (A-CONSTANT 1.))

DATA-OFFSET-FLOATING-ZEROES-ADR-INIT
	((M-CURRENT-MEMORY-DATA) M-STARTING-POINT)
	(POPJ)

DATA-OFFSET-FLOATING-ZEROES-ADR-STEP
	((M-CURRENT-MEMORY-DATA) (BYTE-FIELD 40 1) M-CURRENT-MEMORY-DATA)
	(POPJ)

DATA-OFFSET-FLOATING-ZEROES-STEP
	((M-STARTING-POINT) (BYTE-FIELD 40 1) M-STARTING-POINT)
	(POPJ)


DATA-OFFSET-FLOATING-ONES 

DATA-OFFSET-FLOATING-ONES-INIT
	(POPJ-AFTER-NEXT (M-STARTING-POINT) DPB (BYTE-FIELD 1 37) M-ONES A-ZERO)
	((A-REPEAT-COUNT) (A-CONSTANT 1.))

DATA-OFFSET-FLOATING-ONES-ADR-INIT
	((M-CURRENT-MEMORY-DATA) M-STARTING-POINT)
	(POPJ)

DATA-OFFSET-FLOATING-ONES-ADR-STEP
	((M-CURRENT-MEMORY-DATA) (BYTE-FIELD 40 1) M-CURRENT-MEMORY-DATA)
	(POPJ)

DATA-OFFSET-FLOATING-ONES-STEP
	((M-STARTING-POINT) (BYTE-FIELD 40 1) M-STARTING-POINT)
	(POPJ)


DATA-FLOATING-ADDRESS 

DATA-FLOATING-ADDRESS-INIT
	(POPJ-AFTER-NEXT (M-STARTING-POINT) SETZ)
	((A-REPEAT-COUNT) (A-CONSTANT 1.))

DATA-FLOATING-ADDRESS-ADR-STEP
	(POPJ-AFTER-NEXT (OA-REG-LOW) DPB M-STARTING-POINT OAL-MROT A-ZERO)
	((M-CURRENT-MEMORY-DATA) LDB (BYTE-FIELD 40 0)
				 M-CURRENT-MEMORY-LOC A-ZERO)

DATA-FLOATING-ADDRESS-STEP
	((M-STARTING-POINT) M+A+1 M-STARTING-POINT A-ZERO)
	(POPJ)

DATA-FLOATING-ADDRESS-COM 

DATA-FLOATING-ADDRESS-COM-INIT
        ((M-CURRENT-MEMORY-DATA) (A-CONSTANT #XFFFF))
	(POPJ-AFTER-NEXT (M-STARTING-POINT) SETZ)  
	((A-REPEAT-COUNT) (A-CONSTANT 16.))
						
						
DATA-FLOATING-ADDRESS-COM-ADR-STEP
      	((M-CURRENT-MEMORY-DATA) LDB(BYTE-FIELD 40 1)					
				 M-CURRENT-MEMORY-DATA A-ZERO)
        (POPJ)
DATA-FLOATING-ADDRESS-COM-STEP
        ((M-CURRENT-MEMORY-DATA) LDB(BYTE-FIELD 40 1)					
				 M-CURRENT-MEMORY-DATA A-ZERO)
	((M-STARTING-POINT) M+A+1 M-STARTING-POINT A-ZERO)	;increment starting-point
	(POPJ)

;separate little test loop

TL	((MD) A-WD1)
	((VMA-START-WRITE) A-WA1)
        (CALL-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)
	((VMA-START-READ) A-RA1)
        (CALL-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)
	((MD) A-WD2)
	((VMA-START-WRITE) A-WA2)
        (CALL-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)
	((VMA-START-READ) A-RA2)
        (CALL-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)
	(JUMP TL)
	(NO-OP)


;;;follows are the map-maintenance routines. WR-MAP-LOOP updates the 4k entries in
;;;the l2 map phy page to point to the next contiguous 4meg byte or 1meg word memory
;;;location.  FLUSH-MAP-LOOP adjusts the map to point at the first 4meg byte of phy
;;;memory on the board


WR-MAP-LOOP
    ((MD) A-ZERO)
 
WR-MAP-LOOP-1
    ((M-PAGE) L2-MAP-PHYSICAL-PAGE)             ;GET OUT MAP DATA
    ((M-PAIGE) LDB (BYTE-FIELD 14 14) M-PAGE A-ZERO)
    ((M-PAIGE) M+A+1 M-PAIGE A-ZERO)            ;INCREMENT REALLY ONLY TWO BITS
    ((M-PAGE) DPB (BYTE-FIELD 2 14) M-PAIGE A-PAGE)
    ((L2-MAP-PHYSICAL-PAGE)  M-PAGE)    	;PUT DATA BACK THERE
    ((M-PAGE) MD)    ;GET READY TO TEST FOR OVERFLOW 
    ((M-PAGE) ADD (A-CONSTANT 400) M-PAGE)      ;BUMP MD,ITS A MAP ADDRESS
    ((MD) M-PAGE)                               ;PUT NEXT ADDRESS AWAY
    (JUMP-LESS (A-CONSTANT 4000000) M-PAGE WR-MAP-LOOP-1)  ;IS THE MAP FULL?
UPDATE-ATOM
    ((M-PAIGE) DPB(BYTE-FIELD 2. 20.) M-PAIGE A-ZERO)
    ((M-TOM) ADD M-PAIGE (A-CONSTANT 4000000))
    (POPJ)

FLUSH-MAP-LOOP
    ((MD) A-ZERO)

FLUSH-MAP-LOOP-1
    ((M-PAGE) L2-MAP-PHYSICAL-PAGE)    ;GET OUT MAP DATA
    ((M-PAGE) DPB (BYTE-FIELD 2 14) M-ZERO A-PAGE)
    ((M-PAIGE) LDB (BYTE-FIELD 2 14) M-PAGE A-ZERO)
    ((L2-MAP-PHYSICAL-PAGE)  M-PAGE)	;PUT DATA BACK THERE
    ((M-PAGE) MD)    ;GET READY TO TEST FOR OVERFLOW 
    ((M-PAGE) ADD (A-CONSTANT 400) M-PAGE)      ;BUMP MD,ITS A MAP ADDRESS
    ((MD) M-PAGE)                        ;PUT NEXT ADDRESS AWAY
    (JUMP-LESS (A-CONSTANT 4000000) M-PAGE FLUSH-MAP-LOOP-1)  ;IS THE MAP FULL?
    (JUMP UPDATE-ATOM)
       


MESS-L1-MAP
    ((MD) A-ZERO)    
    ((M-PAIGE) A-ZERO)

MESS-A
    ((L1-MAP) M-PAIGE)
    ((M-PAIGE) M+A+1 M-PAIGE A-ZERO)    
    (CALL-GREATER M-PAIGE (A-CONSTANT 177) KLUGE)
    ((M-PAGE) MD)                        ;GET READY TO TEST FOR OVERFLOW 
    ((M-PAGE) ADD M-PAGE (A-CONSTANT 1_13.))      
    ((MD) M-PAGE)                        
    (JUMP-LESS M-PAGE (A-CONSTANT 1_25.) MESS-A)
    (POPJ)

KLUGE
    ((M-PAIGE) A-ZERO)
    (POPJ)



PARITY-CHECK
        ((A-WA2) VMA)
        ((A-WA1) MD)
        ((MD) (A-CONSTANT 3776400))                        ;setup for mem-mode-read parity
        ((L2-MAP-CONTROL) (A-CONSTANT 3400))
        ((M-PAIGE) L2-MAP-PHYSICAL-PAGE)
        ((M-PAGE) DPB(BYTE-FIELD 2 14) M-ONES A-PAIGE)
        ((M-PAGE) DPB(BYTE-FIELD 1 22.) M-ONES A-PAGE)     ;for byte ops
        ((L2-MAP-PHYSICAL-PAGE) M-PAGE)
        ((M-WAB) (A-CONSTANT #x3FFDFF))
        ((VMA-START-READ) M-WAB)
        (JUMP-IF-PAGE-FAULT ERROR-BAD-PAGE-FAULT)
        ((M-WAB) MD)
        ((MD) (A-CONSTANT 3776400))
        ((L2-MAP-CONTROL) (A-CONSTANT 1400))
        ((L2-MAP-PHYSICAL-PAGE) M-PAIGE)       
        (JUMP-IF-BIT-SET (BYTE-FIELD 1 2) M-WAB ERROR-PARITY-ERROR)
        ((MD) A-WA1)
        ((VMA) A-WA2)
        (POPJ)
))	;END OF MICROCODE