1463 lines
56 KiB
Plaintext
1463 lines
56 KiB
Plaintext
;__________________________________________________________________________________________________
|
||
;
|
||
; File: IOPMgr.a
|
||
;
|
||
; Contains: This module provides the message passing interface between the 680XX and the
|
||
; drivers running on the IOPs. It also provides the routines to download code
|
||
; and to initialize the IOPs.
|
||
;
|
||
; NOTE: The IOP hardware is called a "Peripheral Interface Controller" or "PIC",
|
||
; which can cause some confusion with other names already in the vocabulary
|
||
; of Macintosh developers ("PICT" for example), so from the software side,
|
||
; we will call them "Input / Output Processors" or "IOP" to avoid (or create)
|
||
; confusion.
|
||
;
|
||
; Written by: Gary G. Davidian
|
||
;
|
||
; Copyright © 1987-1993 by Apple Computer, Inc. All rights reserved.
|
||
;
|
||
; Change History (most recent first):
|
||
;
|
||
; <SM9> 11/10/93 KW fix localtalk for iop based machines on STP card use forSTP601v1
|
||
; <SM8> 11/9/93 KW BTU on the STP card doesn't handle bytereads very well so
|
||
; changed IOP stuff. Changes are only made when forSTP601=TRUE
|
||
; <SM7> 8/20/93 chp References to SCCIOPBypassInt have been resolved to the more
|
||
; general and historically accepted SccDecode entry point in
|
||
; InterruptHandlers.a. It wasn't necessary to have two names for
|
||
; the same thing.
|
||
; <SM6> 11/19/92 RB When looking for iop code, look in ROM first.
|
||
; <SM5> 9/10/92 kc Fix booting problem on Eclipse. (The last change was trashing a
|
||
; register in IOPInterrupt)
|
||
; <SM4> 6/11/92 PN Roll in Cmd-Shift-Esc patch from PatchIIci.a
|
||
; <SM3> 5/21/92 kc Append "Trap" to the names of Enqueue and Dequeue to avoid name
|
||
; conflict with the glue.
|
||
; <9> 4/27/92 JSM Get rid of conditionals: isUniversal, hasIOPSCC, and hasIOPSWIM
|
||
; are always true, left in the padForOverpatch conditional for
|
||
; now.
|
||
; <8> 12/30/91 RB Made a beq instruction use the long format in order to link. The
|
||
; SCCIOPByPassInt routine cannot be accessed with a 16 bit
|
||
; reference from ROM.
|
||
; <7> 10/1/91 JSM Don’t use eclipseDebug.
|
||
; <6> 8/30/91 JSM Cleanup header.
|
||
; <5> 6/12/91 LN removed #include 'HardwareEqu.a'
|
||
; <4> 9/1/90 BG Added a check to leave Eclipses in Bypass Mode if we are running
|
||
; from RAM so that ReAnimator doesnt have its SCC communications
|
||
; path kicked out from under itself.
|
||
; <3> 1/11/90 CCH Added include of “HardwarePrivateEqu.a”.
|
||
; <2> 1/11/90 SWC Set the bypass mode bit in SCCIOPFlag if we can't put the SCC
|
||
; IOP into enhanced mode so that the serial and AppleTalk drivers
|
||
; will at least configure correctly. Changed the initialization of
|
||
; the SCC IOP SccIOCtlReg from $44 to $23 (per Bob Hollyer).
|
||
; <2.2> 12/1/89 GGD Cleaned up after BAD DOG (SWC), don't include Private.a twice,
|
||
; It was already included by Inc.Sum.a.
|
||
; <2.1> 12/1/89 SWC Oops! Forgot to INCLUDE Private.a since that's where SCCIOPFlag
|
||
; is defined.
|
||
; <2.0> 12/1/89 SWC Changed the polarity of the mode bit (0) in SCCIOPFlag so that a
|
||
; zero means we use IOP mode and a 1 means we use bypass so that
|
||
; if PRAM is reset, Zone 5 will use IOP mode as its default state.
|
||
; <1.9> 11/29/89 SWC Copied the PRAM byte controlling SCC IOP state to new low mem
|
||
; variable SCCIOPFlag ($BFE) so that we can change the PRAM value
|
||
; without hosing current IOP clients.
|
||
; <1.8> 11/2/89 GGD NEEDED FOR ZONE-5 Changed the rules pertaining to the usage of
|
||
; the IOP Ram Address Pointer register, The old convention was
|
||
; that interrupts could trash it, the new convention is that
|
||
; interrupts must save/restore it. Modified all routines to
|
||
; preserve it, and improved the cross processor data transfer
|
||
; performance by not having to mask interrupts and save/restore
|
||
; the addr reg within the xfer loop. Added Vectoring of the
|
||
; interrupt handler, and change internal calls of IOPMgr trap
|
||
; routines to jump through the OS Dispatch table, to make future
|
||
; patching easier.
|
||
; <1.7> 7/25/89 GGD Fixed interrupt masking bug in Deferred Task queueing which
|
||
; caused a circular queue if the SCC IOP interrupted the SWIM IOP
|
||
; interrupt processing at the wrong time. NEEDED FOR F19, Code
|
||
; size doesn't change.
|
||
; <1.6> 7/14/89 GGD Added conditionals around the overpatch padding so that it can
|
||
; be easily located. Turned off the Debugging VBL task. Improved
|
||
; the handling of interrupts from unknown IOPs to check for the
|
||
; SCC IOP, and pass the interrupt on to SCCIOPBypassInt if it was
|
||
; from the SCC.
|
||
; <1.5> 6/30/89 GGD Modified SCCIOPByPass to not hang waiting for a reply if the
|
||
; Send failed. Added padding in preparation for the F19 overpatch.
|
||
; <1.4> 5/29/89 GGD Added new routine SCCIOPHwInit which resets the SCC IOP, puts it
|
||
; into bypass mode, and initializes the IOControl register holdoff
|
||
; and wait delays.
|
||
; <1.3> 5/20/89 GGD Removed IOP register equates, and moved them into HardwareEqu,
|
||
; converted to use new names for registers and bits. Made the VBL
|
||
; debugging task support code conditionally assembly so that it
|
||
; can be easily turned off in the future. Re-wrote initialization
|
||
; code to make it universal.
|
||
; <1.2> 2/8/89 SGS Added support for SCC IOP
|
||
; <1.1> 11/10/88 CCH Fixed Header.
|
||
; <1.0> 11/9/88 CCH Adding to EASE.
|
||
; <1.1> 11/6/88 GGD Modified interrupt handler to allow for non-deferrable message
|
||
; handling (needed for MacsBug/ADB support). Fixed a few
|
||
; un-noticed bugs. Changed interrupt handler to service all
|
||
; interrupt sources before returning because on IoMac the SWIM IOP
|
||
; interrupt line is an edge-triggered VIA input and not a level
|
||
; triggered interrupt. Changed install IOP code to use
|
||
; _RGetResource to find the 'iopc' resource so that a system file
|
||
; can override it.
|
||
; <1.0> 10/7/88 rwh New to EASE today.
|
||
; 6/6/88 GGD Re-Written to allow queued xmt requests, and more flexible data
|
||
; structures to allow IOPs to be added dynamicaly.
|
||
; 7/31/87 GGD Created today.
|
||
;__________________________________________________________________________________________________
|
||
|
||
TITLE 'IOPmgr - Input / Output Processor Manager'
|
||
|
||
BLANKS ON
|
||
STRING ASIS
|
||
PRINT OFF
|
||
LOAD 'StandardEqu.d'
|
||
INCLUDE 'HardwarePrivateEqu.a'
|
||
INCLUDE 'UniversalEqu.a'
|
||
PRINT ON
|
||
INCLUDE 'IOPequ.a'
|
||
MACHINE MC68020
|
||
PRINT NOMDIR
|
||
|
||
macro
|
||
assert &boolExpr
|
||
if not(&Eval(&boolExpr)) then
|
||
aerror &concat('Assertion Failed - ',&boolExpr)
|
||
endif
|
||
endm
|
||
|
||
JIOPMoveData EQU ($88*4)+OSTable ; OS trap table entry for _IOPMoveData
|
||
|
||
Debugging equ 0 ; use debugging VBL task <1.3><1.6>
|
||
|
||
IOPPRAM equ $00000089 ; IOP PRAM index <1.2>
|
||
Active equ $FF ; dummy value for active
|
||
ReplyLen equ $01 ; bypass message reply length
|
||
MsgLen equ $03 ; bypass message length
|
||
KernMsg equ $01 ; kernel message box number
|
||
ByPassCmd equ $04 ; bypass command
|
||
|
||
|
||
MaxIOPRamAddr equ $7FFF ; IOP has 32KB RAM
|
||
IOPMsgPage equ $02
|
||
IOPXmtMsgBase equ $0200
|
||
IOPRcvMsgBase equ $0300
|
||
PatchReqAddr equ $021F ; Shared Loc to sync patching
|
||
IOPAliveAddr equ $031F ; IOP sets to $FF when idle
|
||
|
||
AliveVBLrate equ 127 ; 127 ticks = 2.1166666 seconds
|
||
|
||
; Message State encodings
|
||
MsgIdle equ 0 ; message buffer idle
|
||
NewMsgSent equ 1 ; new message just sent
|
||
MsgReceived equ 2 ; message received, and being processed
|
||
MsgCompleted equ 3 ; message processing complete, reply available
|
||
|
||
|
||
; Internal IOP Manager data structures (IOPmgrVars is the root pointer)
|
||
|
||
IOPMgrGlobals record {IOPInfoPtrs},increment ; miscellaneous globals used by the IOP manager
|
||
if Debugging then ; <1.3>
|
||
ds.w 1 ; force nice long word alignments
|
||
VTask ds.b vblPhase+2 ; Virtical Retrace Task info
|
||
endif ; <1.3>
|
||
DTask ds.b dtQElSize ; Deferred task Manager task info
|
||
ds.b 1 ; filler
|
||
DTaskQueued ds.b 1 ; $FF if task queued or running, $00 when done
|
||
CompleteQHdr ds.b qHeadSize ; queue of completed requests
|
||
IntHandlerPtr ds.l 1 ; [long] ptr to IOP interrupt handler
|
||
IOPInfoPtrs ds.l NumberOfIOPs ; [long] ptrs to IOP info for each IOP
|
||
|
||
IOPInfos ds.b 0 ; start of IOPInfo records for installed IOPs
|
||
|
||
GlobalsSize equ *-IOPMgrGlobals ; size of IOPMgrGlobals
|
||
endr
|
||
|
||
|
||
IOPmgr PROC EXPORT
|
||
EXPORT InitIOPMgr
|
||
EXPORT IOPInfoAccess
|
||
EXPORT IOPMsgRequest
|
||
EXPORT IOPMoveData
|
||
EXPORT IOPInterrupt
|
||
EXPORT MoveReqHandler
|
||
EXPORT SCCIOPByPass ;<1.2>
|
||
EXPORT SCCIOPHwInit ;<1.4>
|
||
IMPORT SccDecode
|
||
IMPORT EnqueueTrap
|
||
IMPORT DequeueTrap
|
||
|
||
TITLE 'IOPmgr - IOP Info Access'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: IOPInfoAccess
|
||
; Inputs: A0 - pointer to IOPAccessInfo paramater block
|
||
; Outputs: D0 - Result Code (NoErr/paramErr)
|
||
; Destroys: A0, A1, D0, D1, D2
|
||
; Calls: none
|
||
; Called by: OsTrap Dispatch Table
|
||
;
|
||
; Function: Performs various access operations on an IOP.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPAccessInfo,IOPInfo,IOPRequestInfo,IOPMoveInfo
|
||
IOPInfoAccess ; a0-a1/d1-d2 saved by OsTrap dispatch
|
||
@SavedRegs reg a2-a4/d3-d4
|
||
movem.l @SavedRegs,-(sp) ; save registers
|
||
moveq.l #NoErr,d0 ; assume success
|
||
moveq.l #0,d1 ; zero extend
|
||
|
||
move.b iaAccessKind(a0),d1 ; get the access kind
|
||
cmpi.b #iaRemoveIOP,d1 ; range check it
|
||
bhi.s @paramError ; if out of range
|
||
move.w @JumpTable(d1.w*2),d2 ; get the routine offset
|
||
|
||
move.b iaIOPNumber(a0),d1 ; get the IOP number
|
||
cmpi.b #MaxIopNum,d1 ; range check it
|
||
bhi.s @paramError ; if out of range
|
||
lea ([IOPmgrVars],d1.w*4,\ ; a1 := pointer into IOPInfoPtrs table
|
||
IOPMgrGlobals.IOPInfoPtrs),a1
|
||
|
||
jmp @JumpTable(d2.w) ; process the request
|
||
|
||
@JumpTable assert iaInstallIOP=((*-@JumpTable)/2)
|
||
dc.w @InstallIOP-@JumpTable
|
||
|
||
assert iaGetIOPInfo=((*-@JumpTable)/2)
|
||
dc.w @GetIOPInfo-@JumpTable
|
||
|
||
assert iaRemoveIOP=((*-@JumpTable)/2)
|
||
dc.w @RemoveIOP-@JumpTable
|
||
|
||
@paramError moveq.l #paramErr,d0 ; indicate failure
|
||
bra.s @Done ; restore registers and return
|
||
|
||
|
||
@GetIOPInfo move.l (a1),iaIOPInfoPtr(a0) ; return the pointer to IOP Info
|
||
@Done movem.l (sp)+,@SavedRegs ; restore registers
|
||
rts ; and return
|
||
|
||
|
||
@RemoveIOP move.l (a1),iaIOPInfoPtr(a0) ; return the old pointer to IOP Info
|
||
clr.l (a1) ; and remove it from the table
|
||
bra.s @Done ; return with success
|
||
|
||
|
||
@InstallIOP tst.l (a1) ; see if it is already installed
|
||
bne.s @paramError ; if so, it's an error
|
||
movea.l iaIOPInfoPtr(a0),a4 ; save IOPInfo pointer
|
||
move.l d1,d3 ; save IOP number
|
||
subq.l #4,sp ; allocate function result
|
||
move.l #'iopc',-(sp) ; ResType = 'iopc' (IOP code)
|
||
move.w d3,-(sp) ; theID = IOP number
|
||
move.w #MapTrue,RomMapInsert ; look in ROM first <SM6> rb
|
||
_GetResource ; top of stack <- IOP code resource handle <SM6> rb
|
||
move.l (sp)+,d0 ; d0 <- resource handle
|
||
beq.s @paramError ; error if neither found
|
||
movea.l d0,a0 ; a0 <- resource handle
|
||
movea.l (a0),a0 ; a0 <- resource pointer
|
||
|
||
; Note that this routine will destroy the old contents of the IopAddrReg, but
|
||
; since we are also destroying all of it's RAM contents, it isn't worth the
|
||
; trouble to save it.
|
||
move.w sr,-(sp) ; save interrupt priority
|
||
ori.w #HiIntMask,sr ; disable interrupts
|
||
assert IopAddrRegPtr=0
|
||
movea.l (a4)+,a2 ; a2 <- IOP Ram Address Reg pointer
|
||
assert IopDataRegPtr=(IopAddrRegPtr+4)
|
||
movea.l (a4)+,a3 ; a3 <- IOP Ram Data Reg pointer
|
||
assert IopCtlRegPtr=(IopDataRegPtr+4)
|
||
movea.l (a4),a1 ; a1 <- IOP Status/Ctl Reg pointer
|
||
move.b #resetIopRun,(a1) ; init the Status/Ctl reg, hold IOP reset
|
||
|
||
; Fill all of IOP memory with $FF
|
||
|
||
move.w #MaxIOPRamAddr,d0 ; d0 <- fill addr / loop counter
|
||
moveq.l #-1,d1 ; d1 <- fill data ($FF)
|
||
@Fill_FF_Loop
|
||
move.w d0,(a2) ; load the address register
|
||
move.b d1,(a3) ; write the data to the data reg
|
||
dbra d0,@Fill_FF_Loop ; fill all of IOP memory with $FF
|
||
|
||
; Complement all of IOP memory. $FF -> $00
|
||
|
||
move.w #MaxIOPRamAddr,d0 ; d0 <- Complement addr / loop counter
|
||
@ComplementLoop move.w d0,(a2) ; load the address register
|
||
move.b (a3),d1 ; read the data byte
|
||
not.b d1 ; complement the data
|
||
move.w d0,(a2) ; reload the address register
|
||
move.b d1,(a3) ; write the data to the data reg
|
||
dbne d0,@ComplementLoop ; Complement all of IOP memory
|
||
bne.s @InitError ; if didn't read back $FF (HW error)
|
||
|
||
; Check all of IOP memory for $00
|
||
|
||
move.w #MaxIOPRamAddr,d0 ; d0 <- Check addr / loop counter
|
||
@Check_00_Loop move.w d0,(a2) ; load the address register
|
||
move.b (a3),d1 ; read the data byte
|
||
dbne d0,@Check_00_Loop ; Check all of IOP memory for $00
|
||
bne.s @InitError ; if didn't read back $00 (HW error)
|
||
|
||
; Download and Verify the IOP code
|
||
|
||
movea.l a0,a1 ; a1 <- copy of code start
|
||
@SegLoop move.b (a0)+,d0 ; get the size of the segment
|
||
beq.s @LoadDone ; size of zero terminates segment list
|
||
move.w (a0)+,(a2) ; setup the code load address
|
||
|
||
@LoadLoop move.b (a0)+,(a3) ; download a byte
|
||
subq.b #1,d0 ; decrement the loop count
|
||
bne.s @LoadLoop ; load all of the bytes
|
||
|
||
move.b (a1)+,d0 ; get size of the segment
|
||
move.w (a1)+,(a2) ; setup the code check address
|
||
|
||
@CheckCodeLoop move.b (a3),d1 ; read a byte from the IOP
|
||
IF forSTP601v1 THEN
|
||
subq.w #3, (a2) ;ZZZ
|
||
ENDIF
|
||
cmp.b (a1)+,d1 ; compare it to what was loaded
|
||
bne.s @InitError ; if download verify error (HW error)
|
||
subq.b #1,d0 ; decrement the loop count
|
||
bne.s @CheckCodeLoop ; check all of the bytes
|
||
|
||
bra.s @SegLoop ; load the next segment
|
||
@LoadDone
|
||
|
||
; Start IOP execution
|
||
|
||
move.w #IOPAliveAddr,(a2) ; Address the ALIVE flag
|
||
clr.b (a3) ; clear ALIVE
|
||
assert IopCtlRegPtr=(IopDataRegPtr+4)
|
||
movea.l (a4),a1 ; a1 <- IOP Status/Ctl Reg pointer
|
||
move.b #setIopRun,(a1) ; release IOP reset
|
||
moveq.l #-1,d0 ; timeout loop counter
|
||
@AliveWaitLoop
|
||
move.w #IOPAliveAddr,(a2) ; Address the ALIVE flag
|
||
cmpi.b #$FF,(a3) ; check for alive
|
||
dbeq d0,@AliveWaitLoop ; loop until alive
|
||
beq.s @Alive ; error if time out (HW error)
|
||
@InitError move.w (sp)+,sr ; restore interrupt priority
|
||
bra.w @paramError ; return with error
|
||
@Alive
|
||
|
||
; Update the Max Xmt / Rcv messages supported
|
||
|
||
move.w #IOPXmtMsgBase,(a2) ; address Xmt MAX
|
||
addq.l #MaxXmt-IopCtlRegPtr,a4 ; point to MaxXmt in IOPInfo
|
||
move.b (a3),(a4)+ ; get the Xmt MAX
|
||
|
||
move.w #IOPRcvMsgBase,(a2) ; address Rcv MAX
|
||
assert MaxRcv=(MaxXmt+1)
|
||
move.b (a3),(a4) ; get the Rcv MAX
|
||
|
||
suba.w #MaxRcv,a4 ; point to start of IOPInfo record
|
||
move.l a4,([IOPmgrVars],d3.w*4,\ ; install pointer into IOPInfoPtrs table
|
||
IOPMgrGlobals.IOPInfoPtrs)
|
||
|
||
lea MoveReqInfo(a4),a0 ; a0 := pointer to IOPRequestInfo
|
||
lea irIOPNumber(a0),a1 ; a1 := initialization pointer
|
||
move.b d3,(a1)+ ; initialize the irIOPNumber field
|
||
assert irRequestKind=(irIOPNumber+1)
|
||
move.b #irWaitRcvMessage,(a1)+ ; initialize the irRequestKind field
|
||
|
||
assert irMsgNumber=(irRequestKind+1)
|
||
assert irMessageLen=(irMsgNumber+1)
|
||
assert irReplyLen=(irMessageLen+1)
|
||
assert irReqActive=(irReplyLen+1)
|
||
move.l #(1<<24)+\ ; irMsgNumber := 1
|
||
(imMoveInfoSize<<16)+\ ; irMessageLen := imMoveInfoSize
|
||
(imMoveInfoSize<<8)+\ ; irReplyLen := imMoveInfoSize
|
||
(0),(a1)+ ; irReqActive := 0
|
||
|
||
lea MoveReqBuffer(a4),a2 ; a2 := pointer to IOPMoveInfo
|
||
assert irMessagePtr=(irReqActive+1)
|
||
move.l a2,(a1)+ ; irMessagePtr := MoveReqBuffer
|
||
assert irReplyPtr=(irMessagePtr+4)
|
||
move.l a2,(a1)+ ; irReplyPtr := MoveReqBuffer
|
||
|
||
lea MoveReqHandler,a2 ; a2 := completion routine address
|
||
assert irHandler=(irReplyPtr+4)
|
||
move.l a2,(a1)+ ; irHandler := MoveReqHandler
|
||
_IOPMsgRequest ; install the message handler
|
||
|
||
move.w (sp)+,sr ; restore interrupt priority
|
||
bra.w @Done ; return with success
|
||
endwith
|
||
TITLE 'IOPmgr - IOP Message Request'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: IOPMsgRequest
|
||
; Inputs: A0 - pointer to IOPRequestInfo paramater block
|
||
; Outputs: D0 - Result Code (NoErr/paramErr)
|
||
; irReqActive - set to $FF, until request completed
|
||
; Destroys: A0, A1, D0, D1, D2
|
||
; Calls: CopyToIOP, Enqueue
|
||
; Called by: OsTrap Dispatch Table
|
||
;
|
||
; Function:
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPRequestInfo
|
||
IOPMsgRequest
|
||
@SavedRegs reg a2/a3/d3/d4 ; a0-a1/d1-d2 saved by OsTrap dispatch
|
||
movem.l @SavedRegs,-(sp) ; save registers
|
||
|
||
moveq.l #paramErr,d0 ; assume Parameter Error status
|
||
moveq.l #0,d2 ; prepare to zero extend
|
||
|
||
lea irIOPNumber(a0),a1 ; a1 <- pointer to parameters
|
||
move.b (a1)+,d2 ; d2 <- zero extended IOP number
|
||
cmpi.w #MaxIopNum,d2 ; range check the iop number
|
||
bhi.s @toParamError ; if out of range
|
||
|
||
movea.l IOPmgrVars,a2 ; get message table base
|
||
movea.l IOPMgrGlobals.IOPInfoPtrs(a2,d2.w*4),a2 ; a2 <- iop info ptr
|
||
move.l a2,d3 ; test for zero
|
||
beq.s @toParamError ; IOP isn't initialized
|
||
move.b IOPInfo.MaxXmt(a2),d3 ; d3 := max message number
|
||
|
||
assert irRequestKind=(irIOPNumber+1)
|
||
move.b (a1)+,d2 ; d2 <- zero extended request Kind
|
||
assert irSendXmtMessage=0
|
||
beq.s @CheckReqKind ; if for Xmt Msg, max is correct
|
||
move.b IOPInfo.MaxRcv(a2),d3 ; d3 := max message number
|
||
@CheckReqKind
|
||
cmpi.w #irRemoveRcvWaiter,d2 ; range check the request Kind
|
||
bhi.s @toParamError ; if out of range
|
||
move.w @JumpTable(d2.w*2),d1 ; d1 := offset to routine
|
||
|
||
assert irMsgNumber=(irRequestKind+1)
|
||
move.b (a1)+,d2 ; d2 <- zero extended Msg number
|
||
beq.s @paramError ; Message zero is reserved
|
||
cmp.b d3,d2 ; compare to max
|
||
bhi.s @paramError ; if out of range
|
||
move.w d2,d3 ; d3.w := iop state address
|
||
assert IOPMsgEntry.IOPMsgEntrySize=(1<<4)
|
||
lsl.w #4,d2 ; d2 := index into MsgTable
|
||
|
||
moveq.l #MaxIopMsgLen,d4 ; prepare to check message lengths
|
||
assert irMessageLen=(irMsgNumber+1)
|
||
cmp.b (a1)+,d4 ; check the message length
|
||
blo.s @paramError ; if out of range
|
||
assert irReplyLen=(irMessageLen+1)
|
||
cmp.b (a1)+,d4 ; check the reply length
|
||
blo.s @paramError ; if out of range
|
||
|
||
lea IOPInfo.MsgTable+IOPMsgEntry.RcvMsgInfoPtr(a2,d2.w),a3
|
||
jmp @JumpTable(d1.w) ; process the request
|
||
@JumpTable assert irSendXmtMessage=((*-@JumpTable)/2)
|
||
dc.w @SendXmtMessage-@JumpTable
|
||
|
||
assert irSendRcvReply=((*-@JumpTable)/2)
|
||
dc.w @SendRcvReply-@JumpTable
|
||
|
||
assert irWaitRcvMessage=((*-@JumpTable)/2)
|
||
dc.w @WaitRcvMessage-@JumpTable
|
||
|
||
assert irRemoveRcvWaiter=((*-@JumpTable)/2)
|
||
dc.w @RemoveRcvWaiter-@JumpTable
|
||
|
||
@toParamError
|
||
bra.s @paramError ; allow short branches
|
||
|
||
@SendXmtMessage
|
||
assert irReqActive=(irReplyLen+1)
|
||
st (a1) ; mark it as active now
|
||
lea IOPMsgEntry.XmtMsgQHdr-IOPMsgEntry.RcvMsgInfoPtr(a3),a1
|
||
move.w sr,d2 ; d2 := saved interrupt priority
|
||
ori.w #HiIntMask,sr ; no interrupts while checking queue
|
||
cmpa.l qHead(a1),a0 ; see if already the head of the queue
|
||
beq.s @SkipEnqueue ; if so, don't enqueue it
|
||
jsr EnqueueTrap ; enqueue the request
|
||
cmpa.l qHead(a1),a0 ; see if at the head of the queue
|
||
bne.s @notAtHead ; exit with request queued
|
||
@SkipEnqueue
|
||
move.w d2,sr ; restore interrupt priority
|
||
moveq.l #0,d0 ; zero extend message length
|
||
move.b irMessageLen(a0),d0 ; get the message buffer length
|
||
movea.l irMessagePtr(a0),a1 ; get the message buffer pointer
|
||
move.b #NewMsgSent,-(sp) ; save new message state
|
||
ori.w #IOPXmtMsgBase,d3 ; d3 := iop message state address
|
||
@SendAndInterrupt
|
||
move.w d3,-(sp) ; save state address for later
|
||
assert MaxIOPMsgLen=(1<<5)
|
||
lsl.b #5,d3 ; d3 := iop message address
|
||
move.l IOPInfo.IopCtlRegPtr(a2),-(sp) ; save ctl/status reg ptr for later
|
||
movea.l IOPInfo.IopDataRegPtr(a2),a3 ; (a3) := IOPRamDataReg
|
||
movea.l IOPInfo.IopAddrRegPtr(a2),a2 ; (a2) := IOPRamAddrReg
|
||
move.w (a2),-(sp) ; save the IOPRamAddrReg
|
||
move.w d3,(a2) ; setup iop ram address
|
||
bsr.w CopyToIop ; copy the message to the IOP
|
||
move.w (sp)+,d0 ; get the saved IOPRamAddrReg
|
||
movea.l (sp)+,a1 ; (a1) := IopCtlReg
|
||
move.w (sp)+,(a2) ; setup iop ram address of message state
|
||
move.b (sp)+,(a3) ; set new state
|
||
move.w d0,(a2) ; restore the IOPRamAddrReg
|
||
move.b #setIopGenInt,(a1) ; interrupt the IOP
|
||
@success moveq.l #noErr,d0 ; report success
|
||
@paramError movem.l (sp)+,@SavedRegs
|
||
rts ; all done
|
||
@notAtHead move.w d2,sr ; restore interrupt priority
|
||
bra.s @success ; return with success
|
||
|
||
@SendRcvReply
|
||
cmpa.l (a3),a0 ; see if we are the waiter
|
||
bne.s @paramError ; return with error if not
|
||
assert irReqActive=(irReplyLen+1)
|
||
tst.b (a1) ; see if the request is already active
|
||
bne.s @paramError ; return with error if active
|
||
st (a1) ; mark it as active now
|
||
moveq.l #0,d0 ; zero extend reply length
|
||
move.b irReplyLen(a0),d0 ; get the reply buffer length
|
||
movea.l irReplyPtr(a0),a1 ; get the reply buffer pointer
|
||
move.b #MsgCompleted,-(sp) ; save new message state
|
||
ori.w #IOPRcvMsgBase,d3 ; d3 := iop message state address
|
||
bra.s @SendAndInterrupt ; send the reply and interrupt the IOP
|
||
|
||
|
||
@WaitRcvMessage
|
||
tst.l (a3) ; see if waiter already exists
|
||
bne.s @paramError ; return with error if so
|
||
assert irReqActive=(irReplyLen+1)
|
||
st (a1) ; mark the request as active
|
||
move.l a0,(a3) ; setup waiter
|
||
bra.s @success ; return with success
|
||
|
||
|
||
@RemoveRcvWaiter
|
||
cmpa.l (a3),a0 ; see if we are the waiter
|
||
bne.s @paramError ; return with error if not
|
||
assert irReqActive=(irReplyLen+1)
|
||
clr.b (a1) ; mark the request as complete
|
||
clr.l (a3) ; setup waiter
|
||
bra.s @success ; return with success
|
||
|
||
endwith
|
||
TITLE 'IOPmgr - IOP Move Data'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: IOPMoveData
|
||
; Inputs: A0 - pointer to IOPMoveInfo paramater block
|
||
; Outputs: D0 - Result Code (NoErr/paramErr)
|
||
; Destroys: A0, A1, D0, D1, D2
|
||
; Calls: CopyToIOP, CopyFromIOP, CompareWithIop
|
||
; Called by: OsTrap Dispatch Table
|
||
;
|
||
; Function: Moves, or compares data between the IOP and the Host
|
||
; memories, using the parameters inthe IOPMoveInfo parameter
|
||
; block. Also has a special mode to apply patches to IOP
|
||
; memory as an atomic operation.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPMoveInfo
|
||
IOPMoveData
|
||
@SavedRegs reg a2/a3 ; a0-a1/d1-d2 saved by OsTrap dispatch
|
||
movem.l @SavedRegs,-(sp) ; save registers
|
||
moveq.l #paramErr,d0 ; assume Parameter Error status
|
||
moveq.l #0,d2 ; prepare to zero extend
|
||
|
||
assert imCopyKind=0
|
||
move.b (a0)+,d2 ; d2 <- zero extended Copy Kind
|
||
cmpi.w #imPatchIop,d2 ; range check the copy kind
|
||
bhi.s @paramError ; if out of range
|
||
move.w @JumpTable(d2.w*2),d1 ; d1 := offset to copy routine
|
||
|
||
assert imIOPNumber=(imCopyKind+1)
|
||
move.b (a0)+,d2 ; d2 <- zero extended IOP number
|
||
cmpi.w #MaxIopNum,d2 ; range check the iop number
|
||
bhi.s @paramError ; if out of range
|
||
|
||
movea.l IOPmgrVars,a1 ; get message table base
|
||
movea.l IOPMgrGlobals.IOPInfoPtrs(a1,d2.w*4),a2 ; get iop info base address
|
||
move.l a2,d2 ; test for zero
|
||
beq.s @paramError ; IOP isn't initialized
|
||
|
||
movea.l IOPInfo.IopDataRegPtr(a2),a3 ; (a3) := IOPRamDataReg
|
||
movea.l IOPInfo.IopAddrRegPtr(a2),a2 ; (a2) := IOPRamAddrReg
|
||
|
||
moveq.l #0,d0 ; zero extend to long
|
||
assert imByteCount=(imIOPNumber+1)
|
||
move.w (a0)+,d0 ; d0 := byte count
|
||
|
||
assert imHostAddr=(imByteCount+2)
|
||
movea.l (a0)+,a1 ; a1 := host buffer address
|
||
move.w (a2),-(sp) ; save the IOPRamAddrReg
|
||
assert imIopAddr=(imHostAddr+4)
|
||
move.w (a0)+,(a2) ; setup iop ram address
|
||
assert imCompRel=(imIopAddr+2) ; a0 pointer to imCompRel for CompareWithIop
|
||
jsr @JumpTable(d1.w) ; do the copy
|
||
move.w (sp)+,(a2) ; restore the IOPRamAddrReg
|
||
moveq.l #noErr,d0 ; return No Error status
|
||
|
||
@paramError
|
||
@return movem.l (sp)+,@SavedRegs ; restore registers
|
||
rts
|
||
|
||
@JumpTable assert imIopToHost=((*-@JumpTable)/2)
|
||
dc.w CopyFromIop-@JumpTable
|
||
|
||
assert imHostToIop=((*-@JumpTable)/2)
|
||
dc.w CopyToIop-@JumpTable
|
||
|
||
assert imCompare=((*-@JumpTable)/2)
|
||
dc.w CompareWithIop-@JumpTable
|
||
|
||
assert imPatchIop=((*-@JumpTable)/2)
|
||
dc.w @Patch-@JumpTable
|
||
|
||
|
||
@Patch move.w sr,d2 ; d2 := saved interrupt priority
|
||
ori.w #HiIntMask,sr ; disable interrupts
|
||
move.w #PatchReqAddr,d1 ; address of Patch Request Byte
|
||
move.w d1,(a2) ; setup the IOP address
|
||
moveq.l #NewMsgSent,d0 ; patch request state byte
|
||
move.b d0,(a3) ; issue the patch request
|
||
|
||
@PatchSync move.w d1,(a2) ; setup the IOP address
|
||
cmp.b (a3),d0 ; see if patch request was accepted
|
||
beq.s @PatchSync ; wait until it is accepted
|
||
|
||
@PatchSegLoop
|
||
move.b (a1)+,d0 ; get the size of the segment
|
||
beq.s @PatchDone ; size of zero terminates segment list
|
||
move.w (a1)+,(a2) ; setup the patch load address
|
||
|
||
@PatchLoadLoop
|
||
move.b (a1)+,(a3) ; patch a byte
|
||
subq.b #1,d0 ; decrement the loop count
|
||
bne.s @PatchLoadLoop ; load all of the bytes
|
||
bra.s @PatchSegLoop ; load the next segment
|
||
|
||
@PatchDone move.w d1,(a2) ; setup the IOP address
|
||
move.b #MsgIdle,(a3) ; tell the IOP that patching is done
|
||
move.w d2,sr ; restore interrupt priority
|
||
rts ; patching is complete
|
||
|
||
endwith
|
||
TITLE 'IOPmgr - Copy From IOP'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: CopyFromIop
|
||
; Inputs: A1 - pointer to Host RAM buffer (dest addr)
|
||
; A2 - pointer to IOPRamAddrReg
|
||
; (A2) - IOP data address (source addr)
|
||
; A3 - pointer to IOPRamDataReg
|
||
; D0 - (word) transfer byte count (zero extended to long)
|
||
; Outputs: none
|
||
; Destroys: A1, D0, D1
|
||
; Calls: none
|
||
; Called by: IOPInterrupt, IOPMoveData
|
||
;
|
||
; Function: Moves data from the IOP to the Host memory.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
CopyFromIop cmpi.w #3,d0 ; check for very short copy
|
||
bls.s @veryShort ; skip alignment if very short
|
||
move.l a1,d1 ; get the Host Address
|
||
andi.w #$0003,d1 ; check for long word alignment
|
||
beq.s @Aligned ; if no alignment needed
|
||
subq.w #4,d1 ; get byte count bias
|
||
add.w d1,d0 ; adjust the byte count
|
||
IF forSTP601v1 THEN
|
||
jmp @Aligned(d1.w*4) ; ZZZdo the alignment
|
||
ELSE
|
||
jmp @Aligned(d1.w*2) ; do the alignment
|
||
ENDIF
|
||
move.b (a3),(a1)+ ; move a byte
|
||
IF forSTP601v1 THEN
|
||
subq.w #3, (a2) ;ZZZ
|
||
move.b (a3),(a1)+ ; move a byte
|
||
subq.w #3, (a2) ;ZZZ
|
||
move.b (a3),(a1)+ ; move a byte
|
||
subq.w #3, (a2) ;ZZZ
|
||
ELSE
|
||
move.b (a3),(a1)+ ; move a byte
|
||
move.b (a3),(a1)+ ; move a byte
|
||
ENDIF
|
||
@Aligned ror.l #2,d0 ; save tail byte count in high 2 bits
|
||
moveq.l #7,d1 ; mask for starting index
|
||
and.w d0,d1 ; number of long words to move first
|
||
neg.w d1 ; negate to index backwards
|
||
lsr.w #3,d0 ; number of 32 byte blocks to move
|
||
jmp @CopyStart(d1.w*2) ; jump into the loop
|
||
|
||
@CopyLoop move.l (a3),(a1)+ ; move a 32 byte block of data....
|
||
move.l (a3),(a1)+ ; ... 4 bytes at a time
|
||
move.l (a3),(a1)+
|
||
move.l (a3),(a1)+
|
||
move.l (a3),(a1)+
|
||
move.l (a3),(a1)+
|
||
move.l (a3),(a1)+
|
||
move.l (a3),(a1)+
|
||
@CopyStart dbra d0,@CopyLoop ; loop through all of the blocks
|
||
|
||
add.l d0,d0 ; load c and n with remaining 2 bits
|
||
bcs.s @Copy2or3bytes
|
||
@Copy0or1byte
|
||
bpl.s @exit ; if no bytes left
|
||
move.b (a3),(a1) ; copy the last byte
|
||
IF forSTP601v1 THEN
|
||
subq.w #3, (a2) ;ZZZ
|
||
ENDIF
|
||
@exit rts ; all done
|
||
|
||
@veryShort roxr.l #2,d0 ; load c and n with remaining 2 bits
|
||
bcc.s @Copy0or1byte
|
||
@Copy2or3bytes
|
||
bpl.s @Copy2bytes ; if only 2 bytes left
|
||
move.b (a3),(a1)+ ; copy 1 byte, 2 still remaining
|
||
IF forSTP601v1 THEN
|
||
subq.w #3, (a2) ;ZZZ
|
||
ENDIF
|
||
@Copy2bytes move.w (a3),(a1) ; copy the last 2 bytes
|
||
IF forSTP601v1 THEN
|
||
subq.w #2, (a2) ;ZZZ
|
||
ENDIF
|
||
rts ; all done
|
||
TITLE 'IOPmgr - Copy To IOP'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: CopyToIop
|
||
; Inputs: A1 - pointer to Host RAM buffer (source addr)
|
||
; A2 - pointer to IOPRamAddrReg
|
||
; (A2) - IOP data address (dest addr)
|
||
; A3 - pointer to IOPRamDataReg
|
||
; D0 - (word) transfer byte count (zero extended to long)
|
||
; Outputs: none
|
||
; Destroys: A1, D0, D1
|
||
; Calls: none
|
||
; Called by: IOPMsgAccess, IOPMoveData
|
||
;
|
||
; Function: Moves data from the Host to the IOP memory.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
CopyToIop cmpi.w #3,d0 ; check for very short copy
|
||
bls.s @veryShort ; skip alignment if very short
|
||
move.l a1,d1 ; get the Host Address
|
||
andi.w #$0003,d1 ; check for long word alignment
|
||
beq.s @Aligned ; if no alignment needed
|
||
subq.w #4,d1 ; get byte count bias
|
||
add.w d1,d0 ; adjust the byte count
|
||
jmp @Aligned(d1.w*2) ; do the alignment
|
||
move.b (a1)+,(a3) ; move a byte
|
||
move.b (a1)+,(a3) ; move a byte
|
||
move.b (a1)+,(a3) ; move a byte
|
||
@Aligned ror.l #2,d0 ; save tail byte count in high 2 bits
|
||
moveq.l #7,d1 ; mask for starting index
|
||
and.w d0,d1 ; number of long words to move first
|
||
neg.w d1 ; negate to index backwards
|
||
lsr.w #3,d0 ; number of 32 byte blocks to move
|
||
jmp @CopyStart(d1.w*2) ; jump into the loop
|
||
|
||
@CopyLoop move.l (a1)+,(a3) ; move a 32 byte block of data....
|
||
move.l (a1)+,(a3) ; ... 4 bytes at a time
|
||
move.l (a1)+,(a3)
|
||
move.l (a1)+,(a3)
|
||
move.l (a1)+,(a3)
|
||
move.l (a1)+,(a3)
|
||
move.l (a1)+,(a3)
|
||
move.l (a1)+,(a3)
|
||
@CopyStart dbra d0,@CopyLoop ; loop through all of the blocks
|
||
|
||
add.l d0,d0 ; load c and n with remaining 2 bits
|
||
bcs.s @Copy2or3bytes
|
||
@Copy0or1byte
|
||
bpl.s @exit ; if no bytes left
|
||
move.b (a1),(a3) ; copy the last byte
|
||
@exit rts ; all done
|
||
|
||
@veryShort roxr.l #2,d0 ; load c and n with remaining 2 bits
|
||
bcc.s @Copy0or1byte
|
||
@Copy2or3bytes
|
||
bpl.s @Copy2bytes ; if only 2 bytes left
|
||
move.b (a1)+,(a3) ; copy 1 byte, 2 still remaining
|
||
@Copy2bytes move.w (a1),(a3) ; copy the last 2 bytes
|
||
rts ; all done
|
||
TITLE 'IOPmgr - Compare With IOP'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: CompareWithIop
|
||
; Inputs: A0 - pointer to imCompRel byte (result addr)
|
||
; A1 - pointer to Host RAM buffer (dest addr)
|
||
; A2 - pointer to IOPRamAddrReg
|
||
; (A2) - IOP data address (source addr)
|
||
; A3 - pointer to IOPRamDataReg
|
||
; D0 - (word) transfer byte count (zero extended to long)
|
||
; Outputs: none
|
||
; Destroys: A1, D0, D1, D2
|
||
; Calls: none
|
||
; Called by: IOPMoveData
|
||
;
|
||
; Function: Compares data from the IOP to the Host memory.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
CompareWithIop
|
||
cmpi.w #3,d0 ; check for very short compare
|
||
bls.s @Aligned ; skip alignment if very short
|
||
move.l a1,d1 ; get the Host Address
|
||
andi.w #$0003,d1 ; check for long word alignment
|
||
beq.s @Aligned ; if no alignment needed
|
||
subq.w #4,d1 ; get byte count bias
|
||
add.w d1,d0 ; adjust the byte count
|
||
not.w d1 ; setup count for DBNE
|
||
@AlignLoop move.b (a3),d2 ; get byte of data from IOP
|
||
IF forSTP601v1 THEN
|
||
subq.w #3, (a2) ;ZZZ
|
||
ENDIF
|
||
cmp.b (a1)+,d2 ; compare to HOST data
|
||
dbne d1,@AlignLoop ; loop until longword aligned
|
||
bne.s @NotEqual ; exit if didn't compare
|
||
|
||
@Aligned moveq.l #3,d1 ; mask for byte remainder
|
||
and.w d0,d1 ; number of tail bytes to compare
|
||
lsr.w #2,d0 ; number of long words to compare
|
||
beq.s @TailStart ; if no longs, start with tail
|
||
subq.w #1,d0 ; adjust loop count for DBNE
|
||
@CmpLoop move.l (a3),d2 ; get long word of data from IOP
|
||
cmp.l (a1)+,d2 ; compare to HOST data
|
||
dbne d0,@CmpLoop ; loop through all long words
|
||
bra.s @TailStart ; then compare the remaining bytes
|
||
|
||
@TailLoop move.b (a3),d2 ; get byte of data from IOP
|
||
IF forSTP601v1 THEN
|
||
subq.w #3, (a2) ;ZZZ
|
||
ENDIF
|
||
cmp.b (a1)+,d2 ; compare to HOST data
|
||
@TailStart dbne d1,@TailLoop ; loop through all remaining bytes
|
||
|
||
@NotEqual sne.b (a0) ; return -1 if IOP < HOST
|
||
bls.s @Exit ; return 0 if IOP = HOST
|
||
neg.b (a0) ; return +1 if IOP > HOST
|
||
@Exit rts
|
||
TITLE 'IOPmgr - IOP Interrupt'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: IOPInterrupt
|
||
; Inputs: D0{31…24} - flags indicating non-deferrable XMT messages
|
||
; D0{23…16} - flags indicating non-deferrable RCV messages
|
||
; D0{15…8} - must be zero
|
||
; D0{7…0} - IOP number of IOP requesting the interrupt
|
||
; Outputs: none
|
||
; Destroys: A0, A1, A2, A3, D0, D1, D2, D3
|
||
; Calls: DTInstall, IOP message Handler
|
||
; Called by: System interrupt handler
|
||
;
|
||
; Function: Services interrupts from the IOPs. Acknowledges the messages,
|
||
; and calls the message handlers directly, or schedules a
|
||
; deferred task manager task to call them, if they were
|
||
; deferrable handlers. If the interrupt was a Bypass Interrupt
|
||
; Request, it will reset the interrupt and JMP to the external
|
||
; label IOPBypassInterrupt passing the IOP number that generated
|
||
; the interrupt in register D0.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPMgrGlobals,IOPInfo
|
||
|
||
IOPInterrupt ; a0-a3/d0-d3 saved by int handler
|
||
movea.l IOPmgrVars,a0 ; point to globals
|
||
jmp ([IntHandlerPtr,a0]) ; jump through the patch vector
|
||
vIOPInterrupt
|
||
move.l IOPInfoPtrs(a0,d0.w*4),d1
|
||
beq.s @noIop ; ignore if IOP doesn't exist
|
||
movea.l d1,a0 ; a0 := pointer to IOPInfo
|
||
assert IopAddrRegPtr=0
|
||
movea.l (a0)+,a2 ; a2 := pointer to IOP Ram addr reg
|
||
assert IopDataRegPtr=(IopAddrRegPtr+4)
|
||
movea.l (a0)+,a3 ; a3 := pointer to IOP Ram data reg
|
||
move.w sr,d2 ; save old interrupt level
|
||
move.b d0,d2 ; save the IOP number, overwrite saved ccr
|
||
move.l a0,-(sp) ; save reg for msg handler to restore
|
||
@checkAgain
|
||
assert IopCtlRegPtr=(IopDataRegPtr+4)
|
||
movea.l (a0)+,a1 ; a1 := pointer to IOP control reg
|
||
move.b (a1),d1 ; get the control register
|
||
lsr.b #iopInt0Active+1,d1 ; test INT0 (xmt MessageCompleted)
|
||
bcs.s @xmtComp ; handle INT0
|
||
lsr.b #iopInt1Active-iopInt0Active,d1 ; test INT1 (rcv NewMessageSent)
|
||
bcs.s @rcvNew ; handle INT1
|
||
lsr.b #iopBypassIntReq-iopInt1Active,d1 ; test BypassIntReq
|
||
bcs.s @bypassInt ; all done if not bypass interrupt
|
||
@IntHandled move.w d2,sr ; restore interrupt level
|
||
addq.l #4,sp ; pop saved a0
|
||
lsr.l #8,d0 ; test the flags
|
||
bne.w @RunNonDeferrable ; if non-deferrables, go check for and run them
|
||
rts ; return from the interrupt <1.6>
|
||
|
||
@noIop cmpi.w #SccIopNum,d0 ; see if it was from the SCC <1.6>
|
||
beq.l SccDecode ; if so, pass it on to the Bypass handler <1.6> <8> rb
|
||
rts ; return from the interrupt <1.6>
|
||
|
||
|
||
@bypassInt
|
||
assert BypassHandler=(IopCtlRegPtr+4)
|
||
move.l (a0),d1 ; get address of bypass int handler
|
||
beq.s @IntHandled ; no bypass handler, not much we can do
|
||
move.w d2,sr ; restore interrupt level
|
||
move.l d0,(sp) ; save the flags/iop number
|
||
movea.l d1,a0 ; setup handler address
|
||
jsr (a0) ; call the ByPass interrupt handler
|
||
move.l (sp)+,d0 ; restore flags/IOP number
|
||
bra.s IOPInterrupt ; check again for other interrupts
|
||
|
||
|
||
@rcvNew move.b #clrIopInt1,(a1) ; clear the interrupt
|
||
move.w #(MsgReceived<<8)+\ ; new state
|
||
(NewMsgSent<<0),d1 ; state to search for
|
||
move.w #IOPRcvMsgBase+1,d3 ; IOP address to start search at
|
||
lea @rcvFound,a1 ; a1 := rcv found routine
|
||
assert BypassHandler=(IopCtlRegPtr+4)
|
||
move.b MaxRcv-BypassHandler(a0),d0 ; get message count
|
||
adda.w #MsgTable-BypassHandler,a0 ; point before the first message
|
||
move.w (a2),-(sp) ; save the IOPRamAddrReg
|
||
bra.s @SearchStart ; start searching the message states
|
||
|
||
@xmtComp move.b #clrIopInt0,(a1) ; clear the interrupt
|
||
moveq.l #(MsgIdle<<8)+\ ; new state
|
||
(MsgCompleted<<0),d1 ; state to search for
|
||
move.w #IOPXmtMsgBase+1,d3 ; IOP address to start search at
|
||
lea @xmtFound,a1 ; a1 := xmt done routine
|
||
assert BypassHandler=(IopCtlRegPtr+4)
|
||
move.b MaxXmt-BypassHandler(a0),d0 ; get message count
|
||
adda.w #MsgTable-BypassHandler,a0 ; point before the first message
|
||
move.w (a2),-(sp) ; save the IOPRamAddrReg
|
||
bra.s @SearchStart ; start searching the message states
|
||
|
||
@searchLoop adda.w #IOPMsgEntry.IOPMsgEntrySize,a0 ; point to next message info
|
||
cmp.b (a3),d1 ; check for state match
|
||
IF forSTP601v1 THEN
|
||
move ccr, -(sp) ;ZZZ
|
||
subq.w #3, (a2) ;ZZZ
|
||
move (sp)+, ccr ;ZZZ
|
||
ENDIF
|
||
dbeq d0,@searchLoop ; loop until match or end of list
|
||
bne.s @searchDone ; if all message states checked
|
||
|
||
move.w (a2),d3 ; get the address pointer
|
||
@MsgRegs reg a0/a1/d0/d1/d2/d3 ; registers to save when servicing message
|
||
movem.l @MsgRegs,-(sp) ; save the registers
|
||
subq.w #1,d3 ; point to the message state that was found
|
||
move.w d3,(a2) ; re-load ram address pointer
|
||
lsr.w #8,d1 ; get the new message state
|
||
move.b d1,(a3) ; set the new message state
|
||
move.w d2,sr ; give higher priority ints a chance
|
||
jsr (a1) ; call the xmt/rcv found routine
|
||
movem.l (sp)+,@MsgRegs ; restore the registers
|
||
@SearchStart
|
||
ori.w #HiIntMask,sr ; disable all interrupts
|
||
move.w d3,(a2) ; restore the address pointer
|
||
dbra d0,@searchLoop ; loop until end of list
|
||
|
||
@searchDone move.w (sp)+,(a2) ; restore the IOPRamAddrReg
|
||
clr.w d0 ; setup for zero extended IOP number
|
||
move.b d2,d0 ; flags in high word, IOP number in low word
|
||
movea.l IOPmgrVars,a1
|
||
tst.b DTaskQueued(a1)
|
||
bne.s @toCkAgain ; if already queued, just return
|
||
tst.l CompleteQHdr+qHead(a1)
|
||
beq.s @toCkAgain ; if nothing queued, just return
|
||
st DTaskQueued(a1)
|
||
lea DTask(a1),a0
|
||
@DTaskRegs reg a2/d0/d2 ; regs to save when queueing a deferred task
|
||
movem.l @DTaskRegs,-(sp) ; save regs
|
||
jsr ([jDTInstall]) ; queue the deferred task
|
||
movem.l (sp)+,@DTaskRegs ; restore regs
|
||
@toCkAgain move.w d2,sr ; give higher priority ints a chance <1.7>
|
||
movea.l (sp),a0 ; setup a0 for entry at @checkAgain
|
||
bra.w @checkAgain ; return from the interrupt <1.7>
|
||
|
||
@XmtFound lea IOPMsgEntry.XmtMsgQHdr+qHead(a0),a1 ; point to request info
|
||
move.l (a1),d1 ; get request info
|
||
beq.s @empty ; if no handler installed
|
||
move.l a1,-(sp) ; save message entry pointer
|
||
movea.l d1,a0 ; setup request info address
|
||
subq.l #qHead,a1 ; point to queue header
|
||
jsr DequeueTrap ; remove it from the msg queue
|
||
movea.l IOPRequestInfo.irReplyPtr(a0),a1 ; get the buffer address
|
||
moveq.l #0,d0 ; zero extend the reply byte count
|
||
move.b IOPRequestInfo.irReplyLen(a0),d0 ; get the byte count
|
||
bsr.s @CopyAndQueue ; read the reply and queue it
|
||
movea.l (sp)+,a1 ; point to message queue head
|
||
move.l (a1),d1 ; get head of queue
|
||
beq.s @empty ; if empty, do nothing
|
||
movea.l d1,a0 ; setup to send the queued message
|
||
jmp ([JIOPMsgRequest]) ; send the next message and return
|
||
@empty rts
|
||
|
||
@RcvFound move.l IOPMsgEntry.RcvMsgInfoPtr(a0),d1 ; get request info
|
||
beq.s @empty ; if no handler installed
|
||
movea.l d1,a0 ; setup request info address
|
||
movea.l IOPRequestInfo.irMessagePtr(a0),a1 ; get the buffer address
|
||
moveq.l #0,d0 ; zero extend the message byte count
|
||
move.b IOPRequestInfo.irMessageLen(a0),d0 ; get the byte count
|
||
@CopyAndQueue
|
||
beq.s @CopyDone ; if no message data to copy
|
||
move.w d3,d1 ; get copy of message state address
|
||
assert MaxIOPMsgLen=(1<<5)
|
||
lsl.b #5,d1 ; convert to message data address
|
||
move.w d1,(a2) ; point to the message
|
||
bsr.w CopyFromIop ; read the message
|
||
@CopyDone movea.l IOPmgrVars,a1 ; point to globals
|
||
adda.w #CompleteQHdr,a1 ; point to the completion queue
|
||
tst.l IOPRequestInfo.irHandler(a0) ; check the handler address
|
||
beq.s @NoHandler ; if no handler, don't enqueue it
|
||
jmp EnqueueTrap ; enqueue the completed request, and return
|
||
|
||
@NoHandler clr.b IOPRequestInfo.irReqActive(a0) ; indicate that it is done
|
||
rts ; return
|
||
|
||
|
||
@RunNonDeferrable
|
||
move.l d0,d3 ; save the flags
|
||
lsr.l #8,d3 ; get flags into low 2 bytes
|
||
movea.l IOPmgrVars,a1 ; get the globals
|
||
lea CompleteQHdr(a1),a1 ; point to the completion queue
|
||
lea qHead-qLink(a1),a0 ; point to ptr to first element
|
||
ori.w #HiIntMask,sr ; disable all ints while touching queue
|
||
@RunLoop move.l qLink(a0),d0 ; get ptr to next element
|
||
beq.s @RunDone ; if end of queue, we're done
|
||
movea.l d0,a0 ; setup queue element pointer
|
||
cmp.b IOPRequestInfo.irIOPNumber(a0),d2 ; is it for this IOP
|
||
bne.s @RunLoop ; if not, go on to next one
|
||
move.b IOPRequestInfo.irMsgNumber(a0),d0 ; get the message number
|
||
assert IOPRequestInfo.irSendXmtMessage=0
|
||
tst.b IOPRequestInfo.irRequestKind(a0) ; test for xmt/rcv
|
||
bne.s @ChkMsgNum ; if receive, bit number is correct
|
||
addq.b #8,d0 ; point to next byte for xmt
|
||
@ChkMsgNum btst.l d0,d3 ; see if this msg is non-deferrable
|
||
beq.s @RunLoop ; if not, go on to next one
|
||
jsr DequeueTrap ; remove it from the queue
|
||
move.l a0,-(sp) ; remember the address
|
||
bsr.s @RunLoop ; check the next one (using recursion)
|
||
|
||
movea.l (sp)+,a0 ; get the queue element address
|
||
clr.b IOPRequestInfo.irReqActive(a0) ; indicate that it is done
|
||
move.l IOPRequestInfo.irHandler(a0),d0 ; get the handler address
|
||
beq.s @RunRTS ; if no handler, don't try to call it
|
||
movea.l d0,a1 ; get handler address
|
||
jmp (a1) ; run the handler (may trash a0-a3/d0-d3)
|
||
|
||
@RunDone move.w d2,sr ; restore interrupt level
|
||
@RunRTS rts ; search done, now let them run
|
||
|
||
endwith
|
||
TITLE 'IOPmgr - IOP Deferred Task'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: IOPDefTask
|
||
; Inputs: none
|
||
; Outputs: none
|
||
; Destroys: A0, A1, D0
|
||
; Calls: IOP message Handler
|
||
; Called by: Deferred task manager
|
||
;
|
||
; Function: Calls the message handlers for the deferrable messages
|
||
; that were marked and acknowledged by the IOP interrupt
|
||
; handler.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
CallCompHandler
|
||
move.w (sp)+,sr ; restore interrupts
|
||
movea.l d0,a0 ; setup element to dequeue
|
||
jsr DequeueTrap ; dequeue the element
|
||
clr.b IOPRequestInfo.irReqActive(a0) ; indicate that it is done
|
||
move.l IOPRequestInfo.irHandler(a0),d0 ; get the handler address
|
||
beq.s IOPDefTask ; if no handler, don't try to call it
|
||
|
||
move.l a1,-(sp) ; save queue pointer across call to handler
|
||
movea.l d0,a1 ; get handler address
|
||
jsr (a1) ; call the handler (may trash a0-a3/d0-d3)
|
||
movea.l (sp)+,a1 ; restore queue pointer
|
||
|
||
IOPDefTask ; Enters HERE ; a0-a3/d0-d3 saved by int handler
|
||
; a1 := pointer to CompleteQHdr
|
||
move.w sr,-(sp) ; save interrupt priority
|
||
ori.w #HiIntMask,sr ; disable interrupts
|
||
move.l qHead(a1),d0 ; read the head of the queue
|
||
bne.s CallCompHandler ; if not empty, dequeue and call it
|
||
|
||
assert IOPMgrGlobals.DTaskQueued=(IOPMgrGlobals.CompleteQHdr-1)
|
||
clr.b -(a1) ; indicate that the task is done
|
||
move.w (sp)+,sr ; restore interrupts
|
||
rts ; all done
|
||
if Debugging then ; <1.3>
|
||
TITLE 'IOPmgr - IOP VBL Task'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: IOPVblTask
|
||
; Inputs: none
|
||
; Outputs: none
|
||
; Destroys: A0, A1, A2, D0
|
||
; Calls: none
|
||
; Called by: Vertical Retrace Manager
|
||
;
|
||
; Function: Tests and clears the Alive flag on each IOP, and crashes
|
||
; if any IOP was not Alive
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPMgrGlobals,IOPInfo
|
||
IOPVblTask ; a0-a3/d0-d3 saved by int handler
|
||
movea.l IOPmgrVars,a0 ; get globals
|
||
move.w #AliveVBLrate,VTask+vblCount(a0) ; re-initialize the count
|
||
move.w sr,-(sp) ; save interrupt priority
|
||
ori.w #HiIntMask,sr ; disable interrupts
|
||
moveq.l #NumberOfIOPs-1,d0 ; loop counter
|
||
@PollLoop movea.l (a0)+,a1 ; a1 := pointer to IOPInfo
|
||
move.l a1,d1 ; test for zero
|
||
beq.s @Next ; skip if IOP doesn't exist
|
||
assert IopAddrRegPtr=0
|
||
movea.l (a1)+,a2 ; a2 := IopAddrRegPtr
|
||
assert IopDataRegPtr=(IopAddrRegPtr+4)
|
||
movea.l (a1)+,a1 ; a1 := IopDataRegPtr
|
||
move.w (a2),-(sp) ; save the IOPRamAddrReg
|
||
move.w #IOPAliveAddr,(a2) ; setup the IOP Ram Address
|
||
cmpi.b #$FF,(a1) ; IOP sets it to $FF when Idle
|
||
beq.s @Alive ; if alive and well
|
||
bsr.s IOPisDead ; crash if dead
|
||
@Alive move.w #IOPAliveAddr,(a2) ; setup the IOP Ram Address
|
||
clr.b (a1) ; we set it to $00 after testing it
|
||
move.w (sp)+,(a2) ; restore the IOPRamAddrReg
|
||
@Next dbra d0,@PollLoop ; poll the next IOP
|
||
move.w (sp)+,sr ; restore interrupt priority
|
||
rts ; return
|
||
|
||
|
||
IOPisDead move.w #dsSysErr,d0 ; Sorry, a system error occurred
|
||
_SysError ; crash
|
||
bra.s IOPisDead ; IOP failure, crash and burn
|
||
|
||
endwith
|
||
endif ; <1.3>
|
||
TITLE 'IOPmgr - Move Request Handler'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: MoveReqHandler
|
||
; Inputs: A0 - pointer to IOPRequestInfo
|
||
; Outputs: none
|
||
; Destroys: A0-A2/D0-D2
|
||
; Calls: IOPMsgRequest, IOPMoveData
|
||
; Called by: IOP interrupt handler
|
||
;
|
||
; Function: Handles Data Movement requests issued by drivers on the IOPs.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPRequestInfo,IOPMoveInfo
|
||
MoveReqHandler ; a0-a3/d0-d3 saved by Interrupt Handler
|
||
|
||
; The message that the IOP sent looks very much like a IOPMoveInfo parameter
|
||
; block, the message from the IOP was read directly into the IOPMoveInfo block.
|
||
|
||
movea.l a0,a2 ; save pointer to IOPRequestInfo for later
|
||
movea.l irMessagePtr(a0),a0 ; message buffer is IOPMoveInfo request block
|
||
|
||
; The IOP number field is the only field that was not in the message from
|
||
; the IOP, so just copy it from the IOPAccessInfo, and then issue the Move.
|
||
|
||
move.b irIOPNumber(a2),imIOPNumber(a0) ; fill in the IOP number
|
||
jsr ([JIOPMoveData]) ; Perform the Move Request
|
||
|
||
; Send the result from IOPMoveData back as the reply.
|
||
; Send the Message Completed interrupt to the IOP, and return.
|
||
|
||
movea.l a2,a0 ; a0 <- IOPRequestInfo
|
||
move.b #irSendRcvReply,irRequestKind(a0)
|
||
jmp ([JIOPMsgRequest]) ; tell IOP that Message Completed and return
|
||
|
||
endwith
|
||
TITLE 'IOPmgr - Initialize IOP Manager'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: jsr InitIOPMgr
|
||
; Inputs: none
|
||
; Outputs: none
|
||
; Destroys: none
|
||
; Calls: none
|
||
; Called by: Start Manager
|
||
;
|
||
; Function: Initializes the IOPs, downloads their code, and starts them
|
||
; running. Allocates and initializes the IOPMgr global data
|
||
; structures.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPMgrGlobals,IOPAccessInfo,IOPInfo
|
||
InitIOPMgr
|
||
@SavedRegs reg a0-a3/d0
|
||
movem.l @SavedRegs,-(sp) ; save registers
|
||
|
||
move.w sr,-(sp) ; save interrupt priority
|
||
ori.w #HiIntMask,sr ; disable interrupts
|
||
|
||
moveq.l #0,d0 ; amount of space for IOPInfos
|
||
|
||
TestFor SCCIOPExists ; see if we have an SCC IOP
|
||
beq.s @noSCCIOP ; if not, don't allocate space for it
|
||
|
||
addi.w #IOPInfoSize,d0 ; allocate space for it
|
||
@noSCCIOP
|
||
|
||
TestFor SWIMIOPExists ; see if we have an SWIM IOP
|
||
beq.s @noSWIMIOP ; if not, don't allocate space for it
|
||
|
||
addi.w #IOPInfoSize,d0 ; allocate space for it
|
||
@noSWIMIOP
|
||
|
||
tst.w d0 ; are there any IOPs
|
||
beq.s @noIOPs ; if not, exit
|
||
|
||
addi.w #GlobalsSize,d0 ; d0 <- data structure size
|
||
_NewPtr ,SYS,CLEAR ; allocate and clear the structure
|
||
|
||
lea -IOPMgrGlobals(a0),a2 ; Globals are negative to the pointer
|
||
move.l a2,IOPmgrVars ; initialize the Pointer
|
||
if Debugging then ; <1.3>
|
||
|
||
; Install the VBL task to look for dead IOPs
|
||
|
||
lea VTask(a2),a0 ; a0 <- VBL task
|
||
move.w #vType,qType(a0) ; initialize qType field
|
||
move.w #AliveVBLrate,vblCount(a0) ; initialize the count
|
||
lea IOPVblTask,a1 ; get the task address
|
||
move.l a1,vblAddr(a0) ; initialize vblAddr field
|
||
_VInstall ; install the VBL task
|
||
endif ; <1.3>
|
||
|
||
; Setup the deferred task manager data structure
|
||
|
||
move.w #dtQType,DTask+qType(a2) ; Initialize DTask.qType
|
||
lea IOPDefTask,a0 ; a0 <- addr of IOPDefTask
|
||
move.l a0,DTask+dtAddr(a2) ; Initialize DTask.dtAddr
|
||
lea CompleteQHdr(a2),a0 ; a0 <- completion queue header
|
||
move.l a0,DTask+dtParm(a2) ; DTask.dtParm (loaded into A1 for DTask)
|
||
|
||
; Setup the Interrupt Handler Pointer
|
||
|
||
lea vIOPInterrupt,a0 ; point to the handler
|
||
move.l a0,IntHandlerPtr(a2) ; initialize the data structure
|
||
|
||
; Install and initialize the IOPs
|
||
|
||
lea IOPInfos(a2),a2 ; point to start of IOPInfo records
|
||
|
||
TestFor SCCIOPExists ; see if we have an SCC IOP
|
||
beq.s @SCCIOPdone ; if not, don't install it
|
||
|
||
moveq.l #(iaInstallIOP<<8)|\
|
||
SccIopNum,d0 ; get the IOP number and access kind
|
||
movea.l SCCrd,a1 ; get the base address
|
||
lea SccDecode,a3 ; get the bypass interrupt handler address
|
||
bsr.s @InstallIOP ; install the SCC IOP
|
||
@SCCIOPdone
|
||
|
||
TestFor SWIMIOPExists ; see if we have an SWIM IOP
|
||
beq.s @SWIMIOPdone ; if not, don't install it
|
||
|
||
moveq.l #(iaInstallIOP<<8)|\
|
||
SwimIopNum,d0 ; get the IOP number and access kind
|
||
movea.l IWM,a1 ; get the base address
|
||
suba.l a3,a3 ; no bypass interrupt handler
|
||
bsr.s @InstallIOP ; install the SWIM IOP
|
||
@SWIMIOPdone
|
||
|
||
@Done move.w (sp)+,sr ; restore interrupts
|
||
movem.l (sp)+,@SavedRegs ; restore registers
|
||
rts ; all done
|
||
|
||
@noIOPs lea @traps,a1 ; point to the list
|
||
move.w (a1)+,d0 ; get the _Unimplemented trap
|
||
_GetTrapAddress ,newTool ; get address of unimplemented trap
|
||
@trapLoop move.w (a1)+,d0 ; get next trap to un-implement
|
||
beq.s @Done ; traps disabled, exit
|
||
_SetTrapAddress ,newOS ; un-implement the trap
|
||
bra.s @trapLoop ; loop through the table
|
||
|
||
@traps _Unimplemented
|
||
_IOPInfoAccess
|
||
_IOPMsgRequest
|
||
_IOPMoveData
|
||
dc.w 0 ; end of list
|
||
|
||
@InstallIOP movea.l a2,a0 ; a0 <- IOPInfoRecord
|
||
assert iaIOPInfoPtr=(iaAccessInfoSize-4)
|
||
move.l a0,-(sp) ; setup IOP info pointer
|
||
clr.w -(sp) ; clear reserved field
|
||
assert iaIOPNumber=(iaIOPInfoPtr-3)
|
||
assert iaAccessKind=(iaIOPInfoPtr-4)
|
||
move.w d0,-(sp) ; setup the IOP number and access kind
|
||
|
||
assert IopAddrRegPtr=0
|
||
lea iopRamAddr(a1),a1 ; point to the address register
|
||
move.l a1,(a0)+ ; setup IopAddrRegPtr
|
||
|
||
assert IopDataRegPtr=(IopAddrRegPtr+4)
|
||
addq.w #iopRamData-iopRamAddr,a1 ; point to the data register
|
||
move.l a1,(a0)+ ; setup IopDataRegPtr
|
||
|
||
assert IopCtlRegPtr=(IopDataRegPtr+4)
|
||
subq.w #iopRamData-iopStatCtl,a1 ; point to the status/control register
|
||
move.l a1,(a0)+ ; setup IopCtlRegPtr
|
||
|
||
assert BypassHandler=(IopCtlRegPtr+4)
|
||
move.l a3,(a0)+ ; setup BypassHandler
|
||
|
||
movea.l sp,a0 ; a0 <- IOPAccessInfo record
|
||
_IOPInfoAccess ; install the IOP
|
||
addq.l #iaAccessInfoSize,sp ; de-allocate the IOPAccessInfo record
|
||
adda.w #IOPInfoSize,a2 ; point to next IOPInfo record
|
||
rts ; go on to the next IOP
|
||
|
||
endwith
|
||
TITLE 'IOPmgr - Set SCC IOP ByPass mode'
|
||
|
||
;_______________________________________________________________________
|
||
;
|
||
; Routine: jsr SCCIOPByPass <1.2>
|
||
; Inputs: none
|
||
; Outputs: none
|
||
; Destroys: none
|
||
; Calls: none
|
||
; Called by: InitIO
|
||
;
|
||
; Function: Checks to see if the SCC IOP should be placed in bypass
|
||
; and set it accordingly.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
with IOPMgrGlobals,IOPAccessInfo,IOPInfo,IOPRequestInfo
|
||
|
||
SCCIOPByPass
|
||
|
||
;
|
||
; Check PRAM to see if we should put the SCC IOP into enhanced communications mode.
|
||
;
|
||
; Bit 0 = 1 -> leave in bypass <2>
|
||
; = 0 -> put in enhanced communications mode <2>
|
||
;
|
||
|
||
@SavedRegs reg a0-a2/d0
|
||
movem.l @SavedRegs,-(sp) ; save registers
|
||
move.l #((01<<16)|IOPPRAM), d0 ; index and number of bytes to get
|
||
clr.b -(sp) ; make room for data
|
||
movea.l sp, a0 ; a0 points to data buffer
|
||
_ReadXPRAM
|
||
|
||
MOVE.B (SP),SCCIOPFlag ; save the PRAM byte in low mem <1.9>
|
||
|
||
moveq.l #$01,d0 ; check the bypass bit
|
||
and.b (sp)+, d0 ; get the PRAM value
|
||
bne.s @Done ; branch if SET, stay in bypass mode <2.0>
|
||
|
||
clr.l -(sp) ; reply buffer
|
||
clr.l -(sp) ; [long] -> Completion Routine Address (Nil)
|
||
pea 4(sp) ; [long] -> Reply Buffer Address
|
||
pea @ByPassMsg ; [long] -> Message Buffer Address
|
||
move.l #((Active<<0)+\ ; [byte] -> Request active
|
||
(ReplyLen<<8)+\ ; [byte] -> Reply Length
|
||
(MsgLen<<16)+\ ; [byte] -> Message Length
|
||
(KernMsg<<24)), -(sp) ; [byte] -> Message Number
|
||
move.l #((irSendXmtMessage<<0)+\ ; [byte] -> kind of request to perform
|
||
(SccIopNum<<8)), -(sp) ; [byte] -> IOP Number for SCC
|
||
; [word] -> queue type
|
||
clr.l -(sp) ; [long] -> link to next queue element
|
||
movea.l sp, a0
|
||
_IOPMsgRequest
|
||
bne.s @FlagBypass ; if send failed, don't wait <1.5><2>
|
||
|
||
@Sync_Loop tst.b irReqActive(sp) ; make this a sync call
|
||
bne.s @Sync_Loop
|
||
|
||
@waitDone adda.w #(irReqInfoSize+4), sp ; adjust stack <1.5>
|
||
|
||
@Done movem.l (sp)+,@SavedRegs ; restore registers
|
||
rts
|
||
|
||
@FlagBypass BSET #0,SCCIOPFlag ;set bit 0=1 to flag bypass mode <2>
|
||
BRA.S @waitDone ; <2>
|
||
|
||
@ByPassMsg DC.B ByPassCmd, 0, $ff ; Turn bypass on or off
|
||
align 2
|
||
endwith
|
||
TITLE 'IOPmgr - Initialize SCC IOP Hardware'
|
||
|
||
;_______________________________________________________________________ <1.4>
|
||
;
|
||
; Routine: jsr SCCIOPHwInit
|
||
; Inputs: none
|
||
; Outputs: none
|
||
; Destroys: A0, A1, D0
|
||
; Calls: none
|
||
; Called by: Start Manager
|
||
;
|
||
; Function: Initializes the SCC IOP, so that the SCC can be used in ByPass
|
||
; mode and has the correct timing to that when TimeSCCDB is
|
||
; computed it will be correct.
|
||
;
|
||
;_______________________________________________________________________
|
||
|
||
|
||
SCCIOPHwInit
|
||
movea.l SCCRd,a1 ; a1 <- IOP Base
|
||
move.b #resetIopRun,iopStatCtl(a1) ; init the Status/Ctl reg, hold IOP reset
|
||
|
||
; Download the IOP code
|
||
|
||
lea SCCIOPInitCode,a0 ; a0 <- start of IOP code (in this ROM)
|
||
move.w (a0)+,d0 ; get the size code (-1 for DBRA)
|
||
move.w (a0)+,iopRamAddr(a1); setup the code load address
|
||
|
||
@LoadLoop move.b (a0)+,iopRamData(a1); download a byte
|
||
dbra d0,@LoadLoop ; load all of the bytes
|
||
|
||
; Start IOP execution
|
||
|
||
move.b #setIopRun,iopStatCtl(a1) ; release IOP reset (let it rip!)
|
||
lsr.w #6,d0 ; $FFFF -> $03FF -> loop 1024 times
|
||
@wait dbra d0,@wait ; delay a bit while IOP initializes
|
||
rts ; all done
|
||
|
||
; 6502 code to throw SCC IOP into bypass mode
|
||
SCCIOPInitCode
|
||
dc.w (@end-@Start)-1 ; size of the code (in bytes), -1 for DBRA
|
||
dc.w $8000-(@end-@Start) ; (word) load address
|
||
@start ; code starts here
|
||
dc.b $A9,$81 ; 7FEE: lda #1*DEBUG+0*SCCISM+1*BYPASS
|
||
dc.b $8D,$30,$F0 ; 7FF0: sta SCCControlReg
|
||
dc.b $A9,$23 ; 7FF3: lda #SccIOCtlReg <2>
|
||
dc.b $8D,$31,$F0 ; 7FF5: sta IOControlReg
|
||
dc.b $80,$FE ; 7FF8: bra $7FF8
|
||
|
||
dc.b $EE,$7F ; 7FFA 7FEE Non-Maskable Interrupt vector
|
||
dc.b $EE,$7F ; 7FFC 7FEE Processor reset vector
|
||
dc.b $EE,$7F ; 7FFE 7FEE Interrupt Request vector
|
||
@end ; code ends here
|
||
|
||
|
||
if PadForOverpatch then ; <1.6>
|
||
align 4 ; <1.5>
|
||
string asis ; <1.5>
|
||
dcb.l ($770-(*-IOPmgr))/4,'Gary' ; padding for overpatch <1.5>
|
||
endif ; <1.6>
|
||
|
||
endproc
|
||
END
|
||
|