1898 lines
70 KiB
Plaintext
1898 lines
70 KiB
Plaintext
;
|
||
; File: DockingMgr.a
|
||
;
|
||
; Contains: support for docking portable Macintoshes into desktop docking modules
|
||
;
|
||
; Written by: Steve Christensen
|
||
;
|
||
; Copyright: © 1992-1993 by Apple Computer, Inc. All rights reserved.
|
||
;
|
||
; This file is used in these builds: ROM
|
||
;
|
||
; Change History (most recent first):
|
||
;
|
||
; <SM8> 12/13/93 PN Roll in KAOs and Horror changes to support Malcom and AJ
|
||
; machines.
|
||
; <SM7> 9/2/93 KH Rolled in the Horror changes (finally)
|
||
; <SM7> 9/2/93 SKH My fixes are back in now...
|
||
; <SM6> 9/1/93 SKH Backed out my changes until I was certain they wouldn't break builds.
|
||
; <SM5> 9/1/93 SKH Rolled in Horror version of docking code (with dock cache control stuff)
|
||
; <SM4> 12/4/92 GD Added a forRomulator conditional so that we don't (re)initialize
|
||
; the SCC when debugging.
|
||
; <SM3> 11/20/92 SWC Rolled in the rest of the Horror changes. Changed INCLUDEs to
|
||
; use new filenames.
|
||
; <H26> 8/13/92 SWC Added a new selector call in SetupDockBases to do any last
|
||
; minute pre-boot initialization. This is provided as a means of
|
||
; allowing the config ROMs to patch up anything we might have
|
||
; forgotten.
|
||
; <H25> 8/11/92 SWC Exported DockInitSCC and fixed it to preserve its registers.
|
||
; <H24> 8/10/92 SWC Specifically check for (and handle) the ‘docking slot’ selector
|
||
; in DockingDispatch so handlers, etc., have a way of determining
|
||
; which slot they're in.
|
||
; <H23> 7/29/92 SWC Fixed a typo (ended up looking at the wrong thing).
|
||
; <H22> 7/27/92 SWC Block checking for eject until after we get to the Finder.
|
||
; <H21> 7/24/92 SWC Added a check if a bar was added during sleep that's not
|
||
; supposed to be added then, and if so, the next time we wake up,
|
||
; remove its handler, etc. (takes care of the case of trying to
|
||
; add it multiple times).
|
||
; <H20> 7/8/92 SWC Made some changes to GracefulShutdown to make it better at
|
||
; successfully shutting down. DockingFilter now prevents waking up
|
||
; if we'd have to run without the LCD display since we currently
|
||
; can't handle removing a monitor from the desktop.
|
||
; <H19> 7/1/92 SWC Reset internal [and external] SCCs in SetHardwareBases so we
|
||
; won't get spurious interrupts from the unused SCC when a bar
|
||
; with another SCC is connected during sleep.
|
||
; <H18> 6/29/92 HJR SWC/Fixed my fix to Dave Wong's external32bit code from <H14>.
|
||
; <H17> 6/29/92 SWC Added in code to allow us to do a graceful shutdown when the
|
||
; eject button is pressed on a docking station.
|
||
; <H16> 6/25/92 SWC Pulled out the save/restore A2 code in <H13> since that's all
|
||
; fixed now. TravelBarHandler now returns SWIM2 power status if a
|
||
; SWIM2 exists.
|
||
; <H15> 6/18/92 SWC As part of our continuing incestuous relationship with the Power
|
||
; Manager, clear the clamshellClosed flag in the ‘sleep denied’
|
||
; Notification Manager completion routine so we won't try to keep
|
||
; posting messages until the current one goes away. Added
|
||
; RegisterVideo to the wakeup installation so we'll have a hook to
|
||
; let the system know about the addition of a new video device. It
|
||
; currently does nothing.
|
||
; <H14> 6/15/92 ag Added code to set the external32bit flag in the gdflags of
|
||
; gdevice data structure based the information from the slot
|
||
; manager.
|
||
; <H13> 6/3/92 SWC Cleaned up some of my duplicated code. Temporarily save/restore
|
||
; A2 around calls to the docking handler because the DeskBar and
|
||
; Gemini docking handlers trash it (a bug to be fixed).
|
||
; <H12> 6/1/92 HJR Changed CheckConnectNiagra for our current implementation. Call
|
||
; InitDefGamma in vAddVideoDevice.
|
||
; <H11> 5/29/92 SWC Set up docking support for Dartanian. Added a routine to notify
|
||
; the user that they tried to attach a bar during sleep that's not
|
||
; supposed to be added during sleep.
|
||
; <H10> 5/20/92 SWC Now pass the CPU's clock speed to the docking handler so it can
|
||
; configure any of its hardware that cares.
|
||
; <H9> 5/8/92 SWC Added a new routine to call Alex Kazim's Comm Toolbox hack to
|
||
; resolve which serial ports are currently available. Abort wakeup
|
||
; docking handler installation if that kind of bar is not allowed
|
||
; to be added during sleep.
|
||
; <SM2> 10/22/92 CS Change some branch short instructions to branches.
|
||
; <1> 5/16/92 kc first checked in
|
||
; <H8> 4/22/92 SWC Changed DockingWakeup so that it will only add video if video is
|
||
; supported AND a monitor is connected, so we can handle the case
|
||
; of adding a bar to use the floppy disk and then remove it when
|
||
; we're done (with video it would be locked in until shutdown).
|
||
; Added a new routine (DockingSleepDenied) to put up a
|
||
; Notification Manager dialog to let the user know that they can't
|
||
; put the system to sleep when a bar won't allow it.
|
||
; <H7> 4/13/92 SWC Added a flag to show that a bar was added during sleep. Added a
|
||
; check for eject from a docking station. Did some code cleanup.
|
||
; <H6> 4/3/92 SWC Increased the overpatch padding size to 4K.
|
||
; <H5> 3/20/92 SWC Rolled in Dave Wong's new Slot Manager support, and fixed how
|
||
; the sleep and wakeup code works. Vectored some more routines.
|
||
; Increased the overpatch file size from 1K to 2K since it
|
||
; overflowed.
|
||
; <H4> 3/6/92 SWC Enable/disable docking slot interrupts depending on whether or
|
||
; not a bar is connected. Make the built-in docking handlers
|
||
; return the SCC ports available when no bar is connected.
|
||
; <H3> 3/3/92 SWC Moved the check for SCSI Disk Mode to SCSIDiskMode.a since
|
||
; that's now part of the build, and the logical place to put it.
|
||
; <H2> 2/17/92 SWC Load the bar's docking attributes into the Power Manager globals
|
||
; so we can decide if we want to sleep, power cycle, etc.
|
||
; <H1> 2/14/92 SWC First checked in.
|
||
|
||
|
||
PRINT OFF
|
||
LOAD 'StandardEqu.d'
|
||
INCLUDE 'HardwarePrivateEqu.a'
|
||
INCLUDE 'UniversalEqu.a'
|
||
INCLUDE 'GestaltEqu.a'
|
||
INCLUDE 'MFPrivate.a'
|
||
INCLUDE 'Notification.a'
|
||
INCLUDE 'PowerPrivEqu.a'
|
||
INCLUDE 'Processes.a'
|
||
INCLUDE 'ROMEqu.a'
|
||
INCLUDE 'Slots.a'
|
||
INCLUDE 'SCSI.a'
|
||
INCLUDE 'SCSIPriv.a'
|
||
INCLUDE 'Shutdown.a'
|
||
INCLUDE 'DockingEqu.a'
|
||
PRINT ON
|
||
|
||
BLANKS ON
|
||
STRING ASIS
|
||
MACHINE MC68020
|
||
|
||
|
||
Unimplement EQU $A89F ; _Unimplemented trap
|
||
SyncIdleTime EQU $ABF7
|
||
|
||
|
||
|
||
DockingMgr PROC EXPORT
|
||
|
||
EXPORT DockingDispatch, InitDocking, SetupDockBases, DockInitSCC, GracefulShutdown
|
||
EXPORT DockingSleep, DockingWakeup, DockingSleepDenied, DockingWakeupDenied
|
||
|
||
IMPORT InitSCC, CacheFlush
|
||
|
||
WITH DockingGlobRec, NMRec, PmgrRec, pmCommandRec, scsiGlobalRecord, SEBlock, SpBlock
|
||
WITH DecoderInfo, DecoderKinds, NubusInfo, ProductInfo, ProcessInfoRec
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; pascal long DockingDispatch(OSType selector, long params)
|
||
;
|
||
; dispatches to the appropriate docking handler
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingDispatch
|
||
MOVEA.L DockingGlobals,A0 ; point to our variables
|
||
MOVEA.L dockingHandler(A0),A1 ; and get the address of our handler
|
||
CMPI.L #dockDockingSlot,8(SP) ; is this the ‘docking slot’ selector? <H24>
|
||
BNE.S @CallHandler ; -> no, pass it thru to the docking handler <H24>
|
||
MOVEA.L (SP)+,A1 ; pop the return address <H24>
|
||
ADDQ.W #8,SP ; and toss the parameters <H24>
|
||
MOVEQ #0,D0 ; <H24>
|
||
MOVE.B dockingSlotNum(A0),D0 ; get the docking slot number <H24>
|
||
MOVE.L D0,(SP) ; and return it as the result <H24>
|
||
@CallHandler
|
||
JMP (A1) ; call the docking handler or just return
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; pascal long NoBoardHandler(OSType selector, long params)
|
||
;
|
||
; docking handler when no docking module is connected
|
||
;__________________________________________________________________________________________________
|
||
|
||
NoBoardHandler
|
||
MOVEA.L (SP)+,A1 ; pop the return address
|
||
ADDQ.W #4,SP ; and toss params
|
||
MOVEQ #0,D0 ; assume an unsupported selector
|
||
CMPI.L #dockSCCPorts,(SP)+ ; is it the port list selector?
|
||
BNE.S @Done ; -> nope
|
||
MOVEA.L DockingGlobals,A0 ; point to the Docking Manager globals
|
||
MOVE.L builtInSCCPorts(A0),D0 ; get which ports are built in
|
||
|
||
@Done MOVE.L D0,(SP) ; return the selector result
|
||
JMP (A1)
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; pascal long TravelBarHandler(OSType selector, long params)
|
||
;
|
||
; docking handler for a travel bar (since it has no configuration ROM)
|
||
;__________________________________________________________________________________________________
|
||
|
||
TravelBarHandler
|
||
MOVEA.L (SP)+,A1 ; pop the return address
|
||
ADDQ.W #4,SP ; and toss params
|
||
MOVE.L (SP)+,D1 ; get the selector
|
||
|
||
MOVEQ #0,D0 ; assume an unsupported selector
|
||
|
||
MOVEA.L DockingGlobals,A0 ; point to the Docking Manager globals
|
||
CMPI.L #dockSCCPorts,D1 ; is it the port list selector?
|
||
BNE.S @NotSCCPorts ; -> nope
|
||
MOVE.L builtInSCCPorts(A0),D0 ; get which ports are built in
|
||
BRA.S @Done
|
||
@NotSCCPorts
|
||
CMPI.L #dockPowerStatus,D1 ; is it a power status call?
|
||
BNE.S @NotPowerStatus ; -> no
|
||
BSR.S @TestForSWIM ; yes, do we have a SWIM2?
|
||
BNE.S @Done ; -> no
|
||
MOVEQ #1<<dockSWIMPower,D0 ; yes, so the SWIM2 is always on
|
||
BRA.S @Done
|
||
@NotPowerStatus
|
||
CMPI.L #dockHardwareAttr,D1 ; is it the hardware attributes selector?
|
||
BNE.S @Done ; -> nope
|
||
MOVE.L #(1<<dockHasADB)|\
|
||
(1<<dockWakeADB),D0 ; assume we support at least ADB
|
||
BSR.S @TestForSWIM ; do we have a SWIM2?
|
||
BNE.S @Done ; -> nope
|
||
ORI.L #(1<<dockHasSWIM)|\
|
||
(1<<dockWakeSWIM),D0 ; yes, set its bits too
|
||
|
||
@Done MOVE.L D0,(SP) ; stuff the result
|
||
JMP (A1)
|
||
|
||
|
||
@TestForSWIM
|
||
MOVE SR,-(SP) ; save the SR
|
||
ORI #$0700,SR ; and lock everyone out while we test
|
||
MOVE.L BusErrVct,-(SP) ; save the old bus error vector
|
||
PEA @NoSWIM2 ; and point it to ours
|
||
MOVE.L (SP)+,BusErrVct
|
||
MOVE.L SP,D2 ; save the stack pointer in case we bus error
|
||
|
||
MOVEQ #$F8-256,D1
|
||
MOVE.B D1,([IWM],wPhase) ; write a value to the phase register
|
||
TST.B ([ROMBase],4) ; read from the ROM to clear the bus lines
|
||
CMP.B ([IWM],rPhase),D1 ; did we get back what was originally written?
|
||
BNE.S @NoSWIM2 ; -> nope, we don't have a SWIM2 connected
|
||
MOVEQ #0,D1
|
||
|
||
@NoSWIM2 MOVEA.L D2,SP ; trash the exception frame if we bus errored
|
||
MOVE.L (SP)+,BusErrVct ; restore the previous bus error vector
|
||
MOVE (SP)+,SR ; re-enable interrupts
|
||
TST.L D1 ; set the CCR
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: InitDocking
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: initializes the Docking Manager if this machine has a slot allocated for docking
|
||
;__________________________________________________________________________________________________
|
||
|
||
InitDocking MOVEM.L D0-D2/A0-A2,-(SP)
|
||
MOVEA.L UnivInfoPtr,A1 ; point to this machine's ProductInfo table
|
||
ADDA.L NuBusInfoPtr(A1),A1 ; and from there, point to the NubusInfo table
|
||
MOVEQ #$0F,D1
|
||
@SearchLoop BTST #dockingSlot,(A1)+ ; is this slot used for docking?
|
||
DBNE D1,@SearchLoop ; -> keep looping if not
|
||
BEQ @NoDocking ; -> no docking slots
|
||
SUBI.W #$0F,D1 ; calculate the real slot number
|
||
NEG.W D1
|
||
|
||
MOVEQ #DockingGlobalSize/2,D0 ; allocate docking globals
|
||
ADD.L D0,D0
|
||
_NewPtr ,SYS,CLEAR
|
||
BNE @NoDocking ; -> couldn't do it, so bail on docking support
|
||
MOVE.L A0,DockingGlobals ; save the pointer
|
||
MOVEA.L A0,A2
|
||
|
||
LEA NoBoardHandler,A1
|
||
MOVE.L A1,(A0)+ ; default docking handler = no board
|
||
MOVE.B D1,(A0)+ ; save the docking slot number
|
||
|
||
; setup to check if a docking station's eject button has been hit...
|
||
|
||
LEA ejectVBLTask+vblCount+2(A2),A0
|
||
MOVE.W #ejectVBLCount,-(A0) ; vblCount
|
||
LEA CheckForEject,A1
|
||
MOVE.L A1,-(A0) ; vblAddr
|
||
ADDQ.W #vType,-(A0) ; vblType
|
||
SUBQ.W #vblType-vblink,A0 ; point to the VBL task element
|
||
_VInstall ; and install the task
|
||
|
||
LEA ejectNMEntry(A2),A0 ; set up the eject Notification Manager record
|
||
LEA EjectNMResponse,A1 ; response procedure
|
||
BSR.S @SetupNMRec
|
||
|
||
LEA sleepNMEntry(A2),A0 ; set up the sleep Notification Manager record
|
||
LEA SleepNMResponse,A1 ; response procedure
|
||
BSR.S @SetupNMRec
|
||
|
||
LEA wakeupNMEntry(A2),A0 ; set up the wakeup Notification Manager record
|
||
LEA WakeupNMResponse,A1 ; response procedure
|
||
BSR.S @SetupNMRec
|
||
|
||
; initialize the vector table...
|
||
|
||
MOVEA.L UnivInfoPtr,A1 ; point to this machine's ProductInfo table
|
||
MOVE.B DecoderKind(A1),D0 ; and get the decoder type
|
||
LEA DockingVectorTable-4,A1
|
||
@NextDecoder
|
||
ADDQ.W #4,A1 ; skip over the offset to this decoder's table
|
||
MOVE.W (A1)+,D1 ; get the next decoder
|
||
BMI.S @FoundTable ; -> end of table: use default vectors
|
||
CMP.B D0,D1 ; is this the correct table?
|
||
BNE.S @NextDecoder ; -> no, try the next one
|
||
@FoundTable ADDA.L (A1),A1 ; point to the vector table
|
||
|
||
LEA builtInSCCPorts(A2),A0
|
||
MOVE.L (A1)+,(A0)+ ; copy the built-in SCC ports
|
||
@InitDispatch
|
||
MOVE.L (A1)+,D1 ; get the next offset
|
||
BEQ.S @InitDone ; -> end of table
|
||
ADD.L A1,D1 ; convert it into an absolute address
|
||
MOVE.L D1,(A0)+ ; and stuff it into our vector table
|
||
BRA.S @InitDispatch
|
||
|
||
; install the docking handler...
|
||
|
||
@InitDone MOVEQ #0,D1 ; (boot call)
|
||
BSR InstallHandler ; now install the correct handler
|
||
@Done MOVEM.L (SP)+,D0-D2/A0-A2
|
||
RTS
|
||
|
||
|
||
@SetupNMRec ADDQ.W #nmType,qType(A0) ; queue type
|
||
MOVEQ #-1,D0 ; sound: use system sound
|
||
MOVE.L D0,nmSound(A0)
|
||
MOVE.L A1,nmResp(A0) ; response procedure
|
||
RTS
|
||
|
||
|
||
@NoDocking MOVE.W #Unimplement,D0 ; get the _Unimplemented trap's address
|
||
_GetTrapAddress ,NEWTOOL
|
||
MOVE.W DockTrap,D0 ; and turn off docking
|
||
_SetTrapAddress ,NEWTOOL
|
||
BRA.S @Done
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: SetupDockBases
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0-D2, A0-A1
|
||
;
|
||
; Function: using the current bar's hardware attributes, initialize "standard" chip base addresses
|
||
; (this is called after enough of the hardware managers are initialized to be able to
|
||
; stuff base addresses into their globals)
|
||
;__________________________________________________________________________________________________
|
||
|
||
SetupDockBases
|
||
BSR.S DockingDispatchExists ; does the _DockingDispatch trap exist?
|
||
BEQ Done ; -> nope, no special initialization is required
|
||
MOVE.L A2,-(SP) ; <H16>
|
||
MOVEA.L DockingGlobals,A2 ; <H16>
|
||
BSR GetDockingAttributes ; get the docking attributes <H11>
|
||
MOVEA.L (SP)+,A2 ; <H16>
|
||
MOVE.L #dockHardwareAttr,D0 ; get the hardware attributes
|
||
BSR DockStatus
|
||
BSR SetHardwareBases ; and initialize any chip base addresses we care about
|
||
MOVE.L #dockBootHook,D0 ; do any last minute pre-boot setup <H26>
|
||
BRA DockStatus ; <H26>
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockingDispatchExists
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: CCR - BNE: _DockingDispatch trap exists
|
||
;
|
||
; Trashes: D0, A0-A1
|
||
;
|
||
; Function: checks if the _DockingDispatch trap exists on this machine
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingDispatchExists
|
||
MOVE.W #Unimplement,D0 ; does the _DockingDispatch trap exist?
|
||
_GetTrapAddress ,NEWTOOL
|
||
MOVEA.L A0,A1
|
||
MOVE.W DockTrap,D0
|
||
_GetTrapAddress ,NEWTOOL
|
||
CMPA.L A0,A1
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockingSleep
|
||
;
|
||
; Inputs: A1 - return address
|
||
;
|
||
; Outputs: A1 - return address
|
||
;
|
||
; Trashes: D0-D2
|
||
;
|
||
; Function: calls the handler to save its hardware state before going to sleep.
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingSleep
|
||
MOVE.L ([DockingGlobals],jDockingSleep),-(SP)
|
||
RTS
|
||
|
||
vDockingSleep
|
||
MOVEM.L A0-A1,-(SP)
|
||
MOVE.L #dockSleepSave,D0 ; have the handler save the bar's state
|
||
BSR DockStatus
|
||
MOVE.L D0,([DockingGlobals],savedSleepState) ; save the pointer to the state
|
||
MOVE.L PMgrBase,a0 ; get PMgr globals <H31>
|
||
BCLR #HDPowerOn,PmgrFlags(a0); clear the hard disk semaphor again, to make sure <H31>
|
||
CLR.L LastHD(A0) ; clear LastHD too <H32>
|
||
MOVEM.L (SP)+,A0-A1
|
||
JMP (A1)
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockingWakeup
|
||
;
|
||
; Inputs: A1 - return address
|
||
;
|
||
; Outputs: A1 - return address
|
||
;
|
||
; Trashes: D0-D2
|
||
;
|
||
; Function: Checks if a docking module as been added, changed, or removed across sleep.
|
||
; If it's been added or changed, clean up after any old handlers and install a new one.
|
||
; If it's been removed, clean up after its handler and install the "no board" handler.
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingWakeup
|
||
MOVE.L ([DockingGlobals],jDockingWakeup),-(SP)
|
||
RTS
|
||
|
||
vDockingWakeup
|
||
@savedRegs REG D3-D4/A0-A2
|
||
MOVEM.L @savedRegs,-(SP)
|
||
MOVEA.L DockingGlobals,A2 ; point to our globals
|
||
|
||
BCLR #dockForceRemoval,dockingFlags(A2) ; did user try to install a "no sleep add" bar? <H21>
|
||
BNE.S @SwitchBars ; -> yes, force removal since they could try multiple times <H21>
|
||
|
||
BSR CheckConnect ; is a docking module currently attached?
|
||
BEQ.S @SwitchBars ; -> no
|
||
|
||
; a module is currently connected; see if it's been added or changed...
|
||
|
||
BSR CheckBarChanged ; has the bar changed across sleep?
|
||
BNE.S @SwitchBars ; -> yes, do the switch
|
||
|
||
MOVE.L #dockWakeupRestore,D0 ; restore the state of anything that was turned off
|
||
MOVEA.L savedSleepState(A2),A0
|
||
BSR DockControl
|
||
CLR.L savedSleepState(A2) ; mark the state info as updated
|
||
|
||
MOVE.L #dockHardwareAttr,D0 ; get the hardware attributes <H19>
|
||
BSR DockStatus ; <H19>
|
||
BSR SetHardwareBases ; force an SCC initialization <H19>
|
||
BRA @Done
|
||
|
||
; no docking module is connected or a new one has been installed, so tell its software...
|
||
|
||
@SwitchBars BSR @GetNubusSlots ; find out if there are any NuBus connectors on this bar
|
||
|
||
MOVE.L #dockRemoved,D0 ; tell the board software that its board is gone
|
||
BSR DockStatus ; (if it was previously installed)
|
||
MOVE.L savedSleepState(A2),D0 ; Get the state info.
|
||
Cmpi.l #-1,D0 ; Was it -1?
|
||
BEQ.S @NoSavedState1 ; -> yes
|
||
Tst.l D0 ; Was it zero?
|
||
Beq.s @NoSavedState ; -> yes
|
||
MOVEA.L D0,A0 ; no, get the pointer
|
||
_DisposPtr ; and get rid of the block
|
||
@NoSavedState1
|
||
CLR.L savedSleepState(A2) ; mark the state info as updated
|
||
@NoSavedState
|
||
|
||
; clean up after any slots that went away (including the docking slot)...
|
||
|
||
Moveq #0,D1 ; Always do Slot #0 first.
|
||
Btst D1,D3 ; If Slot #0 doesn’t to be removed,
|
||
Beq.s @SkipZeroRmv ; then just go on.
|
||
Bsr RemoveVideo ; Unregister Slot #0’s video.
|
||
Bsr RemoveSlot ; And make slot zero go away.
|
||
@SkipZeroRmv
|
||
MOVEQ #sLastSlot,D1
|
||
@RemoveSlot BTST D1,D3 ; does this slot need to be removed?
|
||
BEQ.S @DontRemove ; -> nope, skip it
|
||
BSR RemoveVideo ; unregister any video associated with this slot <H16>
|
||
BSR RemoveSlot ; make the slot go away <poof!>
|
||
@DontRemove Subq #1,D1 ; decrement down to…
|
||
Bne.s @RemoveSlot ; …next slot (skipping zero)
|
||
|
||
; set everything back up for the new bar...
|
||
|
||
MOVE.B dockingSlotNum(A2),D1 ; install the bar in the docking slot
|
||
BSR AddSlot
|
||
|
||
BSET #dockSleepAddition,dockingFlags(A2)
|
||
; remember that this bar was added during sleep
|
||
MOVEQ #(1<<dockWakeupInit),D1 ; (this is a wakeup call)
|
||
BSR InstallHandler ; install the appropriate docking code
|
||
BTST #dockNoWakeup,D0 ; should we allow wakeup with this bar connected? <H9>
|
||
BNE.S @Done ; -> no, bail out <H9>
|
||
|
||
MOVE.L #dockHardwareAttr,D0 ; get the hardware attributes
|
||
BSR DockStatus
|
||
SWAP D0 ; and use the wakeup attributes
|
||
MOVE.W D0,D4 ; <H8>
|
||
; <H8>
|
||
TST.B D4 ; video support AND monitor plugged in? <H8>
|
||
BPL.S @NoBarVideo ; -> nope <H8>
|
||
|
||
BSR.S @GetNubusSlots ; find out if there are any NuBus connectors on this bar
|
||
|
||
Moveq #0,D1 ; Always do Slot #0 first (it’s never the docking slot).
|
||
Btst D1,D3 ; If Slot #0 doesn’t to be removed,
|
||
Beq.s @SkipZeroAdd ; then just go on.
|
||
Bsr AddSlot ; Make the slot appear.
|
||
Bsr AddVideoDevice ; Initialize its video.
|
||
Beq.s @SkipZeroAdd ; If failed, skip.
|
||
Bsr RegisterVideo ; Otherwise, register the new device.
|
||
@SkipZeroAdd
|
||
MOVEQ #sLastSlot,D1
|
||
@AddSlot BTST D1,D3 ; does this slot need to be added?
|
||
BEQ.S @DontAdd ; -> nope, skip it
|
||
CMP.B dockingSlotNum(A2),D1 ; is this the docking slot? <H15>
|
||
BEQ.S @IsAdded ; -> yes, it's already added: just do the video thing <H15>
|
||
BSR AddSlot ; make the slot appear <whoosh!>
|
||
@IsAdded BSR AddVideoDevice ; and initialize its video (if any)
|
||
BEQ.S @DontAdd ; -> no video or error <H15>
|
||
BSR RegisterVideo ; register the new device with the system <H15>
|
||
@DontAdd Subq #1,D1 ; decrement down to…
|
||
Bne.s @AddSlot ; …next slot (skipping zero)
|
||
|
||
@NoBarVideo MOVE.W D4,D0 ; get the wakeup attributes <H8>
|
||
BSR.S SetHardwareBases ; and use them to setup base hardware addresses
|
||
|
||
BSR ResolveSerialPorts ; make sure serial ports are properly registered <H9>
|
||
|
||
Move.l #dockFlush,D0 ; We’re done waking up,
|
||
Bsr DockStatus ; so alert the handler.
|
||
|
||
@Done MOVEM.L (SP)+,@savedRegs
|
||
JMP (A1)
|
||
|
||
|
||
@GetNubusSlots
|
||
MOVE.L #dockNuBusConnectors,D0 ; find out if there are any NuBus connectors on this bar
|
||
BSR DockStatus
|
||
MOVE.L D0,D3 ; and save which slots they're in
|
||
MOVEQ #0,D0
|
||
MOVE.B dockingSlotNum(A2),D0 ; mark the docking slot as well
|
||
BSET D0,D3
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: SetHardwareBases
|
||
;
|
||
; Inputs: D0 - bitmap of hardware available on the bar
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0-D2, A0-A1
|
||
;
|
||
; Function: handles installation of hardware base addresses for "standard" chips on the bar
|
||
;__________________________________________________________________________________________________
|
||
|
||
SetHardwareBases
|
||
MOVE.L ([DockingGlobals],jSetHardwareBases),-(SP)
|
||
RTS
|
||
|
||
vSetHardwareBases
|
||
@savedRegs REG A2-A4
|
||
MOVEM.L @savedRegs,-(SP)
|
||
|
||
MOVEA.L UnivInfoPtr,A0 ; point to the DecoderInfo table
|
||
ADDA.L ProductInfo.DecoderInfoPtr(A0),A0
|
||
MOVEM.L SCCRdAddr(A0),A0-A1 ; copy the internal SCC's base addresses
|
||
MOVEM.L A0-A1,SCCRd ; to the low-mem vectors
|
||
|
||
BTST #dockHasSCC,D0 ; does the bar contain a SCC?
|
||
BEQ.S @NoSCC ; -> no
|
||
|
||
MOVE.L #dockSCCReadAddr,D0 ; call the handler to get the SCC base read address
|
||
BSR DockStatus
|
||
BEQ.S @NoSCC ; -> it returned zero (confusion), so just use built-in
|
||
MOVE.L D0,A3 ; save the SCC base read address <H19>
|
||
MOVE.L #dockSCCWriteAddr,D0 ; call the handler to get the SCC base write address
|
||
BSR DockStatus
|
||
BEQ.S @NoSCC ; -> it returned zero (confusion), so just use built-in
|
||
MOVE.L D0,A4 ; save the SCC base write address <H19>
|
||
|
||
BSR.S DockInitSCC ; reset the internal SCC so it doesn't cause us trouble <H19>
|
||
MOVEM.L A3-A4,SCCRd ; stuff in the new SCC base addresses <H19>
|
||
@NoSCC BSR.S DockInitSCC ; initialize the SCC we'll be using <H19>
|
||
|
||
MOVEA.L SCSIGlobals,A2
|
||
MOVE.L #dockSCSIAddr,D0 ; call the handler to get the SCSI registers base address
|
||
BSR DockStatus
|
||
MOVE.L D0,base5380_2(A2) ; and save it in the SCSI Manager's variables
|
||
BNE.S @HaveSCSI2 ; -> second SCSI chip's base is valid
|
||
MOVEQ #-1,D0 ; otherwise set SCSI2Base to -1
|
||
@HaveSCSI2 MOVE.L D0,SCSI2Base
|
||
|
||
MOVE.L #dockSCSIDMAAddr,D0 ; call the handler to get the SCSI DMA base address
|
||
BSR DockStatus
|
||
MOVE.L D0,pdma5380_2(A2) ; and save it in the SCSI Manager's variables
|
||
|
||
MOVE.L #dockSCSIHskAddr,D0 ; call the handler to get the SCSI handshake base address
|
||
BSR DockStatus
|
||
MOVE.L D0,hhsk5380_2(A2) ; and save it in the SCSI Manager's variables
|
||
|
||
MOVEM.L (SP)+,@savedRegs
|
||
Done RTS
|
||
|
||
|
||
DockInitSCC MOVEM.L D0-D2/A0-A2,-(SP) ; <H25>
|
||
BSR DockingDispatchExists ; is the Docking Manager initialized? <H25>
|
||
BEQ.S @Done ; -> no, skip it <H25>
|
||
IF forRomulator THEN
|
||
TestInRam a0 ; are we running the ROM image from RAM?
|
||
bne.s @Done ; if so, then don't init the SCC
|
||
ENDIF
|
||
MOVEQ #sccOn-256,D0 ; turn SCC power on <H19>
|
||
BSR.S @SCCPower
|
||
BSR.L InitSCC ; reset the SCC so it doesn't cause us trouble
|
||
MOVEQ #sccOff,D0 ; turn SCC power off
|
||
BSR.S @SCCPower ; <H25>
|
||
@Done MOVEM.L (SP)+,D0-D2/A0-A2 ; <H25>
|
||
RTS ; <H25>
|
||
@SCCPower
|
||
IF hasPwrControls THEN
|
||
IF isUniversal THEN
|
||
TestFor hwCbPwrMgr ; does this machine have a Power Manager?
|
||
BEQ.S @NoPMGR ; -> nope, skip
|
||
ENDIF
|
||
MOVE.B D0,-(SP)
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
MOVE.W #1,-(SP) ; pmLength = 1 byte to send
|
||
MOVE.W #powerCntl,-(SP) ; pmCommand = power control
|
||
MOVEA.L SP,A0 ; point to the parameter block
|
||
_PMgrOp ; turn SCC power on or off
|
||
LEA pmRBuffer+4+2(SP),SP ; toss the parameter block and buffer
|
||
@NoPMGR
|
||
ENDIF
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: CheckConnect
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: CCR - BNE: bar connected
|
||
;
|
||
; Trashes: A0, D0
|
||
;
|
||
; Function: checks if a connector bar is currently plugged in
|
||
;__________________________________________________________________________________________________
|
||
|
||
CheckConnect
|
||
MOVE.L jCheckConnect(A2),-(SP)
|
||
RTS
|
||
|
||
vCheckConnect
|
||
MOVEQ #0,D0 ; return BEQ as default case
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: TurnOffBarIO, TurnOnBarIO
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: A0, D0
|
||
;
|
||
; Function: turns bar I/O clock on or off
|
||
;__________________________________________________________________________________________________
|
||
|
||
TurnOffBarIO
|
||
MOVE.L jTurnOffBarIO(A2),-(SP)
|
||
RTS
|
||
|
||
TurnOnBarIO MOVE.L jTurnOnBarIO(A2),-(SP)
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: InstallHandler
|
||
;
|
||
; Inputs: D1 - startup/wakeup flag to pass to docking handler's initialization code
|
||
; - (if D1.l is -1, then we just want to reload the docking attributes)
|
||
; A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: D0 - docking attributes returned by the new bar
|
||
;
|
||
; Trashes: D0-D2, A0-A1
|
||
;
|
||
; Function: installs the appropriate support code into the docking selector for the
|
||
; currently installed board (or no board)
|
||
;__________________________________________________________________________________________________
|
||
|
||
InstallHandler
|
||
MOVE.L jInstallHandler(A2),-(SP)
|
||
RTS
|
||
|
||
vInstallHandler
|
||
Cmpi.l #-1,D1 ; If we just want to reload the docking attributes,
|
||
Beq.s GetDockingAttributes ; then go there now.
|
||
|
||
MOVEA.L NoBoardAddr(A2),A1 ; default to "no board"
|
||
|
||
BSR.S TurnOffBarIO ; turn off bar I/O
|
||
|
||
BSR.S CheckConnect ; is a board connected?
|
||
BEQ.S @DoInstall ; -> nope
|
||
|
||
BSR.S TurnOnBarIO ; turn on bar I/O
|
||
|
||
BSR GetDockingHandler ; try to load the docking handler for this bar
|
||
BEQ.S @DoInstall ; -> got it
|
||
MOVEA.L TravelBarAddr(A2),A1 ; bar doesn't have a handler, so use the travel bar's
|
||
|
||
@DoInstall MOVEA.L dockingHandler(A2),A0 ; get the address of the old docking handler
|
||
MOVE.L A1,dockingHandler(A2) ; and install the new one
|
||
|
||
CMPA.L noBoardAddr(A2),A0 ; is the old handler the "no board" one?
|
||
BEQ.S @Done ; -> yes, we're done
|
||
CMPA.L travelBarAddr(A2),A0 ; is the old handler the travel bar one?
|
||
BEQ.S @Done ; -> yes, we're done
|
||
_DisposPtr ; dispose of the block it occupied
|
||
|
||
@Done
|
||
IF NOT forRomulator THEN ; <H27>
|
||
MOVE.L D1,-(SP) ; save startup/wakeup flag <H28>
|
||
Move.l #dockCacheStatus,D0 ; Set up to determine if an external cache…
|
||
Movea.l #dockCacheCPU,A0 ; …works with our CPU.
|
||
Bsr.s DockControl ; Do it.
|
||
MOVE.L (SP)+,D1 ; restore startup/wakeup flag <H28>
|
||
Moveq #0,D2 ; Clear D2 for good measure.
|
||
Move.b CPUFlag,D2 ; Get the current CPU flag.
|
||
Addq #1,D2 ; De-normalize it.
|
||
Btst D2,D0 ; If we can deal with this cache,
|
||
Bne.s @UseExtCache ; then do so.
|
||
BSET #dockIgnoreExtCache,D1 ; Otherwise, just ignore it.
|
||
@UseExtCache
|
||
ENDIF ; <H27>
|
||
MOVE.L #dockInit,D0 ; call the new handler to initialize itself…
|
||
MOVEA.L D1,A0 ; …with the appropriate flags
|
||
BSR.S DockControl ; <H2>
|
||
|
||
IF hasPwrControls THEN ; <H2>
|
||
IF isUniversal THEN ; <H2>
|
||
TestFor hwCbPwrMgr ; does this machine have a Power Manager? <H2>
|
||
BEQ.S GetDockingAttributes ; -> nope, skip <H2>
|
||
ENDIF ; <H2>
|
||
MOVEQ #PowerDispRec.CPUSpeedDisp,D0 ; <H10>
|
||
_PowerDispatch ; get the CPU's maximum and current speed in MHz <H10>
|
||
EXT.L D0 ; sign-extend it to a long <H10>
|
||
BMI.S GetDockingAttributes ; -> either very fast, or selector is not supported :) <H10>
|
||
MOVEA.L D0,A0 ; stuff it into ‘params’ <H10>
|
||
MOVE.L #dockCPUSpeed,D0 ; go tell the docking handler what it is <H10>
|
||
BSR.S DockControl ; <H10>
|
||
ENDIF ; <H2>
|
||
|
||
GetDockingAttributes
|
||
MOVE.L #dockDockingAttr,D0 ; get the docking attributes for this bar <H2>
|
||
BSR.S DockStatus ; <H2>
|
||
BTST #dockSleepAddition,dockingFlags(A2) ; is this a startup or wakeup case? <H11>
|
||
BNE.S @SaveAttr ; -> wakeup: pass the attributes unmodified <H11>
|
||
BCLR #dockNoWakeup,D0 ; startup: if we go to sleep, we want to wake up again <H11>
|
||
|
||
@SaveAttr BSR.S DockingFilter ; do any filtering before we save it <H16>
|
||
|
||
IF hasPwrControls THEN ; <H2>
|
||
IF isUniversal THEN ; <H2>
|
||
TestFor hwCbPwrMgr ; does this machine have a Power Manager? <H2>
|
||
BEQ.S @NoPMgr ; -> nope, skip <H2>
|
||
ENDIF ; <H2>
|
||
MOVEA.L PmgrBase,A1 ; and save them in the Power Manager's globals <H2>
|
||
MOVE.B D0,PmgrRec.dockFlags(A1); <H2>
|
||
@NoPMgr ; <H2>
|
||
ENDIF ; <H2>
|
||
RTS ; <H2>
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockStatus,DockControl
|
||
;
|
||
; Inputs: D0 - docking selector
|
||
; A0 - parameters for control calls (nil for status calls)
|
||
;
|
||
; Outputs: D0 - function result
|
||
;
|
||
; Trashes: D1-D2, A0-A1
|
||
;
|
||
; Function: executes the handler code for the currently installed docking module
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockStatus SUBA.L A0,A0 ; no parameters for status calls
|
||
DockControl SUBQ.W #4,SP ; result
|
||
MOVE.L D0,-(SP) ; docking selector
|
||
MOVE.L A0,-(SP) ; params
|
||
DockTrap _DockingDispatch ; call the handler
|
||
MOVE.L (SP)+,D0 ; get the result
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockingFilter
|
||
;
|
||
; Inputs: D0 - docking attributes returned by the bar
|
||
; A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: D0 - filtered docking attributes
|
||
;
|
||
; Trashes: D1,D2,A0,A1
|
||
;
|
||
; Function: filters the docking attributes so we can decide how to behave depending on what kind
|
||
; of system software support we have (currently we don't have much)
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingFilter
|
||
MOVE.L jDockingFilter(A2),-(SP)
|
||
RTS
|
||
|
||
vDockingFilter
|
||
MOVE.L D0,-(SP)
|
||
MOVE.L #dockHardwareAttr,D0 ; get the hardware attributes
|
||
BSR DockStatus
|
||
MOVE.L D0,D1
|
||
MOVE.L (SP)+,D0
|
||
BTST #dockSleepAddition,dockingFlags(A2) ; is this a startup or wakeup case?
|
||
BEQ.S @Startup ; -> wakeup
|
||
SWAP D1 ; use the wakeup hardware attributes
|
||
BTST #dockNoLCDScreen,D0 ; do we need to lose the LCD screen? <H20>
|
||
BEQ.S @Startup ; -> no <H20>
|
||
BSET #dockNoWakeup,D0 ; yes, we can't wakeup since we don't support screen removal<H20>
|
||
@Startup ANDI.W #(1<<dockHasFPU)|\
|
||
(1<<dockHasVideo),D1 ; does this bar have either an FPU or video?
|
||
BEQ.S @Done ; -> no
|
||
BSET #dockNoSleep,D0 ; yes, we don't let it sleep
|
||
@Done RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: CheckBarChanged
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: CCR - BNE: bar has changed
|
||
;
|
||
; Trashes: A0, D0
|
||
;
|
||
; Function: checks whether or not the currently connected bar is the same one we think is connected
|
||
;__________________________________________________________________________________________________
|
||
|
||
CheckBarChanged
|
||
MOVE.L jCheckBarChanged(A2),-(SP)
|
||
RTS
|
||
|
||
vCheckBarChanged
|
||
LEA -spBlockSize(SP),SP ; allocate a parameter block on the stack
|
||
MOVEA.L SP,A0 ; and point to it
|
||
MOVE.B dockingSlotNum(A2),spSlot(A0) ; spSlot = docking slot
|
||
* _CheckSlot ; find the board sResource
|
||
|
||
MOVEQ #$27,D0
|
||
_SlotManager
|
||
|
||
LEA spBlockSize(SP),SP ; clean up the stack
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: AddSlot
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
; D1 - slot number
|
||
;
|
||
; Outputs: CCR - BNE: bar has changed
|
||
;
|
||
; Trashes: A0, D0
|
||
;
|
||
; Function: given that a slot is currently empty, sets up the slot so we can use it
|
||
;__________________________________________________________________________________________________
|
||
|
||
AddSlot MOVE.L jAddSlot(A2),-(SP)
|
||
RTS
|
||
|
||
vAddSlot MOVEQ #spBlockSize/2-1,D0 ; allocate a cleared parameter block on the stack <H33>
|
||
@ClearBlock CLR.W -(SP) ; <H33>
|
||
DBRA D0,@ClearBlock ; <H33>
|
||
MOVEA.L SP,A0 ; and point to it
|
||
MOVE.B D1,spSlot(A0) ; spSlot = slot to add
|
||
* _AddCard ; initialize a newly-installed card
|
||
|
||
MOVEQ #$1E,D0
|
||
_SlotManager
|
||
|
||
LEA spBlockSize(SP),SP ; clean up the stack
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: RemoveSlot
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
; D1 - slot number
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: A0, D0
|
||
;
|
||
; Function: cleans up a slot after a bar has gone away
|
||
;__________________________________________________________________________________________________
|
||
|
||
RemoveSlot MOVE.L jRemoveSlot(A2),-(SP)
|
||
RTS
|
||
|
||
vRemoveSlot MOVEQ #spBlockSize/2-1,D0 ; allocate a cleared parameter block on the stack <H33>
|
||
@ClearBlock CLR.W -(SP) ; <H33>
|
||
DBRA D0,@ClearBlock ; <H33>
|
||
MOVEA.L SP,A0 ; and point to it
|
||
MOVE.B D1,spSlot(A0) ; spSlot = slot to kill
|
||
* _RemoveCard ; throw everything away
|
||
|
||
MOVEQ #$1F,D0
|
||
_SlotManager
|
||
|
||
LEA spBlockSize(SP),SP ; clean up the stack
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: GetDockingHandler
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: A1 - pointer to docking handler if it's found
|
||
; CCR - BNE: couldn't load the docking handler
|
||
;
|
||
; Trashes: A0, D0-D1
|
||
;
|
||
; Function: tries to load the docking handler if it can find one
|
||
;__________________________________________________________________________________________________
|
||
|
||
GetDockingHandler
|
||
MOVE.L jGetDockingHandler(A2),-(SP)
|
||
RTS
|
||
|
||
vGetDockingHandler
|
||
LEA -spBlockSize(SP),SP ; allocate a parameter block on the stack
|
||
MOVEA.L SP,A0 ; and point to it
|
||
MOVE.W #CatDock,spCategory(A0) ; spCategory = docking handler
|
||
CLR.W spCType(A0) ; spCType = 0
|
||
CLR.W spDrvrSW(A0) ; spDrvrSW = 0
|
||
CLR.W spDrvrHW(A0) ; spDrvrHW = 0
|
||
MOVE.B #7,spTBMask(A0) ; spTBMask = mask cType, DrSW, DrHW
|
||
MOVE.B dockingSlotNum(A2),spSlot(A0) ; spSlot = docking slot
|
||
CLR.B spId(A0) ; spId = 0
|
||
CLR.B spExtDev(A0) ; no external devices
|
||
CLR.W spHwDev(A0) ; spHWDev = 0
|
||
Clr.l spParamData(A0) ; (The docking sRsrc must be enabled.)
|
||
Bset #foneslot,spParamData+3(A0) ; Limit search to this slot.
|
||
_GetTypeSRsrc ; Get the spsPointer.
|
||
BNE.S @NoHandler ; -> can't find a docking handler
|
||
|
||
MOVE.B #sRsrcDock,spId(A0) ; spId = docking handler
|
||
_SGetBlock ; load the docking handler into the system heap
|
||
BNE.S @NoHandler ; -> couldn't do it
|
||
MOVEA.L spResult(A0),A1 ; get the address of the docking handler
|
||
|
||
Bsr.l CacheFlush ; Flush those caches (trashes reg D1).
|
||
Moveq #0,D0 ; Make sure we return BEQ here.
|
||
|
||
@NoHandler LEA spBlockSize(SP),SP ; toss the parameter block
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: AddVideoDevice
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
; D1 - slot number
|
||
;
|
||
; Outputs: D0 - video driver's refNum
|
||
; CCR - BNE: video device was successfully installed
|
||
;
|
||
; Trashes: D0, D2, A0, A1
|
||
;
|
||
; Function: Looks for a video driver in the specified slot. If it finds one, it installs it,
|
||
; and then sets up and initializes a GDevice for that monitor.
|
||
;__________________________________________________________________________________________________
|
||
|
||
AddVideoDevice
|
||
MOVE.L jAddVideoDevice(A2),-(SP)
|
||
RTS
|
||
|
||
AVStack RECORD {A6Save},DECREMENT
|
||
result DS.W 1
|
||
A6Save DS.L 1
|
||
driverName DS.B 256
|
||
sExecBlock DS.B seBlockSize
|
||
slotPB DS.B spBlockSize
|
||
AVStackSz EQU *
|
||
ENDR
|
||
|
||
WITH AVStack
|
||
vAddVideoDevice
|
||
@savedRegs REG D1/D3/A2-A3 ; <H14>
|
||
MOVEM.L @savedRegs,-(SP) ; <H14>
|
||
CLR.W -(SP) ; assume we can't setup a video device <H15>
|
||
|
||
LINK A6,#AVStackSz ; allocate a parameter block on the stack
|
||
MOVEA.L SP,A0 ; and point to it
|
||
MOVEQ #1<<foneslot,D0 ; look only in the given slot
|
||
MOVE.L D0,spParamData(A0)
|
||
MOVE.W #CatDisplay,spCategory(A0) ; category = display
|
||
MOVE.W #typVideo,spCType(A0) ; type = video
|
||
MOVE.W #drSwApple,spDrvrSW(A0) ; software type = Apple
|
||
CLR.W spDrvrHW(A0) ; hardware type = any
|
||
MOVE.B #1,spTBMask(A0) ; mask = ignore spDrvrHW
|
||
MOVE.B D1,spSlot(A0) ; spSlot = slot to check
|
||
CLR.B spID(A0) ; begin at ID 0
|
||
CLR.B spExtDev(A0) ; no external devices
|
||
_GetTypeSRsrc ; look for any video driver
|
||
BNE @NoDriver ; -> couldn't find one
|
||
|
||
MOVEA.L spsPointer(A0),A2 ; save ptr to sRsrc <H14>
|
||
|
||
LEA driverName(A6),A1 ; point to the driver name string
|
||
MOVE.L A1,spResult(A0)
|
||
_sReadDrvrName ; get the driver's name
|
||
BNE @NoDriver ; -> couldn't find it
|
||
|
||
MOVE.W spSlot(A0),sExecBlock+seSlot(A6) ; copy slot number and sRsrc ID
|
||
MOVE.L A1,sExecBlock+seIOFileName(A6) ; pointer to driver's name
|
||
MOVE.B spExtDev(A0),sExecBlock+seDevice(A6); which device to read from
|
||
|
||
LEA -ioQElSize(SP),SP ; allocate a parameter block on the stack
|
||
MOVE.L spResult(A0),ioFileName(SP) ; driver name
|
||
CLR.B ioPermssn(SP) ; permission = whatever goes
|
||
CLR.L ioMix(SP) ; this needs to be zero
|
||
MOVEQ #1<<fMulti,D0 ; show that we're using an SEBlock
|
||
MOVE.W D0,ioFlags(SP)
|
||
LEA sExecBlock(A6),A1
|
||
MOVE.L A1,ioSEBlkPtr(SP) ; pointer to SEBlock
|
||
MOVE.L A0,A1 ; save the pointer to the spBlock
|
||
MOVEA.L SP,A0 ; and point to the I/O pb
|
||
_Open ,IMMED ; open the driver
|
||
MOVEQ #0,D3 ; <H15>
|
||
MOVE.W ioRefNum(A0),D3 ; save the driver's reference number <H15>
|
||
MOVEA.L A1,SP ; toss the parameter block
|
||
MOVEA.L A1,A0 ; point back at the slot pb
|
||
|
||
LEA -SizesPRAMRec(SP),SP ; allocate a slot PRAM record on the stack
|
||
MOVE.L SP,spResult(A0) ; and point to it
|
||
_sReadPRAMRec ; get info about this video device
|
||
MOVEQ #0,D0
|
||
MOVE.B 2(SP),D0 ; get the default video mode
|
||
LEA SizesPRAMRec(SP),SP ; clean up
|
||
|
||
MOVE.L D0,-(SP) ; save mode <H14>
|
||
MOVE.B #sRsrcFlags,spID(A0) ; look for sRsrcFlags <H14>
|
||
MOVE.L A2,spsPointer(A0) ; set spsPointer to sRsrc <H14>
|
||
_sReadWord ; read flag word <H14>
|
||
BNE.S @Use24Bit ; no flag field - default to 24 bit mode <H14>
|
||
MOVEQ #1<<f32BitMode,D0 ; is this a 32-bit device? <H14>
|
||
AND.L spResult(A0),D0 ; d0 = flag word <H14>
|
||
BEQ.S @Use24Bit ; -> no <H14>
|
||
BSET #31,D3 ; yes - set flag in d3 <H18>
|
||
@Use24Bit MOVE.L (SP)+,D0 ; restore mode <H14>
|
||
|
||
SUBQ.W #4,SP
|
||
MOVE.W D3,-(SP) ; refNum <H18>
|
||
MOVE.L D0,-(SP) ; mode
|
||
_NewGDevice ; allocate a new GDevice for our card
|
||
MOVE.L (SP)+,D0 ; was it allocated?
|
||
BEQ.S @NoDriver ; -> no, bail
|
||
MOVEA.L D0,A3 ; save the GDHandle
|
||
|
||
LEA DeviceList-gdNextGD,A0
|
||
MOVEQ #0,D1 ; initialize rightmost screen location
|
||
BRA.S @FirstDevice
|
||
|
||
@NextDevice MOVEA.L D0,A0 ; get the handle to the next GDevice
|
||
MOVEA.L (A0),A0 ; and de-reference it
|
||
MOVE.W gdRect+right(A0),D0 ; get the right edge of this device
|
||
CMP.W D0,D1 ; is this one farther right than the last?
|
||
BGE.S @FirstDevice ; -> nope
|
||
MOVE.W D0,D1 ; yes, keep track of it
|
||
@FirstDevice
|
||
MOVE.L gdNextGD(A0),D0 ; any more GDevices in the list?
|
||
BNE.S @NextDevice ; -> yes
|
||
|
||
MOVE.L A3,gdNextGD(A0) ; tack our GDevice onto the end of the list
|
||
MOVEA.L (A3),A0 ; de-reference the handle
|
||
BSET #screenDevice-8,gdFlags(A0) ; mark our GDevice as a screen device
|
||
TST.L D3 ; test flag whether this a 32 bit device <H18>
|
||
BPL.S @Not32 ; no <H18>
|
||
BSET.B #ext32Device-8,gdFlags(A0) ; mark as 32 bit frame buffer <H14>
|
||
|
||
@Not32 PEA gdRect(A0) ; theRect = device's bounds
|
||
MOVE.L D1,-(SP) ; dv,dh
|
||
|
||
MOVEA.L gdPMap(A0),A0 ; get the PixMap handle
|
||
MOVEA.L (A0),A0 ; and de-reference it
|
||
PEA pmBounds(A0) ; theRect = PixMap's bounds
|
||
MOVE.L D1,-(SP) ; dv,dh
|
||
_OffsetRect ; move the PixMap's bounds
|
||
_OffsetRect ; and gdRect to their new location
|
||
|
||
MOVEA.L A3,A0 ; put the GDevice handle into A0 <H12>
|
||
IMPORT InitDefGamma ; <H12>
|
||
BSR.L InitDefGamma ; call this to test <H12>
|
||
|
||
MOVE.W D3,result(A6) ; show success <H15>
|
||
@NoDriver UNLK A6 ; clean up the stack
|
||
MOVE.W (SP)+,D0 ; save the refNum and setup the CCR <H15>
|
||
MOVEM.L (SP)+,@savedRegs ; restore them regs correctly <H14>
|
||
RTS
|
||
|
||
ENDWITH ; {AVStack}
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: RegisterVideo
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
; D0 - video driver's refNum
|
||
; D1 - slot number
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, D2, A0, A1
|
||
;
|
||
; Function: Given that we've successfully installed a video driver from the docking bar's ROM,
|
||
; this routine makes the system aware of the new device, ála the Monitors control panel.
|
||
;__________________________________________________________________________________________________
|
||
|
||
RegisterVideo
|
||
MOVE.L jRegisterVideo(A2),-(SP)
|
||
RTS
|
||
|
||
vRegisterVideo
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: RemoveVideo
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
; D1 - slot number
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, D2, A0, A1
|
||
;
|
||
; Function: Provides an expansion hook for future system software to allow us to gracefully
|
||
; remove a monitor from the desktop.
|
||
;__________________________________________________________________________________________________
|
||
|
||
RemoveVideo MOVE.L jRemoveVideo(A2),-(SP)
|
||
RTS
|
||
|
||
vRemoveVideo
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________ <H9>
|
||
;
|
||
; Routine: ResolveSerialPorts
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, D1, D2, A0, A1
|
||
;
|
||
; Function: Calls Alex Kazim's hack to the Comm Toolbox to remove and add the appropriate serial
|
||
; port resources.
|
||
;__________________________________________________________________________________________________
|
||
|
||
ResolveSerialPorts
|
||
MOVE.L jResolveSerialPorts(A2),-(SP)
|
||
RTS
|
||
|
||
vResolveSerialPorts
|
||
MOVE.W #CTB_ModemIconID,-(SP) ; remove the modem port (if it exists)
|
||
_CTBRemovePort
|
||
|
||
MOVE.W #CTB_PrinterIconID,-(SP); remove the printer port (if it exists)
|
||
_CTBRemovePort
|
||
|
||
MOVE.W #CTB_ModemIconID,-(SP) ; add in the modem port (if it exists)
|
||
_CTBAddPort
|
||
|
||
MOVE.W #CTB_PrinterIconID,-(SP); add in the printer port (if it exists)
|
||
_CTBAddPort
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockSleepDenied
|
||
;
|
||
; Inputs: A0 - pointer to the Power Manager's variables
|
||
;
|
||
; Outputs: CCR - BNE: NM task was successfully installed, BEQ: can't install
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: If the Docking Manager was initialized, install a Notification Manager request to
|
||
; let the user know that they can't put the portable to sleep because the connected
|
||
; bar doesn't think that's a good idea.
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingSleepDenied
|
||
MOVE.L ([DockingGlobals],jDockingSleepDenied),-(SP)
|
||
RTS
|
||
|
||
vDockingSleepDenied
|
||
@savedRegs REG D0-D2/A0-A1
|
||
MOVEM.L @savedRegs,-(SP)
|
||
BSR DockingDispatchExists ; is the Docking Manager initialized?
|
||
BEQ.S @NoDocking ; -> no, bail
|
||
|
||
MOVEA.L DockingGlobals,A0 ; point to our globals
|
||
LEA sleepNMEntry(A0),A0 ; and then to the NM record
|
||
BSR NMInstall ; install the NM request if it's not already installed
|
||
@NoDocking MOVEM.L (SP)+,@savedRegs
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: DockingWakeupDenied
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: If the Docking Manager was initialized, install a Notification Manager request to
|
||
; let the user know that they tried to wakeup with a new bar attached that's not
|
||
; supposed to be added during sleep. After this call is made, the system will go
|
||
; back to sleep, so the message will be displayed when we succussfully wake up.
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingWakeupDenied
|
||
MOVE.L ([DockingGlobals],jDockingWakeDenied),-(SP)
|
||
RTS
|
||
|
||
vDockingWakeupDenied
|
||
@savedRegs REG D0-D2/A0-A1
|
||
MOVEM.L @savedRegs,-(SP)
|
||
BSR DockingDispatchExists ; is the Docking Manager initialized?
|
||
BEQ.S @NoDocking ; -> no, bail
|
||
|
||
MOVE.L #dockEjectCPU,D0 ; tell the docking station to eject when the power goes off
|
||
BSR DockStatus
|
||
|
||
MOVEA.L DockingGlobals,A0 ; remember we have to remove the current handler next time we wake up
|
||
BSET #dockForceRemoval,dockingFlags(A0) ; <H21>
|
||
LEA wakeupNMEntry(A0),A0 ; point to the NM record
|
||
BSR NMInstall ; install the NM request if it's not already installed
|
||
@NoDocking MOVEM.L (SP)+,@savedRegs
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; pascal void SleepNMResponse(NMRec *nmReq)
|
||
;
|
||
; Notification Manager response procedure for signaling that the sleep notification is complete.
|
||
;__________________________________________________________________________________________________
|
||
|
||
SleepNMResponse
|
||
MOVEA.L PMgrBase,A1
|
||
BCLR #InSleep,PmgrFlags(A1) ; show that we're not in the sleep code anymore
|
||
BCLR #ClamshellClosed,PmgrFlags(A1) ; and that the clamshell switch is fair game again <H15>
|
||
BRA.S WakeupNMResponse ; branch to the standard response procedure
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; pascal void EjectNMResponse(NMRec *nmReq)
|
||
;
|
||
; Notification Manager response procedure for signaling that the eject notification is complete.
|
||
;__________________________________________________________________________________________________
|
||
|
||
EjectNMResponse
|
||
MOVEA.L DockingGlobals,A1 ; <H17>
|
||
CLR.B dockingEjectFlags(A1) ; back us out of the eject <H17>
|
||
MOVE.L #dockEjectStatus,D0 ; reset the eject switch in case the user pressed it <H17>
|
||
BSR DockStatus ; while the NM dialog was up <H17>
|
||
* BRA.S WakeupNMResponse ; fall thru into the standard response procedure
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; pascal void WakeupNMResponse(NMRec *nmReq)
|
||
;
|
||
; Notification Manager response procedure for signaling that the wakeup notification is complete.
|
||
;__________________________________________________________________________________________________
|
||
|
||
WakeupNMResponse
|
||
MOVEA.L (SP)+,A1 ; pop the return address
|
||
MOVEA.L (SP)+,A0 ; and the pointer to the NM record
|
||
CLR.B nmRefCon(A0) ; flag that the notification has been received
|
||
_NMRemove ; remove the request from the queue
|
||
JMP (A1)
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: CheckForEject
|
||
;
|
||
; Inputs: A0 - pointer to VBL task element
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: D0, D1, D2, A0, A1, A2
|
||
;
|
||
; Function: Checks if the user has pushed the eject button on a docking station (assuming there
|
||
; is one). If so, it shuts down and ejects the CPU if it's not locked into the station.
|
||
; If it is locked, we'll put up a message telling them why they can't eject.
|
||
;__________________________________________________________________________________________________
|
||
|
||
CheckForEject
|
||
MOVE.L A0,-(SP)
|
||
MOVE.W #Unimplement,D0 ; is _SyncIdleTime implemented?
|
||
_GetTrapAddress ,NEWTOOL
|
||
MOVEA.L A0,A1
|
||
MOVE.W #SyncIdleTime,D0
|
||
_GetTrapAddress ,NEWTOOL
|
||
CMPA.L A0,A1
|
||
BEQ.S @NoSyncIdle ; -> no, we're done
|
||
|
||
MOVEA.L DockingGlobals,A2
|
||
MOVE.L A0,dockOldSyncIdleTime(A2) ; save the old trap address
|
||
LEA EjectShutdown,A0 ; and head patch us
|
||
MOVE.W #SyncIdleTime,D0
|
||
_SetTrapAddress ,NEWTOOL
|
||
|
||
LEA CheckForEject2,A1
|
||
MOVE.L A1,ejectVBLTask+vblAddr(A2) ; shorten this VBL task (no _SyncIdleTime check now)
|
||
@NoSyncIdle MOVEA.L (SP)+,A0
|
||
|
||
CheckForEject2
|
||
MOVE.W #ejectVBLCount,vblCount(A0) ; reset the counter
|
||
|
||
IF hasPwrControls THEN ; <H22>
|
||
MOVEA.L PMgrBase,A1 ; <H22>
|
||
TST.B SysTaskFlag(A1) ; has SystemTask been called yet? <H22>
|
||
BEQ.S NMDone ; -> no, don't allow ejects yet (the system will freak) <H22>
|
||
ENDIF ; <H22>
|
||
|
||
MOVEA.L DockingGlobals,A2 ; point to the docking globals
|
||
IF dockEjectPressed=7 THEN
|
||
TST.B dockingEjectFlags(A2) ; is a request pending?
|
||
BMI.S NMDone ; -> yes, let it complete
|
||
ELSE
|
||
BTST #dockEjectPressed,dockingEjectFlags(A2) ; is a request pending?
|
||
BNE.S NMDone ; -> yes, let it complete
|
||
ENDIF
|
||
|
||
MOVE.L #dockEjectStatus,D0 ; get the eject status
|
||
BSR DockStatus
|
||
BTST #dockEjectEnabled,D0 ; was the eject button hit?
|
||
BEQ.S NMDone ; -> no, done
|
||
|
||
BSET #dockEjectPressed,dockingEjectFlags(A2) ; set a flag to prevent re-entrancy
|
||
|
||
MOVE.L #dockLockAttr,D0 ; get the lock attributes
|
||
BSR DockStatus
|
||
BTST #dockLockEnabled,D0 ; is the CPU locked into the docking station?
|
||
BNE.S @Locked ; -> yes, put up a message
|
||
|
||
MOVE.L #dockEjectCPU,D0 ; tell the docking station to eject on power off
|
||
BSR DockStatus
|
||
TST.L dockOldSyncIdleTime(A2) ; is the _SyncIdleTime patch installed?
|
||
BNE.S NMDone ; -> yes, we'll finish later
|
||
|
||
_SDPowerOff ; just shutdown the system since the Finder's not running anyway
|
||
BRA.S *
|
||
|
||
@Locked LEA ejectNMEntry(A2),A0 ; point to the NM record
|
||
;••• MOVE.L lockedEjectMsg(A2),nmStr(A0); load the “CPU is locked to docking bar” message
|
||
NMInstall TST.B nmRefCon(A0) ; is this request already pending?
|
||
BNE.S NMDone ; -> yes, let it complete
|
||
TST.L nmStr(A0) ; is there a string to use to notify the user?
|
||
BEQ.S NMDone ; -> no, can't do anything
|
||
_NMInstall ; and install the request
|
||
SEQ D0 ; mark the request installed if successful
|
||
MOVE.B D0,nmRefCon(A0) ; force CCR to BNE if it was installed
|
||
NMDone RTS
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; pascal void EjectShutdown(void)
|
||
;
|
||
; This is a head patch to _SyncIdleTime ($ABF7) to send a shutdown message to
|
||
; the Finder at a time when it can do something.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
EjectShutdown ; <H17>
|
||
MOVEA.L DockingGlobals,A1 ; point to the Docking Manager's globals
|
||
IF dockEjectPressed=7 THEN
|
||
TST.B dockingEjectFlags(A1) ; has the user pressed the eject button?
|
||
BPL.S @NoEject ; -> no, just passing thru
|
||
ELSE
|
||
BTST #dockEjectPressed,dockingEjectFlags(A1) ; has the user pressed the eject button?
|
||
BEQ.S @NoEject ; -> no, just passing thru
|
||
ENDIF
|
||
TST.B ejectNMEntry+nmRefCon(A1) ; is a NM dialog up?
|
||
BNE.S @NoEject ; -> yes, problems, so don't do the eject thing
|
||
BSET #dockShuttingDown,dockingEjectFlags(A1) ; have we been here before?
|
||
BNE.S @NoEject ; -> yes, once is enough
|
||
MOVEA.L jGracefulShutdown(A1),A0 ; call the graceful shutdown routine
|
||
JSR (A0)
|
||
BEQ.S @NoEject ; -> the shutdown is under way
|
||
|
||
BCLR #dockShuttingDown,dockingEjectFlags(A1) ; we couldn't shutdown now
|
||
TST.W D0 ; are we waiting on the Finder?
|
||
BGT.S @NoEject ; -> yes, we'll finish up later
|
||
|
||
LEA ejectNMEntry(A1),A0 ; point to the NM record
|
||
;••• MOVE.L finderBlockedMsg(A1),nmStr(A0); load the “something’s blocking shutdown” message
|
||
BSR.S NMInstall ; install the NM request if it's not already installed
|
||
BNE.S @NoEject ; -> task was installed
|
||
BCLR #dockEjectPressed,dockingEjectFlags(A1) ; back us out of the eject
|
||
|
||
@NoEject MOVEA.L dockOldSyncIdleTime(A1),A0 ; return so the Finder can do the shutdown
|
||
JMP (A0)
|
||
|
||
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
; Routine: GracefulShutdown
|
||
;
|
||
; Inputs: none
|
||
;
|
||
; Outputs: D0 - result code
|
||
; =0: shutdown message successfully sent to the Finder
|
||
; >0: waiting for the Finder to become the front process
|
||
; <0: a problem occurred (no Finder, something blocking, etc.)
|
||
;
|
||
; Trashes: none
|
||
;
|
||
; Function: Sends a shutdown event to the Finder (if the Finder is running) so it will
|
||
; quit all running applications. If the required OS support is not present,
|
||
; we'll back down to doing just a straight shutdown instead.
|
||
;————————————————————————————————————————————————————————————————————————————————————————
|
||
|
||
receiverIDisPSN EQU $00008000 ; use a process number for the receiver ID
|
||
|
||
GracefulShutdown
|
||
@savedRegs REG D1-D2/A0-A2
|
||
MOVEM.L @savedRegs,-(SP)
|
||
|
||
; check if the Process Manager/MultiFinder is installed...
|
||
|
||
MOVE.W #Unimplement,D0 ; get the address of the _Unimplemented trap
|
||
_GetTrapAddress ,NEWTOOL
|
||
MOVEA.L A0,A1
|
||
MOVE.W #$A88F,D0 ; get the address of _OSDispatch
|
||
_GetTrapAddress ,NEWTOOL
|
||
CMPA.L A0,A1 ; is _OSDispatch implemented?
|
||
BEQ @JustShutDown ; -> no, do it the old way
|
||
|
||
MOVE.W @Gestalt,D0 ; is Gestalt implemented?
|
||
_GetTrapAddress ,NEWOS
|
||
CMPA.L A0,A1
|
||
BEQ @JustShutDown ; -> no
|
||
|
||
MOVE.L #gestaltAppleEventsAttr,D0 ; get AppleEvents attributes
|
||
@Gestalt _Gestalt
|
||
MOVE.L A0,D0
|
||
BTST #gestaltAppleEventsPresent,D0 ; are AppleEvents supported?
|
||
BEQ @JustShutDown ; -> no, can't send a message
|
||
|
||
; try to find the Finder in the list of active processes...
|
||
|
||
LINK A6,#-ProcessInfoRec.size ; allocate a process info record on the stack
|
||
MOVEQ #ProcessInfoRec.size,D0 ; initialize the record
|
||
MOVE.L D0,processInfoLength(SP)
|
||
CLR.L processName(SP)
|
||
CLR.L processNumber.highLongOfPSN(SP)
|
||
MOVE.L #kNoProcess,processNumber.lowLongOfPSN(SP)
|
||
CLR.L processAppSpec(SP)
|
||
MOVEA.L SP,A2 ; point to the process info record
|
||
|
||
SUBQ.W #2,SP ; space for result (this gets left on the stack)
|
||
@FindFinder PEA processNumber(A2) ; PSN
|
||
_GetNextProcess ; get the next process' PSN
|
||
MOVE.W (SP),D0
|
||
BNE @NoFinder ; -> no more processes: couldn't find the Finder
|
||
|
||
PEA processNumber(A2) ; PSN
|
||
MOVE.L A2,-(SP) ; info
|
||
_GetProcessInformation ; get information about this process
|
||
MOVE.W (SP),D0
|
||
BNE.S @NoFinder ; -> bad PSN?
|
||
|
||
CMPI.L #'FNDR',processType(A2) ; is this process the Finder?
|
||
BNE.S @FindFinder ; -> no, keep looking
|
||
|
||
; make sure the Finder's the front process before telling it to shut down...
|
||
|
||
LEA -ProcessSerialNumber.size-2(SP),SP ; <H20>
|
||
PEA 2(SP) ; PSN <H20>
|
||
_GetFrontProcess ; get the process number of the front process <H20>
|
||
TST.W (SP)+ ; is there a front process? <H20>
|
||
BNE.S @JustShutDown ; -> no, just shut down (why no foreground process?) <H20>
|
||
|
||
CLR.L -(SP) ; space for ‘result’ + result code <H20>
|
||
PEA processNumber(A2) ; PSN1 <H20>
|
||
PEA 4+2+2(SP) ; PSN2 <H20>
|
||
PEA 4+4+2(SP) ; result <H20>
|
||
_SameProcess ; compare process numbers <H20>
|
||
TST.W (SP)+ ; <H20>
|
||
BNE.S @JustShutDown ; -> bad process number? <H20>
|
||
TST.B (SP)+ ; is the Finder the front process? <H20>
|
||
LEA ProcessSerialNumber.size(SP),SP ; (toss the process number record) <H20>
|
||
BNE.S @FinderInFront ; -> yes, we're ready to shutdown <H20>
|
||
|
||
PEA processNumber(A2) ; PSN
|
||
_SetFrontProcess ; force the Finder to the front
|
||
MOVE.W (SP),D0 ; is it going to happen?
|
||
BNE.S @NoFinder ; -> nope, something's preventing it
|
||
MOVEQ #1,D0 ; show the Finder is being brought to the front <H20>
|
||
BRA.S @NoFinder ; <H20>
|
||
|
||
; the Finder's now in front so tell it to shut everybody down...
|
||
|
||
@FinderInFront
|
||
_BeginSystemMode ; enter system mode
|
||
|
||
PEA @ShutDownEvent ; theEvent
|
||
PEA processNumber(A2) ; receiverID
|
||
CLR.L -(SP) ; msgRefCon
|
||
CLR.L -(SP) ; msgBuff
|
||
CLR.L -(SP) ; msgLen
|
||
MOVE.L #receiverIDisPSN,-(SP) ; postingOptions
|
||
_PostHighLevelEvent ; send the event to the Finder (leave result on stack)
|
||
|
||
_EndSystemMode ; exit system mode
|
||
|
||
MOVEQ #0,D0 ; show no error
|
||
@NoFinder UNLK A6 ; toss the stack frame
|
||
MOVEM.L (SP)+,@savedRegs
|
||
RTS
|
||
|
||
@JustShutDown
|
||
_SDPowerOff ; ‘single’ Finder: shutdown the system
|
||
BRA.S *
|
||
|
||
@ShutDownEvent ; HighLevel EventRecord to tell the Finder to shutdown
|
||
DC.W 0 ; what
|
||
DC.L 'FNDR' ; message = event class (Finder's application signature)
|
||
DC.L 0 ; ticks
|
||
DC.L 'shut' ; where = event ID (shutdown)
|
||
CLR.W 0 ; meta
|
||
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; The following tables are used for initializing the routine vectors for a particular machine.
|
||
; If there are no special machine-specific characteristics, there doesn't need to be a vector
|
||
; table since in that case the default vectors will be used.
|
||
;__________________________________________________________________________________________________
|
||
|
||
DockingVectorTable
|
||
IF hasMSC THEN
|
||
DC.B 0,MSCDecoder ; handle MSC Decoder
|
||
DC.L MSCVectors-*
|
||
ENDIF
|
||
|
||
IF hasNiagra THEN ; <H11>
|
||
DC.B 0,NiagraDecoder ; handle Niagra decoder <H11>
|
||
DC.L NiagraVectors-* ; <H11>
|
||
ENDIF ; <H11>
|
||
|
||
IF hasPratt THEN ; <K2>
|
||
DC.B 0,PrattDecoder ; handle Pratt decoder <K2>
|
||
DC.L PrattVectors-* ; <K2>
|
||
ENDIF ; <K2>
|
||
|
||
DC.W -1 ; default vectors (this should be the last entry)
|
||
DC.L DefaultVectors-*
|
||
|
||
|
||
DefaultVectors
|
||
DC.L (1<<dockSCCModemPort) |\; both SCC ports are available
|
||
(1<<dockSCCPrinterPort)
|
||
DC.L NoBoardHandler-(*+4)
|
||
DC.L TravelBarHandler-(*+4)
|
||
DC.L vDockingSleep-(*+4)
|
||
DC.L vDockingWakeup-(*+4)
|
||
DC.L vInstallHandler-(*+4)
|
||
DC.L vSetHardwareBases-(*+4)
|
||
DC.L vCheckConnect-(*+4)
|
||
DC.L vCheckBarChanged-(*+4)
|
||
DC.L vAddSlot-(*+4)
|
||
DC.L vRemoveSlot-(*+4)
|
||
DC.L vGetDockingHandler-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L vAddVideoDevice-(*+4)
|
||
DC.L vRegisterVideo-(*+4)
|
||
DC.L vRemoveVideo-(*+4)
|
||
DC.L vResolveSerialPorts-(*+4)
|
||
DC.L vDockingSleepDenied-(*+4)
|
||
DC.L vDockingWakeupDenied-(*+4)
|
||
DC.L vDockingFilter-(*+4)
|
||
DC.L GracefulShutdown-(*+4)
|
||
DC.L 0
|
||
|
||
|
||
IF hasMSC THEN
|
||
;•••••••••••••••••••••••••••••••••••••••••••••• MSC •••••••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
MSCVectors DC.L (1<<dockSCCModemPort) ; just the modem port is available
|
||
DC.L NoBoardHandler-(*+4)
|
||
DC.L TravelBarHandler-(*+4)
|
||
DC.L vDockingSleep-(*+4)
|
||
DC.L vDockingWakeup-(*+4)
|
||
DC.L vInstallHandler-(*+4)
|
||
DC.L vSetHardwareBases-(*+4)
|
||
DC.L CheckConnectMSC-(*+4)
|
||
DC.L vCheckBarChanged-(*+4)
|
||
DC.L vAddSlot-(*+4)
|
||
DC.L vRemoveSlot-(*+4)
|
||
DC.L vGetDockingHandler-(*+4)
|
||
DC.L ClockOffMSC-(*+4)
|
||
DC.L ClockOnMSC-(*+4)
|
||
DC.L vAddVideoDevice-(*+4)
|
||
DC.L vRegisterVideo-(*+4)
|
||
DC.L vRemoveVideo-(*+4)
|
||
DC.L vResolveSerialPorts-(*+4)
|
||
DC.L vDockingSleepDenied-(*+4)
|
||
DC.L vDockingWakeupDenied-(*+4)
|
||
DC.L vDockingFilter-(*+4)
|
||
DC.L GracefulShutdown-(*+4)
|
||
DC.L 0
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: CheckConnectMSC
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: CCR - BNE: bar is connected, BEQ: no bar (bar none?)
|
||
;
|
||
; Trashes: A0,D0
|
||
;
|
||
; Function: calls the Power Manager to determine if a bar is connected
|
||
;__________________________________________________________________________________________________
|
||
|
||
CheckConnectMSC
|
||
CLR.W -(SP) ; make space for the result
|
||
MOVE.L SP,-(SP) ; pmRBuffer
|
||
MOVE.L (SP),-(SP) ; pmSBuffer
|
||
CLR.W -(SP) ; pmLength
|
||
MOVE.W #readExtSwitches,-(SP) ; pmCommand
|
||
MOVEA.L SP,A0 ; point to the buffer
|
||
_PMgrOp ; get the info
|
||
LEA pmRBuffer+4(SP),SP ; toss the parameter block
|
||
BTST #dockingBar,(SP)+ ; setup the CCR for exit
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: ClockOffMSC
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: A0
|
||
;
|
||
; Function: turns off the I/O clock going to the connector when a bar is not plugged in
|
||
;__________________________________________________________________________________________________
|
||
|
||
ClockOffMSC MOVEA.L VIA2,A0
|
||
BCLR #MSCIOClk,MSCClkCntl(A0); turn off the I/O clock to the bar
|
||
MOVE.B #(0<<ifIRQ) | (1<<RvIRQ6En),MSCSlotIER(A0) ; disable slot E interrupts
|
||
RTS
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: ClockOnMSC
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: none
|
||
;
|
||
; Trashes: A0
|
||
;
|
||
; Function: turns on the I/O clock going to the connector when a bar IS plugged in
|
||
;__________________________________________________________________________________________________
|
||
|
||
ClockOnMSC MOVEA.L VIA2,A0
|
||
BSET #MSCIOClk,MSCClkCntl(A0); turn on the I/O clock to the bar
|
||
MOVE.B #(1<<ifIRQ) | (1<<RvIRQ6En),MSCSlotIER(A0) ; enable slot E interrupts
|
||
RTS
|
||
|
||
ENDIF ; {hasMSC}
|
||
|
||
|
||
IF hasNiagra THEN ; <H11>
|
||
;•••••••••••••••••••••••••••••••••••••••••••• Niagra ••••••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
NiagraVectors
|
||
DC.L (1<<dockSCCModemPort) |\; both SCC ports are available
|
||
(1<<dockSCCPrinterPort)
|
||
DC.L NoBoardHandler-(*+4)
|
||
DC.L NoBoardHandler-(*+4)
|
||
DC.L vDockingSleep-(*+4)
|
||
DC.L vDockingWakeup-(*+4)
|
||
DC.L vInstallHandler-(*+4)
|
||
DC.L vSetHardwareBases-(*+4)
|
||
DC.L CheckConnectNiagra-(*+4)
|
||
DC.L vCheckBarChanged-(*+4)
|
||
DC.L vAddSlot-(*+4)
|
||
DC.L vRemoveSlot-(*+4)
|
||
DC.L vGetDockingHandler-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L vAddVideoDevice-(*+4)
|
||
DC.L vRegisterVideo-(*+4)
|
||
DC.L vRemoveVideo-(*+4)
|
||
DC.L Done-(*+4) ; <H12>
|
||
DC.L vDockingSleepDenied-(*+4)
|
||
DC.L vDockingWakeupDenied-(*+4)
|
||
DC.L vDockingFilter-(*+4)
|
||
DC.L GracefulShutdown-(*+4)
|
||
DC.L 0
|
||
|
||
ENDIF ; {hasNiagra}
|
||
|
||
;__________________________________________________________________________________________________ <H12>
|
||
;
|
||
; Routine: CheckConnectNiagra, CheckConnectPratt
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: CCR - BNE: bar is connected, BEQ: no bar (bar none?)
|
||
;
|
||
; Trashes: A0,D0
|
||
;
|
||
; Function: returns ‘connected’ if the VSC video is turned on since Dartanian's ‘bar’ is built
|
||
; into the box.
|
||
;__________________________________________________________________________________________________
|
||
|
||
CheckConnectPratt
|
||
CheckConnectNiagra
|
||
lea -spBlockSize(sp),sp ; alloc spBlock
|
||
movea.l sp,a0
|
||
move.b dockingSlotNum(a2),spSlot(a0) ; slot VSC video is on
|
||
_sCkCardStat ; see if card was added ok
|
||
lea spBlockSize(sp),sp ; dealloc spBlock
|
||
seq d0 ; if bad, return "not connected"
|
||
tst.b d0 ; set the CCR
|
||
rts
|
||
|
||
|
||
|
||
IF hasPratt THEN ; <K2>
|
||
;•••••••••••••••••••••••••••••••••••••••••••• Pratt ••••••••••••••••••••••••••••••••••••••••••••••
|
||
|
||
PrattVectors
|
||
DC.L (1<<dockSCCModemPort) ; only port A (modem port) is available
|
||
DC.L NoBoardHandler-(*+4)
|
||
DC.L NoBoardHandler-(*+4)
|
||
DC.L vDockingSleep-(*+4)
|
||
DC.L vDockingWakeup-(*+4)
|
||
DC.L vInstallHandler-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L CheckConnectPratt-(*+4)
|
||
DC.L CheckBarChangedPratt-(*+4)
|
||
DC.L vAddSlot-(*+4)
|
||
DC.L vRemoveSlot-(*+4)
|
||
DC.L vGetDockingHandler-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L vAddVideoDevice-(*+4)
|
||
DC.L vRegisterVideo-(*+4)
|
||
DC.L vRemoveVideo-(*+4)
|
||
DC.L Done-(*+4)
|
||
DC.L vDockingSleepDenied-(*+4)
|
||
DC.L vDockingWakeupDenied-(*+4)
|
||
DC.L PrattDockingFilter-(*+4)
|
||
DC.L GracefulShutdown-(*+4)
|
||
DC.L 0
|
||
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: PrattDockingFilter
|
||
;
|
||
; Inputs: D0 - docking attributes returned by the bar
|
||
; A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: D0 - filtered docking attributes
|
||
;
|
||
; Trashes: D1,D2,A0,A1
|
||
;
|
||
; Function: Filters the docking attributes so we can decide how to behave depending on what kind
|
||
; of system software support we have. The Display Manager is (currently) a disk thing,
|
||
; so we’ll patch this filter out on disk if the Display Manager is around, otherwise
|
||
; we don’t allow sleeping if external video is enabled.
|
||
;
|
||
; Note: This filter differs from the “standard” filters in that we don’t need to check
|
||
; for the case where the LCD screen isn’t useable (since all-in-one PowerBooks
|
||
; don’t “dock” per se), and since Pratt is ’040 based, the FPU doesn’t matter.
|
||
; (I believe that the FPU won’t matter for the PowerPC case, either.)
|
||
;__________________________________________________________________________________________________
|
||
|
||
PrattDockingFilter
|
||
MOVE.L D0,-(SP)
|
||
MOVE.L #dockHardwareAttr,D0 ; get the hardware attributes
|
||
BSR DockStatus
|
||
MOVE.L D0,D1
|
||
MOVE.L (SP)+,D0
|
||
BTST #dockSleepAddition,dockingFlags(A2) ; is this a startup or wakeup case?
|
||
BEQ.S @Startup ; -> wakeup
|
||
SWAP D1 ; use the wakeup hardware attributes
|
||
@Startup ANDI.W #(1<<dockHasVideo),D1 ; does this bar have video?
|
||
BEQ.S @Done ; -> no
|
||
BSET #dockNoSleep,D0 ; yes, we don't let it sleep
|
||
@Done RTS
|
||
|
||
;__________________________________________________________________________________________________
|
||
;
|
||
; Routine: CheckBarChangedPratt
|
||
;
|
||
; Inputs: A2 - pointer to Docking Manager's globals
|
||
;
|
||
; Outputs: CCR - BNE: bar has changed
|
||
;
|
||
; Trashes: A0, D0
|
||
;
|
||
; Function: Since the “bar” on Pratt-based CPUs is built-in, the Docking Handler would never be
|
||
; swapped out. So, we now call the Docking Handler to ask it if the world changed.
|
||
; If it did, then “BNE”.
|
||
;__________________________________________________________________________________________________
|
||
|
||
CheckBarChangedPratt
|
||
Bsr.s DockingDispatchExists ; If DockingDispatch is around,
|
||
Bne.s @CallHandler ; then call the Docking Handler.
|
||
Moveq #0,D0 ; Otherwise, just say things are okay.
|
||
Rts ; And Vamoose.
|
||
@CallHandler
|
||
Move.l #(1<<dockWorldChanged),D0 ; Inform the Docking Handler that we
|
||
Movea.l D0,A0 ; …want to know if the world changed.
|
||
Move.l #dockInit,D0 ; The Docking Handler will return
|
||
Bsr.s DockControl ; #(1<<dockWorldChanged) if so.
|
||
Rts
|
||
|
||
ENDIF ; {hasPratt}
|
||
|
||
|
||
ENDWITH
|
||
|
||
END
|