;
;	File:		EGRET Manager.a
;
;	Contains:	Contains low level code to support sending and receiving
;				packets (ADB, Pseudo Commands, Ticks, etc) to/from the Egret
;				6805uC.
;
;	Written by:	Gary Rensberger
;
;	Copyright:	© 1990-1993 by Apple Computer, Inc.  All rights reserved.
;
;	Change History (most recent first):
;
;	  <SM19>	 11/9/93	KW		added some eieioSTP macros.  Only expands for CygnusX1 ROM.
;	  <SM18>	 9/29/93	SAM		From mc900ftjesus.
;	   <MC3>	 9/25/93	SAM		Whoot! What a mess.  Removed usless/redundant entry points and
;									imports/exports by the thousands.  Cleaned up tons of stuff.
;									Changed the labels of a few routines to reflect the fact that
;									they apply to both egret and cuda. Export ChkFirmware for
;									vectorization.  Backedout change <SM17>.
;	  <SM17>	 9/23/93	PN		Add condition for Egret
;	  <SM16>	 7/12/93	kc		Re-roll in ShiftRegIRQPatch to fix Quadra 900-950 ReadTime bug.
;	  <SM15>	 12/1/92	RB		Turned off the debug feature in Egret.
;	  <SM14>	11/20/92	GS		Removed the CudaPDMPatch from the initialization of the DFAC and
;									PDMs for Caboose or Cuda.  This initialization for Cyclone is
;									now done in the Gibbly.
;	  <SM13>	 11/3/92	SWC		Changed ShutdownEqu.a->Shutdown.a.
;     <SM12>    10/02/92    AEK     Conditionalize call to InitReliabitity to keep it from being
;                                   called twice if not on an overpatched ROM
;
;	  <SM11>	 9/18/92	GS		Debug Enter - removed PDMSuspend command.  DebugExit - add
;									MacsbugContinue command,   add Window update.  EgretDFACandPDM
;									routine - removed the Keybd NMI enable for the Cuda FW.  In the
;									Cuda FW, the command to enable/disable Keybd NMI no longer is a
;									valid command.  Keybd NMI is always enabled with the Cuda FW.
;	  <SM10>	 6/26/92	GS		(RBM)  Removed the Enable KeyboardNMI call made in the
;									EgretDFACandPDM
;									routine.  With the new version of Cuda FW (Cuda 0.22), the NMI
;									is always ON.
;									No longer has entry in the pseudo cmd table for SetDFACmode.
;									Instead, a new
;									command exists, called RdWrIIC to perform bidirectional IIC
;									transactions.
;									This requires special setup of the Cuda globals by the routine
;									'SetTransferParams' (see CudaMgr.a).
;									
;	   <SM9>	 5/24/92	RB		Removed the routine QuadraEgretChanges since EgretDFACandPDM is
;									a better version from the Pandora ROM. This routine gets called
;									from StartInit.a
;	   <SM8>	 5/24/92	RB		Removing "patches" as they get rolled into the other
;									sources...PowerSwitchIntPatch is out.
;	   <SM7>	 5/23/92	RB		Making Cyclone changes...Revised some patches rolled in from
;									Terror. Pandora comments follow: with some duplications... Note
;									that a lot of this code should be reworked with the ADBMgr, the
;									first step is to get it all in... **** From EgretPatches.a: <P2>
;									4/24/92 GS Added a Egret Dispatch call to suspend/continue PDM
;									when entering exiting Macsbug. This is to prevent problems of
;									determining whether or not to ignore PDM messages. **** From
;									EgretMgr.a: <P4> 2/10/92 GS Exported the PseudoTable for use by
;									the CudaMgr.a code. Cleaned up some comments. <P3> 02/07/92 jmp
;									Added some padding so that Pandora matches Horror. <P2> 1/16/92
;									GS Added code to determine the Egret Firmware Type (Egret8,
;									Caboose, Cuda), then set up the appropiate vectors for IRQ,
;									Ticks, Dispatcher...
; ———————————————————————————————————————————————————————————————————————————————————————
;	 								 Pre-Pandora ROM comments begin here.
; ———————————————————————————————————————————————————————————————————————————————————————
;		 				<5>	 2/20/91	BG		Fixed error in CheckPacket. The check for allowable
;									pseudo-packets was a hard-coded name check instead of an
;									end-of-table check.
;		 				<4>	12/11/90	JJ		Mac LC: Changes references to VISAChipBit to V8ChipBit.
;		 				<3>	 12/7/90	CCH		Adjusted the patch code in CheckPacket so that it fits in the
;									same number of bytes as the original code.
;		 				<2>	 12/6/90	BG		(with GA) Rolled in Eclipse-related Egret/Caboose changes.
;						<P9>	 4/24/92	GS		Removed DSorDebuggerPatch that was called from StartErr.a  New
;									code and PDM Selectors used by PDM removed the need.  Updated
;									the DebugUtil code in EgretPatches.a to handle these cases.
;						**** From EgretPatchesToo.a:
;						<P8>	 4/24/92	KW		(SWC,H5) Moved ADB and DebugUtil routines to ADBPrimitives.a.
;						<P10>	  4/10/92	gjs		Make Timer Mgr Task fire off a Cuda Tickle pkt every 3 sec 
;									instead of 7 secs.  Still having problem with 2nd User Alert
;									with mulitple hits to Keybd Reset key.  Also bump up the Timer
;									Timeout passed back to Cuda.
;						<P9>	  4/08/92	gjs		Upon installing a TimeMgr task to tickle Cuda during the User
;									alert, send a tickle to cover the first 7-10 seconds of the
;									display of the alert.
;						<P8>	  3/30/92	GS		The KeyBdSwHandler has been changed to set up a User Alert 
;									if the KeybdPower switch has been depressed, or if the 
;									chassis swithc or Secure Key switch has been used for a power down
;									a deferred Task will be executed, with out a User Alert.
;						<P7>	  3/17/92	GS		The PowerSwitch Int Handler has been changed to user the new
;									ShutDown mgr code in the system.  This makes all _ShutDown trap
;									calls with the selector set to 1 a soft power off.
;						<P6>	  3/3/92	GS		Update some Cuda Code to save some regs in Tickle timer code,
;									and begin to setup for the new power down msg to indicate kybd
;									or chassis sw power down.
;						<P5>	02/11/92	jmp		The EgretDFACandPDAM routine (which used to be the
;									EclipseEgretPatches routine) got bigger, so I moved it into the
;									pad space, with a branch from the original location.
;						<P4>	 2/11/92	GS		Update the Cuda Patches used to support SoftPower On/Off. Added
;									comments and revision tags. Updated a patch label from
;									EclipseEgretPatches to EgretDFACandPDM to better describe the
;									function of the patch. Also added functionality to the patch to
;									handle Caboose and Cuda firmware initializations.
;						<P3>	02/07/92	jmp		(jmp,H3/BG,Z19) Fixed ReGenSoundInt to wait in between disabling
;									and re-enabling sound interrupts.  Also changed ReGenSoundInt to
;									work like Kip originally intended (i.e. regenerate interrupts
;									only on the channel(s) that need it).
;						<P2>	 1/16/92	GS		Rolled in the newPatches that are associated with the Cuda
;									firmware for SoftPower On/Off.
; ———————————————————————————————————————————————————————————————————————————————————————
;	  								Pre-Pandora ROM comments begin here. (EgretPatchesToo)
; ———————————————————————————————————————————————————————————————————————————————————————
;						<H2>	12/21/91	jmp		(BG,Z18) Added code to re-generate sound interrupts when
;									checking the keyswitch values since reading port B causes
;									interrupts to get cleared (stupid design of original VIAs).
;
;	   <SM6>	 5/17/92	kc		Roll in Horror sources. (prepend via equates with v)
;	   <SM5>	 5/13/92	SES		Fixed bug in ShiftRegIrq patch roll in. Additional sr restore
;									instructions were added only where necessary instead of trying
;									to restore "globally" right before exiting.
;	   <SM4>	  5/5/92	SES		Rolled in patches from PatchIIciROM.a, including ShiftRegIrq
;									patch for saving/restoring sr, and addition of SCC polling in
;									EgretDispatch. Also fixed minor bug in tickHandler where
;									with/endwith directives were left out.
;	   <SM3>	  5/4/92	FM		fix typo
;	   <SM2>	  5/4/92	FM		Roll in changes from PatchIICiRom.a file that were "lost" in the
;									review process… Changing the TickHandler to update the Time
;									lo-mem global so that the RdDateTime can simply return whats in
;									the global.
;		<21>	 1/20/92	KC		Move RequestDonePatch into ADBMgr.a. Changed
;									CheckForCabooseKeyswitch into TestFor KeyswCabooseBit macro
;									call.
;		<20>	 1/13/92	kc		Added Terror changes, origional comments below.
;		 {?}						Added "Enable PDMMessage" and "SendDefault DFAC" to PseudoCntTable.
;		 {5}	 2/20/91	BG		Fixed error in CheckPacket. The check for allowable
;									pseudo-packets was a hard-coded name check instead of an
;									end-of-table check.
;		<19>	12/29/91	RB		Added Terror changes and rolled in patches to support Quadras.
;		<18>	 8/30/91	JSM		Cleanup header, don’t include SysErr.a since it’s in
;									StandardEqu.d.
;		<17>	 6/12/91	LN		removed #include 'HardwareEqu.a'
;		<16>	 4/24/91	dba		fix warning
;		<15>	10/22/90	JJ		Rex V8: Change VISAChipBit to V8ChipBit.
;		<14>	 5/15/90	GA		Removing calls to SCCPollDelay. Routine not needed.
;		<13>	  5/8/90	GA		Disabled all interrupts during interrupt handler to prevent
;									AppleTalk from interrupting Egret Manager and the issuing a
;									ReadXPram call which calls Egret Manager Synchronously. Changed
;									the Delay100 routine to SCCPollDelay. It polls and buffers any
;									serial data from the SCC and calls the Serial Driver PollProc
;									routine if one is present. Modified SendEgretCmd to have a retry
;									count to communicate with Egret. If the Retry count expires,
;									EgretMgr calls Error1Handler. Modified SendPtype to read the
;									interrupt flags register in the via 32767 times (≈41.9 millsecs
;									max) and then try send the packet type again based on the retry
;									count.
;		<12>	 4/25/90	GA		Fixed a bug with SendDFAC to allow 1 to 4 bytes to be sent to
;									Egret. Fixed a bug with the error reporting mechanism to return
;									all 4 bytes of the error packet returned by Egret.
;		<11>	 4/10/90	GA		Fixed a bug in the error checking code. Made a change to make
;									KeyLite program work (returns parameter block byte count
;									unchanged).
;		<10>	  4/2/90	GA		Removing the Routine Read LastByte from the SendEgretCmd code.
;									Also, fixing lines of source which have had their C/R changed to
;									a Null ($00) character. We suspect that Romlister may trash
;									source files which are open during the build.
;		 <9>	 3/30/90	GA		Added Error reporting for bad parameter blocks from the system
;									to Egret.
;		 <8>	 3/22/90	GA		Changed the Via_Full Ack process on the last byte of
;									transactions to clarify the Logic Analyzer displays.
;		 <7>	 3/15/90	GA		Ray and I added conditionalized code to send Stop Autopoll and
;									send mode 0 one second interrupt command s in place of the
;									SendNOPCmd to support the B3 release of Egret. This code will be
;									inactivated when the final Egret parts come in.
;		 <6>	 3/13/90	GA		Added a routine called SENDNOPCMD. This routine is register
;									driven and issues a command to Egret to Stop AutoPoll and one
;									second interrupts in Egret
;		 <5>	  3/9/90	GMR		Optimized code in a few places. Moved assertion of SysSes bit to
;									after test of XcvrSes, to fix bug on 2 byte tick packets.
;		 <4>	 2/28/90	GMR		Rewrote file.
;		 <3>	 2/14/90	GA		Added support code for Restart & shutdown in Egret. Issues stop
;									autopoll & stop 1 sec interrupts prior to restarting the system.
;		 <2>	  2/9/90	GA		1. Added two calls to DelayLoop to give Egret time to see
;									transitions of SysSession signal.
;
;									2. SendWithCheck & SynChkSend now wait for the shift register
;									   interrupt bit to be asserted before exiting when a transaction
;									   is aborted.
;
;									3. Moved code which sends bitmap and starts autopoll to Egret into
;									   EgretMgr.a.  ADBMgr now issues a JSR StartEgretAutopoll to do
;									   the same function.  This makes the Erickson overpatch easier.
;
;		 <1>	  2/3/90	GA		first checked in
;
************************************************************************
				machine		mc68020

				BLANKS		ON
				STRING		ASIS

				PRINT		OFF
				LOAD		'StandardEqu.d'
				INCLUDE		'EgretEqu.a'
				INCLUDE		'HardwarePrivateEqu.a'
				INCLUDE		'UniversalEqu.a'
				INCLUDE		'IOPEqu.a'
				INCLUDE		'AppleDeskBusPriv.a'
				INCLUDE		'ShutDown.a'
				INCLUDE		'FSEqu.a'
				INCLUDE		'PowerPrivEqu.a'
				PRINT		ON

				include		'EgretEqu.a'
				eject

EgretDebug		EQU		0

EgretMgr		PROC		EXPORT

				EXPORT		InitEgretOrCuda, EgretDispatch, CheckPacket
				EXPORT		PseudoCntTable, ADBCntTable, SetResponseParams, ChkFirmware

				IMPORT		GetHardwareInfo, Error1Handler
				IMPORT		CudaDispatch,CudaShiftRegIRQ,CudaTickHandler
				IMPORT		CudaInit, SendCudaCmd

rayFix			EQU		1				; needed to fix Egret bug on old parts
ErrEgretInit	equ		$0030			; TEMPORARY definition of error equate defined in STEQU.a


			WITH 	EgretGlobals,EgretPB,RespHeader			; <60> rb
;===============================================================================================
;	Routine:	InitEgret
;
;	Function:	Allocates globals, sets vACR to shift in mode, sets up globals for an auto-response
;				packet (ADB/Ticks).
;
;	Inputs:		none
;
;	Outputs:	none
;
;	Destroys:	a0-a2, d0-d2
;________________________________________________________________________________________________
InitEgretOrCuda
			moveq.l #EgretGlobSize,D0			; get size of globals
			_NewPtr ,SYS,CLEAR					; allocate space on heap and clear

			move.l	a0,EgretBase				; save ptr to it
			movea.l	a0,a2						;

			move.w	sr,-(sp)					; save irq enable status
			ori.w	#HiIntMask,sr				; mask out interrupts

			lea		workPb(a2),a0				; pointer to work parameter block 	<SM7> rb
			move.l	a0,adbPb(a2)				; store in adb parameter block		<SM7> rb
			
			bsr		SetResponseParams			; setup globals to handle auto response packets again

			bsr.l	ChkFirmware					; Set up dispatch,IRQ, and ticks (Sets up _EgretDispatch trap)
			move.l  a0,Lvl1DT+8	        		; the level 1 dispatch table
			move.l	a1,tickComp(a2)				; set up default tick packet handler
			
			movea.l	VIA,a1						; point to the VIA
		eieioSTP
			bclr.b	#SRdir,vACR(a1)				; shift reg direction = input
		eieioSTP
			move.b	#(1<<ifIRQ)|\
						(1<<ifSR),vIER(a1)		; enable shift register interrupts
		eieioSTP
			move.w	(sp)+,sr					; restore interrupts
			rts


;________________________________________________________________________________________________
;	Routine:	EgretDispatch
;
;	Function:	This is the Egret manager trap routine.  It waits for Egret to be idle, sends
;				the first byte of the command packet.  If Egret didn't abort, then it sets up
;				globals for the IRQ handler, and if a completion routine was specified, it returns
;				back to the caller.  If no completion routine, then it waits synchronously for
;				the command/response to finish, using the busy bit.  When the IRQ handler has finished
;				the response packet, it preps the globals to expect an auto-response packet
;				(ticks or ADB), clears 'busy' and calls the completion routine (if any).
;
;	Inputs:		a0	-	pointer to parameter block
;
;	Outputs:	d0	-	result (0 for now)
;
;	Destroys:	a0-a2, d0-d1
;________________________________________________________________________________________________
EgretDispatch
			bsr		CheckPacket					; Validate the Packet type & command byte
			bne		@done						; Exit if Error packet
			movea.l	EgretBase,a2				; a2 gets ptr to globals
			movea.l	VIA,a1						; a1 points to VIA base



@checkSpecial
			cmpi.b	#specialPkt,pbCmdType(a0)	; is this a special command?						<SM7> rb
			bne.s	@ckPDMInit					; check for Eclipse PowerDown Message Initialization <SM7> rb
			
			move.l	a0,ADBpb(a2)				; yes, is to set the ADB param block (for autopoll data). <SM7> rb
			bra		@done						;														<SM7> rb

@ckPDMInit										;														<SM7> rb
;
;		Check for Eclipse PowerDown Message Vector
;		Initialization.
;
			cmpi.b	#PDMVectPkt,pbCmdType(a0)	; check for PowerDown message vector Init <60> rb	<SM7> rb
			bne.s	@EgretRestart				; Must be Egret Command		<60> rb	<SM7> rb
			
			move.l	pbParam(a0),PDMComp(a2)		; handler for Eclipse PowerDown Message Packet <60> rb <SM7> rb
			bra		@done						; and exit

@EgretRestart

	
			move.w	sr,-(sp)					; save SR
 			ori.w	#hiIntMask,sr				; mask interrupts
		eieioSTP
			btst.b	#xcvrSes,vBufB(a1)			; does Egret want to abort?
		eieioSTP
			beq.s	@abort						; yes, wait for it to go away
			bset.b	#busy,flags(a2)				; not an abort, mark that we're busy.
		eieioSTP
			beq.s	@sendPackType				; we were not busy before, so try to send the first byte

@abort		move.w	(sp)+,sr					; we were busy, enable interrupts
			bsr		pollByte					; poll shift reg, calling handler if interrupts masked

			bra.s	@EgretRestart				; and keep waiting for busy to go away...

@sendPackType									; interrupts masked here
		eieioSTP
			bset.b	#sysSes,vBufB(a1)			; assert System Session (we're starting command packet)
		eieioSTP
			bset.b	#SRdir,vACR(a1)				; switch to output
		eieioSTP
			move.b	pbCmdType(a0),vSR(a1)		; send command packet to shift reg
		eieioSTP
			bset.b	#viaFull,vBufB(a1)			; tell Egret we sent it
		eieioSTP

;<SM4><SES> Rolled in from PatchIIciROM.a
;----------------------------------------------------------------------------------------------------
;	This patch fixes possible loss of data to the SCC by calling
;	the Poll Proc when SCC data is available.
;
;	NOTE: This is a slightly modified version of the one from PatchIIciROM.a
;----------------------------------------------------------------------------------------------------
;_________________________
;		If PollProc exists, Poll the SCC and save any available data
;		When the shift register irq comes in call the PollProc
;		then process the shift register irq data
;
			movem.l	d0/d1/a0-a4/a6,-(sp)		; save some registers

			move.l	sp,PollStack				; Pointer to buffer for polled bytes

		eieioSTP
			btst.b	#0,SccIopFlag				; Check if we are in IOP mode (On Eclipse...)
		eieioSTP
			beq.s	@NoPollWait					; If IOP then we don't need to poll

			tst.l	PollProc					; Check for a Poll Proc available
			beq.s	@NoPollWait					; If no Poll Proc then we don't need to poll

			movea.l	SccRd,a3					; SCC may have data to get
			movea.l	a3,a6
			addq.l	#Actl,a3					; Point to data available register (RR0)
			addq.l	#AData,a6					; Point to the SCC data register

@wait
		eieioSTP
			btst.b	#RxCa,(a3)					; Test for SCC data available
		eieioSTP
			beq.s	@2
			move.b	(a6),-(sp)					; Push the data on the stack
@2			
		eieioSTP
			btst.b	#vShift,vIFR(a1)			; now wait for shift reg IRQ

		eieioSTP
			beq.s	@wait

			cmpa.l	PollStack,SP				; Is there any poll data
			beq.s	@NoSCCData
;
;		We have SCC data and a Poll Proc to call.  Go call it
;
			pea		@NoSCCData					; Return addr for PollProc
			move.l	PollProc,-(SP)				; Point to the PollProc
			rts									; Call the PollProc


@NoPollWait
		eieioSTP
			btst.b	#vShift,vIFR(a1)			; now wait for shift reg IRQ
		eieioSTP

			beq.s	@NoPollWait

@NoSCCData	movem.l	(sp)+,d0/d1/a0-a4/a6		; restore work registers

@VsrIrq
		eieioSTP
			btst.b	#xcvrSes,vBufB(a1)			; did Egret abort?
		eieioSTP
			bne.s	@accepted					; no, then it will accept our packet
			bclr.b	#SRdir,vACR(a1)				; yes, switch back to input
		eieioSTP
			bclr.b	#sysSes,vBufB(a1)			; ack the abort
		eieioSTP
			bsr		CallShiftRegIRQ				; handle it
		eieioSTP
			bra.s	@abort						; and wait

;<SM4><SES> end of EgretDispatch SCC poll fix

@accepted										; we sent the packetType, now set up for the IRQ handler
			jsr		SetTransferParams			; setup globals for this packet
			bsr		CallShiftRegIRQ				; transfer second byte (command) to start things
			move.w	(sp)+,sr					; now enable interrupts
		eieioSTP

			tst.l	pbCompletion(a0)			; do we have a completion routine
		eieioSTP
			bne.s	@done						; yes, then return asynchronously

@waitComplete
			btst.b	#busy,flags(a2)				; otherwise, are we still busy?
		eieioSTP
			beq.s	@done						; no, then we're done...
			
			bsr.s	pollByte					; yes, poll out a byte if necessary	
	
;  	bclr.b	#busy,flags(a2)				; otherwise, are we still busy?

			bra.s	@waitComplete				; and wait here (synchronously)

@done		moveq	#0,d0						; no errors for now
			rts

;________________________________________________________________________________________________
;
;		Validate the Packet type and Command if Pseudo Pkt.
;
;		If an error is encountered with the packet a error packet will be
;		built in the pbParam area of the parameter block as if Egret had
;		returned the packet.  Also, the pbResult field will contain a System
;		error code for bad parameter block format.
;
;		Entry: A0 = Parameter block pointer
;
;		Exit:	sr.Z = 0 if valid  packet/pseudocmd nonzero otherwise
;
_________________________________________________________________________________________________

CheckPacket
			cmp.b	#SpecialPkt,pbCmdType(a0)	; could be an ADB initialization packet
			beq.s	@OkExit
			
			cmp.b	#PDMVectPkt,pbCmdType(a0)	; could be PowerDown message Vector Init Packet <60> rb
			beq.s	@OKExit						; if equal, CONTINUE <60> rb

			cmp.b	#ErrorPkt,pbCmdType(a0)		; ADB ($00) and Pseudo ($01) only
			bhi.s	@BadPkt						; Invalid packet

			cmp.b	#PseudoPkt,pbCmdType(a0)	; Check for pseudo commands
			bne.s	@OkExit						; On Pseudo Packets check the command

			cmp.b	#MaxPseudoCmd,pbCmd(a0)		; Validate the Pseudo command number   {5}
			bls.s	@OkExit

@BadPseudo	move.w	#InvPseudo,pbParam(a0)		; report a pseudo command error
			move.w	pbCmdType(a0),pbParam+2(a0)	; we are faking an error packet
			bra.s	@ErrorExit

@BadPkt		move.w	#InvPkt,pbParam(a0)			; report invalid packet error
			move.w	pbCmdType(a0),pbParam+2(a0)	; we are faking an error packet

@ErrorExit	move.w	#paramErr,pbResult(a0)		; parameter error in result field
			bra.s	@Exit

@OkExit		move.w	#0,pbResult(a0)				; So far packet OK
@Exit		rts

;________________________________________________________________________________________________
;	Routine:	PollByte
;
;	Function:	This routine checks to see if level 1 interrupts are masked, exits if not.
;				If masked, it polls the flag register for a shift reg interrupt, and
;				calls the handler if found.
;
;	Inputs:		a1	-	VIA base ptr
;				a2	-	globals pointer
;
;	Outputs:	none
;
;	Destroys:	d0,d1
;________________________________________________________________________________________________
PollByte

			move.w	sr,d0						; get 68xxx interrupt mask
			andi.w	#hiIntMask,d0				; are we at interrupt level?
			beq.s	@exit						; no, just exit
		eieioSTP
			btst.b	#vShift,vIFR(a1)			; yes, poll the shift reg
		eieioSTP
			beq.s	@exit						; no shift reg interrupt, return
			bsr.s	CallShiftRegIRQ				; yes, handle it
@exit		rts


;________________________________________________________________________________________________
;	Routine:	SendByte
;
;	Function:	This routine clears viaFull bit, delays 125us, sends a byte to the shift reg,
;				then asserts viaFull bit.
;
;	Inputs:		d0	-	byte to send
;				a1	-	VIA base ptr
;
;	Outputs:	none
;
;	Destroys:	d1
;________________________________________________________________________________________________
SendByte
		eieioSTP
			bclr.b	#viaFull,vBufB(a1)			; negate via full
		eieioSTP
			bsr.s	Delay100					; give Egret time to see it
		eieioSTP
			move.b	d0,vSR(a1)					; send the byte to the shift reg
		eieioSTP
			bset.b	#viaFull,vBufB(a1)			; let Egret know it's there
		eieioSTP
			rts

;________________________________________________________________________________________________
CallShiftRegIRQ
			movem.l	a0-a3/d0-d3,-(sp)			; save regs like interrupt handler does
			movea.l  Lvl1DT+8,a0	        	; get the shift reg IRQ handler
			jsr		(a0)						; call it
			movem.l	(sp)+,a0-a3/d0-d3			; restore regs
			rts

;________________________________________________________________________________________________
viaFullAck
		eieioSTP
			bset.b	#viaFull,vBufB(a1)			; acknowlege the byte
		eieioSTP
			bsr.s	Delay100					; give Egret time to see it
		eieioSTP
			rts									; gets cleared on exit from IRQ handler

;________________________________________________________________________________________________
Delay100
			move.l	d1,-(sp)					; save d1
			move.w	timeViaDB,d1				; 1 ms loop count
			lsr.w	#3,d1						; / 8 = 125 us
		;	cmpi.b	#boxQuadra900,boxFlag		; is this a Quadra900 ?		<60> rb
		;	bne.s	@loop						; no ? then skip			<60> rb
			add.w	#EclipseDelay,d1			; <60> rb, we need an extra 25 usecs on Eclipse <GAA Eclipse>
@loop
		eieioSTP
			tst.b	(a1)						; access the VIA
		eieioSTP
			dbra	d1,@loop
			move.l	(sp)+,d1					; restore d1
		eieioSTP
			rts

;________________________________________________________________________________________________
;	Routine:	ShiftRegIRQ
;
;	Function:	This routine is called in response to a VIA shift reg interrupt.  It will transfer
;				the next byte in the current packet.  When the packet is complete, the globals are
;				prepped for an auto-response packet (ADB/Ticks), then the completion routine
;				is called (if present).
;
;	Inputs:		a1	-	VIA base ptr
;
;	Outputs:	a2	-	globals pointer
;
;	Destroys:	a0-a2,d0,d1
;________________________________________________________________________________________________
			EXPORT	ShiftRegIRQ

ShiftRegIRQ
			move.w	sr,d3
			ori.w	#hiIntMask,sr				; mask interrupts <13>
			movea.l	EgretBase,a2				; get ptr to globals <13>
			bset.b	#busy,flags(a2)				; make sure we're marked as busy
		eieioSTP

			btst.b	#SRdir,vACR(a1)				; see if VIA direction is output
		eieioSTP
			beq.s	@input						; no, then we're receiving..

			tst.b	vSR(a1)						; clear the shift reg interrupt
		eieioSTP
			tst.w	sendHdrCnt(a2)				; any bytes left in header?
			ble.s	@ckSendData					; no, see if any send bytes left...

			movea.l	sendHdrPtr(a2),a0			; get ptr to header
			move.b	(a0)+,d0					; get next header byte
			move.l	a0,sendHdrPtr(a2)			; and update header ptr
			bsr		SendByte					; send the byte
			subq.w	#1,sendHdrCnt(a2)			; count it
			move.w	d3,sr						; restore interrupts							<SM5><SES>
			bra		@exit						; and exit
@ckSendData
			tst.w	sendDataCnt(a2)				; any bytes left in data to send
			ble.s	@CmdFinished				; no, then we're finished with command packet
			movea.l	sendDataPtr(a2),a0			; get current data ptr
			move.b	(a0)+,d0					; yes, get next data byte
			move.l	a0,sendDataPtr(a2)			; and update the ptr
			bsr		SendByte					; send it
			subq.w	#1,sendDataCnt(a2)			; count it
			move.w	d3,sr						; restore interrupts							<SM5><SES>
			bra		@exit						; and exit
@CmdFinished
		eieioSTP

			bclr.b	#SRdir,vACR(a1)				; now switch to input
@sendCmd
		eieioSTP
			andi.b	#~((1<<viaFull) | \			; negate VIA full bit
					   (1<<sysSes)),vBufB(a1)	; negate System Session
		eieioSTP
			bsr.s	Delay100					; give Egret time to see System Session
			move.w	d3,sr						; restore interrupts							<SM5><SES>
			bra		@exit						; and exit

@input		;-----------------------------------------------------------------------------
		eieioSTP
			move.b	vSR(a1),d0					; read the byte from shift reg into D0
		eieioSTP
			tst.w	rcvHdrCnt(a2)				; any bytes left in response packet header?
			ble.s	@ckRcvData					; if not then must be data byte

@getHdrByte	
		eieioSTP
			btst.b	#sysSes,vBufB(a1)			; is System Session asserted?
		eieioSTP
			bne.s	@notFirst					; yes, then this is not the first byte
			bsr.s	Delay100					; delay 100us
			bra.s	@stuff
@notFirst
			bsr.s	viaFullAck					; acknowlege the byte using via full
@stuff		move.w	rcvHdrIndex(a2),d1			; get index into header
			lea		rcvHeader(a2),a0			; point to header buffer
			move.b	d0,(a0,d1.w)				; store byte away
			addq.w	#1,rcvHdrIndex(a2)			; bump to next byte
			subq.w	#1,rcvHdrCnt(a2)			; count it
			ble.s	@CheckError					;  <12>
		eieioSTP
			btst.b	#xcvrSes,vBufB(a1)			; is Egret done?
		eieioSTP
			bne.s	@done						; yes, we're through...
			bset.b	#sysSes,vBufB(a1)			; make sure System Session is asserted			<5>
		eieioSTP
			bra		@exitRd						; not done with header yet... exit

@ckRcvData
			movea.l	rcvDataPtr(a2),a0			; get ptr to receive data buffer
			move.b	d0,(a0)+					; store the data byte
			move.l	a0,rcvDataPtr(a2)			; and update header ptr
			subq.w	#1,rcvDataCnt(a2)			; count it
			bgt.s	@ack						; not last, normal acknowlege
			btst.b	#openData,flags(a2)			; is this an open ended data packet?

		eieioSTP		
			beq.s	@ack						; no, normal acknowlege
			bsr.s	viaFullAck					; acknowlege the byte using via full <8>
		eieioSTP
			bclr.b	#sysSes,vBufB(a1)			; yes, let Egret know we don't want more <8>
@wait
		eieioSTP
			btst.b	#xcvrSes,vBufB(a1)			; wait for egret to acknowledge termination <8>
		eieioSTP
			beq.s	@wait						; branch until xcvr session goes high <8>
			bra.s	@done						; and we're done

;
;		If we have an error packet in progres then read 5 bytes instead of 4 for the header. <12>
;		A flag will be set on the fourth byte of an error packet and will be cleared <12>
;		after reading the fifth byte of the error packet. <12>

@CheckError	lea		rcvHeader(a2),a0			; point to header buffer <12>
			cmp.b	#ErrorPkt,1(a0)				; check packet type for error packet <12>
			bne.s	@CheckDone					; not an error packet go check for data <12>

			bclr.b	#BadPkt,flags(a2)			; check for error packet in progress flag <12>
			bne.s	@CheckDone					; we read the fifth byte of the error packet <12>
@readbyte5	addq.w	#1,rcvHdrCnt(a2)			; adjust the count before reading the fifth byte <12>
			bset.b	#BadPkt,flags(a2)			; set the flag then read the fifth byte <12>
			bra		@exitRd						; <12>

;
;		Acknowledge the data byte
;
@ack		bsr.s	viaFullAck					; normal byte, acknowlege it
@checkDone	
		eieioSTP
			btst.b	#xcvrSes,vBufB(a1)			; was that Egrets last byte?
		eieioSTP
			bne.s	@done						; yes, we're through...
			tst.w	rcvDataCnt(a2)				; any receive data bytes to get?
			bgt		@exitRd						; yes, then just exit

			;---------------------------------------------------------------------------
@done	
		eieioSTP
			bclr.b	#viaFull,vBufB(a1)			; make sure via full is low
		eieioSTP
			bclr.b	#sysSes,vBufB(a1)			; let Egret know we're done
		eieioSTP
			bsr		delay100					; Give Egret time to see transitions & Poll SCC <13>

			movea.l	curPb(a2),a0				; a0 points to current param block
			lea		rcvHeader(a2),a1			; a1 points to header buffer <11>
			cmp.b	#ErrorPkt,1(a1)				; check for Error response packet <11>
		eieioSTP
			bne.s	@NotError
;
;		The current transaction generated an Error <11>
;
			move.l	1(a1),pbParam(a0)			; Return the Error Response packet to the caller (dont include attn byte) <11>
			move.w	#paramErr,pbResult(a0)		; and return a parameter block error <11>

@NotError	cmpa.l	adbPb(a2),a0				; was this an implicit command?
			beq.s	@implicit					; yes, handle autopoll/tick packet

			tst.b	1(a1)						; is this an ADB response?
			bne.s	@ckComp						; no, then data already transfered, call completion

@adbResp
		IF rayFix THEN
			cmpa.l	adbPb(a2),a0				; is this autopoll data
			bne.s	@skip						; no, don't fix ray's flag
			bset.b	#EgAutoPoll,2(a1)			; yes, fix em
		eieioSTP
@skip
		ENDIF

			btst.b	#EgAutoPoll,2(a1)			; check status, is this AutoPoll data?
		eieioSTP
			bne		@ckAutoPollComp				; yes, handle if we have completion routine

			move.b	2(a1),pbFlags(a0)			; explicit ADB command, stuff flags byte
			move.w	rcvHdrIndex(a2),d0			; get header+data byte count
			subq.w	#4,d0						; - header bytes
			beq.s	@dontupdate					; if no data received don't update the byte count <11>
			move.w	d0,pbByteCnt(a0)			; stuff data byte count
@dontupdate	move.l	pbBufPtr(a0),a2				; get users buffer ptr
			addq.w	#4,a1						; point at the data
			bra.s	@cnt
@xfer		move.b	(a1)+,(a2)+					; copy the byte
		eieioSTP
@cnt		dbra	d0,@xfer					; repeat for all bytes

			move.l	EgretBase,a2				; get globals ptr again

@ckComp		move.l	pbCompletion(a0),d0			; any completion routine?
			beq		@exitNoComp					; no, just exit

			move.l	d0,a1						; yes, get it's address
			move.l	a0,-(sp)					; save param block ptr
			bsr		SetResponseParams			; setup globals to handle auto response packets again
			move.w	d3,sr						; restore interrupts
			move.l	(sp)+,a0					; restore param block ptr
			jmp		(a1)						; and call it


;--------------------------------------------------------------------------------------------
; AutoPoll or Tick data, push it on stack and call completion rtn

@implicit
			tst.b	RespPktType(a1)				; is this an ADB response?		<SM16>.start
			beq.s	@ckAutoPollComp				; yes, handle it

			cmpi.b	#tickPkt,RespPktType(a1)	; is this a short tick response?
			beq.s	@ckTickComp					; yes, handle it (has no param block)

			cmpi.b	#PDMPkt,RespPktType(a1)		; is this a PowerDown Message Packet?
			beq.s	@ckPowerDownComp			; yes, handle it

			cmpi.b	#pseudoPkt,RespPktType(a1)	; is this a pseudo command?
			bne.s	@InvalidPacket				; no, something is wrong
			
			cmpi.b	#RdTime,RespCmd(a1)			; is this a read time response?
			beq.s	@ckTickComp					; yes, handle it

@InvalidPacket			
		IF	EgretDebug	THEN					; We have an invalid packet

			pea		@InvPktStr					; call Macsbug
			_DebugStr
			bra.s	@exitNoComp					; exit without completion

@InvPktStr	dc.b	$14,'INVALID EGRET Packet'	; Egret error string
			align
		Else
			bra.s	@exitNoComp					; exit without completion
		Endif

@ckPowerDownComp
												; call service routine if it exists. 		<SM16>.end
			move.l	PDMComp(a2),d2				; get the completion routine address
			beq.s	@exitNoComp					; go away if vector is null
			move.l	d2,a3						; call the Service routine
			move.b	RespCmd(a1),d0				; get the powerDown Switch destination position
			bsr.l	SetResponseParams			; setup globals to handle auto response packets again
			move.w	d3,sr						; restore interrupts
			jsr		(a3)
			bra.s	@exit


@ckTickComp										; tick data, check for completion routine
			move.l	tickComp(a2),d2				; get completion routine in d2
			beq.s	@exitNoComp					; none specified, just exit
			bra.s	@push						; otherwise, push response packet on stack, call it.


@ckAutoPollComp									; ADB autopoll data, check for completion rtn
		IF rayFix THEN
			bset.b	#EgAutoPoll,2(a1)			; Set AutoPoll bit to fix bug in old Egret parts
		ENDIF
			tst.l	a0							; do we really have a current param block? (we should)
			beq.s	@exitNoComp					; no, exit

			move.l	pbCompletion(a0),d2			; any completion routine? (keep in d2)
			beq.s	@exitNoComp					; no, just exit

@push		suba.w	#12,sp						; allocate 12 byte buffer on stack
			movea.l	sp,a2						; point to the buffer
			move.l	(a1)+,(a2)+					; copy response header 	onto stack
			move.l	(a1)+,(a2)+					; copy response data 	onto stack
			move.l	(a1)+,(a2)+					; copy response data 	onto stack
			movea.l	EgretBase,a2				; restore ptr to globals
			move.w	rcvHdrIndex(a2),d0			; d0 = # bytes in response header
			subq.w	#4,d0						; byte count = # data bytes (strip off header bytes)
			bsr		SetResponseParams			; setup globals to handle auto response packets again
			move.w	d3,sr						; restore interrupts

			move.l	sp,a1						; a1 = ptr to response packet
			addq.l	#2,a1						; a1 = ptr to status flag
			move.l	d2,a3						; get completion routine
			jsr		(a3)						; call it (a0 points to param block for ADB)

			adda.w	#12,sp						; pop buffer
			bra.s	@exit						; and exit

@exitNoComp										; no completion routine specified,
			bsr		SetResponseParams			; setup globals to handle auto response packets again
			move.w	d3,sr						; restore interrupts
			bra.s	@exit						; and exit

@exitRd	
		eieioSTP
			bclr.b	#viaFull,vBufB(a1)			; make sure via full is low
		eieioSTP
			move.w	d3,sr						; restore interrupts							<SM5><SES>
@exit		rts




;________________________________________________________________________________________________
;	Routine:	SetTransferParams
;
;	Function:	This routine sets up transmit/receive ptrs (globals) for the packet pointed to by A0,
;				for use by the Shift Reg interrupt handler.
;
;	Inputs:		a0	-	Param block pointer
;				a2	-	Ptr to globals
;
;	Outputs:	none
;	Destroys:	d0,d1
;________________________________________________________________________________________________
SetTransferParams
			move.l	a1,-(sp)						; save a1
			lea		pbCmd(a0),a1
			move.l	a1,sendHdrPtr(a2)				; point to 1st byte of header to send
	eieioSTP
			moveq	#0,d0
			move.b	pbCmd(a0),d0					; get command

			tst.b	pbCmdType(a0)					; is this an ADB command?
			bne.s	@pseudo							; no, must be a pseudo command

			andi.b	#%00001111,d0					; keep low 4 bits
			lea		ADBCntTable,a1					; get ptr to our ADB command table
			bra.s	@check							; and look up our send/rcv byte counts

;
;	Pseudo Command. Now Check for SEND DFAC and treat as special case if it is. <12>
;	On DFAC, use the byte count in the parameter block as the count to send <12>
;	to Egret instead the count contained in the PseudoCntTable. <12>
;
@pseudo
			cmp.b	#WrDFAC,pbCmd(a0)				; check for DFAC <12>
			bne.s	@notDFAC						; use the table if not DFAC <12>

			move.w	pbByteCnt(a0),d1				; was Write DFAC use the byte count in the pBlock <12>
			addq.w	#1,d1							; include the packet byte already sent <12>
			move.w	d1,sendHdrCnt(a2)				; set up header byte count <12>
	eieioSTP
			move.w	#0,sendDataCnt(a2)				; do not send the bytes as data also <12>
	eieioSTP
			clr.w	sendDataCnt(a2)					; no extended data bytes <12>
	eieioSTP
			clr.l	sendDataPtr(a2)					; no extended data ptr <12>
	eieioSTP
			bra.s	@rcvParams

@notDFAC	lea		PseudoCntTable,a1				; get ptr to our pseudo command table
@check		lsl.w	#1,d0							; x 2 for word table
			move.w	(a1,d0.w),d1					; get send/rcv byte counts for this command

			ror.w	#8,d1							; get send byte count in low byte
			tst.b	d1								; is this an open-ended send command?
			bmi.s	@sendExt						; yes, branch...
			move.b	d1,d0							; get byte count from table
			ext.w	d0								; extend to word
			addq.b	#1,d0							; data bytes + 1 = header byte count
			move.w	d0,sendHdrCnt(a2)				; set up header byte count
	eieioSTP
			clr.w	sendDataCnt(a2)					; no extended data bytes
	eieioSTP
			clr.l	sendDataPtr(a2)					; no extended data ptr
	eieioSTP
			bra.s	@rcvParams						; now setup receive ptrs

@sendExt	moveq	#$7F,d0							; prepare to mask sign
			and.w	d1,d0							; get rid of sign
			addq.w	#1,d0							; + 1 for command (packet type already sent)
			move.w	d0,sendHdrCnt(a2)				; set up header byte count
	eieioSTP
			move.w	pbByteCnt(a0),sendDataCnt(a2)	; set up data byte count
	eieioSTP
			move.l	pbBufPtr(a0),sendDataPtr(a2)	; set up send data ptr
	eieioSTP

@rcvParams	clr.w	rcvHdrIndex(a2)					; reset index into header buffer
	eieioSTP
			move.w	#4,rcvHdrCnt(a2)				; 4 byte header default
	eieioSTP
			asr.w	#8,d1							; get receive data byte count
			bmi.s	@rcvExt							; branch for open-ended reads

			tst.b	pbCmdType(a0)					; reading, is this a pseudo command?
			beq.s	@rcvADB							; no, must be adb data

			lea		pbParam(a0),a1					; pseudo data will be received in pbParam
	eieioSTP
			move.l	a1,rcvDataPtr(a2)
	eieioSTP
			move.w	d1,rcvDataCnt(a2)				; get receive count from table
	eieioSTP
			bra.s	@exit							; and exit

@rcvADB		add.w	d1,rcvHdrCnt(a2)				; total header bytes = 4 + ADB data
	eieioSTP
			clr.w	rcvDataCnt(a2)					; not used
	eieioSTP
			bclr.b	#openData,flags(a2)				; this is not an open ended data packet (readPram, read6805)
			bra.s	@exit

@rcvExt		move.w	pbByteCnt(a0),rcvDataCnt(a2)	; set up received data byte count
	eieioSTP
			move.l	pbBufPtr(a0),rcvDataPtr(a2)		; set up received data buffer ptr
	eieioSTP
			bset.b	#openData,flags(a2)				; this is an open ended data packet (readPram, read6805)

@exit		move.l	a0,curPb(a2)					; set up current param block
	eieioSTP
			movea.l	(sp)+,a1						; restore a1
			rts

;________________________________________________________________________________________________
;	Routine:	SetResponseParams
;
;	Function:	This routine sets up transmit/receive ptrs (globals) for an auto response packet
;				(e.g. ticks, ADB autopoll data), for use by the Shift Reg interrupt handler.
;
;	Inputs:		a2	-	Ptr to globals
;
;	Outputs:	none
;
;	Destroys:	none
;________________________________________________________________________________________________
SetResponseParams
			clr.l	sendHdrPtr(a2)					; no command packet params
			clr.w	sendHdrCnt(a2)					;
			clr.w	sendDataCnt(a2)					;
			clr.l	sendDataPtr(a2)					;

			move.w	#12,rcvHdrCnt(a2)				; receive up to 12 response header bytes
			clr.w	rcvHdrIndex(a2)					; reset response header index
			clr.w	rcvDataCnt(a2)					; no extended data bytes
			clr.l	rcvDataPtr(a2)					; no receive data buffer
			move.l	adbPb(a2),curPb(a2)				; point to adb's autopoll param block

			andi.b	#~((1<<busy)|\					; we're not busy now
					   (1<<openData)),flags(a2)		; we're not expecting an open ended data packet

			rts


; <SM4><SES> put back function banner
;________________________________________________________________________________________________
;	Routine:	tickHandler
;
;	Function:	This is the completion routine for tick response packets.
;
;	Inputs:		a2		-	ptr to globals
;				(sp)	-	points to response packet
;
;	Outputs:	none
;
;	Destroys:	???
;________________________________________________________________________________________________
; <SM22> FM This patch was rolled in from the PatchIIciRom.a file.
; <SM22> FM Its purpose is to keep the tim lo-mem up to date at
; <SM22> FM interrupt time so that the RdDateTime trap can simply
; <SM22> FM read the Time lo-mem global.
;----------------------------------------------------------------------------------------------------
;	This patch fixes a bug in Egret Manager TickHandler routine.						<89><101>
;	The routine will store the 32 bit time passed by Egret to the
;	system if the packet is a ReadRealTime into TIME lowmen.
;	Decrements the lowmem Time by one to compensate for the interrupt
;	Handler incrementing it by one and then calls the LVL1DT interrupt
;	handler.
;	If the packet is a tick packet then it calls LVL1DT to increment the
;	time setting and check the alarm state.
;
;	Entry:
;		A1.l = Points at Response data buffer At Flags byte:
;
;			+---------+----------+---------+---------+---------//-------+
;			| Attn    | Pkt Type | Flags   | Pkt Cmd | 8 Bytes data Max |
;			+---------+----------+---------+---------+---------//-------+
;
;		A2.l = Points at Egret Manager Globals
;
;----------------------------------------------------------------------------------------------------
			EXPORT	TickHandler
TickHandler
			WITH	respPacket,EgretGlobals					; <SM4><SES>
			
			subq.l	#2,a1									; <SM22> FM point to the beginning of the Response data buffer
			cmpi.b	#TickPkt,respPacket.respType(a1)		; <SM22> FM Check the Packet type
			beq.s	@CallLVL1DT								; <SM22> FM If tick packet just call LVL1DT handler
;
;	The packet was a readTime packet from Egret.  Update the Time lowmem and
;	adjust it to compensate for the increment in the LVL1DT handler.
;
			move.l	respPacket.respData(a1),Time			; <SM22> FM write the new time in lowmem TIME
			subq.l	#1,Time									; <SM22> FM adjust to compensate for increment in LVL1DT
;
;	JUMP to routine pointed to by the Contents of LVL1DT
;
	
@CallLVL1DT
	
			move.l	VIA,a1						; point to the VIA
			move.l	LVL1DT,a0					; get vector
			jmp		(a0)

			ENDWITH								; <SM4><SES>


;________________________________________________________________________________________________
; These tables contain the transmit byte count and receive byte counts for each Egret command,
; one table for pseudo commands, and one table for ADB commands.
;
;	tx byte cnt
;	____________
;	bit 7		=	1 means pbByteCnt = number of data bytes to send after header
;	bit	6-0		=	# of pbParam bytes to send	(in header)
;
;	rx byte cnt
;	____________
;	bit 7		=	1 means open ended read call (e.g. read6805, readPram)
;	bit	6-0		=	Pseudo Cmds: 	# of pbParam bytes to read into (after 4 byte header)
;	bit	6-0		=	ADB Cmds: 		# of data bytes to read into pbBufPtr
;________________________________________________________________________________________________

PseudoCntTable
			dc.b	$00,	$00			; 00 NoOperation		send 0 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 01 StartStopAutopoll	send 1 byte, 	receive 0 data bytes
			dc.b	$02,	$FF			; 02 Read6805			send 2 bytes, 	receive n data bytes
			dc.b	$00,	$04			; 03 ReadClock			send 0 bytes, 	receive n data bytes
			dc.b	$00,	$02			; 04 GetRomSize			send 0 bytes, 	receive 2 data bytes
			dc.b	$00,	$02			; 05 GetRomBase			send 0 bytes, 	receive 2 data bytes
			dc.b	$00,	$02			; 06 GetRomHeader		send 0 bytes, 	receive 2 data bytes
			dc.b	$02,	$FF			; 07 ReadPRAM			send 2 bytes, 	receive n data bytes
			dc.b	$82,	$00			; 08 Write6805			send 2+n bytes, receive 0 data bytes
			dc.b	$04,	$00			; 09 SetClock			send 4 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0A PowerDown			send 0 bytes, 	receive 0 data bytes
			dc.b	$04,	$00			; 0B SetPowerUp			send 4 bytes, 	receive 0 data bytes
			dc.b	$82,	$00			; 0C WritePRAM			send 2+n bytes, receive 0 data bytes
			dc.b	$01,	$00			; 0D SetResetFlag		send 1 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 0E SendDFAC			send 1 bytes, 	receive 0 data bytes
			dc.b	$00,	$02			; 0F RunDiags			send 0 bytes, 	receive 2 data bytes
			dc.b	$00,	$01			; 10 CtrlEnabSense		send 0 bytes, 	receive 1 data bytes
										; 10 BatterySense		send 0 bytes, 	receive 1 data bytes
			dc.b	$00,	$00			; 11 Restart			send 0 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 12 SetVpp				send 1 bytes, 	receive 0 data bytes
										; 12 SetIPL				send 1 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 13 SetFileServer		send 1 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 14 SetAutoPoll		send 1 bytes, 	receive 0 data bytes
			dc.b	$00,	$02			; 15 GetPramSize		send 0 bytes, 	receive 2 data bytes
			dc.b	$00,	$01			; 16 GetAutoPollRate	send 0 bytes, 	receive 1 data bytes
			dc.b	$01,	$00			; 17 SetBusDelay		send 1 bytes, 	receive 0 data bytes
			dc.b	$00,	$01			; 18 GetBusDelay		send 0 bytes, 	receive 1 data bytes
			dc.b	$02,	$00			; 19 SetDevList			send 2 bytes, 	receive 0 data bytes
			dc.b	$00,	$02			; 1A GetDevList			send 0 bytes, 	receive 2 data bytes
			dc.b	$01,	$00			; 1B SetOneSecMode		send 1 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 1C SetKbdNMI			send 1 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 1D SetPostParse		send 1 bytes, 	receive 0 data bytes
			dc.b	$01,	$00			; 1E SetHangTime		send 1 bytes, 	receive 0 data bytes
			dc.b	$00,	$01			; 1F GetHangTime		send 0 bytes, 	receive 1 data bytes
			dc.b	$80,	$00			; 20 SendDefault DFAC	send 0-4 bytes, receive 0 data bytes	{?} rb
			dc.b	$01,	$00			; 21 Enable PDMMessage	send 1 bytes, 	receive 0 data bytes	{?} rb
			dc.b	$00,	$00			; 22 RdWrIIC			send n bytes, 	receive n data bytes	<S2> [rbm]
			dc.b	$01,	$00			; 23 Set WakeUpMode		send 1 bytes, 	receive 0 data bytes	<T2><SM7> rb
			dc.b	$01,	$00			; 24 Tickle PDM Timer	send 1 bytes, 	receive 0 data bytes	<T2><SM7> rb


ADBCntTable
			dc.b	$00,	$00			; 0000	SendReset	send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0001	Flush		send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0010				send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0011				send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0100				send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0101				send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0110				send 0 bytes, 	receive 0 data bytes
			dc.b	$00,	$00			; 0111				send 0 bytes, 	receive 0 data bytes
			dc.b	$80,	$00			; 10xx	Listen		send n bytes, 	receive 0 data bytes
			dc.b	$80,	$00			; 10xx	Listen		send n bytes, 	receive 0 data bytes
			dc.b	$80,	$00			; 10xx	Listen		send n bytes, 	receive 0 data bytes
			dc.b	$80,	$00			; 10xx	Listen		send n bytes, 	receive 0 data bytes
			dc.b	$00,	$08			; 11xx	Talk		send 0 bytes, 	receive 8 data bytes max
			dc.b	$00,	$08			; 11xx	Talk		send 0 bytes, 	receive 8 data bytes max
			dc.b	$00,	$08			; 11xx	Talk		send 0 bytes, 	receive 8 data bytes max
			dc.b	$00,	$08			; 11xx	Talk		send 0 bytes, 	receive 8 data bytes max



			EndWith


			Eject
;=========================================================================
; Routines: 	EgretInit
;
; This routine sends a NOP/WarmStart command to Egret.  This routine is
; called early during rom Startup to stop autopoll and 1 sec irq.  Also,
; the routine will issue a Send DFAC command to Egret to initialize the
; the DFAC hardware to a known state.  The routine does not use ANY
; memory it is register driven only.
;
; NOTE:	This routine actually sends a STOP AUTO POLL, SET ONE SECOND
;		INTERRUPT MODE 0 call and a SEND DFAC command to Egret.
;		The Stop Autopoll and set one second interrupt modes calls will
;		be changed to a single NOP/WarmStart when Egret 3 becomes
;		available (S/B 4/6/90).
;
; Inputs:	NONE
;
; Outputs:	NONE
;
; Destroys:	D0, D1, D2, D3, A1, A5, A6, A4	(Egret 2 implementation)
; Destroys:	D0, D3, A1, A5, A6				(Egret 3 implementation)
;
;	NOTE: This routine is called via a BSR6 and returns via a RTS6
;-------------------------------------------------------------------------
			EXPORT	EgretInit

EgretInit	movea.l	DecoderInfo.VIA1Addr(a0),a1		; get VIA 1 base address
		eieioSTP
			bclr.b	#vSyssesbit,vBufB(a1)	; kill any pending transactions <8> <13>
		eieioSTP
			bclr.b	#vViafullbit,vBufB(a1)	; <8> <13>
		eieioSTP
			moveq	#$28,d0					; we want to delay 4 millisecs
@killtime	bsr5	delay100us				; in 100 usec increments
			dbra	d0,@killtime
			move.l	a6,a4					; save the return address

		if		rayFix	then
;
;	Send the Stop autopoll pseudo command
;
			move.l	#(APoll << 16) + PseudoPkt,d0	; first command to send is Stop Auto Poll
			moveq	#0,d1					; sending one byte of data $00 = stop autopoll
			moveq	#1,d2
			bsr6	SendEgretCmd			; send the command to Egret
			tst.w	d0						; check for an error
			bne.s	@exit					; failed to send the command (hang timeout expired)
;
;	Send the mode 0 1 second interrupt pseudo command
;
			move.l	#(Wr1SecMode << 16) + PseudoPkt,d0	 ; mode 0 1 sec interrupts (stop 1 second irq)
			moveq	#0,d1					; sending one byte of data
			moveq	#1,d2
			bsr6	SendEgretCmd			; send the command to Egret
			tst.w	d0						; negative if error
			bne.s	@exit					; failed to send the command (hang timeout expired)

		else
;
;	Send the NOP/WarmStart command
;
			move.w	#NopCmd,d0				; Nop/WarmStart stops autopoll and 1 sec irq
			swap	d0						; packet type Pseudo
			move.w	#pseudopkt,d0
			moveq	#0,d2					; no data to send
			bsr6	SendEgretCmd			; send the command to Egret
			tst.w	d0						; nonzero if error
			bne.s	@exit					; failed to send the command (hang timeout expired)

		endif

;
;	Send Elsie/Erickson initial DFAC setting
;
		with	ProductInfo

			moveq	#0,d2						; force full scan of hardware features <10>
			bsr6	GetHardwareInfo				; get the ProductInfo Record <9>
			btst.b	#v8chipbit,ExtValid+3(a1)	; See if system has a VISA chip (bit7)<9><10>
			beq.s	@Erickson					; 0 = No Visa (Erickson) 1 = Visa (Elsie) <9>

			move.l	#ElsieDFAC,d1				; Assume running on Erickson (Not Elsie) <9>
			bra.s	@sendit

@Erickson	move.l	#EricksonDFAC,d1				; Erickson DFAC setting <9>
@sendit		move.l	#(WrDFAC << 16) + PseudoPkt,d0	; Send DFAC command
			moveq	#1,d2							; One byte to send
			bsr6	SendEgretCmd					; send the command to Egret
			tst.w	d0								; negative if error
@exit		move.l	a4,a6							; restore return address
			rts6									; return to the caller

			endwith

				eject
************************************************************************************************************
* SendEgretCmd:	This register based routine will send up to four bytes of data to Egret.  The
*				packet type, command, byte count and data are passed in registers.  The routine
*				will return with d0.w = $0000 if it sent the command successfully.  A value of
*				$FFFF signifies that the command did not get through.  The system and Egret hung
*				and the system aborted the transaction.
*
*	WARNING:	This routine will not error check the transaction requested.  It is  the responsibility of
*	WARNING:	the caller to make sure that the packet type, command, data and data byte count are valid
*	WARNING:	for the transaction requested.  Failure to follow the rules will make this routine fail and
*	WARNING:	CRASH the system.
*
*		Input:
*				a0.l	Pointer to Base address table
*
*				d0.l =  High word PACKET Command
*						Low word PACKET Type
*
*				d1.l =	Up to four bytes of data to send
*						Long word data byte assigment = byte 4, byte 3, byte 2, byte 1
*						Byte 1 sent out first
*
*				d2.l = 	Byte count to send. (0-4 bytes)
*						Byte count > 4 will send four bytes only
*
*		Output:	d0.w	$0000 if call succeeded, Nonzero if failed
*
*				d1.l	high word = flags, low word packet type returned by Egret
*
*		Destroys:	D2.l, D3.l, D4.l, A5.l, A4.l, A1.l
*
************************************************************************************************************

			Export	SendEgretCmd
SendEgretCmd
			movea.l	DecoderInfo.VIA1Addr(a0),a1			; get VIA 1 base address				<P2> <SM7> rb, start
			move.l	#((MaxTout<<16) OR MaxRetries),d4	; number of retries before giving up with Egret <13>
			bsr5	Delay100us
		eieioSTP
			btst.b	#vsysSesBit,vBufB(a1)	; check for a transaction in progress
		eieioSTP
			beq.s	@AllOK

@Timeout
		eieioSTP
			bclr.b	#vsysSesBit,vBufB(a1)	; kill the rest of the transaction <8>
		eieioSTP
			bclr.b	#vViaFullBit,vBufB(a1)	; <8>
		eieioSTP
			bsr5	Delay100us				; in progretss <8>
  			bsr5	Delay100us				; <8>

@AllOK		swap.w	d4						; timeout in low word of d4 Retry count in high word <13>
		eieioSTP
			btst.b	#vxcvrSesBit,vBufB(a1)	; check for abort pending
		eieioSTP
			beq		IrqMissed				; MIssed Vsr Irq because of INITVIAS
			bset	#vsysSesBit,vBufB(a1)	; assert sysSesBit
		eieioSTP
			bsr5	@SendPtype				; send the packet type
			beq		RealAbort				; Discard Aborting transaction					<SM7> rb, end
;
;	If not abort transaction in progress then send the command byte
;
			swap	d0
			bsr5	sendByte1				; send the command byte
			bsr5	delay100us				; give Egret time to see viaEmpty
;
;	Now send number of bytes contained in d1 based on
;	byte count contained in d2.w
;
			move.l	d1,d0					; get the data to send
			subq	#1,d2					; adjust for DBRA
			cmp.w	#3,d2					; if count out of range quit
			bhi.s	@EndCmd					; if count valid then adjust for dbra
@sendloop	bsr5	sendByte1
			bsr5	delay100us
			lsr.l	#8,d0					; move data byte to low byte of register
@loopEntry	dbra	d2,@sendloop			; decrement byte count
;
;	Wait for the response packet header
;
@EndCmd		
		eieioSTP
			bclr.b	#SRdir,vACR(a1)			; shift in
		eieioSTP
			bclr.b	#vSyssesbit,vBufB(a1)	; negate vSyssesbit
		eieioSTP
			bsr5	Delay100us
;
;	Now receive the Standard Response packet Header
;
			bsr5	readAttn				; get the Attention byte
		eieioSTP
			bsr5	Delay100us
		eieioSTP
			bset.b	#vSyssesbit,vBufB(a1)	; assert vSyssesbit
		eieioSTP
			bsr5	readByte				; get the packet type
			and		#$00FF,d0				; keep low byte only
			swap	d0						; save the packet type
			bsr5	readByte				; get the flags byte
			and.w	#$00FF,d0				; keep low byte only
			swap	d0						; keep the flags byte as an error code
			exg		d0,d1					; save the packet type and flags returned
			bsr5	readByte				; get the command
		eieioSTP
			bclr.b	#vSyssesbit,vBufB(a1)	; negate vSyssesbit
		eieioSTP
			bsr5	Delay100us
;
;	Check for an error packet returned by Egret
;
			move.l	d1,d0					; save the packet type and flags
			cmp.b	#errorpkt,d0			; check for error packet
			beq.s	@Exit					; error pkt then just exit
			sub.w	d0,d0					; zero for success
@exit		rts6

;--------------------------------------------------------------------------
@SendPtype									;												<2>
		eieioSTP
			bset.b	#SRdir,vACR(a1)			; shift out
		eieioSTP
			btst.b	#vXcvrsesbit,vbufB(a1)	; check for abort
		eieioSTP
			beq.s	@AbortReq				; go away if abort requested
			move.b	d0,vSR(a1)				; load byte into shift reg
		eieioSTP
			bset.b	#vViafullbit,vBufB(a1)	; indicate shift reg is full
		eieioSTP
;
;	Check Vsr Irq until timeout.  If timeout then check the retry count
;	and Call Death Chimes if Retry count exausted.
;
@PollDelay		
		eieioSTP
			btst.b	#ifSR,vIFR(a1)			; wait for shift to complete
		eieioSTP
			bne.s	@VsrIrq					; Go service Shift register Irq <13>
			dbra.w	d4,@PollDelay			; try again if timed out <13><SM7> rb
			move.w	#MaxTout,d4				; Reset the Timeout <13><SM7> rb
			swap.w	d4						; get the Retry count <13><SM7> rb
			subq.w	#1,d4					; Try again if Retry count not Exausted <13><SM7> rb
			beq.s	@Timeout				; <13>

@DeadEgret	move.w	#ErrEgretInit,d7		; Egret failed <13>
			move.l	#0001,d6				; d6.l must be nonzero <13>
			bigjmp	Error1Handler,a3		; Play death chimes <13>

@VsrIrq	
		eieioSTP
			tst.b	vSR(a1)					; clear the interrupt
		eieioSTP
			bclr.b	#vViafullbit,vBufB(a1)	; now indicate shift reg empty
		eieioSTP
;
;		Delay 100 usec
;
			move.w	#DelayCnt,d3
@wait20		
		eieioSTP
			tst.b	(a1)					; sync to VIA clock
		eieioSTP
			dbra	d3,@wait20				; delay at least 100 us (very rough)
		eieioSTP
			btst.b	#vXcvrsesbit,vbufB(a1)	; check for abort
		eieioSTP
@AbortReq	rts5

;--------------------------------------------------------------------------
; DumpAbort	This routine will read all the data for an abort transaction and
;			discard it.  When done it will jump back to SendNopCmd entry point
;			to retry our command.  This command will eventually complete...

RealAbort
		eieioSTP
			bclr.b	#vSyssesbit,vBufB(a1)	; deassert system session
		eieioSTP
IrqMissed	bsr5	Delay100us				; Let Egret see SysSes. ≥ 125µsec
		eieioSTP
			bclr.b	#SRdir,vACR(a1)			; shift in
		eieioSTP
			tst.b	vSR(a1)					; discard the byte
		eieioSTP
			bset	#vSyssesbit,vBufB(a1)	; assert vSyssesbit
		eieioSTP

DumpAbort

		eieioSTP
		bclr	#vViafullbit,vBufB(a1)	; then negate VIA full bit
		eieioSTP

@loop
		eieioSTP
			btst.b	#ifSR,vIFR(a1)			; wait for shift to complete
		eieioSTP
			beq.s	@loop
			bset.b	#vViafullbit,vBufB(a1)	; acknowlege byte
		eieioSTP
			tst.b	vSR(a1)					; discard the byte
		eieioSTP
;
;		Delay 100 usec
;
			move.w	#DelayCnt,d3
@wait
		eieioSTP
			tst.b	(a1)					; sync to VIA clock
			dbra	d3,@wait				; delay at least 100 us (very rough)
		eieioSTP
			btst.b	#vXcvrsesbit,vBufB(a1)	; check for last byte
		eieioSTP
			beq.s	DumpAbort				; Clock Tick Packets only 2 bytes
;
;		Last byte was read
;
			bclr	#vViafullbit,vBufB(a1)	; then negate VIA full bit
		eieioSTP
			bclr.b	#vSyssesbit,vBufB(a1)	; negate vSyssesbit
		eieioSTP
			bsr5	Delay100us				; delay 200 usec
			bra.s	SendEgretCmd			; go try sending our command again

;--------------------------------------------------------------------------
sendByte1									;												<2>
		eieioSTP
			bset.b	#SRdir,vACR(a1)			; shift out
		eieioSTP
			move.b	d0,vSR(a1)				; load byte into shift reg
		eieioSTP
			bset.b	#vViafullbit,vBufB(a1)	; indicate shift reg is full
		eieioSTP
@poll	
		eieioSTP
			btst.b	#ifSR,vIFR(a1)			; wait for shift to complete
		eieioSTP
			beq.s	@poll
			tst.b	vSR(a1)					; clear the interrupt
		eieioSTP
			bclr.b	#vViafullbit,vBufB(a1)	; now indicate shift reg empty
		eieioSTP
			rts5

;--------------------------------------------------------------------------
readByte	
		eieioSTP			
			btst.b	#ifSR,vIFR(a1)			; wait for shift to complete
		eieioSTP
			beq.s	readByte
			bset.b	#vViafullbit,vBufB(a1)	; Tell Egret we saw the byte
		eieioSTP
			move.b	vSR(a1),d0				; read the byte
;
;		Delay 100 usec
;
		eieioSTP
			move.w	#DelayCnt,d3
@wait
		eieioSTP
			tst.b	(a1)					; sync to VIA clock
		eieioSTP
			dbra	d3,@wait				; delay at least 100 us (very rough)
		eieioSTP
			bclr	#vViafullbit,vBufB(a1)	; then negate VIA full bit
		eieioSTP
			rts5

;--------------------------------------------------------------------------
readAttn
		eieioSTP

			btst.b	#ifSR,vIFR(a1)			; wait for shift to complete
		eieioSTP
			beq.s	readAttn
		eieioSTP
			tst.b	vSR(a1)					; clear the interrupt
		eieioSTP
			rts5

;--------------------------------------------------------------------------
delay100us	
		move.w	#DelayCnt,d3
;	add.w	d3,d3						; let's make it even rougher
@wait
		eieioSTP
			tst.b	(a1)					; sync to VIA clock
		eieioSTP
			dbra	d3,@wait				; delay at least 100 us (very rough)
		eieioSTP
			rts5

;_______________________________________________________________________
;
;  Routine:		EclipsePDMPatch
;
;  Desc:		Patch for ECLIPSE PowerDown Messsage Handler Install
;				and PowerDown Message Enable
;_______________________________________________________________________

			EXPORT	EclipsePDMPatch
EclipsePDMPatch	
			WITH	EgretPB
;
;		Initialize the Eclipse PowerDown Message handler.
;
			movem.l	a0-a1,-(sp)						; work registers
			suba.l	#EgretPbSize,sp					; make room for PB
			move.l	sp,a0							; point a0 to pbBuffer									<T3>
			move.w	#(PDMVectPkt << 8),pbCmdType(a0); InitPDM Vector Packet (Cmd ignored)
			clr.l	pbCompletion(a0)				; No Completion
			lea		KeySwitchHandler,a1				; address of keyswitch sense handling					<T5>
			move.l	a1,PbParam(a0)
			_EgretDispatch

; •••••••••••••••••••••••••••••••••••••••••••••••••
;	We don't want to enable messages where we set up the Power Down Message Handler.  This is because		<T10>
;	up until the time a system is located to boot from, when the user turns the keyswitch OFF, there		<T10>
;	are no files to flush, no volumes to unmount and Caboose can safely turn the machine off with us		<T10>
;	getting in the way.  Once we get a system loaded, we'll enable Power Down Messages with the other		<T10>
;	routine, EclipsePDEPatch() (see below).																	<T10>
; •••••••••••••••••••••••••••••••••••••••••••••••••

;	We need to allocate a TimeMgr TMTask record that we can use once we enable power down messages so		<T15>
;	we can power the machine down even if UnMounts fail or hang.  ExpandMemRec has JUST been initialized	<T15>
;	when this patch gets called, so this is safe to do.														<T15>

		WITH	ExpandMemRec

			movea.l	expandMem,a1					; get base of ExpandMemRec								<T15>
			moveq.l	#(tmQSize+dtQElSize),d0			; request a TimeMgr TMTask+Deferred Task-sized record in SysHeap		<T15>
			_NewPtr	,SYS,CLEAR						;														<T15>
			move.l	a0,emKeyTMTaskPtr(a1)			; save pointer to TMTask record in ExpandMemRec			<T15>
		ENDWITH
			adda.l	#EgretPbSize,sp					; discard the parameter block
			movem.l	(sp)+,a0-a1						; restore registers
@EgretDone
			
			rts										; Return to Caller

;_______________________________________________________________________
;
;	Eclipse Keyswitch Handler
;	-------------------------
;
;		This routines either
;			(1) turns off Eclipse, or
;			(2) catches and ignores keyswitch changes interrupts
;			from Caboose, since we look directly at the keyswitch
;			position values on VIA2[PB][v2Keyswitch] or [v2PowerOff].
;
;		As of DVT hardware, the values of these keyswitch positions
;		should be available on VIA2 and no longer need to be maintained
;		in SW.
;_______________________________________________________________________
;
;		PowerDown Message Handler
;
			export	KeySwitchHandler				;														<T5>
			import	EgretPowerOff					; from EgretPatches.a									<T14>
			
KeySwitchHandler									; Handler of Power Down / Keyswitch Sense messages		<T5>

;	Caboose sends a message whenever the keyswitch sense changes.											<T5> thru next <T5>
;
;	Input:  D0.B		Keyswitch position
;
;				0			OFF
;				1			Secure
;				2			Insecure or ON ("normal")
;	

			tst.b	d0								; check for PowerOff message							<T10>
			bne.s	@rts							; IF Message == PowerDOWN THEN							<T10>

			movem.l	a0-a1,-(sp)						; save A0, A1											<T15> thru next <T15>

;	First, install a time manager task that will forcefull shut us down in 5 seconds.  That way,
;	in case something goes wrong with the deferred task, we will shut off anyway.

		WITH	ExpandMemRec

			movea.l	expandMem,a1					; get base address of ExpandMemRec
			movea.l	emKeyTMTaskPtr(a1),a0			; retrieve "final" Time Mgr queue element
			movea.l	a0,a1							; use A1 to clear the record
			moveq.l	#((tmQSize+dtQElSize)/2)-1,d0	; clear the TimeMgr+DeferredTask queue elements
@clrRec		clr.w	(a1)+							; just in case someone has crapped them up
			dbra	d0,@clrRec
			lea		PullThePlug,a1					; get address of where to go when timer expires
			move.l	a1,tmAddr(a0)					; tell the TimeMgr about it
			_InsTime								; go install the Turn Off The Power Time Mgr task
			move.l	#(5*1000),d0					; set timeout to be 5 SECONDS
			_PrimeTime								; activate the task

;	Now install the Deferred Task that will attempt to unmount all mounted volumes.
;
;	The ExpandMemRec Ptr points at an area that is tmQSize+dtQSize bytes big.
;
;	Initialize the Deferred Task queue element to point at our Unmount Volumes Deferred Task.

			adda.w	#tmQSize,a0						; move A0 to point at the Deferred Task Queue Element
			move.w	#dtQType,dtType(a0)				; and initialize the record
			lea		EclipseAdios,a1
			move.l	a1,dtAddr(a0)
			jsr		([jDTInstall])					; go install our Unmount and Shutdown deferred task
			movem.l	(sp)+,a0-a1						; restore A0, A1
			tst.w	d0								; see whether or not deferred task install was done
			bne.s	PullThePlug						; if it failed, shut down RIGHT NOW
@rts		rts										; if it was successful, return to the int. handler

		ENDWITH

;_______________________________________________________________________
;
;	Routine:	EclipseAdios
;
;	Desc:		Deferred Task installed when the keyswitch is turned
;				to the OFF position.  This attempts to Unmount all
;				volumes.  Once that attempt has been made, the system
;				is powered down.
;
;	Inputs:		None.
;	Returns:	None.
;	Trashes:	The System.  Power to Eclipse is turned off.  G'night.
;
;_______________________________________________________________________

EclipseAdios

;	Try and unmount any mounted volumes before we power down.

			move.l	VCBQHdr+qHead,a1				;   Start at the head of the VCBQ
			bra.s	@checkVCB						;   Check if valid
@UMloop
			tst.w	vcbFSID(a1)						;   Make sure it’s FSID = 0
			bne.s	@nextQEntry						;   ... i.e. not a server

; Try to unmount the volume.

			sub.w	#ioQElSize,a7					;   get an I/O param block
			movea.l	a7,a0
	
			move.w	vcbVRefNum(a1),ioVRefNum(a0)	;   stuff VCB VRefNum into PB
			move.l	#0,ioFileName(a0)
			move.l	#0,ioCompletion(a0)				;   no completion routine
			move.l	a1,-(sp)						;   save A1 (queue link ptr)
			_HUnmountVol							;   attempt to forcefully unmount volume
			movea.l	(sp)+,a1						;   restore A1
			adda.w	#ioQElSize,a7					;   get rid of PB.  we'll reallocate the PB if needed

@nextQEntry	movea.l	qLink(a1),a1					;   get next queue entry
@checkVCB	move.l	a1,d0							;   at EOQ yet?
			bne.s	@UMloop							;   nope, try this one

PullThePlug											; ENDIF
			bsr.l	EgretPowerOff					; power junkies go into sudden withdrawl				<T16>
			bra.s	PullThePlug						; with no hope of recovery								<T16>

;_______________________________________________________________________
;
;  Routine:		EclipseDFACPatch
;
;  Desc:		Patch for ECLIPSE send default DFAC Messsage
;_______________________________________________________________________
			EXPORT	EclipseDFACPatch

EclipseDFACPatch
;
;		Build a Parameter block for the default DFAC message
;
			movem.l	a0-a1,-(sp)						; work register
			suba.l	#EgretPbSize,sp					; make room for PB
			move.l	sp,a0							; point a0 to pbBuffer									<T4>
			move.w	#(pseudoPkt << 8) \
					+ SetDefDFAC,pbCmdType(a0)		; InitPDM Vector Packet (Cmd ignored)
			clr.l	pbCompletion(a0)				; No Completion
;
;	Build the DFAC message issue the call and clean up
;
			move.w	#$0100,-(sp)					; byte count and one DFAC byte in buffer
			move.l	sp,pbBufPtr(a0)					; Buffer pointer
			move.w	#$0002,pbByteCnt(a0)			; byte count includes the byte count byte in the buffer
			_EgretDispatch
			adda.l	#EgretPbSize+2,sp				; discard the parameter block and data buffer
			movem.l	(sp)+,a0-a1
@EgretDone
			rts										; Return to Caller

;_______________________________________________________________________									<T16> thru next <T16>
;
;  Routine:		DebugUtilRunKbdPatch
;
;  Desc:		Checks to see if the machine we're running on has a
;				keyswitch, and if so, if it's in the OFF position.
;				If so, then we probably don't have any choice as to
;				whether volumes can be flushed and unmounted, so we
;				go directly to the PowerOff routine.  Do not pass Go,
;				do not collect $200.  (is that 200 hex dollars?)
;
;  NOTE:		This handles both the DebugEnter _and_ DebugPoll cases.
;_______________________________________________________________________

			EXPORT		DebugUtilRunKbdPatch		; provide address to InterruptHandlers.and anyone else
DebugUtilRunKbdPatch

			TestFor	KeyswCabooseBit					; do we have a caboose?			<21>
			beq.s	@justDoIt						;  nope							<21>

;	If you made it here, you're a Caboose-flavor keyswitch.
;
;	VIA2 has v2PowerOff and v2Keyswitch (SECURE mode) wired, with 0=TRUE.

			move.l	a1,-(sp)						;     save A1 temporarily
			movea.l	VIA2RBV,a1						;     retrieve address of VIA2
		eieioSTP
			btst.b	#v2PowerOff,VBufB(a1)			;     is the keyswitch OFF?
		eieioSTP
			move.l	(sp)+,a1						;     restore A1
			beq.s	@powerOff						;     IF Keyswitch != OFF THEN
@justDoIt
			bra		DebugPwrMgrADBPatch2			;         check for PowerMgr stuff
@powerOff											;     ELSE
			bra.s	PullThePlug						;         administer the death blow						<T16>

DebugPwrMgrADBPatch2
			TestFor	hwCbPwrMgr				; see if we have a power manager
			beq.s	@noPmgrADB				; if not, skip it

			movea.l	VIA,a1					; point to the VIA
			movea.l	Lvl1DT+(ifCB1*4),a0		; get the handler address
			jsr		(a0)					; call the interrupt handler
			addq.l	#4,SP					; clean up stack from bsr			
			movem.l	(sp)+,d3/a3				; restore registers
			rts
@noPmgrADB
			rts	

;_______________________________________________________________________
;
;  Routine:		EgretDFACandPDM			formerly:	EclipseEgretPatches				<P4><MC2>
;
;  Desc:		Calls egret patches for Eclipse with Caboose, keyswitch
;				Calls Egret patches for Anyone with Cuda, SoftPower Off
;_______________________________________________________________________

				EXPORT	EgretDFACandPDM
				IMPORT	CudaPDMPatch

EgretDFACandPDM	

			move.l	#EgretFWMask, d0				; get productInfo record mask for Egret FW
			and.l	UnivRomFlags,d0					; isolate the field
			sub.l	#Caboose,d0						; Do we have an Egret/Caboose?
			bne.s	@Done							; -> Nope. Don't do nothing!

	; Instead of calling EclipseDFACPatch, this should more generally initialize DFAC
	; for all machines that care about it (or even if we don't but it needs it anyway).
	;	-- bg/djw, 12/6/90

@EgretCaboose
			bsr		EclipseDFACPatch				; call the Eclipse DFAC control patch
			bsr		EclipsePDMPatch					; call the Eclipse keyswitch/PowerDown Msgs patch
@Done		rts										; Return to Caller


;--------------------------------------------------------------------------
;ChkFirmware																		<P2>
;
;	This routine will determine if the Egret Chip is using Egret 8 or Caboose
;	firmware or the new Cuda firmware.  Based on this result, the IRQ handler,
;	Dispatcher, and Tick handler vectors are set up...
;	Inputs:
;		A2	->	EgretGlobals
;	Outputs:
;		A0 	->	ShiftRegIRQ	
;		A1	->	TickHandler
;	Trashes:
;		A0,A1

			
ChkFirmware											;								<P2>
			movem.l	a2/d0-d2, -(sp)					; preserve used regs

			move.l	#EgretFWMask,d0					; mask for EgretFW				<MC2>
			and.l	UnivRomFlags,d0					; isolate the field
			sub.l	#Egret8,d0						; see if we have EgretFW
			beq.s	@haveEgret						; set Zero flag, exit

	; If we dont have Egret FW, we still might have an Caboose FW

			sub.l	#Egret8,d0						; see if we have CabooseFW
			beq.s	@haveCaboose					; if we do, chk for Cuda

@haveCuda											;								
			biglea	CudaDispatch, a0				; Cuda FW dispatcher			
			move.l	#$92,d0							; set $92 trap					
			_SetTrapAddress	,NEWOS
			
			biglea 	CudaShiftRegIRQ,a0				; stuff Cuda IRQ handler in	
			biglea	CudaTickHandler,a1				; stuff Cuda tick handler in
			bra.s	@chkDone						;								

@haveEgret
@haveCaboose
			lea		EgretDispatch, a0				; Egret FW dispatcher	
			move.l	#$92,d0							; set $92 trap			
			_SetTrapAddress	,NEWOS							;				
													;							
			lea 	ShiftRegIRQ,a0					; stuff Egret IRQ handler in
			lea		tickHandler,a1					; stuff Egret tick handler in
@chkDone
			movem.l	(sp)+, a2/d0-d2					; restore used regs
			rts
			


;--------------------------------------------------------------------------			<P2>
;SendEgretCmdPatch
;
;	This routine will determine if the Egret Chip is using Egret 8 or Caboose
;	firmware or the new Cuda firmware.  From the firmware type, determine what
;	routine to use, SendEgretCmd for Egret or Caboose, and SendCudaCmd for Cuda
;
;	NOTE:  This routine is REGISTER based, there isn't a stack						<P4>
;	SendEgretCmd is called via BSR6, so must Preserve A6, as the return address		<P4>
;	SendEgretCmdPatch is called via a BSR5 return is in A5							<P4>
;		Input:
;				a0.l	Pointer to Base address table
;
;				d0.l =  High word PACKET Command
;						Low word PACKET Type
;
;				d1.l =	Up to four bytes of data to send
;						Long word data byte assigment = byte 4, byte 3, byte 2, byte 1
;						Byte 1 sent out first
;
;				d2.l = 	Byte count to send. (0-4 bytes)
;						Byte count > 4 will send four bytes only
;
;--------------------------------------------------------------------------			<P2>

SendEgretCmdPatch
		move.l	a5, a3						; preserve patch return addr
		move.l	a6, a4						; preserve EgretInit rtn addr
		bigbsr6	GetHardwareInfo,a1			;							
		move.l	a4, a6						; restore EgretInitrtn addr	
		move.l	a3, a5						; restore patch rtn addr	
		moveq.l	#ProductInfo.ADBMask,d0		;mask for ADB kind					<23>
		and.l	d1,d0						;isolate the field					<23>
		subq.l	#ProductInfo.ADBEgret,d0	;see if we have Egret ADB			<23>
		
		and.l	#EgretFWMask,d4				; isolate the field			
		sub.l	#Egret8,d4					; see if we have Egret8 FW	
		beq.s	@patchdone					; if we do, zero flag set	
;
;	If we dont have Egret FW, we still might have an Caboose			
;
		sub.l	#Egret8,d1					; see if we have Caboose FW	
@haveEgret										; if we do, zero flag set
		beq.s	@patchdone					; its Egret or Caboose, just exit...
@haveCuda									;							
		bigjmp	SendCudaCmd,a3				; jump to Cuda Send routine	
@patchdone									;							
		movea.l	DecoderInfo.VIA1Addr(a0),a1			; get VIA 1 base address
		move.l	#((MaxTout<<16) OR MaxRetries),d4	; number of retries before giving up with Egret <13>
		rts5
		
;--------------------------------------------------------------------------
;EgretInitPatch															
;																		
;	This routine will determine if the Egret Chip is using Egret 8 or Caboose		<P4> 
;	firmware or the new Cuda firmware.  From the firmware type, determine what
;	routine to use, EgretInit for Egret or Caboose, and CudaInit for Cuda	
;																		
;	NOTE:  This routine is REGISTER based, there isn't a stack
;	EgretInit is called via BSR6, so must Preserve A6, as the return address
;	EgretInitPatch is called via a BSR5 return is in A5					
;	
EgretInitPatch								;							
		move.l	a5, a3						; preserve patch return addr
		move.l	a6, a4						; preserve EgretInit rtn addr
		bigbsr6	GetHardwareInfo,a1			;							
		move.l	a4, a6						; restore EgretInitrtn addr	
		move.l	a3, a5						; restore patch rtn addr	
		
		and.l	#EgretFWMask,d1				; isolate the field			
		sub.l	#Egret8,d1					; see if we have Egret8 FW	
		beq.s	@patchdone					; if we do, zero flag set	
;
;	If we dont have Egret FW, we still might have an Caboose			
;
		sub.l	#Egret8,d1					; see if we have Caboose FW				
@haveEgret										; if we do, zero flag set			
		beq.s	@patchdone					; its Egret or Caboose, just exit...	
@haveCuda									;										
		bigjmp	CudaInit,a3					; jump to CudaInit routine in CudaMgr.a 
@patchdone									;										
		movea.l	DecoderInfo.VIA1Addr(a0),a1	; get VIA 1 base address				
	eieioSTP
		bclr.b	#vsysSesBit,vBufB(a1)		; kill any pending transactions <8> <13> <P2>
	eieioSTP
		bclr.b	#vViaFullBit,vBufB(a1)		; 								<8> <13> <P4>
	eieioSTP
		rts5

TerrorEgret		

				IMPORT	ExplicitRequestDone, ImplicitRequestDone
;_______________________________________________________________________
;
;  Routine:		StartReqEgret
;  Inputs:		D2 - length of transmit buffer data
;				D3 - command byte / implicit flag (bit 31)
;				A2 - pointer to buffer containing transmit data
;				A3 - pointer to ADBBase
;
;  Outputs:		A3 - pointer to ADBBase
;				
;  Destroys:	A0-A2/D0-D2
;  Calls:		exits through _EgretDispatch
;
;  Function:	Sends an ADB request to the Egret, and asynchronously waits for a reply.
;
;_______________________________________________________________________

			with	ADBVars,EgretPB


jEgretDispatch	equ	OSTable+($92*4)		; OS trap table entry for _EgretDispatch

StartReqEgret
			tst.l	d3					; see if explicit/implicit
			bmi.s	@implicit			; if implicit, we generally don't need to do anything

;_______________________________________________________________________
;	Process Explicit Requests

@explicit	bset.b	#fDBExpRunning,fDBAuFlag(a3); explicit command starting, exclude new ones
			bne.s	@ignoreExplicit				; if already in progress, don't run it twice
			move.b	d3,ExplicitEPB.pbCmd(a3)	; setup the ADB command
			move.w	d2,ExplicitEPB.pbByteCnt(a3); setup byte count
			move.l	a2,ExplicitEPB.pbBufPtr(a3)	; setup buffer pointer

			bset.b	#fDBExpInited,fDBAuFlag(a3)	; see if explicit command initialization has occured
			bne.s	@expInited					; if already inited, no need to change anything

			lea		@ExplicitCompleted,a0			; explicit request completion routine address
			move.l	a0,ExplicitEPB.pbCompletion(a3)	; setup buffer pointer

			lea		ImplicitEPB(a3),a0	; point to the param block used to wait for autopoll data
			clr.l	pbCompletion(a0)	; remove the handler
			bsr.s	@SendToEgret		; remove the auto poll handler

			move.l	#(pseudoPkt<<24)\	; pcCmdType := pseudoPkt
					+(aPoll<<16)\		; pbCmd := aPoll
					+($00<<8),d0		; pbParam := $00 (only high byte is used)
			bsr.s	@syncReq			; send command to stop auto polling
@expInited

			lea		ExplicitEPB(a3),a0	; point to the param block
@SendToEgret
			moveq.l	#0,d1				; zero the trapword flag bits (in case they ever get used)
			movea.l	jEgretDispatch,a2	; get the OSTrap table entry
			jmp		(a2)				; _EgretDispatch, issue the request (asynchronously), return


;_______________________________________________________________________
;	Process Implicit Requests

@implicit	btst.b	#fDBInit,fDBFlag(a3); see if initialization is happening
			bne.s	@impDone			; if so, implicit commands are ignored
			bset.b	#fDBImpInited,fDBAuFlag(a3)	; see if implicit command initialization has occured
			beq.s	@InitImplicit		; if not inited, do initialization to allow autopolling
@ignoreExplicit
@impDone	rts							; auto-polling/srq data will arrive unsolicited from now on

@InitImplicit
			lea		ImplicitEPB(a3),a0	; point to the param block used to wait for autopoll data
			lea		@ImplicitCompleted,a1	; handler address
			move.l	a1,pbCompletion(a0)	; install the handler
			bsr.s	@SendToEgret		; install the auto poll handler

			move.l	#(pseudoPkt<<24)\	; pcCmdType := pseudoPkt
					+(wrDevList<<16),d0	; pbCmd := wrDevList
			move.w	DevMap(a3),d0		; pbParam := DevMap (in first 2 bytes)
			bsr.s	@syncReq			; send command to specify auto polling addresses

			move.l	#(pseudoPkt<<24)\	; pcCmdType := pseudoPkt
					+(aPoll<<16)\		; pbCmd := aPoll
					+($FF<<8),d0		; pbParam := $FF (only high byte is used)
										; send command to start auto polling

@syncReq	suba.w	#EgretPBSize,sp		; allocate a param block on the stack for a sync call
			movea.l	sp,a0				; point to the param block
			move.l	d0,pbCmdType(a0)	; init pcCmdType, pbCmd, and high word of pbParam
			clr.l	pbCompletion(a0)	; no completion routine, sync call
			bsr.s	@SendToEgret		; call send the request off to the ADB micro
			adda.w	#EgretPBSize,sp		; deallocate the param block
			rts							; auto-polling/srq data will arrive unsolicited from now on
			Title	'KbdADB - ADB Manager  -  ExplicitCompleted'

;_______________________________________________________________________
;
;  Routine:		@ExplicitCompleted
;  Inputs:		A0 - Pointer to the EgretPB of the Explicit Request
;
;  Outputs:		D2 - length of receive buffer data
;				D3 - command byte / SRQ flag (bit 31)
;				A2 - pointer to buffer containing receive data
;				A3 - pointer to ADBBase
;
;  Calls:		exits through ImplicitRequestDone / ExplicitRequestDone
;  Called by:	Egret Manager, Asynchronous request completion routine
;
;  Function:	Completion routine for servicing explicit ADB requests.
;
;_______________________________________________________________________

@ExplicitCompleted						; A0 := pointer to EgretPB
		if EgretDebug then
			btst.b	#EgAutoPoll,pbFlags(a0)	; see if this was from auto poll
			beq.s	@ExplicitOK			; if not, we're still OK
			_Debugger					; something is wrong with this picture
@ExplicitOK
		endif			
			moveq.l	#(1<<EgSRQ),d3		; mask to test for SRQ pending
			and.b	pbFlags(a0),d3		; isolate the SRQ flag
			neg.l	d3					; set bit 31 if SRQ pending
			move.b	pbCmd(a0),d3		; get the ADB command byte
			moveq	#0,d2				; zero extend the length
			move.w	pbByteCnt(a0),d2	; get the length
			movea.l	pbBufPtr(a0),a2		; get the buffer pointer
			bsr.s	@FillInVars			; setup A3, and ADB globals for ADB Parser
			bclr.b	#fDBExpRunning,fDBAuFlag(a3)	; explicit command completed, allow new ones

;
;	For Egret must check the ADB Device address against the Device Bitmap				<5>
;	to see if the device exists.  If it does not, force Egret to Poll the Mouse
;	as the MRU device and Keyboard as the LRU device. (Bug Fix for Egret)
;
;	Entry:	a3.l	= ADB Globals
;			d0.b	= ADB device address

			move.w	devmap(a3),d1			; get the ADB device Bitmap
			btst.l	d0,d1					; check bit position in low word
			bne.s	@exit					; Device Exits

;------------------------------------------------------------------------------
;	Force the MRU & LRU values to Mouse & Keyboard to work around bug where Egret
;	AutoPolls devices which are not in the DevMap.
;
;	Entry:		NONE
;
;	Exit:		NONE
;	
;	Destroys:	NONE
;
;------------------------------------------------------------------------------

			suba.l	#EgretPbSize,sp						; make room for Egret Manager PB
			movea.l	sp,a0
			move.l	#0,pbCompletion(a0)					; no Completion vector
			move.w	#((pseudoPkt << 8) + \
					Wr6805addr),pbCmdType(a0)			; packet type & command
			move.w	#((MouseAddr * $1000) + \			; Mouse & Keyboard into MRU & LRU
					(KbdAddr * $10)),-(sp)				; Mouse Addr in bits C-F, Kbd Addr bits 4-7
			move.l	sp,pbBufPtr(a0)						; buffer pointer in PB
			move.w	#MRUAddr,pbParam(a0)				; Egret address to write
			move.w	#2,pbByteCnt(a0)					; 2 bytes to write
			_EgretDispatch								; issue the call
			adda.l	#EgretPbSize+2,sp					; Discard Buffer & Parameter block	<5>

@exit
			bigjmp	ExplicitRequestDone,a0	; Return control to the ADB Manager

@FillInVars	movea.l	ADBBase,a3			; point to ADB globals in low memory

;	keep the ADB Parser program happy by updating the following variables
;	They are not used by this implementation, but we fill them in with approximate
;	values to make the tool happy.

			move.b	d3,fDBCmd(a3)		; last ADB command
			move.b	d3,pollCmd(a3)		; assume that it was a poll command
			move.b	d3,d0				; copy the command
			lsr.b	#4,d0				; get the address
			move.b	d0,pollAddr(a3)		; assume that it was a poll address
			rts							; all done
			Title	'KbdADB - ADB Manager  -  ImplicitCompleted'

;_______________________________________________________________________
;
;  Routine:		@ImplicitCompleted
;  Inputs:		A0 - Pointer to the EgretPB of the Implicit Request
;				D0 - Number of data bytes returned (word, 0..8)
;				A1 - Pointer to Flags, Command, Data Buffer
;
;  Outputs:		D2 - length of receive buffer data
;				D3 - command byte / SRQ flag (bit 31)
;				A2 - pointer to buffer containing receive data
;				A3 - pointer to ADBBase
;
;  Calls:		exits through ImplicitRequestDone / ExplicitRequestDone
;  Called by:	Egret Manager, Asynchronous request completion routine
;
;  Function:	Completion routine for servicing explicit ADB requests.
;
;_______________________________________________________________________

@ImplicitCompleted
		if EgretDebug then
			btst.b	#EgAutoPoll,(a1)	; see if this was from auto poll
			bne.s	@ImplicitOK			; if so, we're still OK
			_Debugger					; something is wrong with this picture
@ImplicitOK
		endif
			moveq.l	#(1<<EgSRQ),d3		; mask to test for SRQ pending
			and.b	(a1)+,d3			; isolate the SRQ flag
			neg.l	d3					; set bit 31 if SRQ pending
			move.b	(a1)+,d3			; get the ADB command byte
			moveq	#0,d2				; zero extend the length
			move.w	d0,d2				; get the length
			movea.l	a1,a2				; get the buffer pointer
			bsr.s	@FillInVars			; setup A3, and ADB globals for ADB Parser
			bigjmp	ImplicitRequestDone,a0	; Return control to the ADB Manager
			endwith



			Export		DebugEnterCont
	
DebugEnterCont
			with ProductInfo

			move.l	UnivRomFlags,d0		; get the Universal system flags
			andi.l	#ADBMask,d0			; we want ADB
			cmpi.l	#ADBEgret,d0		; and specifically EGRET version of ADB
			bne.s	@EgretDone

			endwith

;
;	Build a Egret Parameter block to stop 1 second interrupts
;
		WITH	EgretPb
			move.l	a0,-(sp)				; work registers
			suba.l	#EgretPB.EgretPbSize,sp	; room for parameter block
			move.l	sp,a0					; point to the parameter block
			move.w	#(EgretPB.EgretPBSize/2)-1,d0	; clear the PB area a word at a time

			move.l	a0,-(sp)				; save pointer to parameter block
@Loop		move.w	#0,(a0)+				; zeros forces mode 0 & no Completion vector
			dbra	d0,@Loop
			move.l	(sp)+,a0				; restore parameter block pointer

			move.w	#((pseudoPkt << 8) + Wr1SecMode),EgretPB.pbCmdType(a0)	; Packet type & command
			_EgretDispatch		
;
;	Suspend the PDM, with out reseting vars within Cuda
;
			move.w	#(PseudoPkt << 8) \
					+ EnDisPDM,pbCmdType(a0); Enable PowerDown Messages					<P3>
			clr.l	pbParam(a0)				; clr parameter blk							<P3>
			move.b	#PDMSuspend,pbParam(a0) ; PDM Continue								<P3>
			clr.l	pbCompletion(a0)		; No Completion								<P3>
;			_EgretDispatch																<SM11> gjs

			adda.l	#EgretPB.EgretPbSize,sp	; discard parameter block
			move.l	(sp)+,a0				; restore work registers
		ENDWITH
@EgretDone

			moveq.l	#noErr,d0				; return with success
			rts

;••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••

			Export		DebugExitCont
	
DebugExitCont
			with ProductInfo

			move.l	UnivRomFlags,d0		; get the Universal system flags
			andi.l	#ADBMask,d0			; we want ADB
			cmpi.l	#ADBEgret,d0		; and specifically EGRET version of ADB
			bne.s	@EgretDone

			endwith

;
;	Build a Egret Parameter block to start 1 second interrupts (Mode 3)
;
		WITH	EgretPB
			move.l	a0,-(sp)				; work registers
			suba.l	#EgretPB.EgretPbSize,sp	; room for parameter block
			move.l	sp,a0					; point to the parameter block
			move.w	#(EgretPB.EgretPBSize/2)-1,d0	; clear the PB area a word at a time

			move.l	a0,-(sp)				; save pointer to parameter block
@Loop		move.w	#0,(a0)+				; zeros forces mode 0 & no Completion vector
			dbra	d0,@Loop
			move.l	(sp)+,a0				; restore parameter block pointer
			move.w	#((pseudoPkt << 8) + Wr1SecMode),EgretPB.pbCmdType(a0)	; Packet type & command
			move.b	#Mode3Clock,EgretPB.pbParam(a0)	; Turn on Mode 3 clock data packets
			_EgretDispatch		
;
;	Macsbug Continue the PDM
;
			move.w	#(PseudoPkt << 8) \
					+ EnDisPDM,pbCmdType(a0); Enable PowerDown Messages					<P3>
			clr.l	pbParam(a0)				; clr parameter blk							<P3>
			move.b	#PDMDebugCont,pbParam(a0) 		; Macsbug Continue				<SM11> gjs <P3>
			clr.l	pbCompletion(a0)		; No Completion								<P3>
			_EgretDispatch

			adda.l	#EgretPB.EgretPbSize,sp	; discard parameter block
			move.l	(sp)+,a0				; restore work registers
@EgretDone
		ENDWITH
			moveq.l	#noErr,d0				; return with success
			CLR.B	DSWndUpdate 			; flag GNE to remove the alert . . . just in case <SM11> gjs
			rts

			ENDP
			END