DIRECTORY
DeviceCleanup USING [Await, Item, Reason],
DLionInputOutput USING [IOPage],
Environment USING [Base],
HeadStartChain USING [Start],
Inline USING [BITAND, BITOR, DIVMOD, LongCOPY, LowHalf],
SA800Face;

SA800HeadDLion: PROGRAM
IMPORTS
DLionInputOutput, DeviceCleanup, RemainingHeads: HeadStartChain, Inline
EXPORTS HeadStartChain, SA800Face
SHARES SA800Face =
BEGIN OPEN SA800Face;

CSB: TYPE = MACHINE DEPENDENT RECORD [
transferMask(0):    WORD,          -- naked notify mask. 
next(1):            IOPBlockPtr,   -- IOCB executed when Output is done.
unused0(2):         UNSPECIFIED,
needReset(3):       BOOLEAN,       -- TRUE => reset required.
tail(4:0..31):      IOCBPtr];      -- Last IOCB in queue. Used only by Initiate.

csb: LONG POINTER TO CSB = LOOPHOLE[DLionInputOutput.IOPage + 111B];  -- 49'X

IOCBPtr:     TYPE = LONG POINTER TO IOCB;
IOPBlockPtr: TYPE = Environment.Base RELATIVE POINTER TO IOPBlock;

nilIOP:      IOPBlockPtr = LOOPHOLE[0];

IOCB: TYPE = MACHINE DEPENDENT RECORD [
operation(0):        Operation,           -- set by head client
iopBlk(8):           IOPBlock,            -- read/written by IOCB
started(24:0..0):    BOOLEAN,             -- => IOCB has been submitted to IOP
thisRun(24:1..15):   [0..77777B],         -- pages/tracks this trip
abortStatus(25):     Status,              -- saved status. An operation may be aborted
nextIOCB(26):        IOCBPtr];            -- points to next IOCB in chain

IOPBlock: TYPE = MACHINE DEPENDENT RECORD [
bufferAddr(0:0..31):   LONG POINTER,   -- address disk buffer (unused if format)
unused(2):             UNSPECIFIED _ 0,
sectorLength(3):       CARDINAL,       -- sector length(bytes)(unused if format)
sectorFormat(4):       FormatWord,     -- sector Format
diskAddress(5:0..31):  DiskAddress,    -- cylinder, head and sector
sectorCount(7):        CARDINAL,       -- sectors to transfer <= sectorPerTrack
result(8):             IOPResult,      -- status posted by IOP
samePage(9:0..0):      BOOLEAN,        -- TRUE => use same memory page for
command(9:1..15):      Command,        -- IOP command word
subCommand(10):        SubCommand,     -- IOP sub-command word (IOP=esc Only)
formatInfo(11:0..31):  FormattingInfo, -- used only in format
reserved(13:0..47):    ARRAY [0..3) OF UNSPECIFIED];

FormattingInfo: TYPE = MACHINE DEPENDENT RECORD [
sectorLengthDiv4(0:0..7):     CARDINAL [0..400B),   -- sector length
encodedSectorLength(0:8..15): EncodedSectorLength,  -- encoded sector length
sectorsPerTrack(1:0..7):      CARDINAL [0..400B),
gap3FillCharsCount(1:8..15):  CARDINAL [0..400B)];  -- interrecord gap count

Command: TYPE = MACHINE DEPENDENT {
nopC(0), readSectorC, writeSectorC, writeDeletedSectorC, readIDC, formatTrackC,
recalibrateC, initializeC, escapeC, (77777B)};

SubCommand: TYPE = MACHINE DEPENDENT {nopSC(0), diskChangeClearSC, (177777B)};

EncodedSectorLength: TYPE = MACHINE DEPENDENT {
b128(0), b256(1), b512(2), b1024(3), bUnknown};

FormatWord: TYPE = MACHINE DEPENDENT RECORD [
troyOrIBM(0:0..11): MACHINE DEPENDENT {IBM(0), Troy(1), (7777B)},
density(0:12..15):  MACHINE DEPENDENT {single(0), double(10B), (17B)}];

IOPResult: TYPE = MACHINE DEPENDENT RECORD [
doorOpened(0:0..0):       BOOLEAN,           -- TRUE => operator opened disk door
unused1(0:1..1):          BOOLEAN _ FALSE,
twoSided(0:2..2):         BOOLEAN,           -- true => two sided diskette installed
diskID(0:3..3):           MACHINE DEPENDENT {SA800(0), SA850(1)},
error(0:4..4):            BOOLEAN,           -- IOP detected an error in the IOCB
unused2(0:5..5):          BOOLEAN _ FALSE,
recalibrateError(0:6..6): BOOLEAN,           -- IOP had error during recalibrate op
dataLost(0:7..7):         BOOLEAN,           -- data transfer not completed
notReady(0:8..8):         BOOLEAN,           -- drive has door open
writeProtect(0:9..9):     BOOLEAN,           -- write-protected diskette now in drive
deletedData(0:10..10):    BOOLEAN,           -- read a deleted data sector
recordNotFound(0:11..11): BOOLEAN,           -- some sector in transfer not found
crcError(0:12..12):       BOOLEAN,           -- CRC error on read op
track00(0:13..13):        BOOLEAN,           -- read heads left on cylinder 0
unused3(0:14..14):        BOOLEAN _ FALSE,
busy(0:15..15):           BOOLEAN];          -- => chip busy, should always be FALSE

commandMatrix: ARRAY Function OF Command = [  -- face => IOP command
nopC, recalibrateC, escapeC, readSectorC, writeSectorC, writeDeletedSectorC,
readIDC, formatTrackC];

nullIOCB: IOCB = [
operation:   [
device:      LOOPHOLE[0], function: nop, incrementDataPointer: FALSE, count: 0,
address:     [cylinder: 0, head: 0, sector: 0], buffer: [address: NIL, length: 0]],
iopBlk:      nullIOPBlk, started: FALSE, thisRun: 0,
abortStatus: initialStatus, nextIOCB: NIL];

nullIOPBlk: IOPBlock =[
bufferAddr:   NIL,
unused:       0,
sectorLength: 0,
sectorFormat: [troyOrIBM: IBM, density: single],
diskAddress:  [cylinder: 0, head: 0, sector: 0],
sectorCount:  0,
result:       nullIOPResult,
samePage:     FALSE, command: nopC, subCommand: nopSC,
formatInfo:   [0, b128, 0, 0],
reserved:     [0, 0, 0]];

nullIOPResult: IOPResult = [
doorOpened: FALSE, twoSided: FALSE, diskID: SA800, error: FALSE,
recalibrateError: FALSE, dataLost: FALSE, notReady: FALSE,
writeProtect: FALSE, deletedData: FALSE, recordNotFound: FALSE,
crcError: FALSE, track00: FALSE, busy: FALSE];

nullDeviceHandle: PUBLIC DeviceHandle _ LOOPHOLE[0];
diskDeviceHandle:        DeviceHandle = LOOPHOLE[1];
internalDeviceHandle:    DeviceHandle = LOOPHOLE[2];  -- for internally generated IOCBs.

trackParameterLength:    CARDINAL =  0; -- space needed for FormatTrack parameters
idLength:                CARDINAL =  3; -- length of field ID in words
numOfCylinders:          CARDINAL = 77; -- number of cylinders on SA800 and SA850 disks

initialAllocationLength: PUBLIC CARDINAL _ SIZE[IOCB];
operationBlockLength:    PUBLIC CARDINAL _ SIZE[IOCB];


initializationIOCB: IOCBPtr;

state: RECORD [
user:                Context                     --user accessable state
_ [protect: FALSE, format: IBM, density: double, sectorLength: 256],
status:              Status    _ diskChange,     --most currently processed status
result:              IOPResult _ nullIOPResult,  --most currently processed IOP result
sectorsPerTrack:     CARDINAL  _ 15,             --function[sectorLength, density]
encodedSectorLength: EncodedSectorLength _ b512];--function[sectorLength]

DiskChangeClear: PUBLIC PROCEDURE [DeviceHandle] =
BEGIN
ready: BOOLEAN;
IF ~state.status.diskChange THEN RETURN;
state.status.diskChange _ FALSE;
ready _ ~Immediate[escapeC, diskChangeClearSC, nop].notReady;
IF ready THEN [] _ Immediate[recalibrateC, nopSC, recalibrate]
END;

GetDeviceAttributes: PUBLIC PROC [DeviceHandle] RETURNS [Attributes] =
BEGIN
RETURN[[
deviceType:    IF state.result.diskID=SA800 THEN SA800 ELSE SA850,
numberOfHeads: IF ~state.status.twoSided THEN 1 ELSE 2,
numberOfCylinders: numOfCylinders, trackLength: trackParameterLength]];
END;

GetNextDevice: PUBLIC PROC [device: DeviceHandle] RETURNS [DeviceHandle] = {
RETURN[IF device = nullDeviceHandle THEN diskDeviceHandle ELSE nullDeviceHandle]};

GetContext: PUBLIC PROC [DeviceHandle] RETURNS [Context] = {RETURN[state.user]};

Initialize: PUBLIC PROC [notify: WORD, initialAllocation: LONG POINTER] =
BEGIN
csb^ _ [
transferMask: notify, next: nilIOP, unused0: NULL,
needReset: FALSE, tail: NIL];
initializationIOCB _ initialAllocation;
initializationIOCB^ _ nullIOCB;
initializationIOCB.operation.device _ internalDeviceHandle;
[] _ Immediate[initializeC, nopSC, nop];
state.status.diskChange _ TRUE;
END;

InitializeCleanup: PUBLIC PROC [DeviceHandle] =
BEGIN
item: DeviceCleanup.Item;
sCsb: CSB;
DO
reason: DeviceCleanup.Reason = DeviceCleanup.Await[@item];
SELECT reason FROM
turnOff, kill =>
{WHILE csb.next#nilIOP DO ENDLOOP; sCsb _ csb^};
turnOn =>  csb^ _ sCsb;
ENDCASE
ENDLOOP
END;



Initiate: PUBLIC PROC [o: OperationPtr]
RETURNS [status: Status, maxSecondsThisOperation: CARDINAL] =
BEGIN OPEN iocb: LOOPHOLE[o, IOCBPtr];
maxSecondsThisOperation _ 0;
IF o.device # diskDeviceHandle AND o.device # internalDeviceHandle THEN
RETURN[Inline.BITOR[statusError, Inline.BITAND[infoMask, state.status]], 0];
IF o.device = diskDeviceHandle THEN iocb.iopBlk _ nullIOPBlk;
iocb.nextIOCB _ NIL; iocb.started _ FALSE; iocb.abortStatus _ inProgress;
IF (status _ CheckIOCB[@iocb]).inProgress THEN
BEGIN
IF csb.next = nilIOP THEN RunIOCB[@iocb] ELSE csb.tail.nextIOCB _ @iocb;
csb.tail _ @iocb;
maxSecondsThisOperation _ SELECT o.function FROM
readSector, writeSector, writeDeletedSector, readID =>
20 + (o.count + iocb.iopBlk.sectorCount)/5,
formatTrack => 20 + (o.count + iocb.iopBlk.sectorCount),
nop, recalibrate => 10,
ENDCASE => 0;
END
ELSE iocb.started _ TRUE;  -- return (error) status if somebody polls this guy
END;

Poll: PUBLIC PROC [o: OperationPtr] RETURNS [status: Status] =
BEGIN OPEN iocb: LOOPHOLE[o, IOCBPtr];
IF ~iocb.abortStatus.inProgress THEN RETURN[iocb.abortStatus];
IF csb.next#nilIOP OR ~iocb.started THEN
RETURN[Inline.BITOR[inProgress, Inline.BITAND[state.status, infoMask]]];
IF (status _ GetStatus[@iocb]).inProgress THEN RunIOCB[@iocb]
ELSE
FOR newIOCB: IOCBPtr _ iocb.nextIOCB, newIOCB.nextIOCB WHILE newIOCB # NIL DO
newIOCB.started _ TRUE;
IF CheckIOCB[newIOCB].inProgress THEN {RunIOCB[newIOCB]; EXIT};
ENDLOOP;
END;

Reset: PUBLIC PROC [DeviceHandle] =
{csb.next _ nilIOP; csb.needReset _ TRUE; csb.tail _ NIL};

SetContext: PUBLIC PROC [device: DeviceHandle, context: Context] RETURNS [BOOLEAN] =
BEGIN
Density:   TYPE = {single, double};
sectorsPerTrack: ARRAY EncodedSectorLength[b128..b1024] OF ARRAY Density OF CARDINAL
= [  --   Single density    Double Density
--  64w--      [26,               36],
-- 128w--      [15,               26],
-- 256w--      [ 8,               15],
-- 512w--      [ 4,                8]];
byteIndex: EncodedSectorLength = SELECT context.sectorLength FROM
64 => b128, 128 => b256, 256 => b512, 512 => b1024, ENDCASE => bUnknown;
IF (byteIndex=bUnknown) OR (csb.next#nilIOP) OR (context.format#IBM) THEN
RETURN[FALSE];
state.user _ context;
state.sectorsPerTrack
_ sectorsPerTrack[byteIndex][IF context.density=single THEN single ELSE double];
state.encodedSectorLength _ byteIndex;
RETURN[TRUE];
END;

Start: PUBLIC PROC = {RemainingHeads.Start[]};


BuildIOCB: PROCEDURE [iocb: IOCBPtr] =
BEGIN OPEN o: iocb.operation;
b: LONG POINTER TO IOPBlock = @iocb.iopBlk;
runLength: CARDINAL;

IF o.device = internalDeviceHandle THEN RETURN;
b.result _ nullIOPResult;
IF state.status.notReady THEN {b.command _ nopC; RETURN};
b.command _ commandMatrix[o.function];
SELECT o.function FROM
nop, recalibrate => NULL;     -- allSetUp
recovery => b.command _ nopC; -- for now, do nothing
readSector, writeSector, writeDeletedSector, readID =>
BEGIN OPEN a: o.address;
runLength _ MIN[o.count, state.sectorsPerTrack-(a.sector-1)];
Touch[
addr: o.buffer.address,
count:
(IF o.function=readID THEN idLength ELSE state.user.sectorLength)
* (IF o.incrementDataPointer THEN runLength ELSE 1),
dirty: (o.function=readSector OR o.function=readID)];
b.samePage     _ ~o.incrementDataPointer;
b.bufferAddr   _ o.buffer.address;
b.sectorLength _ state.user.sectorLength;
b.sectorFormat _ [
troyOrIBM: IF state.user.format = Troy THEN Troy ELSE IBM,
density:   IF state.user.density = double THEN double ELSE single];
b.diskAddress  _ o.address;  -- set first disk address
b.sectorCount  _ runLength;  -- set number of sectors to transfer
iocb.thisRun   _ runLength;  -- and set run length for getStatus fixup.
END;
formatTrack =>
BEGIN OPEN a: o.address;
Density:   TYPE = {single, double};
gap3: ARRAY EncodedSectorLength [b128..b1024] OF ARRAY Density OF CARDINAL
= [  --   Single density    Double Density
--  64w--      [27,               26],
-- 128w--      [42,               54],
-- 256w--      [58,               84],
-- 512w--      [75,              116]];
b.formatInfo _ [
sectorLengthDiv4:    state.user.sectorLength/2, -- (x * 2 bytes/wd)/4
encodedSectorLength: state.encodedSectorLength,
sectorsPerTrack:     state.sectorsPerTrack,
gap3FillCharsCount:
gap3[state.encodedSectorLength]
[IF state.user.density=single THEN single ELSE double]];
runLength _ MIN[
o.count, IF state.status.twoSided THEN 1 ELSE (numOfCylinders - a.cylinder)];
b.sectorFormat _ [
troyOrIBM: IF state.user.format = Troy THEN Troy ELSE IBM,
density:   IF state.user.density = double THEN double ELSE single];
b.diskAddress  _ o.address;
b.sectorCount  _ runLength;
iocb.thisRun   _ runLength;
END
ENDCASE;
END;

CheckIOCB: PROCEDURE [iocb: IOCBPtr] RETURNS [status: Status] =
BEGIN OPEN a: iocb.operation.address, o: iocb.operation, Inline;
IsWriteOp: PROC [f: Function] RETURNS [BOOLEAN] =
INLINE {RETURN[f=writeSector OR f=writeDeletedSector OR f=formatTrack]};
IF ~iocb.abortStatus.inProgress THEN RETURN[iocb.abortStatus];
status _ inProgress;
IF o.function = formatTrack THEN a.sector _ 1;
SELECT TRUE FROM
o.device = internalDeviceHandle => NULL;
state.status.diskChange => status _ diskChange;
(IsWriteOp[o.function]
AND (state.user.protect OR state.status.writeProtect)) =>
status _ writeProtect;
(IsTransferOp[o.function] AND
(a.cylinder  >= numOfCylinders
OR a.head   > (IF state.status.twoSided THEN 1 ELSE 0)
OR a.sector NOT IN [1..state.sectorsPerTrack]
OR o.count  = 0)) => status _ recordNotFound;
ENDCASE => NULL;
iocb.abortStatus _ status _ BITOR[status, BITAND[infoMask, state.status]];
END;

GetStatus: PROCEDURE [iocb: IOCBPtr] RETURNS [status: Status] =
BEGIN OPEN b: iocb.iopBlk, o: iocb.operation;
command:        Command   = b.command;
result:         IOPResult _ b.result;   -- done merely for better code
pResult:        POINTER TO READONLY IOPResult = @result;

BEGIN OPEN a: o.address;
countDone: CARDINAL _ (iocb.thisRun - b.sectorCount);
o.count _ o.count - countDone;
SELECT command FROM
formatTrackC =>
IF countDone#0 THEN SELECT TRUE FROM
b.result.twoSided AND (a.head = 0) => a.head _ 1;
ENDCASE => {a.head _ 0; a.cylinder _ a.cylinder + countDone};
readSectorC, readIDC, writeSectorC, writeDeletedSectorC =>
BEGIN
IF o.incrementDataPointer THEN
BEGIN
length: CARDINAL =
(IF command=readIDC THEN idLength ELSE state.user.sectorLength) * countDone;
o.buffer.length  _ o.buffer.length  - length;
o.buffer.address _ o.buffer.address + length;
END;
[quotient: countDone, remainder: a.sector]
_ Inline.DIVMOD[(a.sector-1) + countDone, state.sectorsPerTrack];
a.sector _ a.sector + 1;
IF countDone#0 THEN SELECT TRUE FROM
b.result.twoSided AND (a.head = 0) => a.head _ 1;
ENDCASE => {a.head _ 0; a.cylinder _ a.cylinder + countDone};
END;
ENDCASE;
END;

status                      _ initialStatus;  -- _ ALL[FALSE];
status.diskChange           _
state.status.diskChange
OR (state.status.notReady  AND ~pResult.notReady)
OR (~state.status.notReady AND (pResult.notReady OR pResult.doorOpened));
status.twoSided             _ pResult.twoSided;
status.notReady             _ pResult.notReady;
status.writeProtect         _ state.user.protect OR pResult.writeProtect;
SELECT command FROM
readSectorC =>
BEGIN
status.deletedData      _ pResult.deletedData;
status.crcError         _ pResult.crcError;
status.dataLost         _ pResult.dataLost;
status.recordNotFound   _ 
pResult.recordNotFound OR (o.address.cylinder >= numOfCylinders AND o.count > 0);
END;
IN [writeSectorC..readIDC] =>
BEGIN
status.crcError         _ pResult.crcError;
status.dataLost         _ pResult.dataLost;
status.recordNotFound   _ 
pResult.recordNotFound OR (o.address.cylinder >= numOfCylinders AND o.count > 0);
END;
formatTrackC =>
BEGIN
status.dataLost         _ pResult.dataLost;
status.recordNotFound   _ 
pResult.recordNotFound OR (o.address.cylinder >= numOfCylinders AND o.count > 0);
END;
recalibrateC =>
BEGIN
status.recalibrateError _ pResult.recalibrateError;
status.track00          _ pResult.track00;
END;
initializeC, escapeC =>
status.track00          _ pResult.track00;
ENDCASE;
status.error _ Inline.BITAND[status, statusError] # 0;
status.inProgress _ ~status.error AND IsTransferOp[o.function] AND o.count > 0;
status.busy _ status.inProgress OR (iocb.nextIOCB # NIL);
state.status _ iocb.abortStatus _ status;
END;

Immediate: PROCEDURE [
command: Command, subCommand: SubCommand, function: Function]
RETURNS [initStatus: Status] =
BEGIN
initializationIOCB.iopBlk.command     _ command;
initializationIOCB.iopBlk.subCommand  _ subCommand;
initializationIOCB.operation.function _ function;
initializationIOCB.operation.device   _ internalDeviceHandle;
initStatus _ Initiate[@initializationIOCB.operation].status;
WHILE initStatus.inProgress DO
initStatus _ Poll[@initializationIOCB.operation] ENDLOOP
END;

IsTransferOp: PROC [f: Function] RETURNS [b: BOOLEAN] =
--INLINE-- BEGIN
b _ SELECT f FROM
readSector, readID, writeSector, writeDeletedSector, formatTrack => TRUE,
ENDCASE => FALSE;
END;

RunIOCB: PROC [iocb: IOCBPtr] =
BEGIN
BuildIOCB[iocb];
iocb.started _ TRUE;
IF csb.next=nilIOP THEN csb.next _ LOOPHOLE[Inline.LowHalf[@iocb.iopBlk]];
END;

Touch: PROC [addr: LONG POINTER, count: CARDINAL, dirty: BOOLEAN] =
BEGIN
IF dirty THEN
BEGIN
next: LONG POINTER = addr+1;
IF count#0 THEN
{addr^ _ 0; Inline.LongCOPY[from:addr, to: next, nwords: count-1]}
END
ELSE THROUGH [0..count) DO dummy: CARDINAL _ addr^; addr _ addr+1 ENDLOOP;
END;

recordNotFound: Status =
[diskChange: FALSE, na1: FALSE, twoSided: FALSE, na3: FALSE, error: TRUE,
inProgress: FALSE, recalibrateError: FALSE, dataLost: FALSE,
notReady: FALSE, writeProtect: FALSE, deletedData: FALSE,
recordNotFound: TRUE, crcError: FALSE, track00: FALSE, index: FALSE,
busy: FALSE];
notReady: Status =
[diskChange: FALSE, na1: FALSE, twoSided: FALSE, na3: FALSE, error: TRUE,
inProgress: FALSE, recalibrateError: FALSE, dataLost: FALSE, notReady: TRUE,
writeProtect: FALSE, deletedData: FALSE, recordNotFound: FALSE,
crcError: FALSE, track00: FALSE, index: FALSE, busy: FALSE];
diskChange: Status =
[diskChange: TRUE, na1: FALSE, twoSided: FALSE, na3: FALSE, error: TRUE,
inProgress: FALSE, recalibrateError: FALSE, dataLost: FALSE,
notReady: FALSE, writeProtect: FALSE, deletedData: FALSE,
recordNotFound: FALSE, crcError: FALSE, track00: FALSE, index: FALSE,
busy: FALSE];
initialStatus: Status = LOOPHOLE[0];  -- ALL[FALSE]
inProgress: Status =
[diskChange: FALSE, na1: FALSE, twoSided: FALSE, na3: FALSE, error: FALSE,
inProgress: TRUE, recalibrateError: FALSE, dataLost: FALSE, notReady: FALSE,
writeProtect: FALSE, deletedData: FALSE, recordNotFound: FALSE,
crcError: FALSE, track00: FALSE, index: FALSE, busy: TRUE];
writeProtect: Status =
[diskChange: FALSE, na1: FALSE, twoSided: FALSE, na3: FALSE, error: TRUE,
inProgress: FALSE, recalibrateError: FALSE, dataLost: FALSE,
notReady: FALSE, writeProtect: TRUE, deletedData: FALSE,
recordNotFound: FALSE, crcError: FALSE, track00: FALSE, index: FALSE,
busy: FALSE];
statusError: Status =
[diskChange: TRUE, na1: FALSE, twoSided: FALSE, na3: FALSE, error: TRUE,
inProgress: FALSE, recalibrateError: TRUE, dataLost: TRUE, notReady: TRUE,
writeProtect: FALSE, deletedData: FALSE, recordNotFound: TRUE,
crcError: TRUE, track00: FALSE, index: FALSE, busy: FALSE];
infoMask: Status =
[diskChange: FALSE, na1: FALSE, twoSided: TRUE, na3: FALSE, error: FALSE,
inProgress: FALSE, recalibrateError: FALSE, dataLost: FALSE,
notReady: FALSE, writeProtect: TRUE, deletedData: FALSE,
recordNotFound: FALSE, crcError: FALSE, track00: TRUE, index: FALSE,
busy: FALSE];



END.....
LOG

Time: September 26, 1980  3:30 PM, by DDavies, start coding.
Time: October 21, 1980  2:25 PM, add mapping of all pages for virt addresses
Time: October 30, 1980  5:17 PM, add mapping of IOCB addresses
Time: November 7, 1980  1:00 PM, add byte swapping for IDs read
Time: November 12, 1980  11:13 AM, by DDavies, add bulletproofing against polling out of order.
Time: December 1, 1980  1:35 PM, by DDavies, remove byte-swapping.
Time: December 1, 1980  10:36 PM, by Forrest, run through reformatter.
Time: January 22, 1981  11:10 AM, by Gobbel, fix bug that causes head to always die if function=formatTrack.
Time: March 23, 1981  7:06 PM, by Forrest, fix bug causing recordNotFound when recalibrate/recover with count=0.
(1792)\f8

öSA800HeadDLion.mesa
last modified August 26, 1982 4:43 pm by Taft
Things to do:
1. One and only one drive is handled by this Head.  The Dandelion will
have exactly one SA80x or SA85x type drive and exactly one floppy disk
controller.
2. The operation.buffer.length is ignored.
It should be removed from the face.
***********************************************************************
C S B
The Dandelion has at most one Shugart SA80x or SA85x
floppy disk. The CSB resides in a resident page of memory (the IOPage).
Only state.next and .needReset are known by IOP code.
***********************************************************************
unused1(6: 0..31):  UNSPECIFIED];
***********************************************************************
I O C B     (and IOP command blocks)
***********************************************************************
after it passes Initiate (new Disk Change while it is in the queue).  This
saves the status so the user finds out why it failed.
(if format, track count)
all sectors (unused if format)
((bytes)/4) MOD 256
order of these guys is significant to Head code as well as IOP
latched until
DiskChangeClear[] AND ~notReady
***********************************************************************
C O N S T A N T S
(canned stati can be found at the end of the module (so they won't lexically
pollute code readers)
***********************************************************************
***********************************************************************
G L O B A L   V A R I A B L E S
***********************************************************************
do not submit an IOCB if there is nothing to do.  This also eliminates
the possiblilty of interrupting an existing IOCB.  Since the occurence of
a new diskChange error causes the IOCB queue to be cleared, the IOCB about
to be submitted will arrive at the Head of the queue so it may be Polled
immediately.
if there is a diskette inserted (notReady=FALSE) then recalibrate
so the FDC and IOP are synchronized.  When the heads are recalibrated they
they are loaded => door lock engaged.  If there were no disk, the FDC would
never see index pulses and never ever unload the heads, leaving the door locked
which is mildly embarrassing. This may also be the first recalibrate if there was no 
disk loaded when the system was initialized.
Assumes an "Initialize" operation has been performed so "state.status"
holds valid state bits
ASSUMES EXACTLY ONE FLOPPY DRIVE IS CONNECTED TO THE DANDELION
This code will only handles a single controller/single device configuration.
This procedure initiates an operation. The client passes an IOCB with most of the parameters filled in. We fill in the parameters that are unique to this implementation of the Head and microcode. Then we chain the IOCB onto the CSB an wake up the microcode.  The variable maxSecondsThisOperation may be used by the driver to timeout and rescue the operation.  It is an upper bound on the number of seconds the operation will take after previous operations have been completed.
This routine requires that the device be idle (i.e., the IOCB chain to be NIL)
as well as all other context to be correct before anything is changed in the
head's context.
exported to HeadStartChain
************************** PRIVATE PROCEDURES **************************
[512w][single] and [64w][double] are picked out of the air
a procedure to check an IOCB before it is submitted to the IOP.  It attempts
to screen out IOCBs which shouldn't even be attempted
a procedure to produce the status of an IOCB after it has been completed by the IOP.
In addition to deciding if the stage just performed had any errors, this procedure
decides if there are any more stages to be performed.  NOTE: there is no reason to
detect abortStatus.inProgress=FALSE since this routine is only called from Poll
which will detect this condition before trying to call GetStatus.
update disk addr and client buffer parameters
if twoSided, countDone can must <= 1
since we break runs at tracks, countDone <= 1
status.na3                  _ FALSE;
(_ TRUE) SA800 since Mokelumne pilot thinks this is a hardware error bit
status.na1                  _ FALSE;
status.index                _ FALSE;  ++ IOP never sends an index pulse back
set error flag if there was an error or the run proceeds off the end of the disk.
change this to use checksum when implemented in microcode
***********************************************************************
Various   B O R I N G    C O N S T A N T S
***********************************************************************
�ʘJš
œ™Jš
œ-™-J˜Jš
œ
™
Jš
œF™FJš
œF™FJš
œ™Jš
œ*™*Jš
œ#™#J˜š
Ïk	˜	Jšœ�œ˜*Jšœ�œ
˜ Jšœ�œ˜Jšœ�œ	˜Jš	œ�œ�œ�œ�œ˜8J˜
J˜—šœ�˜š
�˜J˜G—Jš�œ˜!Jš�œ˜Jš�œ
�œ˜J˜Jš
œG™GJš
œ™Jš
œ4™4Jš
œG™GJš
œ5™5Jš
œG™Gš
�œ�œ�œ
�	œ
�œ˜&Jšœ�œÏc˜9Jšœ#ž%˜HJšœ�œ
˜ Jšœ�œž˜=Jšœ#ž-˜P—Jš
œ!™!J˜Jšœ�œ
�œ
�œ
�œ�œ#ž˜MJ˜Jš
œG™GJš
œ$™$Jš
œG™GJšœ
�œ�œ
�œ
�œ
�œ
˜)Jš	œ
�œ�œ
�œ
�œ
˜BJ˜Jšœ�œ˜'J˜š
�œ�œ�œ
�	œ
�œ˜'Jšœ*ž˜?Jšœ*ž˜AJšœ�œž$˜NJšœ*ž˜Cšœ*ž,˜VJš
œJ™JJš
œ5™5—Jšœ*ž˜IJ˜—š	œ
�œ�œ
�	œ
�œ˜+Jšœ�œ
�œž)˜PJšœ�œ˜'Jšœ�œž)˜PJšœ'ž˜7Jšœ'ž˜Cšœ�œž(˜OJš
œ™—Jšœ'ž˜>šœ�œ	ž#˜JJš
œ™—Jšœ'ž˜:Jšœ'ž&˜MJšœ'ž˜=Jšœ�œ�œ
�œ˜4J˜—š	œ�œ�œ
�	œ
�œ˜1šœ�œž˜DJš
œ™—Jšœ4ž˜LJšœ�œ˜1Jšœ�œž˜LJ˜—Jš
œ>™>šœ	�œ�œ
�	œ˜#J˜OJ˜.J˜—Jšœ�œ�œ
�	œ*˜NJ˜šœ�œ�œ
�	œ˜/J˜/J˜—š	œ�œ�œ
�	œ
�œ˜-Jšœ�œ
�	œ�œ˜AJšœ�œ
�	œ"˜GJ˜—š	œ�œ�œ
�	œ
�œ˜,šœ�œž$˜QJš
œ
™
Jš
œ™—Jšœ�œ�œ
˜*Jšœ�œž'˜TJšœ�œ
�	œ˜AJšœ�œž$˜QJšœ�œ�œ
˜*Jšœ�œž&˜SJšœ�œž˜KJšœ�œž˜CJšœ�œž(˜UJšœ�œž˜JJšœ�œž$˜QJšœ�œž˜DJšœ�œž ˜MJšœ�œ�œ
˜*Jšœ�œž'˜TJ˜—Jš
œG™GJš
œ™Jš
œL™LJš
œ™Jš
œG™Gšœ�œ
�œž˜DJ˜LJ˜J˜—šœ
�œ˜˜Jšœ
�œ*�œ˜OJšœB�œ˜S—Jšœ"�œ
˜4Jšœ&�œ˜+J˜—˜Jšœ�œ
˜J˜J˜Jšœ�œ˜0J˜0J˜J˜Jšœ�œ#˜6J˜J˜J˜—˜Jšœ�œ�œ�œ
˜@Jšœ�œ�œ�œ
˜:Jšœ�œ�œ�œ
˜?Jšœ
�œ�œ�œ˜.J˜—Jšœ�œ�œ˜4Jšœ(�œ˜4Jšœ(�œž"˜XJ˜Jšœ�œž*˜RJšœ�œž˜FJšœ�œž/˜WJ˜Jš	œ�œ
�œ�œ
�œ˜6Jš	œ�œ
�œ�œ
�œ˜6J˜J˜Jš
œG™GJš
œ™Jš
œG™GJ˜J˜šœ�œ˜šœ1ž˜HJšœ�œ
�œ&˜D—Jšœ1ž!˜RJšœ1ž%˜VJšœ�œž!˜RJšœ1ž˜IJ˜—Jš
œF™FJš
œI™IJš
œJ™JJš
œH™HJš
œ™šÏnœ�œ
�	œ˜2Jš
�˜Jšœ�œ
˜Jš�œ�œ
�œ
˜(Jšœ�œ
˜ J˜=Jš
œA™AJš
œJ™JJš
œK™KJš
œO™OJš
œU™UJš
œ,™,Jš�œ�œ1˜>Jš�œ
˜J˜—Jš
œF™FJš
œ™šŸœ�œ
�œ�œ˜FJš
�˜š�œ˜Jšœ�œ�œ�œ˜BJšœ�œ�œ�œ˜7J˜G—Jš�œ
˜J˜—Jš
œ>™>šŸ
œ�œ
�œ�œ˜LJš�œ
�œ�œ�œ˜RJ˜—Jš
Ÿ
œ�œ
�œ�œ�œ˜PJ˜Jš
œL™LšŸ
œ�œ
�œ
�œ�œ
�œ˜IJš
�˜˜Jšœ-�œ
˜2Jšœ�œ�œ˜—J˜'J˜J˜;J˜(Jšœ�œ
˜Jš�œ
˜J˜—šŸœ�œ
�œ˜/Jš
�˜J˜Jšœ�œ
˜
š
�˜J˜:š�œ�˜˜Jšœ
�œ�œ
�œ˜0—J˜Jš
�˜—Jš
�˜—Jš�œ
˜J˜J˜——Jš
œÜ™Ü˜šŸœ�œ
�œ˜'Jš�œ+�œ˜=Jš�œ
�œ�œ
˜&J˜š�œ�œ!�˜GJš�œ�œ�œ˜L—Jš�œ�œ˜=Jšœ�œ�œ ˜Iš�œ(�˜.Jš
�˜Jš�œ�œ�œ˜HJ˜šœ�œ�˜0˜6J˜+—J˜8J˜Jš�œ˜
—Jš
�˜—Jš�œ�œž3˜NJš�œ
˜J˜—šŸœ�œ
�œ�œ˜>Jš�œ
�œ�œ
˜&Jš�œ�œ
�œ˜>š�œ�œ�˜(Jš�œ�œ�œ˜H—Jš�œ(�œ˜=š
�˜š�œ4�œ�œ
�˜MJšœ�œ
˜Jš�œ�œ�œ˜?Jš�œ
˜——Jš�œ
˜J˜—šŸœ�œ
�œ˜#Jšœ$�œ
�œ˜:J˜—Jš
œN™NJš
œL™LJš
œ™š
Ÿ
œ�œ
�œ*�œ�œ˜TJš
�˜Jšœ�œ˜#š
œ�œ"�œ
�œ	�œ
�˜TJšœž%˜*Jšž	œ˜&Jšž	œ˜&Jšž	œ˜&Jšž	œ˜'—šœ!�œ�˜AJšœ4�œ
˜H—š	�œ�œ�œ�œ�˜IJš�œ
�œ˜—J˜˜Jšœ�œ�œ�œ	˜P—J˜&Jš�œ
�œ˜
Jš�œ
˜J˜—Jš
œ™JšŸœ�œ
�œ˜.J˜Jš
œH™HJ˜šŸ	œ�	œ˜&Jš�œ
�œ˜Jšœ�œ
�œ
�œ˜+Jšœ�œ
˜J˜Jš�œ!�œ
�œ
˜/J˜Jš�œ�œ�œ˜9J˜&š�œ�˜Jšœ�œž˜)Jšœž˜4˜6Jš�œ
�œ˜Jšœ�œ.˜=˜J˜˜Jšœ
�œ�œ
�œ˜AJšœ�œ�œ�œ˜4—Jšœ�œ˜5—J˜)J˜"J˜)˜Jš	œ�œ�œ�œ
�œ
˜:Jšœ�œ�œ�œ	˜C—Jšœž˜6Jšœž$˜AJšœž*˜GJš�œ
˜—˜Jš�œ
�œ˜Jšœ�œ˜#š
œ�œ#�œ
�œ	�œ
�˜JJš
œ:™:Jšœž%˜*Jšž	œ˜&Jšž	œ˜&Jšž	œ˜&Jšž	œ˜'—˜Jšœ0ž˜EJ˜/J˜+˜˜Jšœ
�œ�œ�œ
˜8———šœ�œ
˜Jšœ	�œ�œ�œ ˜M—˜Jš	œ�œ�œ�œ
�œ
˜:Jšœ�œ�œ�œ	˜C—J˜J˜J˜Jš
�˜—Jš�œ
˜—Jš�œ
˜J˜—Jš
œL™LJš
œ5™5šŸ	œ�	œ�œ˜?Jš�œ
�œ6˜@šŸ	œ�œ�œ�œ˜1Jš�œ�œ�œ�œ˜H—Jš�œ�œ
�œ˜>J˜Jš�œ�œ˜.š�œ
�œ
�˜Jšœ#�œ
˜(J˜/˜Jš�œ�œ˜9J˜—šœ�˜˜Jš�œ
�œ�œ�œ˜6Jš�œ
�œ
�œ˜-Jš�œ+˜-——Jš�œ�œ
˜—Jšœ�œ	�œ˜JJš�œ
˜J˜—Jš
œT™TJš
œR™RJš
œR™RJš
œO™OJš
œA™AšŸ	œ�	œ�œ˜?Jš�œ
�œ#˜-J˜&Jšœ(ž˜FJšœ�œ
�œ
�œ˜8J˜Jš
œ-™-Jš�œ
�œ˜Jšœ�œ"˜5J˜š�œ	�˜˜š	�œ
�œ
�œ
�œ
�˜$Jš
œ$™$Jšœ�œ˜1Jš�œ6˜=——˜:Jš
�˜š�œ�˜Jš
�˜šœ�œ˜Jšœ
�œ�œ
�œ&˜L—J˜-J˜-Jš�œ
˜—˜*Jšœ	�œ2˜A—J˜Jš
œ-™-š	�œ
�œ
�œ
�œ
�˜$Jšœ�œ˜1Jš�œ6˜=—Jš�œ
˜—Jš�œ
˜—Jš�œ
˜J˜Jšœ.ž˜>˜J˜Jš�œ�œ˜1Jš�œ�œ�œ˜I—J˜/—š
œ$™$Jš
œH™HJ˜/Jšœ1�œ˜I—Jš
œ$™$š
œL™Lš�œ	�˜˜Jš
�˜J˜.J˜+J˜+˜Jšœ�œ'�œ˜Q—Jš�œ
˜—š�œ˜Jš
�˜J˜+J˜+˜Jšœ�œ'�œ˜Q—Jš�œ
˜—˜Jš
�˜J˜+˜Jšœ�œ'�œ˜Q—Jš�œ
˜—˜Jš
�˜J˜3J˜*Jš�œ
˜—˜J˜*—Jš�œ
˜—Jš
œQ™QJšœ�œ˜6Jšœ"�œ�œ
˜OJšœ �œ�œ˜9J˜)Jš�œ
˜J˜šŸ	œ�	œ˜J˜=Jš�œ˜Jš
�˜J˜0J˜3J˜1J˜=J˜<š�œ�˜Jšœ1�˜8—Jš�œ
˜J˜—šŸœ�œ�œ�œ˜7Jšž
œ
�˜šœ�œ�˜JšœD�œ
˜IJš�œ�œ
˜—Jš�œ
˜J˜—šŸœ�œ˜Jš
�˜J˜Jšœ�œ
˜Jš�œ�œ�œ˜JJš�œ
˜J˜—Jš
œ9™9šŸœ�œ�œ
�œ	�œ	�œ˜CJš
�˜š�œ�˜
Jš
�˜Jšœ�œ
�œ
˜š�œ	�˜J˜B—Jš
�˜—Jš
�œ
�œ�œ�œ�œ
˜JJš�œ
˜J˜—Jš
œG™GJš
œ*™*Jš
œG™G˜šœ
�œ�œ�œ�œ	�œ
˜IJšœ�œ�œ�œ
˜<Jšœ
�œ�œ�œ
˜9Jš	œ�œ�œ�œ	�œ
˜DJšœ�œ˜
——˜šœ
�œ�œ�œ�œ	�œ
˜IJš	œ�œ�œ�œ�œ
˜LJšœ�œ�œ�œ
˜?Jš	œ
�œ�œ	�œ�œ˜<——˜šœ
�œ�œ�œ�œ	�œ
˜HJšœ�œ�œ�œ
˜<Jšœ
�œ�œ�œ
˜9Jš	œ�œ�œ�œ	�œ
˜EJšœ�œ˜
——Jšœ�œž
˜3˜šœ
�œ�œ�œ�œ	�œ
˜JJš	œ�œ�œ�œ�œ
˜LJšœ�œ�œ�œ
˜?Jš	œ
�œ�œ	�œ�œ˜;——˜šœ
�œ�œ�œ�œ	�œ
˜IJšœ�œ�œ�œ
˜<Jšœ
�œ�œ�œ
˜8Jš	œ�œ�œ�œ	�œ
˜EJšœ�œ˜
——˜šœ
�œ�œ�œ�œ	�œ
˜HJš	œ�œ�œ�œ�œ
˜JJšœ�œ�œ�œ
˜>Jš	œ
�œ�œ	�œ�œ˜;——˜šœ
�œ�œ�œ�œ	�œ
˜IJšœ�œ�œ�œ
˜<Jšœ
�œ�œ�œ
˜8Jš	œ�œ�œ�œ	�œ
˜DJšœ�œ˜
J˜J˜J˜——Jš�œ˜——Jš
�˜J˜Jšœ�œ˜<Jšœ�œ-˜LJšœ�œ�œ
˜>Jšœ�œ ˜?Jšœ�œ>˜_Jšœ�œ#˜BJšœ�œ&˜FJšœ�œL˜lJšœ�œS˜pJ˜
J˜—…—Ox