// PupAlEthb.bcpl - Pup Alto Ethernet driver (level 0), BCPL portion
// Copyright Xerox Corporation 1979, 1980
// Last modified September 26, 1980  3:24 PM by Boggs

get "Pup0.decl"
get "PupAlEth.decl"

external
[
// outgoing procedures
SendEtherPacket; EncapsulateEtherPup; SendEtherStats
FeedEther; @EtherInterrupt; EtherFinish

// incoming procedures
StartIO; StartEther; DoubleIncrement
Enqueue; Dequeue; SysErr; MoveBlock
SetTimer; TimerHasExpired; Dismiss
CauseInterrupt; DestroyInterrupt
DisableInterrupts; EnableInterrupts

// incoming statics
pbiIQ; pbiFreeQ; ndbQ; lvUserFinishProc
savedEtherUFP; lenEtherPacket
]

// Note: if pupDebug is true, then code will be compiled which
//  calls DoubleIncrement, which is in PupAl1A.asm -- above level 0!

//----------------------------------------------------------------------------
let EncapsulateEtherPup(pbi, pdh) be
//----------------------------------------------------------------------------
// performs Ethernet dependent encapsulation
// pbi -> a PBI
// pdh is physical destination host for Pup
[
pbi>>EtherPBI.dest = pdh
pbi>>EtherPBI.src = pbi>>PBI.ndb>>NDB.localHost
pbi>>EtherPBI.type = typePup
pbi>>PBI.packetLength = (pbi>>PBI.pup.length+5) rshift 1
]

 
//----------------------------------------------------------------------------
and SendEtherPacket(pbi) be
//----------------------------------------------------------------------------
[
let ndb = pbi>>PBI.ndb
if pbi>>EtherPBI.dest eq @(ndb>>EtherNDB.eHLoc) %
 pbi>>EtherPBI.dest eq 0 then // sending to ourself or bcst
   [  // fake reception of packet
   let ipbi = Dequeue(pbiFreeQ)
   if ipbi ne 0 then
      [
      MoveBlock(ipbi+1, pbi+1,
       (offset EtherPBI.dest/16-1)+pbi>>PBI.packetLength)
      let q = pbiFreeQ
      let pf = ndb>>NDB.pfQ.head
      while pf ne 0 do
         [
         if (pf>>PF.predicate)(ipbi) then
            [ q = pf>>PF.queue; break ]
         pf = pf>>PF.link
         ]
      Enqueue(q, ipbi)
      ]
   ]

// transmit the packet
Enqueue(lv ndb>>EtherNDB.oQ, pbi)
if ndb>>EtherNDB.eOB eq 0 then CauseInterrupt(ndb>>EtherNDB.mask)
compileif pupDebug then
   [ DoubleIncrement(lv ndb>>EtherNDB.packetsSent) ]
]


//----------------------------------------------------------------------------
and SendEtherStats(pbi, ndb) = valof
//----------------------------------------------------------------------------
[
compileif pupDebug then
   [
   MoveBlock(lv pbi>>PBI.pup.words, lv ndb>>EtherNDB.stats, lenEtherStats)
   pbi>>PBI.pup.length = pupOvBytes + lenEtherStats
   ]
resultis pupDebug
]

//----------------------------------------------------------------------------
and EtherInterrupt(ndb) be
//----------------------------------------------------------------------------
// Control comes here when an Ethernet interrupt occurs.
// The contents of ePLoc at the time of the interrupt is in
//  lastEPLoc (zero means that the interrupt was manually initiated).
// If an input done interrupt has occurred, lastEIB holds the pbi
//  just received and lastEELoc holds the ending word count.
// In any event, if eState is nonzero, input has been restarted.
[
// if the interface has posted, dispose of the packet appropriately
let lastEPLoc = ndb>>EtherNDB.lastEPLoc
if lastEPLoc ne 0 then switchon lastEPLoc rshift 8 into
   [
   case 0: // good input microcode status
      [
      let q, lastEIB = pbiFreeQ, ndb>>EtherNDB.lastEIB
      test lastEPLoc eq 377b  // hardware status
         ifso  // good packet, put on input queue
            [
            lastEIB>>PBI.packetLength = lenEtherPacket-ndb>>EtherNDB.lastEELoc
            lastEIB>>PBI.ndb = ndb
            let pf = ndb>>NDB.pfQ.head
            while pf ne 0 do
               [
               if (pf>>PF.predicate)(lastEIB) then
                  [ q = pf>>PF.queue; break ]
               pf = pf>>PF.link
               ]
            compileif pupDebug then
               [ DoubleIncrement(lv ndb>>EtherNDB.packetsRcvd) ]
            ]
         ifnot  // bad packet, throw it away
            [
            compileif pupDebug then
               [ DoubleIncrement(lv ndb>>EtherNDB.numBadRcvStatus) ]
            ]
      Enqueue(q, lastEIB)
      endcase
      ]
   case 1: // good output microcode status
      [
      if lastEPLoc eq #777 then  //hardware status
         [
         Enqueue(ndb>>EtherNDB.eOB>>PBI.queue, ndb>>EtherNDB.eOB)
         ndb>>EtherNDB.eOB, @(ndb>>EtherNDB.eOCLoc) = 0, 0
         compileif pupDebug then
            [
            let load, i = @(ndb>>EtherNDB.eLLoc), -1
               [ load = load rshift 1; i = i+1 ] repeatuntil load eq 0
            DoubleIncrement(lv ndb>>EtherNDB.loadTable^i)
            endcase
            ]
         ]
      compileif pupDebug then
         [ DoubleIncrement(lv ndb>>EtherNDB.numBadXmtStatus) ]
      endcase
      ]

// EtherInterrupt (cont'd)

   case 3: // load overflow, or software-induced timeout
      [
      if ndb>>EtherNDB.eOB ne 0 then
         Enqueue(ndb>>EtherNDB.eOB>>PBI.queue, ndb>>EtherNDB.eOB)
      ndb>>EtherNDB.eOB, @(ndb>>EtherNDB.eOCLoc) = 0, 0
      compileif pupDebug then
         [ DoubleIncrement(lv ndb>>EtherNDB.loadTable^16) ]
      ]
   case 2: // input buffer overrun
   case 5: // reset of some kind
      endcase
   case 4: // zero length buffer
   default: // impossible microcode branch
      SysErr(lastEPLoc, ecBadEtherStatus)
   ]

compileif pupDebug then
   [
   if ndb>>EtherNDB.eState eq 0 then
      DoubleIncrement(lv ndb>>EtherNDB.inputOff)
   ]

// set up new input and output buffers if appropriate
if ndb>>EtherNDB.eIB eq 0 then
   [
   ndb>>EtherNDB.eIB = Dequeue(pbiFreeQ)
   if ndb>>EtherNDB.eIB ne 0 then
      [
      @(ndb>>EtherNDB.eIPLoc) = lv ndb>>EtherNDB.eIB>>EtherPBI.dest
      @(ndb>>EtherNDB.eICLoc) = lenEtherPacket
      ]
   ]
if ndb>>EtherNDB.eOB eq 0 then
   [
   ndb>>EtherNDB.eOB = Dequeue(lv ndb>>EtherNDB.oQ)
   if ndb>>EtherNDB.eOB ne 0 then
      [
      @(ndb>>EtherNDB.eOPLoc) = lv ndb>>EtherNDB.eOB>>EtherPBI.dest
      @(ndb>>EtherNDB.eOCLoc) = ndb>>EtherNDB.eOB>>PBI.packetLength
      SetTimer(lv ndb>>EtherNDB.tTimer, 10)  //time out in 100 ms
      ]
   ]

// restart the interface if it is off or output is now ready
StartEther(ndb)
]


//----------------------------------------------------------------------------
// and EtherPupFilter(pbi) =  // hand-coded in PupAlEtha.asm
//----------------------------------------------------------------------------
//   (pbi>>PBI.pup.length+5) rshift 1 eq pbi>>PBI.packetLength &
//    pbi>>EtherPBI.type eq typePup

//----------------------------------------------------------------------------
and FeedEther(ctx) be
//----------------------------------------------------------------------------
// This background process performs two tasks:
// (1) if the interface is turned off (presumably for lack of input
//     buffers) and buffers are now availble, start the receiver.
// (2) if the interface is transmitting and has timed out, reset it
//     and fake a load overflow indication to unhang the software.
[
let ndb = ctx!3
if ndb>>EtherNDB.eState eq 0 & pbiFreeQ!0 ne 0 then
   [ @(ndb>>EtherNDB.ePLoc) = 0; CauseInterrupt(ndb>>EtherNDB.mask) ]
if ndb>>EtherNDB.eState ls 0 & TimerHasExpired(lv ndb>>EtherNDB.tTimer) then
   [
   DisableInterrupts()
   StartIO(ndb>>EtherNDB.resetCmd)  // causes pending interrupt
   @(ndb>>EtherNDB.ePLoc) = 3 lshift 8  // fake a load overflow
   EnableInterrupts()
   ]
Dismiss(4)
] repeat


//----------------------------------------------------------------------------
and EtherFinish(code) be
//----------------------------------------------------------------------------
// Turns off all Ethernet interfaces.
[
if ndbQ ne 0 then
   [
   let ndb = ndbQ!0
   while ndb ne 0 do
      [
      if ndb>>NDB.netType eq netTypeEther then
         [
         @(ndb>>EtherNDB.eBLoc) = 0
         StartIO(ndb>>EtherNDB.resetCmd)
         DestroyInterrupt(ndb>>EtherNDB.mask)
         ]
      ndb = ndb!0
      ]
   ]
@lvUserFinishProc = savedEtherUFP
savedEtherUFP = -1
]