Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-06-11 23:29:30 +00:00
Code Issues Projects Releases Wiki Activity
master
sys7.1-doc-wip/Libs/InterfaceSrcs/piDDP.a
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

929 lines
33 KiB
Plaintext
Raw Permalink Blame History

;
; File: piDDP.a
;
; Contains: xxx put contents here xxx
;
; Written by: xxx put writers here xxx
;
; Copyright: © 1992 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <SM3> 1/29/93 RB Do not move the SCCLockout value to the status register, always
; do an ORI.W with it so that NuKernel works and the stack is not
; changed.
; <2> 10/13/92 DCL Steve Bollinger (4-2122) 9/24/92
; Network events don't work anymore, so we always set the packet
; recvd flag. The caller can just poll this to see when we are
; done. set the packet recvd flag
;
;
BLANKS ON
STRING ASIS
EJECT
;_______________________________________________________________________
;
; DDP Routines
;_______________________________________________________________________
;
;_______________________________________________________________________
;
; Socket Listener
;
; This socket listener is called from MPP.
;
; Upon entering the socket listener, the LAP header bytes, and the
; appropriate DDP header bytes have been written into the RHA and the
; RHA's ptr will point past the last byte in the RHA.
;
; A4 and A5 are usable until ReadRest 2(A4) is called. After that,
; the normal interrupt conventions (A0-A3,D0-D3) apply. D2 is
; preserved across ReadPacket and ReadRest.
;
; The RHA contains enough room for LAP and long DDP headers, plus 8
; extra bytes. This socket listener moves as many as 4 bytes into the
; RHA in order to prevent the SCC from overflowing.
;
; If the buffer is to small to hold the incoming packet, it will be
; truncated to fit and a buf2small error will be returned. When this
; happens, checksums and the RetCksErr flag are ignored, so that even
; if the caller specified "don't return checksum errors" he could
; potentially be returned a packet with a checksum error if the buffer
; was too small.
;
; Call:
; A0,A1 .LONG SCC read/write addresses (preserve)
; A2 .LONG local vars (preserve)
; A3 .LONG ptr into the RHA (hdr bytes already loaded in)
; A4 .LONG address of the ReadPacket routine
; D0 .BYTE socket number for this read
; D1 .WORD length still left to read (preserve)
;
;
; Return:
; D0 .WORD error result
;
; Possible errors:
;
; Modification History:
; 8/24/84 Ready for alpha release (GRT)
; 8/24/84 Checksum routine added (ABO)
; 10/11/84 Code-crunching and speedup (RFA)
; 3/15/85 RecoverHandle call added (GRT)
; 5/1/86 GRT Not using _RecoverHandle anymore
;
;_______________________________________________________________________
tmpOffset EQU 0 ; entry num of the handler we are using
tmpRHAPtr EQU tmpOffset+2 ; pointer into RHA at end of DDP hdr
SocketListener PROC
MOVEQ #4,D3 ; max number of bytes to read
CMP D3,D1 ; check to see how many bytes are left
BHS.S @02 ; if more then just use the 4 bytes
MOVE D1,D3 ; else its less, so read however many left
@02 LEA saveArea,A5 ; save A3 because we need it later
MOVE.L A3,tmpRHAPtr(A5) ; (12) save ptr to RHA
MOVE D3,D2 ; remember # of bytes & check for zero
SWAP D2 ; move into upper word for now
MOVE.B D0,D2 ; save socket number in D2 also
TST D3 ; how many bytes to read?
BEQ.S @03 ; if zero, branch around ReadPacket
JSR (A4) ; read the bytes into the RHA and adjust
******************************************************************************
*** BEGINNING OF MAIN TIME CRITICAL SECTION **********************************
BNE.S @08 ; if error, exit
; A4 and A5 are restored upon completion of the ReadPacket call.
; A5 -> ptr to my save area
@03 LEA theSocketTable,A3 ; A3 -> my socket table
MOVEQ #maxSkts-1,D3 ; start at end of list
@05 CMP.B aSktNum(A3,D3),D2 ; match?
DBEQ D3,@05 ; no, check next one
BNE.S @11 ; if not found, goto @11
; If we have reached here, we have found the socket entry in our table, and we
; will now get the buffer ptr stored in the AB record. If a Read call has not
; been issued, we will throw the packet away.
LSL #2,D3 ; get offset into RBPtr field
MOVE D3,tmpOffset(A5) ; save offset * 4
MOVE.L aRBPtr(A3,D3),A3 ; get read block ptr
MOVE.L A3,D0 ; set CCR to see if read buf was NIL
BEQ.S @11 ; if no read buffer, ignore packet
MOVE.L rbABHdl(A3),A3 ; A3 = AB record handle
MOVE.L (A3),A3 ; deref it
MOVE ddpReqCount(A3),D3 ; D3 = number of bytes want to read
MOVE.L ddpDataPtr(A3),A3 ; A3 -> buffer ptr for packet
SWAP D2 ; restore byte count into low word
ADD D2,A3 ; modify ptr
SUB D2,D3 ; D3 = bytes to read - what I've already read
JSR 2(A4) ; read in rest of packet
*** END OF TIME CRITICAL SECTION **********************************************
*******************************************************************************
BNE.S @08 ; if error, just exit
BRA.S @12 ; else go on
@08 RTS ; short branch exit point
; Error exit section - This will exit the socket listener and call MPP (which
; will read the rest of the packet and ignore it.
@11 MOVEQ #0,D3 ; tell MPP we dont want the packet
JMP 2(A4) ; and call MPP
; OK, the packet is now hopefully where it is supposed to be so we can now pass
; other information back to the user.
;
; D3 = number of bytes Read in compared to the number of bytes in the buffer
; (if D3 < 0 then the users buffer was not big enough, so report an error)
;
; Registers D0-D3 and A0-A3 are now usuable
@12 TST D3 ; check to see if we overflowed buffer
BGE.S @13 ; if not then branch
MOVE #buf2SmallErr,D0 ; set error code
; Copy any bytes I temporarily stored in the RHA back into the user's buffer
; A0 -> ABRecord, A1 -> save area, A3 -> 1st DDP data byte in RHA
@13 MOVE.L A2,-(SP) ; save local var ptr
LEA saveArea,A1 ; get save area start point
LEA theSocketTable,A2 ; point to socket table
MOVE tmpOffset(A1),D1 ; restore table offset
MOVE.L aRBPtr(A2,D1),A2 ; A2 -> Read Block
MOVE.L rbABHdl(A2),A0 ; A0 = ABRecord handle
MOVE.L (A0),A0 ; deref it
MOVE ddpReqCount(A0),D1 ; get requested number of bytes
SUB D3,D1 ; get how many we actually read
MOVE D1,ddpActCount(A0) ; actual bytes read in
MOVE.L tmpRHAPtr(A1),A3 ; get saved RHA pointer
MOVE.L ddpDataPtr(A0),A2 ; A2 -> input data buffer
CMP ddpReqCount(A0),D2 ; is buffer big enough to hold 'em?
BLE.S @15 ; yes, proceed
MOVE ddpReqCount(A0),D2 ; no, only copy what will fit
@15 SUBQ #1,D2 ; dec counter
BLT.S @17 ; if neg then exit
MOVE.B 0(A3,D2),0(A2,D2) ; copy RHA bytes into buffer
BRA.S @15 ; do it again until done
; Move any pertinant data to the AB record to send back to the caller.
; We return the dest node ID to the user to let him know if it was a broadcast
; or directed. A $FF means broadcast, else it will be this node's ID
@17 MOVE.L (SP)+,A2 ; restore A2 MPP local vars
MOVE D0,abResult(A0) ; set return result code
CLR.B ddpTypeField-1(A0) ; clear junk byte for Pascal
MOVE.B DDPType-DDPHSzLong(A3),ddpTypeField(A0) ; ddp type
MOVE.B DDPSrcSkt-DDPHSzLong(A3),ddpAddrSkt(A0) ; 'from' skt num
CLR.B ddpNodeID-1(A0) ; clear junk byte for Pascal
MOVE.B ToRHA+LAPDstAdr(A2),ddpNodeID(A0) ; dest node ID
; Set up A1 -> Socket Table, D1 and D2 are offsets into that table
MOVE tmpOffset(A1),D2 ; D2 = entry offset in table * 4
MOVE D2,D1 ; D1 has it too!
LSR #2,D1 ; get actual offset into socket field
LEA theSocketTable,A1 ; A1 -> theSocketTable of info
CMP.B #shortDDP,ToRHA+LAPType(A2) ; is this a short DDP hdr?
BNE.S @18 ; branch for long header
MOVE.B ToRHA+LAPSrcAdr(A2),ddpAddrID(A0) ; stuff source node ID
CLR ddpAddrNet(A0) ; clear network number
MOVE.L aRBPtr(A1,D2),A3 ; get read block ptr
BRA.S @23 ; all done - go clean up
; If DDP long header, we return extended header info in addr blk to user
@18 MOVE.B DDPSrcNode-DDPHSzLong(A3),ddpAddrID(A0) ; 'from' xtend hdr ID
MOVE DDPSrcNet-DDPHSzLong(A3),ddpAddrNet(A0) ; 'from' xtend net ID
TST DDPChecksum-DDPHSzLong(A3) ; examine checksum in packet
MOVE.L aRBPtr(A1,D2),A3 ; get read block ptr
BEQ.S @23 ; if cksum zero, nothing to calculate
TST D0 ; any errors so far (buf2small)?
BNE.S @23 ; if so, forget checksum
BSR CalcCheckSum ; calculate checksum (D3 = error)
BEQ.S @23 ; checksums match
TST.B rbRetCksErr(A3) ; does user want Cksum errs returned?
BEQ.S @40 ; no, ignore this packet
MOVE #ckSumErr,abResult(A0) ; else report the error
@23 MOVE.L rbABHdl(A3),A0 ; A0 = AB rec handle
_HUnlock ; unlock the ABRecord handle
; Steve Bollinger (4-2122) 9/24/92
; Network events don't work anymore, so we always set the packet recvd
; flag. The caller can just poll this to see when we are done.
; set the packet recvd flag
ST aRcvFlag(A1,D1) ; set the pkt recvd flag to true
; unlink and unlock read block from the queue (has to be at the beginning)
; A3 -> read block
@30 MOVE.L 0(A3),aRBPtr(A1,D2) ; unlink read blk
MOVE.L rbHdl(A3),A0 ; A0 = read block handle
JSR UnlockAndLinkHdl ; dispose of the handle
@40 RTS
EJECT
;_______________________________________________________________________
;
; CalcCheckSum
;
; Calculate the checksum of the DDP packet. This checksum includes
; the DDP header bytes (starting from Dst Net field) and the data bytes.
;
; Call:
; A0 -> ABRecord
; A2 -> MPP variables
;
; Return:
; D3 = 0 if checksum match, non-zero otherwise
; D1 and A1 are saved/restored, D0 is trashed
;
; Modification History:
; 8/24/84 ABO Ready for alpha release
; 9/11/84 GRT Saved register A1
; 10/12/84 RFA Code crunch, saved D1
; 11/6/84 GRT If checksum calculated to be zero, then set to -1
;
;_______________________________________________________________________
CalcCheckSum MOVEM.L D1/A1,-(SP) ; save registers
CLR D3 ; start from scratch
LEA ToRHA+LAPHdSz+DDPDstNet(A2),A1 ; A1 -> Dest Net field
MOVEQ #DDPHSzLong-DDPDstNet,D1 ; size of DDP header to cksum
BSR.S DoCheckSum ; Checksum DDP header fields
MOVE.L ddpDataPtr(A0),A1 ; A1 -> user data
MOVE ddpActCount(A0),D1 ; D1 = user data count
BSR.S DoCheckSum ; Checksum user data
TST D3 ; check final result of checksum
BNE.S @10 ; if not zero then branch
SUBQ #1,D3 ; however, if it was, then force to -1
@10 SUB ToRHA+LAPHdSz+DDPChecksum(A2),D3 ; Subtract off pkt's cksum
MOVEM.L (SP)+,D1/A1 ; restore registers
RTS ; D3 zero if all ok, CCR set
;_____________________________
;
; DoCheckSum - accumulate ongoing checksum
;
; Call:
; D1 = number of bytes to checksum
; D3 = current checksum
; A1 -> bytes to checksum
;
; Return:
; Uses D0
; D3 = accumulated checksum
;_____________________________
DoChecksum CLR D0 ; Clear D0 high byte
SUBQ #1,D1 ; Decrement count by 1 for DBRA
@10 MOVE.B (A1)+,D0 ; D0 (word) = next byte
ADD D0,D3 ; Accumulate checksum
ROL #1,D3 ; Rotate checksum
DBRA D1,@10 ; And keep going
RTS
ENDPROC
;_______________________________________________________________________
;
; LookUpSkt
;
; This routine looks up a socket in my socket table. It is called by
; both DDPCloseSocket and DDPRead.
;
; Entry:
; D3 = socket number to find in table
;
; Exit
; D1 = offset value in table
; z-bit set in CCR if found else cleared
;_______________________________________________________________________
LookUpSkt PROC
LEA theSocketTable,A1 ; point to start of socket table
MOVEQ #maxSkts-1,D1 ; start at end of table
@10 CMP.B aSktNum(A1,D1),D3 ; check for match
DBEQ D1,@10 ; found it?
RTS
ENDPROC
EJECT
;_______________________________________________________________________
;
; DDPOpenSocket
;
; Opens a socket for DDP and optionally installs a socket listener
; for the requested socket. Socket number 0 means ephemeral. Socket
; number 1 owned by the RTMP socket listener (automatically attached
; when MPP initializes.
;
; This interface maintains its own socket table, apart from MPP's.
; This table holds info for all sockets opened by DDPOpenSocket for
; which the default socket listener was specified.
;
; A NIL value in sktListener will automatically install this interfaces
; built-in socket listener into my socket table.
;
; FUNCTION DDPOpenSocket(VAR theSocket : Byte; sktListener : Ptr): INTEGER;
;
; Stack upon entry:
;
; TOS => .LONG Return address
; .LONG Pointer to socket listener (see above)
; .LONG address of the sockets variable
; .WORD function result code
;
; Returns: .WORD Result code
;
; Possible errors: No more sockets
;
; The IO queue element is allocated on the stack for the control call.
; This call is made synchronously.
;
; Modification History:
; 8/24/84 GRT Ready for alpha release
; 10/12/84 RFA Code-crunch
;
;_______________________________________________________________________
DDPOpenSocket PROC EXPORT
JSR RemoveHdlBlks ; check to see if handles need to be disposed
MOVE.L (SP)+,D2 ; save return address
MOVE.L (SP)+,A1 ; get socket listener ptr
MOVE.L A1,D1 ; set ccr; is it zero??
BNE.S @10 ; if not then branch and continue
LEA SocketListener,A1 ; get address of built-in listener
MOVE.L A1, D1 ; save it away in D1
@10 MOVE.L (SP)+,A1 ; address of socket variable
MOVE.L D3,-(SP) ; save D3 register
MOVE.B 1(A1),D3 ; get socket number
SUB #IOQElSize,SP ; allocate space for the IOQEl
MOVE.L SP,A0 ; A0 -> IO queue element block
MOVE.B D3,socket(A0) ; socket number
MOVE.L D1,listener(A0) ; socket listener
MOVE #OpenSkt,CSCode(A0) ; code for attach proto hndlr
MOVE #MPPRefNum,IORefNum(A0) ; set refnum up
_Control
TST D0 ; check D0 - CCR doesn't get set right by _Control
BNE.S @90 ; if error, branch and exit
; Return the socket number to the user. Check skt listener address to see if
; we need to add it to our table. If it was not sent as NIL then don't add it.
MOVE.B Socket(A0),D3 ; get the (possibly) new socket
MOVE.B D3,1(A1) ; return skt num to user
LEA SocketListener,A0 ; see if we're using the default
CMPA.L D1,A0 ; socket listener
BNE.S @90 ; if not, then don't add to our table
; Caller wants to use the default socket listener, so store the socket number
; in my own table for use by DDPRead and the socket listener.
LEA theSocketTable,A1 ; A1 -> my table of skt listeners
MOVE #maxSkts-1,D1 ; start at the end of the list
@20 TST.B aSktNum(A1,D1) ; test for zero
DBEQ D1,@20 ; find it?
BNE.S @80 ; if not found then branch with error
; Found an entry so set up info in the socket table
@30 MOVE.B D3,aSktNum(A1,D1) ; store the socket number
CLR.B aRcvFlag(A1,D1) ; zero out the pkt rcvd flag
LSL #2,D1 ; offset to actual place in table
CLR.L aRBPtr(A1,D1) ; no read blocks linked in yet
BRA.S @90
@80 MOVE #ddpSktErr,D0 ; no free entry in table (ERROR)
@90 ADD #IOQElSize,SP ; deallocate the queue element
JMP ExitD3 ; restore D3 and exit
ENDPROC
EJECT
;_______________________________________________________________________
;
; DDPCloseSkt
;
; Detaches the socket listener and socket number from the table. Unlocks
; all Read Blocks associated with the socket and queues them for disposal.
; Unlocks all ABRecords associated with the Read Blocks. Error
; is returned by MPP if the socket was not found in the table.
;
; FUNCTION DDPCloseSocket(theSocket : Byte): INTEGER;
;
; Stack upon entry:
;
; TOS => .LONG Return address
; .BYTE pascal filler
; .BYTE socket number
; .WORD function result code
;
; Returns: .WORD Result code
;
; Possible errors: MPP errors: Socket not found
;
; The IO queue element is allocated on the stack for the control call.
; This call is made synchronously.
;
; Modification History:
; 8/24/84 GRT Ready for alpha release
; 10/12/84 RFA Code-crunch
; 10/16/84 RFA Clean up all Read Blocks and unlock all ABRecs
; 3/15/85 GRT RecoverHandle call added
;
;_______________________________________________________________________
DDPCloseSocket PROC EXPORT
JSR RemoveHdlBlks ; memory handles to be disposed?
MOVE.L (SP)+,D2 ; save return address
MOVE (SP)+,D0 ; get socket number (stored in word order)
MOVE.L D3,-(SP) ; save register
MOVE.B D0,D3 ; skt number
SUB #IOQElSize,SP ; allocate IOQElement
MOVE.L SP,A0 ; A0 -> IOQEl
MOVE.B D3,socket(A0) ; pass parameter to IOQ
MOVE #CloseSkt,CSCode(A0) ; control code
MOVE #MPPRefNum,IORefNum(A0) ; set refnum up
_Control ; make the call
ADD #IOQElSize,SP ; deallocate the IOQ element
TST.B D0 ; did we get an error
BNE.S @15 ; if so then branch
; Scan through table until either an matched entry is found, or until
; the end of the table is reached. If the entry is not found, we can't assume
; an error since the socket might have not been for our socket table.
JSR LookUpSkt ; check for socket
BNE.S @15 ; if not found then just exit
CLR.B aSktNum(A1,D1) ; zero out the field to nullify it
CLR.B aRcvFlag(A1,D1) ; just to be on the safe side
LSL #2,D1 ; get offset into RBPtrs
MOVE.L aRBPtr(A1,D1),A0 ; get first Read Block
CLR.L aRBPtr(A1,D1) ; zero it out for cleanup
MOVE.L A0,A1 ; A1 -> Read Block
@10 MOVE.L A1,D0 ; is it nil?
BEQ.S @15 ; if so, we're done
MOVE.L rbABHdl(A1),A0 ; A0 = AB rec handle
_HUnlock ; and unlock it
MOVE.L A1,A0
_RecoverHandle ; recover handle to read block
MOVE.L (A1),A1 ; but first, get ptr to next RdBlk
JSR UnlockAndLinkHdl ; unlock and queue it up for disposal
BRA.S @10
@15 JMP ExitD3 ; return
ENDPROC
EJECT
;_______________________________________________________________________
;
; DDPWrite
;
; Write a packet out to the cable either synchronously or asynchronously.
; If sync, do the operation and return when completed. If async, pass
; control back after queueing the call, and when completed, post a network
; event back to the application with a message consisting of the ABRecHandle.
;
; The ABRecHandle is locked down during most of the call. abResult will
; contain a 1 in it as long as the operation is still in progress (ASYNC
; only)
;
; FUNCTION DDPWrite(abRecord : ABRecHandle; doCheckSum : BOOLEAN;
; async : BOOLEAN): INTEGER;
;
; Stack upon entry:
;
; TOS => .LONG Return address
; .BYTE pascal filler
; .BYTE async flag
; .BYTE pascal filler
; .BYTE checkSum flag
; .LONG handle to record data structure
; .WORD function result code
;
; Returns: .WORD Result code
; Additional data in record structure
;
; Possible errors:
;
;
; Upon allocation of the IOQElement block, an additional 36 bytes are
; allocated at the end. The data structure looks like this:
;
; |=========================|
; : :
; : IOQElement blk : 50 bytes
; : :
; : :
; |=========================|
; : AB record hdl : 4 byte hdl to AB record
; |-------------------------|
; : Q element hdl : 4 byte hdl to this queue element
; |-------------------------| <----------- WDS1Start
; : WDS element1 (hdr info) : 6 bytes (2 byte length, 4 byte ptr)
; |-------------------------|
; : WDS element2 (write) : 6 bytes (points to data to write)
; |-------------------------|
; |_ WDS Termination _| 2 bytes
; | Word |
; |-------------------------|
; | async flag | 1 byte
; |=========================| <----------- WDS1stEntry
; : 7 bytes for LAP : 7 bytes (THIS IS ODD ALIGNED!)
; : header, DDP length :
; : and checksum fields :
; |-------------------------|
; |_ Destination Network _| 2 Bytes
; | Number |
; |-------------------------|
; |_ _| 2 Bytes unused in call
; | |
; |-------------------------|
; | Dest Node Address | 1 Byte
; |-------------------------|
; | | 1 Byte unused in call
; |-------------------------|
; | Dest Skt Number | 1 Byte
; |-------------------------|
; | | 1 Byte unused in call
; |-------------------------|
; | Level 2 Type | 1 Byte
; |-------------------------|
; | | 1 Byte unused in call
; |=========================|
;
; Modification History:
; 8/24/84 GRT Ready for alpha release
; 10/12/84 RFA D0 must be .long when calling GetHdlAndLock
; 12/17/84 GRT CmpEventPost changed to Cmp1EventPost
; 4/30/86 GRT Saving Q element handle in the queue element
;_______________________________________________________________________
DDPWrite PROC EXPORT
JSR RemoveHdlBlks ; check for disposable handles
LEA retAddr,A1 ; save place for ret address
MOVE.L (SP)+,(A1) ; save return address; A1 available now
MOVE.B (SP)+,D1 ; save async flag
MOVE.B (SP)+,D2 ; save checksum flag
MOVE.L (SP)+,A0 ; abRecord handle
MOVEM.L A2-A3,-(SP) ; save A2/3
_HLock ; lock abRecord down
TST D0 ; check error - MUST DO THIS!
BNE @90 ; if not zero return an error
MOVE.L (A0),A2 ; A2 -> Ptr to ABRecord
MOVE.L A0,A1 ; save another copy of handle for later
MOVE #1,abResult(A2) ; still in execution
MOVE.B #tDDPWrite,abOpCode(A2) ; put call type in record
; We are allocating an extra n bytes at the end of the IOQElement for storage
; of the misc data (see diagram)
MOVE.L #IOQElSize+WDSXtraDDPSize,D0 ; number of bytes to allocate
JSR GetHdlAndLock ; allocate the memory A0->IOQElement Hdl
BNE.S @90 ; error if didn't work
MOVE.L A0,D0 ; save handle in D0
MOVE.L (A0),A0 ; A0 -> IOQElement blk (dereferenced)
MOVE.L D0,qElHdl(A0) ; save handle in queue element
; A2 -> ABRecord. A0 -> IOQElement
MOVE.L A1,abRecHdl(A0) ; save hdl in IOQElement
LEA WDS1Start(A0),A3 ; start of our vars in IOQ blk
MOVE #16,(A3)+ ; length is always 16 for the WDS hdr
LEA WDS1stEntry(A0),A1 ; address of the WDS header entry
MOVE.L A1,(A3)+ ; A1 = WDS entry 1 ptr
MOVE ddpReqCount(A2),(A3)+ ; buffer size to write out
MOVE.L ddpDataPtr(A2),(A3)+; buffer data pointer
CLR (A3)+ ; zero means end of WDS
MOVE.B D1,(A3) ; async flag stored in IOQELBlk
; Fill in the parameters of the IO Q element
MOVE.B ddpTypeField(A2),dType(A0) ; store ddp type field
MOVE.B ddpSocket(A2),Socket(A0) ; store source socket
MOVE ddpAddrNet(A2),dDstNet(A0) ; store dest network
MOVE.B ddpAddrID(A2),dDstNodeAddr(A0); store dest node address
MOVE.B ddpAddrSkt(A2),dDstSkt(A0) ; store dest socket number
LEA WDS1Start(A0),A2 ; get pointer to WDS block
MOVE.L A2,WDSPointer(A0) ; move it into the IOQElement
MOVE.B D2,ChecksumFlag(A0) ; pass checksum flag to DDP
MOVE #WriteDDP,CSCode(A0) ; set control code
LEA DDPWrteCompletion,A2 ; A2 -> our IO completion routine
JSR DoControlCall ; make the control call
@90 MOVEM.L (SP)+,A2-A3 ; restore A2/3
MOVE.L retAddr,D2 ; get back return address
JMP ExitD0 ; and exit
;_______________________________________________________________________
;
; DDPWrteCompletion
;
; This routine is called when the IO has been completed
; A0 -> IOQElBlk
;_______________________________________________________________________
DDPWrteCompletion
MOVEM.L D0/A0-A2,-(SP) ; save registers
JSR CmpEntrance ; set up registers and unlock ab record hdl
JSR Cmp1EventPost ; if event needs to be posted, do it
MOVEM.L (SP)+,D0/A0-A2 ; restore registers
RTS
ENDPROC
EJECT
;_______________________________________________________________________
;
; DDPRead
;
; Read a packet coming in from the cable.
;
; IMPORTANT: The DDPRead call can only be used with the built in socket
; listener.
;
; The ABRecHandle is locked down until the call completes. The socket
; listener is responsible for unlocking it. (unless an error occurs in the
; read queueing, in which case its unlocked by this routine)
;
; All packets received with a long DDP header are examined to see if they
; contain a valid checksum. If so, we calculate the checksum and see if they
; match. If they don't, the retCksumErrs flag is checked to see if the user
; wants packets with checksum errors returned to him/her. If they do, we
; return the packet but with a ckSumErr error. If not, the packet is thrown
; away and the Read does not complete.
;
; FUNCTION DDPRead(abRecord : ABRecHandle; retCksumErrs : BOOLEAN;
; async : BOOLEAN): INTEGER;
;
; Stack upon entry:
;
; TOS => .LONG Return address
; .BYTE async flag
; .BYTE pascal filler
; .BYTE return checksum errs flag
; .BYTE pascal filler
; .LONG handle to record data structure
; .WORD function result code
;
; Returns: .WORD Result code
; Additional data in record structure
;
; Possible errors: Bad socket (zero or not open)
;
;
; A 14 byte read block is allocated dynamically for every read call. This
; block is linked in a FIFO queue for every active socket number . When a
; pkt is received, the first read block data in the link is read and the
; socket listener attempts to read the packet into the buffer pointed to by
; the ddpDataPtr parameter in the ABRecord.
;
; |-------------------------|
; | Link to next | 4 byte pointer link
; | read block |
; | |
; |-------------------------|
; | AB record handle | 4 byte hdl to AB record
; | |
; | |
; |-------------------------|
; | async flag | 1 byte
; |-------------------------|
; | return cksum errs flag | 1 byte
; |-------------------------|
; | read block hdl | 4 byte hdl to this read block
; | |
; | |
; |-------------------------|
;
; Modification History:
; 8/24/84 GRT Ready for alpha release
; 10/12/84 RFA Code-crunch, D0 must be .long when calling GetHdlAndLock,
; & handles being recovered wrong under error conditions
; 3/15/85 GRT RecoverHandle call added
; 4/30/86 GRT Read block handle saved in the read block
;_______________________________________________________________________
DDPRead PROC EXPORT
JSR RemoveHdlBlks ; check disposable handles
LEA returnAddr,A1 ; address of save longword
MOVE.L (SP)+,(A1) ; save return address
MOVE.B (SP)+,D2 ; save async flag
SWAP D2 ; in upper word of D2
MOVE.B (SP)+,D2 ; save checksum errs flag
MOVE.L (SP)+,A0 ; record handle
MOVEM.L D3/A2-A3,-(SP) ; save registers for later
MOVE.L A0,A3 ; save ABRecHdl in A3
_HLock ; lock abRecord down
TST D0 ; test result of the lock operation
BNE ReadExit ; if not zero return an error
; first check my socket listener table for the matching socket number
MOVE #readQErr,D0 ; assume an error
MOVE.L (A0),A2 ; A2 -> ABRecord
MOVE.B ddpSocket(A2),D3 ; get the socket number
BEQ.S Read1Exit ; zero type is invalid
JSR LookUpSkt ; check for socket number in table
BNE.S Read1Exit ; if not found then leave
; we found the socket, so get a Read Block and set it up
MOVE #1,abResult(A2) ; in execution
MOVE.B #tDDPRead,abOpCode(A2) ; put call type in
MOVEQ #rdBlkSize,D0 ; size of a read blk entry
JSR GetHdlAndLock ; get a handle to the memory
BNE.S Read1Exit ; exit if error (must clean up)
MOVE.L A0,D0 ; save handle in D0
MOVE.L (A0),A0 ; A0 -> my read block (dereference)
MOVE.L D0,rbHdl(A0) ; put handle in read block
; A0 -> my read block A2 -> AB record stuff the read blk full of data
CLR.L rbNxPtr(A0) ; zero out ptr to next element
MOVE.L A3,rbABHdl(A0) ; copy the AB rec hdl into it
MOVE.B D2,rbRetCksErr(A0) ; save the checksum flag
SWAP D2 ; get the async flag
MOVE.B D2,rbAFlag(A0) ; save the async byte flag
; must reset the pkt recvd flag before the read buffer is linked in
; SCC interrupts are being turned off while linking the block in
; A0 -> read blk, A1 -> theSocketTable (set up by LookUpSkt)
@10 CLR.B aRcvFlag(A1,D1) ; zero out the pkt recvd flag
MOVE D1,D2 ; D1,D2 has offset
LSL #2,D2 ; D2 * 4 = actual offset in table
MOVE SR,-(SP) ; save status register on stack
ORI.W #SCCLockOut,SR ; lock out the SCC interrupts <SM2> rb
LEA aRBPtr(A1,D2),A3 ; A3 -> read element entry link
@15 TST.L (A3) ; is next link empty?
BEQ.S @20 ; yes, we're at then end
MOVE.L (A3),A3 ; no, step to next link
BRA.S @15 ; and repeat
@20 MOVE.L A0, (A3) ; put Read Block at end of list
MOVE (SP)+,SR ; restore interrupt status
CLR D0 ; I guess that there are no errors!
TST.B rbAFlag(A0) ; is this an async call?
BNE.S ReadExit ; if so exit (don't unlock the handle)
; Since the call is sync, we wait until the pkt recvd flag says one has come in
; The result code will have been put in the record by the protocol handler.
@25 TST.B aRcvFlag(A1,D1) ; has a packet been received?
BEQ.S @25 ; if not, then wait
MOVE abResult(A2),D0 ; pick the result code out of the record
BRA.S ReadExit ; exit
; If an error occurred we must unlock the ABRecord block
Read1Exit MOVE D0,D1 ; save error code
MOVE.L A2,A0
_RecoverHandle ; recover handle to abRec
_HUnlock ; unlock the handle
MOVE D1,D0 ; recover error code
ReadExit MOVEM.L (SP)+,D3/A2-A3 ; restore registers
MOVE D0,(SP) ; stuff function result
MOVE.L returnAddr,A1 ; get return address
JMP (A1) ; return
EJECT
ENDPROC
EJECT
;_______________________________________________________________________
;
; DDPRdCancel
;
; Cancel a pending asynchronous DDPRead and free its associated data structures.
;
; IMPORTANT: The DDPRdCancel call can only be used with asynchronous DDPRead
; calls on a socket whose socket listener is the default.
;
; The ABRecord is unlocked, and the associated Read Block is dequeued from
; the list of pending Read requests and marked for disposal. This call can
; only be made synchronously.
;
; FUNCTION DDPRdCancel(abRecord : ABRecHandle): INTEGER;
;
; Stack upon entry:
;
; TOS => .LONG Return address
; .LONG handle to record data structure
; .WORD function result code
;
; Returns: .WORD Result code
; The abResult field of the abRecord is set to zero
;
; Possible errors: Bad socket (zero or not open)
; abRecord not found
;
; Note that by the time the Read request queue is searched for the Read Block
; pointing to the specified abRecord, a packet may arrive and satisfy the
; request. An "abRecord not found" error will then be returned. In such a
; case, the caller should check the abResult field of the abRecord to see
; if it indeed has completed. If it did, it will contain zero or a negative
; error indication. If it is equal to 1, then something is seriously wrong.
;
; Modification History:
; 10/23/84 RFA New today
; 3/15/85 GRT RecoverHandle call added
; 5/1/86 GRT changed rbABPtr to rbABHdl
; 12/10/86 SJF fixed _RecoverHandle Bug
;_______________________________________________________________________
DDPRdCancel PROC EXPORT
JSR RemoveHdlBlks ; check disposable handles
MOVEM.L (SP)+, D2/A0 ; D2 = return adr, A0 = abRec hdl
MOVEM.L D3/A2-A4, -(SP) ; save some registers
; first check my socket listener table for the matching socket number
MOVE #readQErr,D0 ; assume an error
MOVE.L (A0),A2 ; A2 -> ABRecord
MOVE.B ddpSocket(A2),D3 ; get the socket number
BEQ.S RdCnclExit ; zero is invalid
JSR LookUpSkt ; check for socket number in table
BNE.S RdCnclExit ; if not found then leave
; we found the socket, so search list of Read Blocks for one that points to abRec
MOVE #recNotFnd, D0 ; assume an error
LSL #2, D1 ; get offset into Read Blocks
LEA aRBPtr(A1,D1), A1 ; A1 = Read Block queue header
MOVE SR, -(SP) ; save old status
ORI.W #SCCLockout, SR ; disable interrupts <SM2> rb
@10 MOVE.L 0(A1), A3 ; check next element
CMP.L #0, A3 ; is there a next element?
BNE.S @20 ; yes, continue checks
MOVE (SP)+, SR ; no, we're at the end & no match!
BRA.S RdCnclExit ; restore interrupt state & return
@20 MOVE.L rbABHdl(A3),A4 ; get handle to ABRecord
CMP.L (A4),A2 ; is this the RdBlk for our abRec?
BEQ.S FoundIt ; yes!
MOVE.L A3, A1 ; no, skip down to next Read Block
BRA.S @10 ; and check it
; we found the right Read Block, so dequeue it and dispose of it
FoundIt MOVE.L (A3), (A1) ; dequeue the Read Block
MOVE (SP)+, SR ; safe now to re-enable interrupts
CLR abResult(A2) ; clear result field in abRecord
_HUnlock ; unlock the abRecord
MOVE.L A3,A0
_RecoverHandle ; recover read block handle
_HUnlock ; unlock it and dispose of it
_DisposHandle ; (hopefully clears D0 as well)
RdCnclExit MOVEM.L (SP)+, D3/A2-A4 ; restore registers
MOVE D0, (SP) ; set function result
MOVE.L D2, A0 ; restore return address
JMP (A0) ; and return
ENDPROC
Reference in New Issue View Git Blame Copy Permalink