Basics USING [ BITOR, HighHalf, LowHalf ],

Checksum USING [ComputeChecksumProc],

DeviceCleanup USING [Await, Item, Perform, Reason],

DLionInputOutput,

MicrocodeBooting USING [BootFileNumber, MicrocodeType, nullBootFileNumber],

MPCodes USING [processorIDChanged, powerOff],

PrincOps USING [aCHKSUM, aGETF, alpha, ControlLink, flagsVacant, InterimPageState, PageCount, PageNumber, PageState, PageValue, RealPageNumber, SD, StateVector, sUnimplemented, VersionResult, zMISC],

PrincOpsUtils USING [Copy, DisableInterrupts, GetReturnFrame, GetReturnLink, LongCopy, MyLocalFrame],

ProcessorFace USING [gmtEpoch, GreenwichMeanTime, ProcessorID, SetMP],

TrapSupport USING [BumpPC, OpTrapTable, opTrapTable];

data2(0): WORD,

data1(1): WORD,

data0(2): WORD,

command(3): ProcessorCommand];

busy(0:0..0): BOOL ← TRUE,

op(0:1..15): ProcessorOperation];

setTOD(1), readTOD(2), readPID(3), boot(4), (32767)};

valid(0): WORD, -- 0 => invalid, 177777B => valid

time(1): LONG CARDINAL,

lowCheck(3): CARDINAL];

By now start trap has occurred and main-body code has run.

Scan the VM looking for the lowest real page mapped. Use this as upper bound on special real memory area (The microcode likes to use some of the bank 0 real memory for the Germ).

firstUsed: PrincOps.RealPageNumber ←
DLionInputOutput.firstReservedPage + DLionInputOutput.reservedPageCount;

FOR i: PrincOps.PageNumber IN [0..DLionInputOutput.numberVirtualPages) DO

specialRealPages ← firstUsed - DLionInputOutput.firstReservedPage;

};

aSETMAP: PrincOps.alpha = 150B;

aGETMAPFLAGS: PrincOps.alpha = 151B;

aSETMAPFLAGS: PrincOps.alpha = 152B;

Gets the state and real page of a virtual page.

OldGetPageValue: PROC [virtual: CARDINAL] RETURNS [state: PrincOps.InterimPageState] = MACHINE CODE {PrincOps.zMISC, PrincOps.aGETF};

NewGetPageValue: PROC [vp: LONG CARDINAL] RETURNS [PrincOps.PageState, LONG CARDINAL] = MACHINE CODE {PrincOps.zMISC, aGETMAPFLAGS};

IF --ProcessorFace.--useLongMapOps

};

initial: ProcessorFace.ProcessorID ← processorID;

item: DeviceCleanup.Item;

DO

};

pCSB: LONG POINTER TO ProcessorCSB = IOPage + ProcessorCSBOffset;

WHILE pCSB.command.busy DO NULL ENDLOOP;

pCSB.command ← [op: readPID];

WHILE pCSB.command.busy DO NULL ENDLOOP;

RETURN[[pCSB.data0, pCSB.data1, pCSB.data2]];

};

I believe that 376B and 377B are actually available on DLions, but at present the Germ assumes they aren't. ADB 1/23/84

IF page < 376B THEN RETURN[page, 376B - page];

page ← MAX[page, 376B + 1];

IF page < 377B THEN RETURN[page, 377B - page];

page ← MAX[page, 377B + 1];

IF page < DLionInputOutput.numberVirtualPages

THEN RETURN[page, DLionInputOutput.numberVirtualPages - page];

RETURN[LAST[PrincOps.PageNumber], 0]

};

tod: LONG POINTER TO TimeOfDayClock = IOPage + TimeOfDayOffset;

IF tod.valid = 0 THEN RETURN[gmtEpoch];

DO

RETURN

};

pCSB: LONG POINTER TO ProcessorCSB = IOPage + ProcessorCSBOffset;

tod: LONG POINTER TO TimeOfDayClock = IOPage + TimeOfDayOffset;

WHILE pCSB.command.busy DO NULL ENDLOOP;

pCSB.data2 ← Basics.LowHalf[gmt];

pCSB.data1 ← Basics.HighHalf[gmt];

pCSB.command ← [op: setTOD];

tod.valid ← 0;

WHILE pCSB.command.busy DO NULL ENDLOOP;

WHILE tod.valid = 0 DO NULL ENDLOOP;

RETURN

};

DIW: LONG POINTER TO WORD = LOOPHOLE[LONG[177753B]];

DIW^ ← Basics.BITOR[DIW^, cvTimeoutMask];

};

pCSB: LONG POINTER TO ProcessorCSB = IOPage + ProcessorCSBOffset;

PrincOpsUtils.DisableInterrupts[];

WHILE pCSB.command.busy DO NULL ENDLOOP;

pCSB.command ← [op: boot];

DO ENDLOOP;

};

NOTE: This code depends on the greenwich mean time clock running

with interrupts disabled and devices turned off.

IF powerOffCount # 0 AND returnIfDisabled THEN RETURN;

PrincOpsUtils.DisableInterrupts[];

DeviceCleanup.Perform[turnOff];

DO

DO

};

Bumps the power off disable count. This is useful during a critical operation to avoid power off operations.

powerOffCount ← powerOffCount + 1;

};

Decrements the power off disable count (pins at 0).

IF powerOffCount > 0 THEN powerOffCount ← powerOffCount - 1;

};

gmtAutomaticPowerOn ← gmt; externalEventRequired ← externalEvent; };

gmtAutomaticPowerOn ← ProcessorFace.gmtEpoch - 1;

}; -- infinity

BootSpecificMicrocode: PUBLIC PROC [bfn: MicrocodeBooting.BootFileNumber] = {

GetBootFileNumber: PUBLIC PROC [type: MicrocodeBooting.MicrocodeType] RETURNS [bfn: MicrocodeBooting.BootFileNumber] = {

v: MACHINE DEPENDENT RECORD [a, b: UNSPECIFIED, state: PrincOps.StateVector];

v.state ← STATE;

ERROR UnimplementedInstruction;

};

[ALL[LOOPHOLE[Unimplemented]], ALL[LOOPHOLE[Unimplemented]]];

l: PrincOps.ControlLink;

code: LONG POINTER TO Code;

Code: TYPE = RECORD [SEQUENCE COMPUTED CARDINAL OF CodeByte];

CodeByte: TYPE = [0..255];

opcode: CodeByte;

state: PrincOps.StateVector;

state ← STATE;

state.source ← l ← PrincOpsUtils.GetReturnLink[];

code ← LOOPHOLE[l.frame.accesslink.code.longbase];

opcode ← code[l.frame.pc];

state.dest ← IF opcode = PrincOps.zMISC
THEN TrapSupport.opTrapTable.misc[code[l.frame.pc+1]]
ELSE TrapSupport.opTrapTable.main[opcode];

If handler is fixed-frame, manually plant the return link.

(Microcode does that for traps, but not for ordinary XFERs to frames.)

IF ~state.dest.proc THEN state.dest.frame.returnlink ← l;

RETURN WITH state; -- Flush my frame and transfer to real trap handler

};

pv: PrincOps.PageValue;

IF useLongMapOps THEN useLongMapOps ← FALSE ELSE ERROR;

TrapSupport.BumpPC[2];

pv ← GetPageValue[virtual];

ps ← pv.state;

pn ← pv.real;

};

state: PrincOps.StateVector;

p: POINTER;

state ← STATE;

TrapSupport.BumpPC[2];

IF count#0 THEN {

state.dest.frame ← PrincOpsUtils.GetReturnFrame[];

RETURN WITH state;

};

state: PrincOps.StateVector;

state ← STATE;

TrapSupport.BumpPC[2];

IF count#0 THEN {

resultP ← p;

state.dest.frame ← PrincOpsUtils.MyLocalFrame[];

TRANSFER WITH state;

};

TrapSupport.BumpPC[2];

RETURN [[

};

RETURN[Checksum.ComputeChecksumProc[cs, nWords, p]];

};