Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-12-12 20:29:12 +00:00
Code Issues Projects Releases Wiki Activity
62f7e0d5dc
sys7.1-doc-wip/DeclData/VSCDeclData/VSCDockingHandler.a
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

831 lines
31 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;
; File: VSCDockingHandler.a
;
; Contains: a docking handler to support Dartanian's built-in VSC video
;
; Written by: Steve Christensen, Helder Ramalho, Dave Wong, Andy Gong (anyone else?)
; Rewritten: Mike Puckett, July 15, 1993.
; Copyright: © 1992-1993 by Apple Computer, Inc. All rights reserved.
;
; Change History (most recent first):
;
; <SM2> 12/13/93 PN Roll in KAOs and Horror changes to support Malcom and AJ
; machines
; <1> 12-04-92 jmp first checked in
; ———————————————————————————————————————————————————————————————————————————————————————
; Pre-SuperMario comments begin here.
; ———————————————————————————————————————————————————————————————————————————————————————
; <H2> 6/1/92 HJR Fix Header.
; <H1> 6/1/92 HJR first checked in
VidLowPwrFrame Record 0, Decrement
VidLowPwrCntBlk Ds.b IOVQElSize ; control call parm block
VidLowPwrVDPageInfo Ds.b VDPageInfo ; params
VidLowPwrFrameSize Equ * ; size of frame
Endr
;__________________________________________________________________________________________________
;
; FUNCTION DockSelect(selector:OSType; params:LONGINT):LONGINT;
;
; Control/info handler for Dartanian/BlackBird.
; - selector is the index into the docking handler tables
; - params is any required input parameter
;
; DockSelect returns the result of the selector.
;
; Trashes: D0-D2, A0-A1
;__________________________________________________________________________________________________
DockSelect
Move.l (Sp)+,D2 ; Pop the return address…
Movea.l (Sp)+,A0 ; …and the input params
Move.l (Sp)+,D0 ; …and the selector.
Lea SelectorTable-4,A1 ; Point to the start of the table.
@FindStatSelector
Addq #4,A1 ; Skip over the previous function result.
Move.l (A1)+,D1 ; If we’re at the end of the function table,
Beq.s @FindCtlSelector ; then check the other one.
Cmp.l D1,D0 ; If this isn’t the right selector,
Bne.s @FindStatSelector ; then keep looking.
Move.l (A1),D1 ; Get the function result into D1.
@Done Move.l D1,(Sp) ; Stuff the funtion result onto the stack.
Movea.l D2,A0 ; Restore the return address.
Jmp (A0) ; And return.
@FindCtlSelector
Addq #4,A1 ; Skip over the function result/routine offset.
Move.l (A1)+,D1 ; If we’re at the end of this table,
Beq.s @Done ; then we just leave.
Cmp.l D1,D0 ; If this isn’t the right selector,
Bne.s @FindCtlSelector ; then keep looking.
Adda.l (A1),A1 ; Get offset to routine.
Jsr (A1) ; Jump to it.
Move.l D0,D1 ; Copy result.
Bra.s @Done ; Vamoose.
SelectorTable
; Selector Function result
; -------- ---------------
;
Dc.l dockSCCPorts, ((1<<dockSCCModemPort)|\ ; Modem port is available.
(0<<dockSCCPrinterPort)) ; Printer port isn’t available.
Dc.l dockROMVersion ; Set the ROM…
Dc.b $02,$00,$40,1 ; …version number.
Dc.l 0, 0 ; -- EOT --
; Selector Routine Offset
; -------- --------------
;
Dc.l dockHardwareAttr, HardwareStuff - * - 4 ; Determine HardwareStuff.
Dc.l dockDockingAttr, DockingStuff - * - 4 ; Determine DockingStuff.
Dc.l dockSCCReadAddr, GetSCCReadAddr - * - 4 ; Get the SCC read address.
Dc.l dockSCCWriteAddr, GetSCCWriteAddr - * - 4 ; Get the SCC write address.
Dc.l dockSCSIDiskMode, SDMStatus - * - 4 ; Determine status of SCSIDiskMode (SDM).
Dc.l dockNuBusConnectors, NuBusStuff - * - 4 ; Determine whether we should return Slot #0 or not.
Dc.l dockInit, InitStuff - * - 4 ; Perform early/wake initializations.
Dc.l dockSleepSave, SleepStuff - * - 4 ; Sleep ’em.
Dc.l dockWakeupRestore, WakeupStuff - * - 4 ; Wake ’em.
Dc.l dockFlush, FlushStuff - * - 4 ; Wipe ’em.
Dc.l 0, 0 ; -- EOT --
;----------------------------------------------------------------------------------
;
; HardwareStuff - routine to determine hardware attributes (status call)
;
; Inputs - A0: input parameter (none defined for this call)
;
; Outputs - D0: hardware attributes
;
;----------------------------------------------------------------------------------
HardwareStuff
Move.l #((1<<dockHasSCC)|\ ; Say the we always have SCC for…
(1<<dockWakeSCC)|\ ; …ugly historical hack reasons.
(1<<dockWakeVideo)),D0 ; Internal and/or external video will always be available on wake.
; For this handler, the only thing that can change (and that we can do anything
; about) is video. So, those are the only bits we really deal with here.
;
Btst #vscVideoPower,VSCBase+vscClockPower ; If the video plane is currently powered off,
Beq.s @EndVidChk ; then just go on.
Ori.l #(1<<dockHasVideo),D0 ; Otherwise, say external video is powered.
@EndVidChk
Rts
;----------------------------------------------------------------------------------
;
; DockingStuff - routine to determine docking attributes (status call)
;
; Inputs - A0: input parameter (none defined for this call)
;
; Outputs - D0: docking attributes
;
;----------------------------------------------------------------------------------
DockingStuff
; Return that we can always wake up and that we can always sleep. Also, always
; return that we can PowerCycle, that we can always use the LCD screen, and
; that we are not a dockingStation.
;
Moveq #((0<<dockNoSleep) |\
(0<<dockNoWakeup) |\
(0<<dockNoPowerCycle) |\
(0<<dockNoLCDScreen) |\
(0<<dockingStation)),D0
Rts
;----------------------------------------------------------------------------------
;
; GetSCCRead/WriteAddr - routine to return the SCC read and write addresses.
;
; Inputs - None
;
; Outputs - D0: The SCC read/write address.
;
; Note: We shouldn’t have to deal with the SCC ports in this handler, but
; the single-port arbitration stuff relies solely on the Docking
; Handler. Strickly speaking, this Docking Handler is only for
; the built-in external video. Ugh!
;
;----------------------------------------------------------------------------------
GetSCCReadAddr
Move.l SCCRd,D0 ; Return the SCC read address.
Rts
GetSCCWriteAddr
Move.l SCCWr,D0 ; Return the SCC write address.
Rts
;----------------------------------------------------------------------------------
;
; SDMStatus - routine to SCSI Disk Mode (status call)
;
; Inputs - A0: input parameter (meaningless for status calls)
;
; Outputs - D0: SCSI Disk Mode status
;
; Note: This probably shouldn’t be here, but it is. This handler is
; supposed to only have to deal with video. Hack, hack, hack.
;
;----------------------------------------------------------------------------------
SDMStatus
Moveq #((1<<dockSDMExists)|\ ; Say that we support SDM.
(0<<dockSDMCable)),D0 ; Default to no cable.
Movea.l VIA,A0 ; Point to the VIA.
Moveq #1<<vSDMCable,D1 ; Mask off the cable sense bit.
And.b vBufB(A0),D1 ; Get it.
Btst #vSDMCable,D1 ; If there’s no cable attached,
Bne.s @Finished ; then just go on.
Addq.b #(1<<dockSDMCable),D0 ; Otherwise, say it’s present.
@Finished Rts
;----------------------------------------------------------------------------------
;
; NuBusStuff - routine to do return NuBus “connectors” (status call)
;
; Inputs - none
;
; Outputs - returns none or Slot 0
;
;----------------------------------------------------------------------------------
;
With PmgrPramRec
NuBusStuff
Moveq #VidMode,D0 ; Say that we want the VidMode byte.
Bsr ReadPMgrPRAM ; Get it.
Bne.s @DoSlot0 ; If we’re supposed to return Slot #0, then do so.
Moveq #0,D0 ; Otherwise, don’t.
Bra.s @Finished ;
@DoSlot0 Moveq #(1<<dockSlot0),D0 ; Say we need to redo Slot #0.
@Finished Rts
Endwith
;----------------------------------------------------------------------------------
;
; InitStuff - routine to do docking initialization (control call)
;
; Inputs - a0: input parameter, indicates sleep wakeup or normal init
;
; Outputs - d0: will return zero at init time; will return non-zero
; on wakeup if the world has changed
;
;----------------------------------------------------------------------------------
;
InitStuff
Move.l A0,D0 ; Get the input flags.
Btst #dockWorldChanged,D0 ; If we got the early wake-up call,
Bne.s @CheckWorld ; then go check the world.
Btst #dockWakeupInit,D0 ; If we’re simply waking up, then
Bne.s @Done ; just leave.
Bsr DetectExtDisplay ; Otherwise, go look for an ext. display.
@Done Moveq #0,D0 ; Say that we were successful.
Rts ; And vamoose.
; Generally speaking, the Docking Manager wants to know if “bulk” changes have occurred. In
; our case, bulk changes never occur (that is, the “bar” is permenantly attatched). So,
; we just want to find out if paticular changes have occurred. Specifically, we want
; to know if the state of the int./ext. video has changed. And, if so, we report this
; information back to the Docking Manager.
;
With PmgrPramRec
@CheckWorld
Bsr DetectExtDisplay ; Go look for an ext. display.
Lea ExtVidState,A0 ; Point to the ext. save-state variable.
Cmp.w (A0),D0 ; If the ext. world hasn’t changed, then
Beq.s @ChkInt ; check the int. world.
Bra.s @ForceInt ; Otherwise, force the DockingMgr to deal w/Slot #0.
; If we got here, then the external display state hasn’t changed. So, before we simply tell
; tell the Docking Manager to do nothing, we check to see if the internal display
; state has changed. We do this by comparing the state of the lid with the state
; of the built-in internal video. If the state of the lid matches the state
; of built-in internal video (e.g., lid down and video off), then we simply tell
; the docking manager to do nothing. However, if the state of the lid does
; not match the state of built-in internal video (e.g., lid up and video off),
; then we tell the Docking Manager to go change the world. We also pass this information
; back to ourselves (via PowerMgr pRAM).
;
@ChkInt Bsr GetLidState ; Get the state of the lid.
Move.b D0,-(Sp) ; Save the state.
Moveq #0,D0 ; Say we want Slot #0
Move.w #drHwCSC,D0 ; Say we want CSC.
Swap D0 ; Set up for call.
Bsr GetSlotDevRefNum ; Do it.
Ext.l D0 ; Normalize result into hiword.
Swap D0 ; Get hiword into loword.
Cmp.b (Sp)+,D0 ; If lidState == vidState, then
Beq.s @Done ; just leave.
@ForceInt Moveq #VidMode,D0 ; Say we want to write the VidMode byte.
Moveq #-1,D1 ; Set the redo-slot-0 flag.
Bsr WritePMgrPRAM ; Do it.
Moveq #(1<<dockWorldChanged),D0 ; Say the world changed.
Rts
Endwith
;----------------------------------------------------------------------------------
;
; SleepStuff - routine to save bar's hardware state (control call)
;
; Inputs - none
;
; Outputs - D0: pointer to hardware state, or error flag (-1)
;
;----------------------------------------------------------------------------------
With VDPageInfo,VidLowPwrFrame
SleepStuff
Lea ExtVidState,A0 ; Point to the ext. save-state variable.
Move.w #indexedNoConnect,(A0) ; Assume nobody’s home.
Link A6,#VidLowPwrFrameSize ; Allocate some local storage on the stack.
; Get a the external driver’s refNum if it’s around.
;
Clr.l -(Sp) ; Make room for docking result.
Move.l #dockDockingSlot,-(Sp) ; Say we want the docking slot number.
Clr.l -(Sp) ; No params.
_DockingDispatch ; Call the Docking Manager.
Move.l (Sp)+,D0 ; Get the docking slot number into D0.
Swap D0 ; Save it.
Move.w #drHwVSC,D0 ; Get the drHwID.
Swap D0 ; Set up for utility call.
Bsr GetSlotDevRefNum ; If ext. video is not around,
Beq.s @NoExtVid ; then don’t call it.
; Call video driver to power down VSC…
;
Lea VidLowPwrCntBlk(A6),A0 ; Point to parameter block space.
Move.w D0,ioRefNum(A0) ; Load the driver refNum.
Clr.w ioVRefNum(A0) ; No driver vRefNum.
Move.w #cscSleepWake,csCode(A0) ; Set up for cscSleepWake.
Lea VidLowPwrVDPageInfo(a6),a1 ; Point to the csParam record.
Move.l A1,csParam(A0) ; Load it.
Clr.w csMode(A1) ; Set mode to sleep the VSC.
_Control ; Do it.
Beq.s @Finished ; If successful, then go on.
@NoExtVid Moveq #-1,D0 ; Otherwise, return failure.
Bra.s @Done ; And leave.
@Finished Moveq #0,D0 ; We didn’t need any special storage.
Lea ExtVidState,A0 ; Point to the save-state variable.
Move.w csMode(A1),(A0) ; Save the state.
@Done Unlk A6 ; Release our stack frame.
Rts
Endwith
;----------------------------------------------------------------------------------
;
; WakeupStuff - routine to do docking cleanup (control call)
;
; Inputs - A0: pointer to hardware state, or error flag (-1)
;
; Outputs - D0: wakeup result (always zero)
;
;----------------------------------------------------------------------------------
With VDPageInfo,VDSetEntryRecord,VidLowPwrFrame
WakeupStuff
Move.l A0,D0 ; Get status from sleep.
Cmpi.l #-1,D0 ; If we failed to sleep,
Beq @Done ; then just leave.
Lea ExtVidState,A0 ; Point to the ext. save-state variable.
Cmpi.w #indexedNoConnect,(A0) ; If the world changed (or nobody’s home),
Beq @Done ; then just leave.
Link A6,#VidLowPwrFrameSize ; Allocate some local storage on the stack.
; Get a the external driver’s refNum if it’s around.
;
Move.w #drHwVSC,D0 ; Get the drHwID for VSC.
Swap D0 ; Save it.
Move.w #dockSlotE,D0 ; Get the slot number. (We could call the Docking Manager, but why?)
Bsr GetSlotDevRefNum ; If ext. video is not around (shouldn’t happen),
Beq.s @Finished ; then don’t call it.
; Call video driver to power up VSC…
;
Lea VidLowPwrCntBlk(A6),A0 ; Point to parameter block space.
Move.w D0,ioRefNum(A0) ; Load the driver refNum.
Clr.w ioVRefNum(A0) ; No driver vRefNum.
Move.w #cscSleepWake,csCode(A0) ; Set up for cscSleepWake.
Lea VidLowPwrVDPageInfo(A6),A1 ; Point to the csParam record.
Move.l A1,csParam(A0) ; Load it.
Move.w #-1,csMode(A1) ; Set mode to wake up the VSC.
_Control ; If we failed to wake up,
Bne.s @Finished ; then just leave.
Move.w ioRefNum(A0),D0 ; Get the driver’s refNum.
Movea.l Devicelist,A2 ; Get the DeviceList Handle.
Movea.l (A2),A2 ; Make it a pointer.
@DevLoop Cmp.w gdRefNum(A2),D0 ; If this is the right gDevice,
Beq.s @SetEm ; then call SetEntries.
Move.l gdNextGD(A2),D1 ; Otherwise, get the next gDevice.
Beq.s @Finished ; If it’s nil, then we’re done.
Movea.l D1,A2 ; Otherwise, copy the gDevice Handle.
Movea.l (A2),A2 ; Make it a pointer.
Bra.s @DevLoop ; Loop until done.
@SetEm Movea.l gdPMap(A2),A2 ; Get the gDevice’s pixMap’s…
Movea.l (A2),A2 ; …current colorTable.
Movea.l pmTable(A2),A2 ; (If this were a direct device, we’d punt here.)
Move.l A0,D1 ; Save the ioPB ptr.
Movea.l A2,A0 ; Set up to…
_HLock ; …lock down the colorTable.
Move.l A0,-(Sp) ; Save the Handle for _HUnlock.
Movea.l (A0),A2 ; Turn it into a pointer.
Movea.l D1,A0 ; Restore ioPB ptr.
Clr.w csStart(A1) ; Set csStart to 0.
Move.w ctSize(A2),csCount(A1) ; Set csCount to pmTable.ctSize.
Lea ctTable(A2),A2 ; Get a pointer to the pmTabl.ctTable.
Move.l A2,csTable(A1) ; Copy it to the csParam block.
Move.w #cscSetEntries,csCode(A0) ; Set up for SetEntries.
_Control ,Immed ; Do it.
Movea.l (Sp)+,A0 ; Set up to…
_HUnlock ; …unlock the colorTable Handle.
@Finished Unlk A6 ; Release our local stack storage.
@Done Moveq #0,D0 ; Always return zero.
Rts
Endwith
;----------------------------------------------------------------------------------
;
; FlushStuff - routine to do docking finalé (status call)
;
; Inputs - A0: input parameter (meaningless for status calls)
;
; Outputs - D0: wipe result (always zero)
;
;----------------------------------------------------------------------------------
;
With PmgrPramRec
FlushStuff
Moveq #VidMode,D0 ; Say we want to write the VidMode byte.
Moveq #0,D1 ; Reset the redo-slot-0 flag.
Bsr WritePMgrPRAM ; Do it.
Moveq #0,D0 ; Return zero.
Rts ; And leave.
Endwith
;=====================================================================
; Data
;=====================================================================
; We need to remember what the state of built-in external video
; is prior to going to sleep so that we can see if it has
; changed across the sleep-wake transition.
;
ExtVidState Dc.w indexedNoConnect ; Records the state of built-in external video across sleep.
;=====================================================================
; Utils
;=====================================================================
;---------------------------------------------------------------------
;
; Routine: Delay100
;
; Inputs: a0 - Ptr to VIA1 base
;
; Outputs: none
;
; Destroys: d0
;
; Function: Delays around 100 us, for reading sense lines on VSC.
;---------------------------------------------------------------------
Delay100 move.w TimeVIADB,d0
lsr.w #3,d0 ; 125 us delay
@wait tst.b (a0)
dbra d0,@wait
rts
;---------------------------------------------------------------------
; This routine reads the VSC/Jet sense lines. On entry, A4 should point to the VSC/Jet base address, D6
; should contain $03, $05, $06, or $07 to indicate the type of extended sense we’re doing, and
; the CPU should have been put into 32-bit addressing mode. On exit, D6 contains the appropriate
; extended sense code.
;
; Note: The idea behind the extended-sense-line ($07) algorithm is as follows: First, drive sense line
; “a” and read the values of “b” and “c.” Next, drive sense line “b” and read the values of “a”
; and “c.” Finally, drive sense line “c” and read the values of “a” and “b.” In this way, a
; six-bit number of the form bc/ac/ab is generated. The other extended-sense algorithms are
; identical to that of $07, except one of the three lines doesn’t need to be driven. For example,
; with $03, “a” doesn’t need to be driven. With $05, “b” doesn’t need to be driven, and
; with $06, “c” doesn’t need to be driven.
;---------------------------------------------------------------------
DoExtendedSense
Movem.l A0/D0-D1,-(Sp) ; Save work registers.
Moveq #0,D1 ; Use D1 to store extended-sense code.
Moveq #0,D0 ; Use D0 as temp from reads.
move.l VIA,a0 ; for delays
; Drive a, Read bc
;
Cmpi.b #indexedSense2P,D6 ; If this is not a type-3 extended sense,
Bne.s @DriveA ; then go ahead and drive A.
Move.b D6,D0 ; Otherwise, write out the assumed value,
Bra.s @EndA ; and go on.
@DriveA move.b #VSCAMask,VSC_MonID(a4) ; abc <- 011
bsr Delay100 ; delay 100 us
move.b VSC_MonID(a4),d0 ; Read the sense lines into d0.
lsr.b #4,d0 ; Shift the senseline inputs down.
@EndA move.b D0,D1 ; 00 00 BC
lsl.b #2,D1 ; 00 BC 00
; Drive b, Read ac
;
Cmpi.b #indexedSenseRGBFP,D6 ; If this is not a type-5 extended sense,
Bne.s @DriveB ; then go ahead and drive B.
Move.b D6,D0 ; Otherwise, write out the assumed value,
Bra.s @EndB ; and go on.
@DriveB move.b #VSCBMask,VSC_MonID(a4) ; abc <- 101
bsr Delay100 ; delay 100 us
move.b VSC_MonID(a4),d0 ; Read the sense lines into d0.
lsr.b #4,d0 ; Shift the senseline inputs down.
@EndB bclr #VSCSenseLineA,d0 ; A0C becomes
beq.s @OrIn ; A0C or
bset #VSCSenseLineB,d0 ; A1C
@OrIn or.b d0,D1 ; 00 BC AC
lsl.b #2,D1 ; BC AC 00
; Drive c, Read ab
;
Cmpi.b #indexedSenseHR,D6 ; If this is not a type-6 extened sense,
Bne.s @DriveC ; then go ahead and drive C.
Move.b D6,D0 ; Otherwise, write out the assumed value,
Bra.s @EndC ; and go on.
@DriveC move.b #VSCCMask,VSC_MonID(a4) ; abc -> 110
bsr Delay100 ; delay 100 us
move.b VSC_MonID(a4),d0 ; Read the sense lines into d0.
lsr.b #4,d0 ; AB0
@EndC lsr.b #1,d0 ; 0AB
or.b d0,D1 ; BC AC AB
Move.b D1,D6 ; Save the extended-sense code.
Movem.l (Sp)+,A0/D0-D1 ; Restore work registers.
Rts ; Return to caller.
; In a “classic” video card setup, we’d normally perform the follwing code in the PrimaryInit.
; However, because we have a clamshell on Blackbird, we need to know whether or not it will
; be closed. If the clamshell is closed, we generally want to keep video turned off on the
; LCD, but only if some sort of external video is running. So, we check here to see if
; there’s a display attatched to the external video connector. If there is a display attached,
; then we just leave video power on. Otherwise, we turn it off, and the hardware attributes
; then return that no external video is available.
;
; No registers are trashed, but D0 returns the detected display code.
;
DetectExtDisplay
@ExtDispRegs Reg A0-A4/D1/D6 ; Define and save the…
Movem.l @ExtDispRegs,-(Sp) ; …registers used here.
; Get some useful values up front.
;
lea VSCVideoBase,a4 ; Get the video base address into a4.
lea AIV3Base,a3 ; Point to AIV3 base.
; First, disable the VBL interrupts.
;
Bset #VidPwrEn,AIV3PwrEn(a3) ; Turn on video power plane…
Clr.b VSC_VidCtrl(A4) ; …but shut off syncs, dot clock, etc….
Move.w #500-1,D0 ; It takes approximately 500µs…
@Wait500 Tst.b ([VIA]) ; …for the power-on signal to
Dbra D0,@Wait500 ; …propagate thru the video circuitry.
Bset #vidReset,VSC_Test(A4) ; Reset the video subsystem by…
Bclr #vidReset,VSC_Test(A4) ; …toggling the reset bit.
move.b #(1<<slotVBL),AIV3SlotEn(a3) ; Disable built-in (slot E) video’s VBLs.
moveq #2,d0 ; default (reset) value
move.b d0,VSC_HFP(a4) ; set horizontal front porch
move.b d0,VSC_HS(a4) ; set horizontal sync
move.b d0,VSC_HBP(a4) ; set horizontal back porch
move.b d0,VSC_HA(a4) ; set horizontal active dots
move.b d0,VSC_SyncA(a4) ; set SyncA dots
move.w d0,VSC_VFP(a4) ; set vertical front porch
move.w d0,VSC_VS(a4) ; set vertical sync lines
move.w d0,VSC_VBP(a4) ; set vertical back porch
move.w d0,VSC_VA(a4) ; set vertical active lines
clr.b VSC_Test(a4) ; clear test register
;-------------------------------------------------------
; Sense the type of display to drive.
;-------------------------------------------------------
With SP_Params,SpBlock
Suba.w #spBlockSize,Sp ; Make a slot parameter block on stack.
Movea.l Sp,A0 ; Get pointer to parm block now.
Move.b #dockSlotE,spSlot(A0) ; Put slot # into pBlock (We could call the Docking Manager, but why?)
Clr.b spExtDev(A0) ; Why ask why, just clear this guy.
Suba.w #SizesPRAMRec,Sp ; Allocate block for pRAM record.
Move.l Sp,spResult(A0) ; Point to it.
Movea.l Sp,A2 ; Save it.
_sReadPRAMRec ; Read slot PRAM.
moveq #0,d6 ; clear our id reg
move.b VSC_MonID(a4),d6 ; Read the sense lines into d6.
lsr.b #4,d6 ; Shift the senseline inputs down.
Cmpi.b #indexedSenseHR,D6 ; If we got a type-6, then do the
Beq.s @ExtendedHR ; extended Hi-Res stuff.
Cmpi.b #indexedNoConnect,D6 ; If we got a type-7, then do the
Beq.s @ExtendedNoConnect ; extended no-connect stuff.
Bra @EndSense ; Otherwise, the display is indexed and we handle it in the table.
@ExtendedHR
Bsr DoExtendedSense ; Do the extended type-6 algorithm.
Lea @XT6Table,A1 ; Point to the table of extended type-6 codes.
@XT6Loop Move.b (A1)+,D0 ; Pick up the next supported extended type-6 code.
Bmi.s @EndExtHR ; If we’re at the end of the list, then just leave.
Move.b (A1)+,D1 ; Pick up the indexed version of the extended code.
Cmp.b D0,D6 ; If we didn’t find a match, then
Bne.s @XT6Loop ; just keep looping.
Move.b D1,D6 ; Translate the extended code into its indexed version.
Bra @EndSense ; And move on.
@EndExtHR Move.b #indexedSenseHR,D6 ; Say that a type-6 display is connected.
Move.b SP_AltSense(A2),D0 ; Get the alternate senseID pRam byte.
Andi.b #spAltSenseValidMask,D0 ; If it is valid, then just pretend that
Bne.s @DoMonID ; the monID monitor is attached.
Bra.s @EndSense ; Otherwise, just say an HR display is attached.
@DoMonID Move.b SP_AltSense(A2),D6 ; Get the no-connect pRam byte.
Andi.b #spAltSenseMask,D6 ; Strip the validation code.
Bra.s @EndSense ; Skip the rest.
@ExtendedNoConnect
Bsr DoExtendedSense ; Do the extended no-connect algorithm.
Lea @XNCTable,A1 ; Point to the table of extended no-connect codes.
@XNCLoop Move.b (A1)+,D0 ; Pick up the next supported extended no-connnect code.
Bmi.s @EndNoConnect ; If we’re at the end of the list, then just leave.
Move.b (A1)+,D1 ; Pick up the indexed version of the extended code.
Cmp.b D0,D6 ; If we didn’t find a match, then
Bne.s @XNCLoop ; just keep looping.
Move.b D1,D6 ; Translate the extended code into its indexed version.
Bra.s @EndSense ; And move on.
@EndNoConnect Move.b #indexedNoConnect,D6 ; Say that nothing’s connected.
Bclr #VidPwrEn,AIV3PwrEn(a3) ; And turn off video power.
Bra.s @EndSense
@XNCTable Dc.b extendedSenseVGA,indexedSenseVGA
Dc.b extendedSenseGF,indexedSenseGF
Dc.b -1,-1
@XT6Table Dc.b extendedMSB1,indexedSenseMSB1
Dc.b extendedMSB2,indexedSenseMSB2
Dc.b extendedMSB3,indexedSenseMSB3
Dc.b -1,-1
@EndSense clr.b VSC_MonID(a4) ; set ID lines to 0 to tri-state them.
Move.b D6,SP_MonID(A2) ; Write the MonID into pRAM buffer.
Move.l A2,spsPointer(A0) ; Set up parameter block.
_sPutPRAMRec ; Write the new record out.
Adda.w #SizesPRAMRec+spBlockSize,Sp ; Deallocate buffer.
Moveq #0,D0 ; Clear D0 for good measure.
Move.b D6,D0 ; Return the detected ext. display code.
Movem.l (Sp)+,@ExtDispRegs ; Restore the registers used here.
Rts ; And vamoose.
Endwith
;---------------------------------------------------------------------
;
; Routine: GetLidState
;
; Inputs: None.
;
; Outputs: D0.b - zero if lid is closed, -1 if lid is open.
;
; Destroys: A0/D0.
;
; Function: Returns the driver refNum of a needed device if that
; device happens to be in a particular slot.
;---------------------------------------------------------------------
;
With PMgrRec, pmCommandRec
GetLidState
Clr.w -(Sp) ; Allocate buffer on stack.
Move.l Sp,-(Sp) ; pmRBuffer
Move.l (Sp),-(Sp) ; pmSBuffer
Clr.w -(Sp) ; pmLength = 0
Move.w #readExtSwitches,-(SP) ; pmCommand
Movea.l SP,A0 ; Point to the parameter block.
_PMgrOp ; Get the clamshell info.
Lea pmRBuffer+4(Sp),Sp ; Toss the parameter block.
Btst #clamshell,(Sp)+ ; Is the clamshell closed?
Seq D0 ; Set up result.
Rts
Endwith
;---------------------------------------------------------------------
;
; Routine: GetSlotDevRefNum
;
; Inputs: D0.w (lo) - slot number to search.
; D0.w (hi) - drHwID of device.
;
; Outputs: D0.w (lo) - if non-zero, refNum of device’s driver.
;
; Destroys: A0/D0.
;
; Function: Returns the driver refNum of a needed device if that
; device happens to be in a particular slot.
;---------------------------------------------------------------------
;
With SpBlock
GetSlotDevRefNum
Suba.w #SpBlockSize,Sp ; Allocate an SpBlock.
Movea.l Sp,A0 ; Point to the SpBlock on the stack.
Move.b D0,spSlot(A0) ; Set the slot number to search in.
Swap D0 ; Load the DrHwID.
Clr.b spId(A0) ; Begin at id 0.
Clr.b spExtDev(A0) ; No external device.
Clr.b spTBMask(A0) ; No mask in search.
Move.w #catDisplay,spCategory(A0) ; Look for: Display,
Move.w #typVideo,spCType(A0) ; Video,
Move.w #drSwApple,spDrvrSW(A0) ; Apple,
Move.w D0,spDrvrHW(A0) ; <DrHwID>.
Clr.l spParamData(A0) ; Look only for enabled sRsrcs.
Bset #foneslot,spParamData+3(A0) ; Limit search to this slot.
_GetTypeSRsrc ; If we found it, then
Beq.s @FoundDevice ; say so.
Moveq #0,D0 ; Otherwise, say the device isn’t loaded.
Bra.s @Done ;
@FoundDevice Move.w spRefNum(A0),D0 ; Get the refNum into D0.
@Done Adda.w #SpBlockSize,Sp ; Restore the stack.
Rts ; And vamoose.
Endwith
;---------------------------------------------------------------------
;
; Routine: ReadPMgrPRAM
;
; Inputs: D0.l - PRAM address.
;
; Outputs: D0.b - byte read
;
; Destroys: A0/D0.
;
; Function: Reads a byte of PowerMgr PRAM.
;---------------------------------------------------------------------
;
With PmgrRec
ReadPMgrPRAM
Movea.l PMgrBase,A0 ; Point to the Power Manager’s globals.
Add.b PRAMBase(A0),D0 ; Get the absolute PRAM address.
Swap D0 ; Save it.
Addq #1,D0 ; Say we want one byte.
Swap D0 ; Save it.
Clr.b -(Sp) ; Make space for a buffer on the stack.
Movea.l Sp,A0 ; Point to it.
_ReadXPRAM ; Read the byte.
Move.b (Sp)+,D0 ; Return it.
Rts
Endwith
;---------------------------------------------------------------------
;
; Routine: WritePMgrPRAM
;
; Inputs: D0.l - PRAM address.
; D1.b - byte to write.
;
; Outputs: None.
;
; Destroys: A0/D0.
;
; Function: Writes a byte of PowerMgr PRAM (but doesn’t set the dirty flag).
;---------------------------------------------------------------------
;
With PmgrRec
WritePMgrPRAM
Movea.l PMgrBase,A0 ; Point to the Power Manager’s globals.
Add.b PRAMBase(A0),D0 ; Get the absolute PRAM address.
Swap D0 ; Save it.
Addq #1,D0 ; Say we want one byte.
Swap D0 ; Save it.
Move.b D1,-(Sp) ; Push the byte to write onto the stack.
Movea.l Sp,A0 ; Point to it.
_WriteXPRAM ; Write it.
Tst.b (Sp)+ ; Clean up the stack.
Rts
Endwith
Reference in New Issue View Git Blame Copy Permalink