// PupAlEIAa.bcpl - PUP level -1 driver for EIA Interface
// Copyright Xerox Corporation 1979

// Last modified October 1, 1978  5:07 PM

get "Pup0.decl"
get "PupAlEIA.decl"

external
[
// outgoing procedures
EIAFinishProc; EIASwatContextProc; EIAInterrupt
StartEIAT; StopEIAT; StartEIAR; StopEIAR

// incoming procedures
EIAOutputDone; EIAInputDone
Enqueue; Dequeue
DisableInterrupts; EnableInterrupts; DestroyInterrupt

// incoming statics
pbiFreeQ; lenPup; eiaNDB; eiaLT
savedEIAFinishProc; lvUserFinishProc; lvSwatContextProc
]

static savedEIASwatProc

//----------------------------------------------------------------------------
let EIAFinishProc() be
//----------------------------------------------------------------------------
[
//Disable the EIA microcode.
(table [ mcEnableEIA; #1401 ])(0)
DestroyInterrupt(eiaNDB>>EIANDB.lcb^0.iEIALCB>>EIALCB.intMask)
@lvUserFinishProc = savedEIAFinishProc
@lvSwatContextProc = savedEIASwatProc
]

//----------------------------------------------------------------------------
and EIASwatContextProc() be
//----------------------------------------------------------------------------
[
let t = table
   [
   #101005	// mov 0 0 snr		; skip if turn on
   #102401	//  mkzero 0 0 skp	; entering.  Turn off eia
   #020403	// lda 0 .+3		; leaving.  Turn on eia
   #063400	// EnableEIA
   #001401	// jmp 1 3
   0		// -> eiaLT
   ]
t!5 = eiaLT
savedEIASwatProc = @lvSwatContextProc
@lvSwatContextProc = t
]

//----------------------------------------------------------------------------
and EIAInterrupt() be
//----------------------------------------------------------------------------
// Control comes here when the EIA microcode interrupts.
[
for line = 0 to maxLine do if eiaLT>>EIALT.eiaLTE^line.exists then
   [
   let lcb = lv eiaNDB>>EIANDB.lcb^line

   //Check input LCBs.
   let eiaLCB = lcb>>LCB.iEIALCB
   let firmStatus = eiaLCB>>EIALCB.firmStatus
   if firmStatus ls 0 then
      [
      //Dont look here again for a completed EIALCB
      eiaLCB>>EIALCB.firmStatus = 0

      //Take care of any errors that might have occured.
      switchon (firmStatus & 77777B) into
         [
         case errorNone:
            [
            lcb>>LCB.iPBI>>PBI.packetLength =
             ((lenPup+1) lshift 1) - (eiaLCB>>EIALCB.byteCount & 77777B)
            EIAInputDone(lcb)
            endcase
            ]
         case errorFatal:
            [
            StopEIAR(lcb)
            endcase
            ]
         case errorETX:
            [
            lcb>>LCB.inputOverrun = lcb>>LCB.inputOverrun +1
            endcase
            ]
         case errorSTX:
         case errorDLE:
            [
            lcb>>LCB.lineControlError = lcb>>LCB.lineControlError +1
            endcase
            ]
         case errorCRC:
            [
            lcb>>LCB.badCRC = lcb>>LCB.badCRC +1
            endcase
            ]
         ]
      //Restart reception of packets.
      if lcb>>LCB.iPBI eq 0 then
         lcb>>LCB.iPBI = Dequeue(pbiFreeQ)
      if lcb>>LCB.iPBI ne 0 then StartEIAR(lcb)
      ]

//EIAInterrupt (cont'd)

   //check output LCBs.
   eiaLCB = lcb>>LCB.oEIALCB
   firmStatus = eiaLCB>>EIALCB.firmStatus
   if firmStatus ls 0 then
      [
      //Dont look here again for a completed EIALCB
      eiaLCB>>EIALCB.firmStatus = 0

      //Take care of any errors that might have occured.
      switchon (firmStatus & 77777B) into
         [
         case errorFatal: StopEIAT(lcb)  //fall through
         case errorNone:
            [
            EIAOutputDone(lcb)
            endcase
            ]
         default: StartEIAT(lcb)
         ]
      ]
   ]
]

//----------------------------------------------------------------------------
and StartEIAR(lcb) be
//----------------------------------------------------------------------------
// Start EIA reception of a packet over the line represented by the LCB.
// This procedure is called by InitAltoEIA to start things up,
// by EIAInterrupt when an input is complete to restart reception, and
// by EIAProcess to restart reception on a line that ran out of PBIs.
[
DisableInterrupts()
let eiaLCB = lcb>>LCB.iEIALCB

//Set up to input into iPBI.
eiaLCB>>EIALCB.byteCount = (lenPup+1) lshift 1
eiaLCB>>EIALCB.bytePointer = lv (lcb>>LCB.iPBI)>>EIAPBI.type
eiaLCB>>EIALCB.firmStatus = 0
eiaLCB>>EIALCB.hardStatus = 0
eiaLCB>>EIALCB.partialCRC = 0

//Link the EIALCB to the line's LTE.
//The microcode is always watching for this to go non-zero.
eiaLT>>EIALT.eiaLTE^(lcb>>LCB.line).iLCB = eiaLCB
EnableInterrupts()
]

//----------------------------------------------------------------------------
and StopEIAR(lcb) be
//----------------------------------------------------------------------------
// Stop EIA reception of a packet over the line represented by the LCB.
// This procedure is called by EIAProcess when it detects a dead line.
[
DisableInterrupts()
//Put the line in throw-away state.
let eiaLTE = lv eiaLT>>EIALT.eiaLTE^(lcb>>LCB.line)

//Put the line in throw-away state, then
//remove the EIALCB from the EIALTE, then
//put the line back into bisync input state.
eiaLTE>>EIALTE.iState = stateThrowAway
eiaLTE>>EIALTE.iLCB = 0
eiaLTE>>EIALTE.iState = stateBiSyncInput

EnableInterrupts()
]

//----------------------------------------------------------------------------
and StartEIAT(lcb) be
//----------------------------------------------------------------------------
// Start EIA transmission of a packet.
[
DisableInterrupts()
let eiaLCB = lcb>>LCB.oEIALCB

//Set up to output from oPBI.
eiaLCB>>EIALCB.byteCount = lcb>>LCB.oPBI>>PBI.packetLength
eiaLCB>>EIALCB.bytePointer = lv (lcb>>LCB.oPBI)>>EIAPBI.type
eiaLCB>>EIALCB.firmStatus = 0
eiaLCB>>EIALCB.hardStatus = 0
eiaLCB>>EIALCB.partialCRC = 0
eiaLT>>EIALT.eiaLTE^(lcb>>LCB.line).oLCB = eiaLCB

//Inform the EIA interface board that there is something new to do.
@eiaControl = swi % (lcb>>LCB.line lshift 9)
EnableInterrupts()
]

//----------------------------------------------------------------------------
and StopEIAT(lcb) be
//----------------------------------------------------------------------------
// Disable EIA transmission of a packet.
// It is safe to call from both interrupt and non interrupt level.
[
DisableInterrupts()
let eiaLTE = lv eiaLT>>EIALT.eiaLTE^(lcb>>LCB.line)

//Put the line in throw-away state, then
//remove the EIALCB from the EIALTE, then
//put the line back into BiSync output state.
eiaLTE>>EIALTE.oState = stateThrowAway
eiaLTE>>EIALTE.oLCB = 0
eiaLTE>>EIALTE.oState = stateBiSyncOutput

EnableInterrupts()
]