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 04:29:09 +00:00
Code Issues Projects Releases Wiki Activity
33cd9271f4
sys7.1-doc-wip/DeclData/DeclVideo/DAFB/DAFBDriver.a
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

3399 lines
130 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: DAFBDriver.a
;
; Contains: This file contains the video driver for use by the Macintosh
; OS for the DAFB hardware.
;
; Written by: David Fung/Mike Puckett
;
; Copyright: © 1990-1993 by Apple Computer, Inc. All rights reserved.
;
; Change History (most recent first):
;
; <SM7> 08-03-93 jmp Changed the reference names of the multiscan display constants
; to their new names.
; <SM6> 11/5/92 SWC Changed VideoEqu.a->Video.a and ShutdownEqu.a->Shutdown.a.
; <SM5> 11/2/92 kc Don't include SonicEqu.a.
; <SM4> 10-29-92 jmp (jmp,H26) Fixed a branching problem in the PageMode
; enabling/disabling code in VidOpen.
; <SM3> 10-17-92 jmp (jmp,H25) Fixed a subtle bug that would only occur when the CPU
; was set up to be in 24-bit mode -- the problem had to do with my
; putting the machine in 32-bit mode and calling a slot manager
; trap (_sGetBlock) that ended up allocating 32-bit memory in a
; 24-bit System heap. Ooops….
; <SM2> 10-13-92 jmp (jmp,H24) Fixed a problem in SetDepth where I was clearing the
; ClkSel bit in the DAFBClkCfg register. For the NSC-8534 this
; bit must be a one, and for the NSC-8531 it must be a zero.
; Also, added a line of code that got “lost” from the Zydeco
; sources.
; <SM1> 10/6/92 GDW New location for ROMLink tool.
; ———————————————————————————————————————————————————————————————————————————————————————
; Pre-ROMLink comments begin here.
; ———————————————————————————————————————————————————————————————————————————————————————
; <SM9> 09-29-92 jmp (jmp,H23) Added about a 1-µSec delay between SetEntries R-G-B
; writes to the Antelope CLUT/DAC (i.e., unlike the Brooktree and
; AMD CLUT/DACs, the Antelope parts don’t use dual-ported RAM
; internally).
; (jmp,H22) The TimingAdj register wasn’t being set up properly in
; PAL 16bpp FF/ST with Antelope parts. Fixed this.
; (jmp,H21) Added more support for the Antelope (AT&T/Sierra)
; CLUT/DAC used on Wombat/WLCD.
; <SM8> 09-03-92 jmp (jmp,H20) Added initial support for the AT&T CLUT/DAC to be used
; in Wombat/WLCD systems.
; <SM7> 07-14-92 jmp (jmp,H18) Fixed a minor bug in ChkMode where I was allowing
; 32bpp to be set on Rubik for a WombatDAFB.
; (jmp,H17) Added in support to make the DAFBDriver function
; correctly among Spike, Eclipse, Zydeco, and all Wombat/WLCD
; CPUs.
; (jmp,H16) Added more Wombat support as well as continued with
; general optimizations.
; (jmp,H15) Tightened up the Wombat TimingAdj adjustment table
; (used bytes instead of words).
; (jmp,H14) Added first-pass support for the Wombat version of
; DAFB.
; <SM6> 6/18/92 KW (jmp,H13) Eliminated yet even more of the old DAFBVidParams
; fields, so I adjusted the code accordingly.
; <SM5> 6/4/92 KW (jmp,H12) Fixed a problem where I wasn’t setting up the timing
; adjust register in the Brooktree DAC case. Oops! (jmp,H11) Made
; the code that deals with the DAFB vidParams “smarter” due my
; compacting vidParams tables. This kind of work will continue
; throughout Wombat development. (jmp,H10) Cleaned up the
; interrupt handler a little, cleaned up WaitVSync a little, fixed
; the “little table of counts” problem from Zydeco, etc….
; <SM4> 5/16/92 kc Roll in Horror Changes. Comments follow:
; <H9> 02/20/92 jmp (jmp,Z51) Fixed a problem in the SetDepth where I wasn’t always
; selecting the correct clock. This problem surfaced due to a
; change in the AC824A (aka AC823).
; <H8> 01/22/92 jmp (jmp,Z50) Updated the original “No Connect” code to take full
; advantage of the newly-defined extended sense codes. Changed
; the name from “NoConnect” to “AltSense.”
; <H7> 01/11/92 jmp Added rudimentary support for the newly-defined extended sense
; codes.
; <H6> 12/17/91 jmp Eliminated some code in GrayScreen that handled base addresses
; that moved across depths, as it is no longer needed.
; <H5> 11/25/91 jmp The vidParams moved from the functional to the board sRsrc to
; save space -- updated the driver accordingly.
; <H4> 11/12/91 jmp Quit forcing the bitdepth back to 1bpp in SetDefaultMode.
; <H3> 11/05/91 jmp Added support for 19” Displays.
; <3> 3/31/92 JSM Rolled this file into Reality.
; <2> 2/14/92 kc Fix "Label defined on next word boundary" assembler warning.
; <50> 01/20/92 jmp Updated the original “No Connect” code to take full advantage of
; the newly-defined extended sense codes. Changed the name from
; “NoConnect” to “AltSense.”
; <49> 01/09/92 jmp Added rudimentary support for the newly-defined extended sense
; codes.
; <48> 12/17/91 jmp Eliminated some code in GrayScreen that handled base addresses
; that moved across depths, as it is no longer needed.
; <47> 11/08/91 jmp Quit forcing the bitdepth back to 1bpp in SetDefaultMode.
; <46> 11/05/91 jmp Added preliminary support for 19” Displays.
; <45> 10/16/91 jmp Added a check in the video open routine that determines whether
; video (i.e., sync) is currently on or not. If it’s off, then we
; now turn it back on. This was added to support turning video
; back on immediately in the event that the video driver is closed
; and needs to be opened again during “normal” operation of the
; CPU.
; <44> 09/17/91 jmp Needed to ensure that the 100 Mhz clock was being shut off when
; “grounding out” the ECL clock signals.
; <43> 09/17/91 jmp Added support for “grounding out” the ECL clock signals in
; software using the AMD-ACDC for Zydeco/Spike33 CPUs.
; <42> 09/13/91 jmp Added support for 16pp on Rubik displays when only 512K of vRAM
; is around in preparation for Spike33s.
; <41> 8/9/91 jmp Just cleaned up some comments and line-spacings.
; <40> 8/9/91 jmp When I removed the NeedsGoodBye control call, I didn’t remove
; the extra check. So, I removed that now.
; <39> 8/9/91 jmp Fixed a VERY minor bug in VidOpen where I was using D0 instead
; of D2 to get the monID.
; <38> 8/9/91 jmp Added support to fix a problem with NTSC & PAL family modes
; where changing the amount of vRAM didn’t cause PrimaryInit to
; re-validate the SP_LastConfig pRAM byte. Also, enabled/disabled
; PageMode in VidOpen depending on the state of pageMode pRAM bit.
; <37> 8/7/91 jmp Added 16bpp support for all displays.
; <36> 7/30/91 jmp Removed the support for the NeedsGoodBye control call.
; <35> 7/29/91 jmp Started validating the mode passed into the SetDefaultMode call;
; none of our previous video drivers have done this. Also, fixed
; the gamma-correction code used on depth switches so that
; mono-only devices are only corrected on the blue channel (as
; they should be).
; <34> 7/13/91 jmp Added routines to extend the factory burn-in no-connect
; detection routines so that ANY display supported by DAFB could
; be used.
; <33> 7/11/91 jmp God, I hate last minute code changes!
; <32> 7/11/91 jmp Yet even more intelligent page-mode handling coded was added.
; <31> 7/11/91 jmp Added even more intelligent code for enabling & disabling page
; mode.
; <30> 7/11/91 jmp Added code to more intelligently handle the enabling & disabling
; of page mode.
; ———————————————————————————————————————————————————————————————————————————————————————
; Pre-Zydeco ROM comments begin here.
; ———————————————————————————————————————————————————————————————————————————————————————
; <29> 6/29/91 jmp Added support for the alternate AC842A-compatible timing adjust,
; horizontal active line, and horizontal front porch DAFB
; parameters.
; <28> 6/27/91 jmp Fixed the Set16bpp call so that it now supports the case where
; 16bpp mode is always non-blocked.
; <27> 6/26/91 jmp Rewrote the ACDC-whacking code to be more AC842A (AMD) friendly.
; <26> 6/25/91 jmp Fixed a problem in 16bpp DirectSetEntries and fixed the problem
; with 16bpp not sticking.
; <25> 6/24/91 jmp Added support for 16bpp Vesuvio & RGB Portrait displays.
; <24> 6/17/91 jmp Fixed a type in the “memory leak” fix in SetGamma that I “fixed”
; last time.
; <23> 6/10/91 jmp Fixed a “memory leak” bug in SetGamma when changing the size of
; the current gamma table (i.e., from size 3 to 1, or vice-versa).
; This caused programs like MacroMind Director 2.0 to get
; out-of-memory errors after playing movies that cycled gamma
; (e.g., for screen fades).
; <22> 6/7/91 jmp Fixed a bug in SetEntries where I had the sense of my
; error-checking backwards. This caused programs like Color
; Studio 1.11 & QuarkXPress 3.0 to hose the System Palette when
; setting a single entry.
; <21> 5/25/91 jmp The close routine was NOT 32-bit clean, and bus-errored when
; called. So, I fixed it.
; <20> 5/24/91 jmp Added support for enabling/disabling sync-on-green.
; <19> 5/22/91 jmp Went back to the more forgiving gamma correction strategy so
; that the gamma tables can be shared among the various built-in
; videos. This is okay, for now, since all the built-in videos
; have similar DACs.
; <18> 5/15/91 jmp Wasn’t cleaning up the stack on exit from GetEntries input
; errors. VidReset wan’t passing the right value to DAFBSetDepth
; (i.e., indexed mode value vs. bpp value). And GetPage wasn’t
; range-checking the input mode properly.
; <17> 5/10/91 jmp Due to the fact that interrupt status registers are NOT inverted
; as originally assumed, the WaitVSync code could have hung
; forever in some cases; fixed that problem. In Get/SetEntries
; fixed the fact that some apps are NOT 32-bit clean; i.e., they
; pass in a 24-bit CTabHandle’s MasterPointer as a Pointer.
; Optimizations: Tightened up the WaitVSync code; changed several
; Move.b’s and Move.w’s to Moveq’s where applicable. Used scaling
; in the VidStatus jumptable (i.e., like the VidCtl jumptable).
; Added SuperVGA support. Now check for 25 vs. 33 MHz CPU
; operation the new, better way. Code reveiw changes: Cleaned up
; the error-handling code in VidOpen; tightened up the code in
; VidOpen that builds a linear gamma table; cleaned up the
; ST-corrected screen baseAddr code; and swapped to 32-bit
; addressing mode in VidClose in order to idle DAFB.
; <16> 4/23/91 jmp Fixed a bug in SetVidMode where I was trashing A0. Also, quit
; jumping thru jSwapMMU and started using _SwapMMUMode, except in
; the interrupt handler. Started using monIDs instead of spIDs
; where possible for config testing -- less compares. Fixed a bug
; in ChkMode where I was using Cmp.w’s instead of Cmp.b’s.
; <15> 4/19/91 jmp The gamma correction code was doing very bad things. First, it
; was always allowing TFB-style tables (i.e., non-hardware
; specific tables) to pass through. Second, it was building
; linear ramps backwards. In SetVidMode, I added 3-channel gamma
; correction code due to the 6500°K simulation for Vesuvio &
; GoldFish. I also fixed a bug in SetGamm where we were not
; setting the new gamma table when in direct mode. Finally, I now
; synthesize a linear gamma table on the fly in VidOpen if a gamma
; directory doesn’t exist (i.e., for NTSC, PAL, and VGA).
; <14> 4/3/91 jmp Moved the Bsr to WaitVSync to just before the DAFBReset sequence
; in DAFBSetDepth. This reduces the problem with the display
; “jumping” when switching bit-depths. The most notable offender
; is MacsBug when stepping.
; <13> 4/1/91 jmp Removed support for DAFB 1.
; <12> 3/25/91 jmp I was not saving the monitor ID at open time for
; gamma-correction checking. I was also not writing to the
; correct guns on mono-only displays (i.e., I was clearing red,
; setting green, and not touching blue; should have been clearing
; red & green, and setting blue). Fixed a bug in three-channel
; direct CLUTs (wasn’t actually pointing to blue). Fixed a bug in
; indexed SetEntries where I was jumping into the RBV video driver
; due to a common label.
; <11> 3/18/91 jmp Fixed “false” tops and bottoms in the convolved screen-clearing
; code. Fixed a problem in SetEntries where A0 was potentially
; being trashed.
; <10> 3/4/91 jmp Fixed 1bpp Rubik Display problem (i.e., first line of vRam not
; being cleared).
; <9> 2/25/91 jmp Changed the interrupt handling code to use CrsrLine instead of
; VBL because CrsrLine is programmable. Added a Bsr to
; DAFBWaitVSync in DAFBDirectClutSet. SetEntries was not 32-bit
; clear as we were not StripAddress’ing the csTable pointer.
; <8> 2/15/91 jmp Fixed bug in SetEntries where an input error would have
; corrupted the stack (i.e., not popping saved register off
; stack). Fixed screen graying code to work properly with the
; convolved modes only supporting 4/8bpp. Conditionalized so that
; when new DAFBs are around, the coding effort will be minimal.
; Added check for 33 vs. 25 Mhz operation.
; <7> 2/10/91 jmp Fixed screen base address calculations (for ST modes). Fixed
; the mode validation (ChkMode) code.
; <6> 2/3/91 jmp Updated GrayScreen for NTSC and PAL ST modes (including blacking
; around the sides).
; <5> 1/30/91 jmp Just replaced the in-line reset instructions with the DAFBReset
; macro defined in RBVDepVideoEqu.a.
; <4> 1/24/91 jmp Finished a first stab at DAFBGetEntries.
; <3> 1/21/91 jmp Incremental change -- fixed/added the IsMono code.
; <2> 1/14/91 DAF Added file for first time, but needed to adjust the comment!
; <1> 1/14/91 DAF First checked in.
;
STRING C
PRINT OFF
LOAD 'StandardEqu.d'
INCLUDE 'DockingEqu.a'
INCLUDE 'EgretEqu.a'
INCLUDE 'GestaltEqu.a'
INCLUDE 'GestaltPrivateEqu.a'
INCLUDE 'HardwarePrivateEqu.a'
INCLUDE 'IOPrimitiveEqu.a'
INCLUDE 'PowerPrivEqu.a'
INCLUDE 'ROMEqu.a'
INCLUDE 'Video.a'
INCLUDE 'SlotMgrEqu.a'
INCLUDE 'ShutDown.a'
; INCLUDE 'SonicEqu.a'
INCLUDE 'UniversalEqu.a'
INCLUDE 'DepVideoEqu.a'
PRINT ON
SEG '_sDAFBDriver'
BLANKS ON
STRING ASIS
MACHINE MC68020
; This is device storage which is stored in the dCtlStorage field of the AuxDCE.
DAFBVidPrivates RECORD 0
saveBaseAddr DS.L 1 ; the screen base address (NOT ST corrected!)
saveScreenBase DS.L 1 ; ST corrected version of saveBaseAddr.
saveSQElPtr DS.L 1 ; the SQ element pointer (for _SIntRemove)
saveGammaPtr DS.L 1 ; the pointer to the Gamma correction table
saveGamDispPtr DS.L 1 ; the pointer to the Gamma block
saveVDACBase DS.L 1 ; the base addr of the VDAC
saveDAFBBase DS.L 1 ; the base addr of the DAFB
saveVidPtr DS.L 1 ; pointer to a big block of DAFB video parameters
GFlags DS.B 1 ; flags word (in hi-byte)
wombatFlag Ds.b 1 ; (hidden WombatDAFB flag)
has16bppACDC Ds.b 1 ; true if AC842A is around
pageModeSet Ds.b 1 ; true if the pRam PageMode enable bit is set
saveMode DS.W 1 ; the current mode setting (in lo-byte)
saveMonID DS.W 1 ; monitor type ID (in lo-byte)
saveSlotId DS.B 1 ; spID of video sRsrc
hasLin16bppCLUT Ds.b 1 ; true if AC842A is Antelope
DAFBVidPrivSize EQU *
ENDR
LDAFBDriver MAIN EXPORT
;-------------------------------------------------------------------
; Video Driver Header
;-------------------------------------------------------------------
;
DAFBDrvr
DC.W $4C00 ; ctl,status,needsLock
DC.W 0,0,0 ; not an ornament
; Entry point offset table
DC.W DAFBVidOpen-DAFBDrvr ; open routine
DC.W DAFBDrvr-DAFBDrvr ; no prime in normal video drivers
DC.W DAFBVidCtl-DAFBDrvr ; control
DC.W DAFBVidStatus-DAFBDrvr ; status
DC.W DAFBVidClose-DAFBDrvr ; close
STRING Pascal
DAFBVidTitle
DC.B '.Display_Video_Apple_DAFB'
ALIGN 2 ; make sure we're aligned
DC.W CurDAFBDrvrVersion ; current version
STRING ASIS
;
; This table simply contains the zero-based maximum index value for each of the depths. It is
; set up to be indexed via the modeID. The DAFBXClutTbl is for supporting 16bpp-capable
; sResources.
;
DAFBClutTbl Dc.b $01,$03,$0F,$FF,$FF
DAFBXClutTbl Dc.b $01,$03,$0F,$FF,$1F,$FF
;
; These are the bit patterns for grays in each depth, except the last one which is the black
; “half-pattern” in 32-bit/pixel mode. The DAFBXPats are for supporting 16bpp-capable
; sResources.
DAFBPats Dc.l OneBitGray,TwoBitGray,FourBitGray,EightBitGray,ThirtyTwoBitGray
DAFBXPats Dc.l OneBitGray,TwoBitGray,FourBitGray,EightBitGray,SixteenBitGray,ThirtyTwoBitGray
;
; Normally, if no monitor is detected on boot, PrimaryInit just shuts video down. However,
; if the no-connect pRam code is valid, then we things up as if the monitor code
; specified in pRam were actually connected. The DAFBMonIDs table (below) is composed
; of the valid monitor IDs supported by DAFB.
;
DAFBMonIDs Dc.w MonIDSEnd-MonIDsBegin-2
MonIDsBegin
Dc.b indexedSenseRGB2P,indexedSenseFP,indexedSenseRubik,indexedSense2P
Dc.b indexedSenseNTSC,indexedSenseRGBFP,indexedSenseHR
Dc.b extendedSensePALBox,extendedSenseNTSC,extendedSenseVGA
Dc.b extendedSenseLP,extendedSensePAL,extendedSense19
Dc.b 0
MonIDSEnd
;
; Because Wombat uses a different clock chip, the TimingAdj value for Spike/Eclipse/Zydeco
; doesn’t work on Wombat. However, the TimingAdj adjustment value is simple to compute
; based on the pixel depth and the clock divider. So, the table represents the value to
; to add to TimingAdj per pixel depth per clock divider. The zeros in the table are
; unused place holders.
;
DAFBWombatTimingAdjTbl
Dc.w 32,16,8,4,2,1 ; PixClk/1
DAFBWombatTimingEntry
Dc.w 16, 8,4,2,1,0 ; PixClk/2
Dc.w 8, 4,2,1,0,0 ; PixClk/4
DAFBWombatTSize Equ DAFBWombatTimingEntry-DAFBWombatTimingAdjTbl
DAFBAntelopeTbl Dc.w 5,2,1 ; PixClk/1,PixClk/2,PixClk/4 TimingAdj,HAL,HFP adjustments.
**********************************************************************
*
* DAFBVidOpen allocates private storage for the device in the AuxDCE and locks
* it down for perpetuity. Also, install the interrupt handler and enable
* the interrupts.
*
* Entry: A0 = param block pointer
* A1 = AuxDCE pointer
*
* Locals: A3 = pointer to private storage
*
* A4/D2/D3 used as scratch
*
**********************************************************************
WITH VDPageInfo,SlotIntQElement,DAFBVidPrivates
DAFBVidOpen
;
; Allocate private storage (since block is CLEAR, GFlags are zeroed) and get
; a pointer to it in A3
;
MOVEQ #DAFBVidPrivSize,D0 ; get size of parameters
_ResrvMem ,SYS ; make room as low as possible
MOVEQ #DAFBVidPrivSize,D0 ; get size of parameters
_NewHandle ,SYS,CLEAR ; get some memory for private storage
BNE @OpError1 ; => return an error in open
MOVE.L A0,dCtlStorage(A1) ; save returned handle in AuxDCE
_HLock ; and lock it down forever
MOVE.L (A0),D0 ; get a pointer to it
_StripAddress ; clean it up
MOVE.L D0,A3 ; get pointer to privates in A3
;
; Remember the VDAC and DAFB base addresses since they're hard to look up.
;
WITH ProductInfo,DecoderInfo,VideoInfo
MOVE.L UnivInfoPtr,A0 ; get a pointer to universal data
ADD.L DecoderInfoPtr(A0),A0 ; point to the base address table
MOVE.L VDACAddr(A0),saveVDACBase(A3) ; save pointer
MOVE.L DAFBAddr(A0),saveDAFBBase(A3) ; save DAFB's base too
;
; Remember the frame buffer base as well. The Open call doesn't set the video mode
; or page, but SetMode will based on this value (a little later).
;
MOVE.L UnivInfoPtr,A0
ADDA.L VideoInfoPtr(A0),A0 ; point to the VideoInfo record
MOVE.L VRAMLogAddr32(A0),saveBaseAddr(A3) ; save base address too
ENDWITH
;
; Get and install the interrupt handler. Call the EnableVGuts utility code to do
; this. This utility also starts the interrupts going. If there is an error
; condition, EnableVGuts returns with Z-bit cleared.
MOVEQ #sqHDSize,D0 ; allocate a slot queue element
_NewPtr ,SYS,CLEAR ; get it from system heap cleared
BNE @OpError2 ; if not allocated, return bad
MOVE.L A0,saveSQElPtr(A3) ; save the SQ element pointer.
Moveq #true32b,D0 ; Say we want to be in 32-bit mode.
_SwapMMUMode ; Do swap.
Move.l saveDAFBBase(A3),A2 ; Get DAFB’s base address into A2.
DAFBUnIdle ; Make sure DAFB is not idle.
_SwapMMUMode ; Swap back.
BSR DAFBEnableVGuts ; Enable VBL interrupts.
BNE @OpError2 ;
;
; Load the default gamma table from the slot resource list.
;
WITH spBlock
SUBA #spBlockSize,SP ; make a slot parameter block
MOVE.L SP,A0 ; get pointer to block in A0
MOVE.B dCtlSlot(A1),spSlot(A0) ; copy the slot number
MOVE.B dCtlSlotId(A1),spID(A0) ; copy the spID of the video sRsrc
CLR.B spExtDev(A0) ;
_sRsrcInfo ; get the spsPointer
BNE @OpError3 ; if failed, then quit.
MOVE.B #sGammaDir,spID(A0) ; look for the gamma directory
_sFindStruct ; get that baby
BNE.S @DoLinear ; if failed, then do linear
MOVE.B #128,spID(A0) ; get the default gamma table, (always 128)
_sGetBlock ; we can use this since we want it on the sys heap
BNE.S @DoLinear ; if failed, then do linear
; Skip over gamma header.
MOVE.L spResult(A0),A0 ; point to head of the block
MOVE.L A0,saveGamDispPtr(A3) ; save the ptr to the gamma block
ADDA #2,A0 ; skip resID
@Name TST.B (A0)+ ; skip over gamma name
BNE.S @Name ;
MOVE.L A0,D0 ; get in d-reg
ADDQ #1,D0 ; word align pointer
BCLR #0,D0 ; round it off
MOVE.L D0,saveGammaPtr(A3) ; put it in private storage
Bra.s @VidParams ; Jump around linear code.
;
; Build a linear default gamma table if necessary.
;
@DoLinear
Moveq #gFormulaData,D0 ; Get gamma table header size.
Add #256,D0 ; Add in one-byte per entry.
_NewPtr ,SYS,CLEAR ; Clear it.
Bne @OpError3 ; If failed, quit.
Move.l A0,saveGamDispPtr(A3) ; Save head of gamma table for disposal.
Move.l A0,saveGammaPtr(A3) ; Head and top are same here.
Move.w #drHwDAFB,gType(A0) ; Set up gType.
Move.w #1,gChanCnt(A0) ; Set up gChanCnt.
Move.w #256,gDataCnt(A0) ; Set up gDataCnt.
Move.w #8,gDataWidth(A0) ; Set up gDataWidth.
Adda #gFormulaData+256,A0 ; Point to end of data table.
Move.w #255,D0 ; Set up loop counter.
@Loop Move.b D0,-(A0) ; Write out value.
Dbra D0,@Loop ; Loop.
;
; Get a pointer to the video hardware setup parameter block. Use this functional spID's spsPointer
; found above in the gamma section.
;
With DAFBVidParams
@VidParams
Move.l Sp,A0 ; Point to the spBlock on the stack.
Clr.w spID(A0) ; Start looking at spID 0, no external devices.
Clr.b spTBMask(A0) ; Only look for the board sRsrc.
Move.w #catBoard,spCategory(A0) ; Look for: catBoard,
Move.w #typBoard,spCType(A0) ; typBoard,
Clr.w spDrvrSW(A0) ; 0,
Clr.w spDrvrHW(A0) ; 0.
Clr.l spParamData(A0) ; (The board sRsrc must be enabled.)
Bset #foneslot,spParamData+3(A0) ; Limit search to slot $0.
_GetTypeSRsrc ; Get the spsPointer.
Bne @OpError4 ; If failed, quit.
MOVE.B #sVidParmDir,spID(A0) ; look for the video parameters dir
_sFindStruct ; Try to load it.
Bne @OpError4 ; If failed, quit.
Move.l saveDAFBBase(A3),A4 ; Get DAFBBase into A4.
Move.b dCtlSlotId(A1),D1 ; Get the appropriate sRsrcID into D1.
Moveq #true32b,D0 ; Set up to flip into 32-bit addressing mode.
_SwapMMUMode ; Do flip.
Move.b D0,-(Sp) ; Save previous addressing mode.
Move.l DAFBFlags(A4),D0 ; Get the DAFBFlags into D0.
Btst #RadiusTPDBit,D0 ; If we don’t have a RadiusTPD,
Beq.s @GetParams ; then just go on.
Btst #RadiusDevType,D0 ; If we have a Radius MonoTPD,
Beq.s @SetMonoTPD ; then say so.
Move.b #pSRsrc_Vid_DAFB_2PRdRGB,D1 ; Otherwise, say we’ve got…
Bra.s @GetParams ; …a ColorTPD.
@SetMonoTPD Move.b #pSRsrc_Vid_DAFB_2PRdMono,D1 ;
@GetParams Move.b (Sp)+,D0 ; Set up to restore previous addressing mode.
_SwapMMUMode ; Do flip.
MOVE.B D1,spID(A0) ; look in the directory for this config's parameters
_sGetBlock ; Try to load it.
Bne @OpError4 ; If failed, quit.
MOVE.L spResult(A0),saveVidPtr(A3) ; get pointer to it
Move.b dCtlSlotId(A1),spID(A0) ; Set up to find the functional sRsrc.
_sRsrcInfo ; Get the spsPointer.
Bne @OpError5 ; If failed, quit.
Move.b #MinorBaseOS,spID(A0) ; Set up to get the video base offset value.
_sReadLong ; Get it.
Bne @OpError5 ; If failed, quit.
Move.l spResult(A0),D0 ; Load the vRAM base offset into D0.
Add.l D0,saveBaseAddr(A3) ; Add it to the vRAM base address.
Endwith
;
; At PrimaryInit time, we used the sense lines to determine the type of attached display. For extended
; sense displays, we just mapped them to the end of indexed-sense displays. Since the gamma-correction
; code uses the monitor ID to determine if the passed-in table is applicable, we need to know the “real”
; monitor ID. At PrimaryInit time, we store the real monitor ID in slot pRAM. So, we extract that
; information out here. Also, it should be noted that it would actually be inappropriate for us
; to re-read the sense-lines now, in that someone could potentially change/unplug the attached
; display between PrimaryInit and VidOpen, and that would cause us all sorts of havoc.
;
With SP_Params
Move.l Sp,A0 ; Point to spBlock on the stack.
Move.b dCtlSlot(A1),spSlot(A0) ; Put slot into spBlock.
Suba #sizeSPRamRec,Sp ; Allocate an SPRam block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_SReadPRAMRec ; Read Slot PRam.
Bne @OpError6 ; If failed quit.
Moveq #0,D3 ; Clear D3.w.
Moveq #0,D2 ; Clear D2.w.
Move.b SP_Depth(Sp),D3 ; Get the mode (it’s byte sized).
Move.b SP_MonID(Sp),D2 ; Get the monID (it’s byte sized).
Move.b SP_Flags(Sp),D1 ; Get the flags.
Adda #sizeSPRamRec+spBlockSize,Sp ; Clean up the stack.
EndWith
;
; Do a little bookkeeping…
;
Move.w D3,saveMode(A3) ; Save the mode for later.
Move.w D2,saveMonID(A3) ; Save the monID for later.
Move.b dCtlSlotId(A1),saveSlotId(A3) ; Also save the spID.
Btst #spSyncOnGreen,D1 ; If we’re not supposed to put sync on green,
Beq.s @CheckAC842A ; then just go on.
Bset #syncOnGreen,GFlags(A3) ; Otherwise, set the flag.
@CheckAC842A Btst #spHas16bppACDC,D1 ; If we don’t have an AC842A,
Beq.s @CheckPageMode ; then go on.
Move.b #1,has16bppACDC(A3) ; Otherwise, say we do.
Btst #spHas16bppSRsrc,D1 ; If we don’t have a 16bpp-capable sRsrc,
Beq.s @CheckPageMode ; then just go on.
Bset #has16bppSRsrc,GFlags(A3) ; Otherwise, set the flag.
@CheckPageMode Move.l saveDAFBBase(A3),A4 ; Get DAFBBase into A4 for below.
Btst #spPageMode,D1 ; If PageMode is supposed to be enabled,
Bne.s @EnablePageMode ; then say so.
Move.b #0,pageModeSet(A3) ; Otherwise, say page mode is disaabled.
Bra.s @PageModeDisabled ;
@EnablePageMode Move.b #1,pageModeSet(A3) ; Say page mode is enabled.
@PageModeDisabled
Move.b #true32b,D0 ; Set up to swap into 32-bit addressing mode.
_SwapMMuMode ; Do swap, and
Move.b D0,-(Sp) ; save the previous mode.
Move.l DAFB_Config(A4),D0 ; Read the DAFBConfig register.
Bfextu D0{dafbWrdIntBit:1},D0 ; If word-interleave is on
Bne.s @DisablePageMode ; then ALWAYS disable page mode.
Tst.b pageModeSet(A3) ; If we’re not supposed to enable page mode,
Beq.s @DisablePageMode ; then disable it.
Moveq #1,D0 ; Otherwise, set up to enable page mode,
Bra.s @HitPageMode ; and do it.
@DisablePageMode
Moveq #0,D0 ; Set up to disable page mode, and
@HitPageMode Move.l D0,DAFB_PgMdEn(A4) ; and do it.
Move.l DAFBFlags(A4),D0 ; Get the DAFBFlags.
Btst #isWombat,D0 ; If we’re not on a Wombat,
Beq.s @ChkCLUTType ; then just go on.
Move.b #1,wombatFlag(A3) ; Otherwise, say we’re on a Wombat.
@ChkCLUTType Btst #wLin16Bpp,D0 ; If we don’t have an Antelope,
Beq.s @ChkVidEnb ; then just go on.
Move.b #1,hasLin16BppCLUT(A3) ; Otherwise, say we’ve got one.
@ChkVidEnb Move.w D0,D1 ; Copy the DAFBFlags.
Move.b (Sp)+,D0 ; Set up to switch back into previous mode,
_SwapMMUMode ; and do it.
Btst #videoEnabled,D1 ; If video is still enabled,
Bne.s @CalcScrnBase ; then just go on.
Move.w saveMode(A3),D1 ; Otherwise, get the mode into D1.
Sub.w #firstVidMode,D1 ; Make it an index.
Bsr DAFBSetDepth ; Set the depth.
Bsr DAFBCalcScreenBaseAddr ; Calculate the new ST-corrected screen baseAddr.
Bsr DAFBGrayScreen ; Paint the screen gray.
Bra.s @SkipIt ; Go on.
@CalcScrnBase
Move.w #firstVidMode,saveMode(A3) ; From PrimaryInit, we’re still at 1bpp.
Bsr DAFBCalcScreenBaseAddr ; Save the ST-corrected screen baseAddr.
@SkipIt
;
; Set GFlags to reflect monochrome-only displays.
;
Cmp.w #indexedSenseFP,saveMonID(A3) ; If this is a Mono-Only Full Page,
Beq.s @SetMonoFlags ; then say so.
Cmp.w #indexedSense2P,saveMonID(A3) ; If this is a Mono-Only Two-Page,
Beq.s @SetMonoFlags ; then say so.
Bra.s @EndMonoCheck ; Otherwise, skip.
@SetMonoFlags Bset #IsMono,GFlags(A3) ; Turn on the IsMono and
Bset #GrayFlag,GFlags(A3) ; GrayFlag flags.
@EndMonoCheck
;
; Determine the clock speed and save it. The act of reading VIAs can cause pending interrupts
; to be lost, so we want only want to do this once.
;
Tst.b wombatFlag(A3) ; If we’re on a Wombat, then
Bne.s @WombatSpeed ; skip the Spike/Eclipse/Zydeco stuff.
Move.l VIA2,A0 ; Point to VIA2.
Btst #v2Speed,vBufB(A0) ; Test the speed register (25 vs. 33 MHz).
Bra.s @EndSpeedChk
@WombatSpeed Move.l VIA,A0 ; Point to VIA1.
Btst #vCpuId2,vBufA(A0) ; Test CPUID reg 2 (20/25 vs. 33/40 MHz).
@EndSpeedChk Bne.s @AllDone ; Leave flag clear if we’re not going slow.
Bset #IsSlow,GFlags(A3) ; Otherwise, set it.
;
; All done!
;
@AllDone MOVEQ #noErr,D0 ; no error
@EndOpen RTS ; return
@OpError6 Adda #sizeSPRamRec,Sp ; Release the SPRam block.
@OpError5 Move.l saveVidPtr(A3),A0 ; Set up to dispose of vidParams table.
_DisposPtr ; Dispose it.
@OpError4 Move.l saveGamDispPtr(A3),A0 ; Set up to dispose of gamma table.
_DisposPtr ; Dispose it.
@OpError3 ADDA #spBlockSize,SP ; release the spBlock
@OpError2 MOVE.L dCtlStorage(A1),A0 ; get the private storage back
_DisposHandle ; release the driver private storage
@OpError1 MOVE.L #OpenErr,D0 ; say can't open driver
BRA.S @EndOpen
ENDWITH
**********************************************************************
*
* Video Driver Control Call Handler. There are 10 standard calls:
*
* ($00) Reset (VAR mode, page: INTEGER; VAR BaseAddr: Ptr);
* ($01) KillIO
* ($02) SetMode(mode, page: INTEGER; VAR BaseAddr: Ptr);
* ($03) SetEntries (Table: Ptr; Start,Count : integer );
* ($04) SetGamma (Table : Ptr );
* ($05) GrayPage (page);
* ($06) SetGray (csMode = 0 for color, 1 for gray)
* ($07) SetInterrupt (csMode = 0 for enable, non-zero for disable);
* ($08) DirectSetEntries (Table: Ptr; Start,Count : integer );
* ($09) SetDefaultMode (csMode = mode to set);
*
* The following calls are DAFB-specific:
*
* ($80) SetSyncOnGreen(csMode = 0 for enable, non-zero for disable);
* ($81) Set16bpp(csMode = 0 for enable, non-zero for disable);
* ($82) SetPageMode(csMode = 0 for enable, non-zero for disable);
* ($83) SetAltSense(csMode = byte 0 is sense code, byte 1 is type);
*
* Entry: A0 = param block pointer
* A1 = AuxDCE pointer
* Uses: A2 = cs parameters (ie. A2 <- csParam(A0)) (must be preserved)
* A3 = ptr to our privates/scrarch (doesn’t need to be preserved)
* A4 = scratch (must be preserved)
* D0-D3 = scratch (don't need to be preserved)
*
* Exit: D0 = error code
*
**********************************************************************
;
; Decode the call…
;
DAFBVidCtl
MOVEM.L A0/A1,-(SP) ; Save exit registers.
MOVE.L csParam(A0),A2 ; A2 <- Ptr to control parameters
MOVE.L dCtlStorage(A1),A3 ; A3 <- Ptr to private storage
MOVE.L (A3),D0 ;
_StripAddress ;
MOVE.L D0,A3 ;
MOVE.W csCode(A0),D0 ; get routine selector
Cmp.w #cscSyncOnGreen,D0 ; If we got the SetSyncOnGreen call,
Beq DAFBSetSyncOnGreen ; hop to it.
Cmp.w #csc16bpp,D0 ; If we got the 16bpp call,
Beq DAFBSet16bpp ; hop to it.
Cmp.w #cscPageMode,D0 ; If we got the PageMode call,
Beq DAFBSetPageMode ; hop to it.
Cmp.w #cscAltSense,D0 ; If we got the alternate senseID call,
Beq DAFBSetAltSense ; hop to it.
CMP.W #9,D0 ; IF csCode NOT IN [0..9] THEN
BHI.S DAFBCtlBad ; Error, csCode out of bounds.
MOVE.W DAFBCtlJumpTbl(PC,D0.W*2),D0 ; Get the relative offset to the routine.
JMP DAFBCtlJumpTbl(PC,D0.W) ; GOTO the proper routine.
DAFBCtlJumpTbl
DC.W DAFBVidReset-DAFBCtlJumpTbl ; $00 => VidReset
DC.W DAFBCtlGood-DAFBCtlJumpTbl ; $01 => CtlGood (no async routines here)
DC.W DAFBSetVidMode-DAFBCtlJumpTbl ; $02 => SetVidMode
DC.W DAFBSetEntries-DAFBCtlJumpTbl ; $03 => SetEntries
DC.W DAFBSetGamma-DAFBCtlJumpTbl ; $04 => SetGamma
DC.W DAFBGrayPage-DAFBCtlJumpTbl ; $05 => GrayPage
DC.W DAFBSetGray-DAFBCtlJumpTbl ; $06 => SetGray
DC.W DAFBSetInterrupt-DAFBCtlJumpTbl ; $07 => SetInterrupt
DC.W DAFBDirectSetEntries-DAFBCtlJumpTbl ; $08 => DirectSetEntries
DC.W DAFBSetDefaultMode-DAFBCtlJumpTbl ; $09 => SetDefaultMode
DAFBCtlBad MOVEQ #controlErr,D0 ; else say we don't do this one
BRA.S DAFBCtlDone ; and return
DAFBCtlGood MOVEQ #noErr,D0 ; return no error
DAFBCtlDone MOVEM.L (SP)+,A0/A1 ; Restore Exit registers.
BRA DAFBExitDrvr
DAFBVidReset
;---------------------------------------------------------------------
;
; Reset the card to its default
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVE #FirstVidMode,csMode(A2) ; return default mode
MOVE #FirstVidMode,saveMode(A3) ; remember FirstVidMode as the requested mode
MOVEQ #0,D1 ; get default depth in D1 (#firstVidMode-#firstVidMode)
MOVEQ #0,D0 ; get page in D0
MOVE D0,csPage(A2) ; return the page
BSR DAFBSetDepth ; set the depth from D1
Bsr DAFBCalcScreenBaseAddr ; Calculate the new ST-corrected screen baseAddr,
Move.l saveScreenBase(A3),csBaseAddr(A2) ; and return it.
BSR DAFBGrayScreen ; paint the screen gray
BRA.S DAFBCtlGood ; => no error
ENDWITH
DAFBSetVidMode
;---------------------------------------------------------------------
;
; Set the card to the specified mode. Only page zero is possible,
; so we need to check that the request was OK.
;
; If the card is already set to the specified mode, then do nothing.
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVE.W csMode(A2),D1 ; D1 = mode
BSR DAFBChkMode ; check mode and convert
BNE.S DAFBCtlBad ; => not a valid mode
TST.W csPage(A2) ; only page zero is valid
BNE.S DAFBCtlBad ; => not a valid page
; Only set if mode has changed.
MOVE.W csMode(A2),D2 ; get the mode spID (D1 has the zero-based mode)
CMP saveMode(A3),D2 ; has the mode changed?
BEQ @ModeOK1 ; if not, then skip graying
; Remember the newly requested mode.
MOVE.W D2,saveMode(A3) ; remember requested mode
; Set the entire color table to gray before switching to avoid screen anomalies.
Movem.l A4-A6/D5-D6,-(Sp) ; Save work registers.
Move.l saveGammaPtr(A3),A0 ; Get pointer to gamma data structure.
Lea gFormulaData(A0),A4 ; Point to first gamma table.
Adda.w gFormulaSize(A0),A4 ;
Move.l A4,A5 ; Point to green data (assuming gChanCnt = 1).
Move.l A4,A6 ; Point to red data (assuming gChanCnt = 1).
Cmp.w #1,gChanCnt(A0) ; If there’s only one table,
Beq.s @OnlyOneTable ; then we’re set.
Move.w gDataWidth(A0),D2 ; Get width of each entry (in bits).
Move.w gDataCnt(A0),D0 ; Get # of entries in table.
Addq #7,D2 ; Round to nearest byte.
Lsr.w #3,D2 ; Get bytes per entry.
Mulu D2,D0 ; Get size of table in bytes.
Adda.w D0,A5 ; Calc base of green (red base + D0).
Adda.w D0,A6 ; Calc base…
Adda.w D0,A6 ; …of blue (red base + D0 + D0).
@OnlyOneTable
Move.w gDataCnt(A0),D3 ; Save number of gamma entries.
MOVEQ #true32b,D0 ; flip to 32-bit addressing mode
_SwapMMUMode ;
MOVE.B D0,-(SP) ; save current addressing mode
Move.w GFlags(A3),D5 ; Get the GFlags into a convient register.
Moveq #0,D6 ; Setup the alternate GFlags register.
Btst #IsMono,D5 ; If this is not a mono-only display,
Beq.s @GetVDAC ; then just go on.
Move.l saveDAFBBase(A3),A0 ; Otherwise, get the DAFBBase into A0.
Move.l DAFBFlags(A0),D0 ; Get the DAFBFlags into D0.
Btst #RadiusTPDBit,D0 ; If this is not a RadiusTPD,
Beq.s @GetVDAC ; then just go on.
Btst #RadiusDevType,D0 ; It this is not a MonoTPD,
Bne.s @GetVDAC ; then just go on.
Bset #IsMono,D6 ; Otherwise, remember to swap green & blue.
@GetVDAC MOVE.L saveVDACBase(A3),A0 ; get the VDAC base addr
Clr.l ACDC_AddrReg(A0) ; Start at position zero in the CLUT.
ADDA #(ACDC_DataReg+3),A0 ; point to data register
MOVE.W SR,-(SP) ; preserve the status register
BSR DAFBWaitVSync ; wait for next blanking period (preserves A0)
; Write out gamma-corrected gray CLUT…
;
Move.w D3,D0 ; Init loop counter.
Subq #1,D0 ; Zero base it.
Lsr.w #1,D3 ; Get midpoint of table(s).
@Repeat Btst #IsMono,D6 ; If this is not a Radius MonoTPD,
Beq.s @NotRadius ; then go on.
Clr.b (A0) ; Write red,
Move.b (A4,D3),(A0) ; green,
Clr.b (A0) ; blue.
Dbra D0,@Repeat ; Loop until done.
Bra.s @EndLoop ; Go on.
@NotRadius Btst #IsMono,D5 ; If this is not a mono-only display
Beq.s @DoRGB ; then just do the standard RGB stuff.
Clr.b (A0) ; Otherwise, just write black out
Clr.b (A0) ; to the red & green channels.
Bra.s @DoMono ;
@DoRGB Move.b (A4,D3),(A0) ; Write red,
Move.b (A5,D3),(A0) ; green,
@DoMono Move.b (A6,D3),(A0) ; blue.
Dbra D0,@Repeat
@EndLoop MOVE (SP)+,SR ; restore the status reg
MOVE.B (SP)+,D0 ; get the MMU mode back
_SwapMMUMode ;
Movem.l (Sp)+,A4-A6/D5-D6 ; Restore work registers.
BSR DAFBSetDepth ; set the depth from D1
; Finish up the bookkeeping.
MOVE.W csMode(A2),saveMode(A3) ; save mode number
CMP.W #FifthVidMode,saveMode(A3) ; was it a direct mode?
BLT.S @BitOff ; no, so turn flag off
BSET #IsDirect,GFlags(A3) ; turn on bit
BRA.S @ModeOK1 ;
@BitOff
BCLR #IsDirect,GFlags(A3) ; turn off bit
@ModeOK1
Bsr DAFBCalcScreenBaseAddr ; Calculate the new ST-corrected screen baseAddr,
Move.l saveScreenBase(A3),csBaseAddr(A2) ; and return it.
BRA DAFBCtlGood ; return no error
ENDWITH
DAFBSetEntries
;---------------------------------------------------------------------
;
; Input :
; csParam -> datablock
; datablock = csTable -> table of colorSpecs (not colortable)
; csStart -> where to start setting, or -1
; csCount -> # of entries to change
;
; This call has two modes. In SEQUENCE mode, csCount entries are changed
; in the CLUT, starting at csStart. In INDEX mode, csCount entries are
; installed into the CLUT at the positions specified by their .value fields.
; This mode is selected by passing csStart = -1. In both cases, entries are
; range-checked to the dynamic range of the video mode (bits/pixel).
;
;---------------------------------------------------------------------
;
; Set the CLUT
; A0 = Ptr to the table
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private data, later to CLUT constants table
; A4 = Ptr to gamma red table
; A5 = Ptr to gamma green table
; A6 = Ptr to gamma blue table
;
; D0-D3 = Scratch
; D4 = Size of stack color table buffer
; D5 = GFlags word
; D6 = Index range [0..n]
; D7 = gamma channel size in bits
;
;---------------------------------------------------------------------
; Initialize loop.
WITH DAFBVidPrivates
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
BNE DAFBCtlBad ; error if so
DAFBSEGuts
TST.L csTable(A2) ; Check for a nil pointer
BEQ DAFBCtlBad ;
MOVEM.L A1/A4-A6/D4-D7,-(SP) ; save registers for gamma
MOVE.W GFlags(A3),D5 ; get GFlags word in D5
CMP.W #indexEntries,csStart(A2) ; was it indexed mode?
BEQ.S @SkipSeq ; if so, then leave bit off (it's never turned on in GFlags)
BSET #UseSeq,D5 ; if not, turn on sequential mode bit
@SkipSeq
MOVE.L saveGammaPtr(A3),A0 ; get pointer to gamma data structure
MOVE.W gFormulaSize(A0),D0 ; get the size of formula data
LEA gFormulaData(A0,D0),A4 ; red correction table starts here
MOVE.L A4,A5 ; get default pointer to green data
MOVE.L A4,A6 ; get default pointer to blue data
MOVE gDataWidth(A0),D7 ; get width of each entry in bits
CMP #1,gChanCnt(A0) ; if only only one table, we're set
BEQ.S @OneTbl ; => just one table
MOVE gDataCnt(A0),D0 ; get # entries in table
MOVE D7,D1 ; copy it to goof around
ADDQ #7,D1 ; round to nearest byte
LSR #3,D1 ; get bytes per entry
MULU D1,D0 ; get size of table in bytes
ADDA D0,A5 ; calc base of green
ADDA D0,A6 ; calc base of blue
ADDA D0,A6 ; calc base of blue
@OneTbl
;
; Get the maximum number of entries, zero based from a convenient table.
;
MOVE.W saveMode(A3),D1 ; get the current video mode
SUB.W #FirstVidMode,D1 ; convert to index
Btst #has16bppSRsrc,D5 ; If we have a 16bpp-capable sRsrc,
Bne.s @GetXTable ; then use the extended table.
Bra.s @NormTable ; Otherwise, just use the normal table.
@GetXTable Lea DAFBXClutTbl,A0 ; Point to extended table of counts.
Bra.s @ChkRange
@NormTable LEA DAFBClutTbl,A0 ; point to little table of counts
@ChkRange MOVEQ #0,D6 ; clear all of D6
MOVE.B (A0,D1),D6 ; get entry from table for this mode
;
; Allocate a temporary color table on the stack. We'll pre-process all the entries that will
; change here so we can hit the hardware as quickly as possible.
;
MOVE.W csCount(A2),D4 ; get the number of entries to change
CMP.W D6,D4 ; is it in the allowable range
BHI DAFBSEBadExit ; if out of range, then exit w/bad result
Move.w csStart(A2),D0 ; Get the start number to range check.
Addq.w #1,D0 ; If csStart < -1, then it’s out of
Bmi DAFBSEBadExit ; range.
;
; In order to support Vesuvio & the RGB Portrait’s 16bpp modes, we ALWAYS use indexed mode
; for SetEntries, since the real entries must be translated from a 5-bit value into an
; 8-bit index. Note: The UseTrans & UseSeq are actually the same bit so that the
; indexed write routine works correctly.
;
MOVE.L csTable(A2),D0 ; Some (bad) people pass in an offset
_StripAddress ; CTabHandle’s MasterPointer here,
Move.l D0,A1 ; so we clean them up. Ugh!
Move.w D4,D1 ; Make a copy of the number of entries, and
Addq #1,D4 ; make it counting for now.
Moveq #0,D6 ; Assume that we aren’t doing 16bpp translations.
; (i.e., #UseTrans in D6 is clear).
Btst #has16bppSRsrc,D5 ; If we have a 16bpp-capable sRsrc,
Bne.s @Chk16bpp ; then check for 16bpp.
Bra.s @IndexTest ; Otherwise, just do the normal stuff.
@Chk16bpp Move.w saveMode(A3),D0 ; Get the current mode.
Cmp.w #FifthVidMode,D0 ; If we’re not doing 16bpp,
Bne.s @IndexTest ; then just go on.
Tst.b hasLin16bppCLUT(A3) ; If 16bpp is linear (i.e., we have an Antelope),
Bne.s @IndexTest ; then just on.
Bset #UseTrans,D6 ; Otherwise, remember that we’re translating.
Bclr #UseSeq,D5 ; If we’re already indexed,
Beq.s @isIndex ; then just go on.
Move.w D1,D2 ; Otherwise, sequence thru table from
Add.w csStart(A2),D2 ; csStart thru csCount entries.
; The following code is BAD, BAD, BAD! We should build our own table here so
; as to NOT mess up the user’s data. But all the previous Apple video drivers
; have done the same thing here, so we’ll continue the trend for now.
@TableLoop Move.w D2,value(A1,D1*colorSpecSize) ; Write the index into the table.
Subq #1,D2 ; Decrement index.
Dbra D1,@TableLoop ;
Bra.s @isIndex
@IndexTest ADDQ #1,D4 ; make number of entries a counting number
BTST #UseSeq,D5 ; are we in sequential mode?
BEQ.S @isIndex ; if equal, we're indexed
@isSeq MULU #3,D4 ; room for R,G,B in sequential mode
BRA.S @allocIt ; and continue
@isIndex ASL #2,D4 ; multiply times 4 for index,R,G,B
@allocIt SUB.W D4,SP ; allocate the buffer and save size in D4
Btst #IsMono,D5 ; If this is not a mono-only display,
Beq.s @EndRdChk ; then just go on.
Moveq #true32b,D0 ; Set up to flip into 32-bit addressing mode.
_SwapMMUMode ; Do flip.
Move.b D0,-(Sp) ; Save previous addressing mode.
Move.l saveDAFBBase(A3),A0 ; Get the DAFBBase into A0.
Move.l DAFBFlags(A0),D0 ; Get the DAFBFlags into D0.
Btst #RadiusTPDBit,D0 ; If this is not a Radius TPD,
Beq.s @SwapBack ; then just go on.
Btst #RadiusDevType,D0 ; If this not a MonoTPD,
Bne.s @SwapBack ; then just go on.
Bset #IsMono,D6 ; Otherwise, remember to swap green & blue channels.
@SwapBack Move.b (Sp)+,D0 ; Set up to restore previous addressing mode.
_SwapMMUMode ; Do restore.
@EndRdChk
;
; Construct the stack version of the color table. It looks like a color table, but each of the
; components is only eight bits (rather than 16). These will be expanded to longs when they
; are written to the hardware
;
MOVE.L SP,A0 ; copy the stack buffer pointer
MOVE.W csCount(A2),D3 ; get the number of entries again
;
; Write the index if in indexed mode. If in sequential mode, blow it off completely,
; since it won't be needed.
@SetupLoop
MOVE.W (A1)+,D1 ; get index
BTST #UseSeq,D5 ; is it sequence mode?
BNE.S @SLSeq ; yup, so go there
Btst #UseTrans,D6 ; If we’re not supposed to do the 5-to-8 translations,
Beq.s @WriteIndex ; then just write out the index to the stack.
Bsr DAFBTrans5to8 ; Otherwise, do the translation.
@WriteIndex MOVE.B D1,(A0)+ ; Write out index to stack table.
@SLSeq
MOVE.W (A1)+,D0 ; get red
MOVE.W (A1)+,D1 ; get green
MOVE.W (A1)+,D2 ; get blue
TST D5 ; test hi bit of the flags
BPL.S @NoGray ; if not set, don't luminence map
BTST #IsDirect,D5 ; test for direct mode as well
BNE.S @NoGray ; don't allow luminence mapping in direct mode
; We're luminence mapping here.
MULU #$4CCC,D0 ; multiply by red weight (0.30)
MULU #$970A,D1 ; multiply by green weight (0.59)
MULU #$1C29,D2 ; multiply by blue weight (0.11)
ADD.L D1,D0 ; sum red and green
ADD.L D2,D0 ; blue also
BFEXTU D0{0:D7},D0 ; get gChanWidth bits for gamma table lookup
MOVE.W D0,D1 ; copy into green register
MOVE.W D0,D2 ; copy into blue register
BRA.S @WriteSP ; go on and write it in the stack buffer
@NoGray
BFEXTU D0{16:D7},D0 ; get gChanWidth bits of red
BFEXTU D1{16:D7},D1 ; get gChanWidth bits of green
BFEXTU D2{16:D7},D2 ; get gChanWidth bits of blue
@WriteSP
Btst #IsMono,D6 ; If this is not a Radius MonoTPD,
Beq.s @NotRadius ; then just go on.
Clr.b (A0)+ ; Write black for red.
Move.b (A4,D0),(A0)+ ; Write gamma corrected “green”.
Clr.b (A0)+ ; Write black for blue.
Dbra D3,@SetupLoop ; Loop until done.
Bra.s @EndSetup ; Go on.
@NotRadius
BTST #IsMono,D5 ; if monochrome display, write black to red & green
BEQ.S @Brighter ; if not, then set all three channels
CLR.B (A0)+ ; write black for red
CLR.B (A0)+ ; and green
BRA.S @Looper ; write out normal blue
@Brighter
MOVE.B (A4,D0),(A0)+ ; write gamma corrected red
MOVE.B (A5,D1),(A0)+ ; write gamma corrected green
@Looper
MOVE.B (A6,D2),(A0)+ ; write gamma corrected blue
DBRA D3,@SetupLoop ; and loop for each entry
@EndSetup
;
; OK, the stack table is set up. Now let's load the hardware.
;
MOVE.W csCount(A2),D3 ; get the count again
MOVE.L saveVDACBase(A3),A4 ; get VDAC base
LEA ACDC_DataReg(A4),A4 ; point to VDAC data register
MOVEQ #true32b,D0 ; flip to 32-bit addressing mode
_SwapMMUMode ;
MOVE.B D0,-(SP) ; save current addressing mode
LEA 2(SP),A0 ; point to the stack buffer again
CLR.L D1 ; get the high 3 bytes of D1 clear
MOVE.W SR,-(SP) ; preserve the status register
BSR DAFBWaitVSync ; wait for next blanking period (preserves A0/D0)
BTST #UseSeq,D5 ; is it sequence mode?
BNE.S DAFBSeqWrite ; yup, sequence mode, so go
;
; Here's the loop that actually writes to the hardware when in indexed mode.
;
DAFBIndexWrite
MOVE.B (A0)+,D1 ; get the index
MOVE.L D1,ACDC_AddrReg-ACDC_DataReg(A4) ; write the index value to the CLUT address
MOVE.B (A0)+,3(A4) ; write red
MOVE.B (A0)+,3(A4) ; write green
MOVE.B (A0)+,3(A4) ; write blue
Tst.b hasLin16BppCLUT(A3) ; If we don’t have an Antelope part,
Beq.s @Next ; then just go on.
Tst.b ([VIA]) ; Otherwise, wait a µSec.
@Next DBRA D3,DAFBIndexWrite ; and loop
BRA.S DAFBSEDone ;
;
; Write the translated starting position for sequence mode.
;
DAFBSeqWrite
MOVE.W csStart(A2),D1 ; get sequence start address
MOVE.L D1,ACDC_AddrReg-ACDC_DataReg(A4) ; write the sequence start position
;
; Here's the loop that actually writes to the hardware when in sequence mode.
;
@SeqLoop
MOVE.B (A0)+,3(A4) ; write red
MOVE.B (A0)+,3(A4) ; write green
MOVE.B (A0)+,3(A4) ; write blue
Tst.b hasLin16BppCLUT(A3) ; If we don’t have an Antelope part,
Beq.s @Next ; then just go on.
Tst.b ([VIA]) ; Otherwise, wait a µSec.
@Next DBRA D3,@SeqLoop ; and loop
;
; Clean up and go home.
;
DAFBSEDone
MOVE (SP)+,SR ; restore status register
MOVE.B (SP)+,D0 ; get the previous mode back
_SwapMMUMode ;
ADD D4,SP ; release stack buffer
MOVEM.L (SP)+,A1/A4-A6/D4-D7 ; restore registers
BRA DAFBCtlGood ; return O-Tay!
DAFBSEBadExit
MOVEM.L (SP)+,A1/A4-A6/D4-D7 ; restore registers
BRA DAFBCtlBad ; return an error code
ENDWITH
DAFBSetGamma
;---------------------------------------------------------------------
;
; Set the gamma table. This call copies the supplied gTable so the
; caller does not have to put the source on the system heap. It
; tests if the gamma table is exactly a match to the currently
; connected monitor, or always allows it if the monitor number in
; the FormulaData is -1. If supplied gamma table ptr is NIL, then
; it loads a linear gamma table into the private table
;
; A0 = Ptr to private storage
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
; Get new gamma table and check that we know how to handle it.
MOVE.L csGTable(A2),D0 ; test for a NIL pointer
BEQ @LinearTab ; if so, then set up a linear gamma table
MOVE.L D0,A2 ; get pointer to new gamma table
TST.W gVersion(A2) ; version = 0?
BNE DAFBCtlBad ; => no, return error
Tst.w gType(A2) ; Test the hardwareID.
Beq.s @ChangeTable ; If 0, then accept a TFB-style gamma table.
CMP.W #drHwDAFB,gType(A2) ; type = DAFB?
BNE DAFBCtlBad ; => no, return error
TST.W gFormulaSize(A2) ; if gType=DAFB, then check for monID in gFormulaData
BEQ.S @ChangeTable ; if zero, then generic, so continue
MOVE.W gFormulaData(A2),D0 ; get the monitor ID this table was intended for
CMP.W saveMonID(A3),D0 ; is this the monitor?
BEQ.S @ChangeTable ; yes, so do it
ADDQ #1,D0 ; was it -1?
BNE DAFBCtlBad ; nope, so must be wrong monitor
; If new table is a different size, reallocate memory.
@ChangeTable
MOVE.L saveGammaPtr(A3),A0 ; get current gamma in A0
MOVE gFormulaSize(A2),D0 ; get size of formula in new
CMP gFormulaSize(A0),D0 ; same as current gamma table
BNE.S @GetNew ; =>no, resize pointer
MOVE gChanCnt(A2),D0 ; get number of tables in new
CMP gChanCnt(A0),D0 ; same as current gamma table?
BEQ.S @SizeOK ; => yes, data size ok
BGT.S @GetNew ; => new one is bigger, save old one
@NewSize Move.l saveGamDispPtr(A3),A0 ; if new one is smaller,
_DisposPtr ; dispose old one
CLR.L saveGamDispPtr(A3) ; flag it's been disposed
@GetNew Moveq #0,D0 ; (_NewPtr takes a long, so clear D0 for later.)
MOVE gDataCnt(A2),D0 ; get number of entries
MULU gChanCnt(A2),D0 ; multiply by number of tables
ADD gFormulaSize(A2),D0 ; add size of formula data
ADD #gFormulaData,D0 ; add gamma table header size
_NewPtr ,Sys ; and allocate a new pointer
BNE DAFBCtlBad ; => unable to allocate storage
MOVE.L saveGamDispPtr(A3),D0 ; get old gamma table
MOVE.L A0,saveGammaPtr(A3) ; save new gamma table
TST.L D0 ; was there an old one?
BEQ.S @SizeOK ; => no, already disposed
MOVE.L D0,A0 ; else get old table
_DisposPtr ; and dispose of old gamma table
MOVE.L saveGammaPtr(A3),A0 ; get new gamma table back
Move.l A0,saveGamDispPtr(A3) ; save it for disposal
; Copy the gamma table header.
@SizeOK MOVE gChanCnt(A2),D0 ; get number of tables
MOVE gFormulaSize(A2),D1 ; get size of formula data
MOVE gDataCnt(A2),D2 ; get number of entries
MOVE.L (A2)+,(A0)+ ; copy gamma header
MOVE.L (A2)+,(A0)+ ; which is
MOVE.L (A2)+,(A0)+ ; 12 bytes long
; Copy the data.
MULU D0,D2 ; multiply by number of tables
ADD D1,D2 ; add in size of formula data
SUBQ #1,D2 ; get count - 1
@NxtByte MOVE.B (A2)+,D0 ; get a byte
MOVE.B D0,(A0)+ ; move a byte
DBRA D2,@NxtByte ; => repeat for all bytes
Bra.s @GammaDone ; Check to see if it’s a direct device.
;
; Set up a linear gamma table. To prevent memory thrash, build this new one
; the same size as the existing one (one or three channel).
;
@LinearTab
MOVE.L saveGammaPtr(A3),A0 ; get current gamma in A0
MOVE.W gFormulaSize(A0),D0 ; get size of formula in new
MOVE.W gChanCnt(A0),D2 ; get the number of tables
SUBQ #1,D2 ; zero based, of course
Move.w gDataCnt(A0),D3 ; get the number of entries
Subq #1,D3 ; zero base
ADDA #gFormulaData,A0 ; point to tables
ADDA D0,A0 ; point past monID, if present
@ChanLoop MOVE.W D3,D0 ; loop count within each channel
@entryLoop MOVE.B D0,(A0) ; write this value out
Not.b (A0)+ ; invert to make table ramp properly
DBRA D0,@entryLoop ; for each entry in channel
DBRA D2,@ChanLoop ; and each channel
@GammaDone
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
BEQ.S @Out ; if not, then we're done
BSR DAFBDirectCLUTSet ; if so, then set up direct CLUT ramps
@Out
BRA DAFBCtlGood ; => return no error
ENDWITH
DAFBGrayPage
;---------------------------------------------------------------------
;
; Clear the specified page in the current mode to gray
;
; A0 = Ptr to private storage
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to driver privates
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVE saveMode(A3),D1 ; D1 = mode
BSR DAFBChkMode ; convert mode to depth in D1
BNE DAFBCtlBad ; => not a valid depth
MOVE csPage(A2),D0 ; D0 = page
BNE DAFBCtlBad ; => not a valid page
BSR DAFBGrayScreen ; paint the screen gray
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
BEQ.S @Out ; if not, then we're done
BSR DAFBDirectCLUTSet ; if so, then set up direct CLUT ramps
@Out
BRA DAFBCtlGood ; => return no error
ENDWITH
DAFBSetGray
;---------------------------------------------------------------------
;
; Set luminance mapping on (csMode = 1) or off (csMode = 0)
;
; When luminance mapping is on, RGB values passed to setEntries are mapped
; to grayscale equivalents before they are written to the CLUT.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
BTST #IsMono,GFlags(A3) ; is this a mono-only monitor?
BEQ.S @1 ; if not, then go ahead
MOVE.B #1,csMode(A2) ; always turn on for mono devices
@1 MOVEQ #0,D1 ; set up for BFEXTU to point to GrayFlag
BSR.S DAFBSetIntCom ; call common code
BRA DAFBCtlGood ; all done
;
; This shared routine setup up a flag in GFlags. It takes a pointer to
; private storage in A3, and the bit field start location in D1.
;
DAFBSetIntCom
MOVE.B csMode(A2),D0 ; get boolean
BFINS D0,GFlags(A3){D1:1} ; set flag bit
RTS ; and return
ENDWITH
DAFBSetInterrupt
;---------------------------------------------------------------------
;
; Enable (csMode = 0) or disable (csMode = 1) VBL interrupts
;
; As a future performance enhancement, interrupts on the card can be
; disabled or enabled from software. For instance, if the cursor is
; not on a screen, and there is nothing in the Slot Interrupt Queue
; for that device, interrupts may be disabled reducing interrupt
; overhead for the system.
;
; The slot interrupt queue element is always allocated by the Open call.
; This routine just inserts and removes it from the slot interrupt task queue.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
;---------------------------------------------------------------------
WITH VDPageInfo,SlotIntQElement,DAFBVidPrivates
MOVEQ #1,D1 ; set up for BFEXTU to point to IntDisFlag
BSR.S DAFBSetIntCom ; call common code
BNE.S @DAFBDisableThem ; if zero, then enable
; This code enables interrupts and installs the interrupt handler.
;
BSR.S DAFBEnableVGuts ; call common code
BNE DAFBCtlBad ; error, flag problem
BRA DAFBCtlGood ; and go home
; This code disables VBL interrupts, then removes the interrupt handler.
;
@DAFBDisableThem
BSR.S DAFBDisableVGuts ; jump to the disabling utility
BRA DAFBCtlGood ; all done
; The following two routines are common code shared between the Open/Close calls
; and the SetInterrupt control call.
;
DAFBDisableVGuts
MOVEQ #true32b,D0 ; flip to 32-bit addressing mode
_SwapMMUMode ;
MOVE.B D0,-(SP) ; save current addressing mode
MOVE.W SR,-(SP) ; preserve the status register
BSR DAFBWaitVSync ; to be safe, wait for the next VBL
MOVE.L saveDAFBBase(A3),A0 ; point to the DAFB base
CLR.L Swatch_IntMsk(A0) ; set slot 0 interrupt disabled
MOVE (SP)+,SR ; re-enable cursor interrupts
MOVE.B (SP)+,D0 ; get back addressing mode
_SwapMMUMode ;
CLR D0 ; setup slot # for _SIntRemove (slot zero!)
MOVE.L saveSQElPtr(A3),A0 ; get the SQ element pointer
_SIntRemove ; remove the interrupt handler
RTS
DAFBEnableVGuts ;
MOVE.L saveSQElPtr(A3),A0 ; get the queue element
LEA DAFBBeginIH,A2 ; save Pointer to interrupt handler
MOVE.W #SIQType,SQType(A0) ; setup queue ID
MOVE.L A2,SQAddr(A0) ; setup int routine address
MOVE.L A3,SQParm(A0) ; pass pointer to privates as the parameter
CLR.W D0 ; setup slot zero
_SIntInstall ; and do install
BNE.S @IntBad
MOVEQ #true32b,D0 ; flip to 32-bit addressing mode
_SwapMMUMode ;
MOVE.B D0,-(SP) ; save current addressing mode
MOVE.L saveDAFBBase(A3),A0 ; point to the DAFB base
; DAFB’s vertical timing generator is driven from a clock which is only half the frequency of the horizontal
; timing generator clock. Therefore, all the vertical timing registers are double-sized. However, the
; CrsrLine register is specified in whole lines. So, in order to get VBL happening at just the right
; time, we must divide VFP by 2.
;
Move.l Swatch_VFP(A0),D0 ; Get current VFP.
Andi.l #$FFF,D0 ; Strip off junk.
Lsr.l #1,D0 ; Divide by 2.
Addq #1,D0 ; Add 1.
Move.l D0,Swatch_CrsrLine(A0) ; Set interrupt to occur AFTER VFP, and
Move.l #dafbEnableVInts,Swatch_IntMsk(A0) ; turn on interrupt.
MOVE.B (SP)+,D0 ; get addressing mode back
_SwapMMUMode ;
CMP D0,D0 ; clear z-bit for good result
@IntBad RTS ; return home (if bad, z-bit is set above, so just leave) <8>
ENDWITH
DAFBDirectSetEntries
;---------------------------------------------------------------------
;
; Change the CLUT in a direct mode.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
; This routine allows knowledgeable programs modify the contents
; of the CLUT in direct modes (usually for limited color previewing).
; It takes the same parameter block as SetEntries, but SetEntries
; intentionally does not operate when the card is in a direct pixMode.
; This routine takes the same data and operates ONLY when in direct
; modes. It calls the same SetEntries guts as the regular routine.
;
;---------------------------------------------------------------------
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
BEQ DAFBCtlBad ; error if not
BRA DAFBSEGuts ; jump to SetEntries internals if it's OK
DAFBSetDefaultMode
;---------------------------------------------------------------------
;
; Write the card default mode into slot pRAM.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
; This routine is called by Monitors when somebody selects an alternate
; video mode family in the Options dialog.
;
;---------------------------------------------------------------------
WITH spBlock,DAFBVidPrivates,SP_Params
;
; Set up a slot parameter block on the stack.
;
SUBA #spBlockSize,SP ; make an slot parameter block on stack
MOVE.L SP,A0 ; get pointer to parm block now
MOVE.B dCtlSlot(A1),spSlot(A0) ; put slot in pBlock
CLR.B spExtDev(A0) ; external device = 0
;
; Read the slot pRAM to determine what the currently saved mode is. The first
; word is the board ID, followed by the default screen depth. Built-in video keeps the video
; sRsrc spID in VendorUse2.
;
SUBA #SizesPRAMRec,SP ; allocate block for pRAM record
MOVE.L SP,spResult(A0) ; point to it
_sReadPRAMRec ; read it
;
; Since PrimaryInit relies on the default mode being set correctly, we check to see that
; the mode to be set is actually valid. Monitors can only see valid sRsrcIDs, so
; it probably won’t cause a problem. But we should check it anyway for unsavory
; applications.
;
Move.b csMode(A2),spID(A0) ; Look for the passed in spID.
Clr.l spParamData(A0) ; Clear the fNext flag; we want THIS sRsrc.
Ori.b #(1<<fall)|\ ; Search for both enabled/disabled sRsrc’s
(1<<foneslot),spParamData+3(A0) ; Only search in our slot.
_GetsRsrc ; Do it.
Bne.s @BadExit ; If failed, quit.
Move.w spCategory(A0),D0 ; Get the category.
Cmp.w #catDisplay,D0 ; If it’s not catDisplay,
Bne.s @BadExit ; then quit.
Move.w spCType(A0),D0 ; Get the type.
Cmp.w #typVideo,D0 ; If it’s not typVideo,
Bne.s @BadExit ; then quit.
Move.w spDrvrSw(A0),D0 ; Get the software kind.
Cmp.w #drSwApple,D0 ; If it’s not drSwApple,
Bne.s @BadExit ; then quit.
Move.w spDrvrHw(A0),D0 ; Get the hardware ID.
Cmp.w #drHwDAFB,D0 ; If it’s not drHwDAFB,
Bne.s @BadExit ; then quit.
;
; It is very important that Monitors (or someone) invalidate and setup the screen resource
; if this call is exercised. Monitors needs to verify (and potentially re-write to pRAM)
; the proper screen depth in the new world.
;
Btst #IsDirect,GFlags(A3) ; If we’re not in a direct mode,
Beq.s @WriteIt ; just go on.
Move.b csMode(A2),D0 ; Get the mode we’re going to.
Cmp.b #sRsrc_Vid_DAFB_NTSCconvSTx,D0 ; If we’re not going to a convolved mode,
Blt.s @WriteIt ; just go on.
Cmp.b #sRsrc_Vid_DAFB_PALconvFF,D0 ;
Bgt.s @WriteIt ;
Move.b #FourthVidMode,SP_Depth(Sp) ; Otherwise, reset the depth to indexed.
@WriteIt MOVE.B csMode(A2),SP_LastConfig(SP) ; write the mode into pRAM buffer
MOVE.L SP,spsPointer(A0) ; set up parameter block
_sPutPRAMRec ; write the new record out
@GoodExit ADDA #SizesPRAMRec+spBlockSize,SP ; Deallocate buffer and
BRA DAFBCtlGood ; return good result.
@BadExit Adda #SizesPRAMRec+spBlockSize,SP ; Deallocate buffer and
Bra DAFBCtlBad ; return bad result.
ENDWITH
DAFBSetSyncOnGreen
;---------------------------------------------------------------------
;
; Enable (csMode = 0) or disable (csMode = non-zero) the sync on green.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
;---------------------------------------------------------------------
With spBlock,DAFBVidPrivates,SP_Params
;
; First, set up a slot parameter block on the stack.
;
Suba #spBlockSize,Sp ; Make a SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Move.b dCtlSlot(A1),spSlot(A0) ; Set it up.
Clr.b spExtDev(A0)
;
; Next, read the current pRam record so that we can write it back if necessary.
;
Suba #SizesPRAMRec,Sp ; Make an sPRAM block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_sReadPRamRec ; Get pRAM.
;
; See what we need to do…
;
Tst.b csMode(A2) ; If csMode = 0, then we are
Beq.s @EnableSyncOnGreen ; enabling sync on green.
Btst #syncOnGreen,GFlags(A3) ; If we’re already NOT putting sync on green,
Beq.s @Done ; then there’s nothing left to do.
Bclr #syncOnGreen,GFlags(A3) ; Otherwise, set up the GFlags field,
Bclr #spSyncOnGreen,SP_Flags(Sp) ; the pRam record, and
Moveq #0,D1 ; the toggle bit.
Bra.s @SyncCommon ;
@EnableSyncOnGreen
Btst #syncOnGreen,GFlags(A3) ; If we’re already putting sync on green,
Bne.s @Done ; then there’s nothing left to do.
Bset #syncOnGreen,GFlags(A3) ; Otherwise, set up the GFlags field
Bset #spSyncOnGreen,SP_Flags(Sp) ; the pRam record, and
Moveq #1,D1 ; the toggle bit.
@SyncCommon
Move.l Sp,spsPointer(A0) ; Set up to whack pRam.
_sPutPRAMRec ; Whack it.
Moveq #true32b,D0 ; Set up to flip into 32-bit addressing mode.
_SwapMMUMode ; Do flip.
Move.b D0,-(Sp) ; Save previous mode for later.
Move.w Sr,-(Sp) ; Save the current interrupt level.
Bsr DAFBWaitVSync ; Wait for VBL at level 2.
Move.w (Sp)+,Sr ; Restore interrupt level.
Tst.b wombatFlag(A3) ; If we’re not on a Wombat,
Beq.s @VIASOG ; then use the VIA SOG.
Move.l saveDAFBBase(A3),A0 ; Get DAFBBase into A0.
Move.l DAFB_ClkCfg(A0),D0 ; Get the current clock config value.
Bfins D1,D0{dafbSyncOnGreen:1} ; Toggle the sync-on-green bit appropriately,
Move.l D0,DAFB_ClkCfg(A0) ; apply it.
Bra.s @EndSOG ;
@VIASOG Move.l VIA2,A0 ; Point to VIA2.
Btst #0,D1 ; If we’re supposed to put sync on green,
Bne.s @SyncOnGreen ; then hop to it.
Bclr #v2SyncOnGreen,vBufA(A0) ; Otherwise, disable sync on green.
Bra.s @EndSOG
@SyncOnGreen
Bset #v2SyncOnGreen,vBufA(A0) ; Enable sync on green.
@EndSOG Move.b (Sp)+,D0 ; Set up to switch back to prev mode,
_SwapMMUMode ; and do it.
@Done Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
Bra DAFBCtlGood ; go home.
EndWith
DAFBSet16bpp
;---------------------------------------------------------------------
;
; Enable (csMode = 0) or disable (csMode = non-zero) the 16bpp mode
; if AC842A is around.
;
; Notes: To determine if 16bpp is possible, one should call
; Get16bpp. If it returns noErr, then 16bpp is
; possible, otherwise it isn’t.
;
; To determine if 16bpp is ALWAYS non-blocked, one should
; attempt to disable 16bpp mode. If noErr is returned,
; but Get16bpp returns the enabled state, then the
; 16bpp is always non-blocked.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage/ptr to DAFBBase addr (not restored)
;
;---------------------------------------------------------------------
With spBlock,DAFBVidPrivates,SP_Params
;
; First, set up a slot parameter block on the stack.
;
Suba #spBlockSize,Sp ; Make an SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Move.b dCtlSlot(A1),spSlot(A0) ; Set it up.
Clr.b spExtDev(A0)
;
; Next, read the current pRam so that we can tell whether an AC842A is actually
; intalled.
;
Suba #SizesPRAMRec,Sp ; Make an sPRAM block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_sReadPRamRec ; Get pRAM.
Btst #spHas16bppACDC,SP_Flags(Sp) ; If we don’t have an AC842A,
Beq.s @BadExit ; then just blow this off.
Moveq #true32b,D0 ; Set up to switch into 32-bit mode,
_SwapMMUMode ; do switch, and
Move.b D0,D1 ; save previous mode.
Btst #IsSlow,GFlags(A3) ; If CPU is running at 25MHz,
Bne.s @DoSet ; then do things as normal.
Move.l saveDAFBBase(A3),A3 ; Get DAFBBase into A3.
Move.l DAFB_Test(A3),D0 ; Get the DAFBTest register.
Andi.w #$0FFF,D0 ; Strip off the junk.
Moveq #9,D2 ; Get the amount to shift.
Lsr.w D2,D0 ; Shift in the version number.
Cmp.b #DAFB3Vers,D0 ; If we don’t have a DAFB 3,
Blt.s @DoSet ; then do things as normal.
Bra.s @GoodExit ; Otherwise, 16bpp is always set.
;
; See what we need to do…
;
@DoSet Tst.b csMode(A2) ; If csMode = 0, then we are
Beq.s @Allow16bpp ; allowing 16bpp.
Bclr #spAllow16bpp,SP_Flags(Sp) ; If we are already blocking 16bpp
Beq.s @GoodExit ; then no need to whack pRam again.
Bra.s @16BppCommon ; Otherwise, whack it.
@Allow16bpp Bset #spAllow16bpp,SP_Flags(Sp) ; If we are already allowing 16bpp,
Bne.s @GoodExit ; then no need to whack pRam again.
@16bppCommon Move.l Sp,spsPointer(A0) ; Set up to whack pRam.
_sPutPRAMRec ; Whack it.
@GoodExit Move.b D1,D0 ; Set up to switch back into previous mode,
_SwapMMUMode ; do switch, and
Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
Bra DAFBCtlGood ; go home.
@BadExit Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
Bra DAFBCtlBad ; return error.
EndWith
DAFBSetPageMode
;---------------------------------------------------------------------
;
; Enable (csMode = 0) or disable (csMode = non-zero) Page Mode.
;
; A1 = Ptr to AuxDCE/ptr to DAFBBase addr (not restored)
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
;---------------------------------------------------------------------
With spBlock,DAFBVidPrivates,SP_Params
;
; First, set up a slot parameter block on the stack.
;
Suba #spBlockSize,Sp ; Make an SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Move.b dCtlSlot(A1),spSlot(A0) ; Set it up.
Clr.b spExtDev(A0)
;
; Next, read the current pRam so that we can set it appropriately…
;
Suba #SizesPRAMRec,Sp ; Make an sPRAM block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_sReadPRamRec ; Get pRAM.
Moveq #true32b,D0 ; Set up to switch into 32-bit mode,
_SwapMMUMode ; do switch, and
Move.b D0,D1 ; save previous mode.
Move.l saveDAFBBase(A3),A1 ; Get DAFBBase into A1 for below.
;
; See what we need to do…
;
Tst.b csMode(A2) ; If csMode = 0, then we are
Beq.s @EnablePageMode ; enabling page mode.
Move.b #0,pageModeSet(A3) ; Say page mode is disaabled.
Bclr #spPageMode,SP_Flags(Sp) ; Flip pRam bit.
Bra.s @EndPageMode ;
@EnablePageMode Move.b #1,pageModeSet(A3) ; Say page mode is enabled.
Bset #spPageMode,SP_Flags(Sp) ; Flip pRam bit.
@EndPageMode Move.l Sp,spsPointer(A0) ; Set up to whack pRam.
_sPutPRAMRec ; Whack it.
Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack.
Move.l DAFB_Config(A1),D0 ; Read the DAFBConfig register.
Bfextu D0{dafbWrdIntBit:1},D0 ; If word-interleave is on
Bne.s @DisablePageMode ; then ALWAYS disable page mode.
Tst.b pageModeSet(A3) ; If we’re not supposed to enable page mode,
Beq.s @DisablePageMode ; then disable it.
Moveq #1,D0 ; Otherwise, set up to enable page mode,
Bra.s @HitPageMode ; and do it.
@DisablePageMode
Moveq #0,D0 ; Set up to disable page mode, and
@HitPageMode Move.l D0,DAFB_PgMdEn(A1) ; and do it.
@ExitPageMode Move.b D1,D0 ; Set up to switch back into previous mode,
_SwapMMUMode ; do switch, and
Bra DAFBCtlGood ; leave.
EndWith
DAFBSetAltSense
;---------------------------------------------------------------------
;
; SetAltSense sets up the alternate senseID pRam byte to contain
; a valid “index” code if a valid sense code is passed
; in csMode (byte 0 is the sense code, byte 1 is the type).
;
; A1 = Ptr to AuxDCE/Ptr to DAFBMonIDs table (not restored)
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
;---------------------------------------------------------------------
With spBlock,DAFBVidPrivates,SP_Params
;
; First, set up a slot parameter block on the stack.
;
Suba #spBlockSize,Sp ; Make an SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Move.b dCtlSlot(A1),spSlot(A0) ; Set it up.
Clr.b spExtDev(A0)
;
; Next, read the current pRam so that we can set it appropriately…
;
Suba #SizesPRAMRec,Sp ; Make an sPRAM block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_sReadPRamRec ; Get pRAM.
;
; See what we need to do…
;
Move.b csMode+1(A2),D0 ; Get the sense-code type.
Beq.s @NoConnect ; If indexed (0), use type 7.
Cmp.b #indexedSense2P,D0 ; If we got a type 3,
Beq.s @2PExtended ; then go there.
Cmp.b #indexedSenseHR,D0 ; If we got a type 6,
Beq.s @HRExtended ; then go there.
Cmp.b #indexedNoConnect,D0 ; If we got a type 7,
Beq.s @NoConnect ; then go there.
Bra @MonIDNotValid ; Otherwise, return an error.
@2PExtended
Move.b csMode(A2),D1 ; Get the sense code into D0.
Cmp.b #extended2PRdRGB,D1 ; If it’s the Radius ColorTPD,
Beq @WriteIt ; then write it out.
Cmp.b #extended2PRdMono,D1 ; If it’s the Radius MonoTPD,
Beq.s @WriteIt ; then write it out.
Bra @MonIDNotValid ; Otherwise, return an error.
@HRExtended
Cmp.b #extendedHR,csMode(A2) ; If it’s not the MultiSync code,
Bne @MonIDNotValid ; return an error.
Move.b #indexedSenseHR,D1 ; Otherwise, default to HR.
Bra.s @WriteIt
@NoConnect
Move.b csMode(A2),D1 ; Get the monID.
Cmp.b #indexedNoConnect,D1 ; If it’s one of the no-connect codes,
Beq.s @ClearIt ; then zero-out the no-connect pRam byte.
Cmp.b #extendedNoConnect,D1 ;
Beq.s @ClearIt ;
Lea DAFBMonIDs,A1 ; Get ptr to DAFBMonIDs table.
Move.w (A1)+,D0 ; Get count of modes.
@ValidLoop Move.b (A1)+,D1 ; Get an ID from the table.
Cmp.b csMode(A2),D1 ; If we have a match,
Beq.s @FoundMatch ; say so.
Dbra D0,@ValidLoop ; Otherwise, keep looping thru
Bra.s @MonIDNotValid ; table until no match is found.
@FoundMatch Tst.b csMode+1(A2) ; If this is not an extended code,
Beq.s @WriteIt ; then just do write.
Cmp.b #extendedSenseVGA,D1 ; Is it the VGA code?
Bne.s @TryPal ; Nope, try PAL.
Move.b #indexedSenseVGA,D1
Bra.s @WriteIt
@TryPal Cmp.b #extendedSensePAL,D1 ; Is it the PAL code?
Bne.s @TryPALBox ; Nope, try PAL encoder box.
Move.b #indexedSensePAL,D1
Bra.s @WriteIt
@TryPALBox Cmp.b #extendedSensePALBox,D1 ; Is it the PAL encoder box code?
Bne.s @TryNTSC ; Nope, try NTSC encoder box.
Move.b #indexedSensePAL,D1
Bra.s @WriteIt
@TryNTSC Cmp.b #extendedSenseNTSC,D1 ; Is it the NTSC encoder box code?
Bne.s @TryLP ; Nope, try GoldFish.
Move.b #indexedSenseNTSC,D1
Bra.s @WriteIt
@TryLP Cmp.b #extendedSenseLP,D1 ; Is it the GoldFish?
Bne.s @Try19 ; Nope, try 19”.
Move.b #indexedSenseLP,D1 ;
Bra.s @WriteIt
@Try19 Cmp.b #extendedSense19,D1 ; Is it a 19”?
Bne.s @WriteIt ; Nope, must be indexed.
Move.b #indexedSense19,D1
@WriteIt Move.b D1,SP_AltSense(Sp) ; Write out “index” to pRam record.
Ori.b #spAltSenseValidMask,SP_AltSense(Sp) ; Validate it.
Bra.s @WritePRam
@ClearIt Clr.b SP_AltSense(Sp) ; Invalidate no-connect byte.
@WritePRam Move.l Sp,spsPointer(A0) ; Set up to whack pRam.
_sPutPRAMRec ; Whack it.
Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack.
Bra DAFBCtlGood ; leave.
@MonIDNotValid Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack.
Bra DAFBCtlBad ; leave with error.
Endwith
**********************************************************************
*
* VideoClose releases the device's private storage and removes the
* interrupt handler.
*
*
* Entry: A0 = param block pointer
* A1 = AuxDCE pointer
*
* Other: A2 = temporary AuxDCE pointer copy
*
**********************************************************************
DAFBVidClose
WITH DAFBVidPrivates
MOVE.L dCtlStorage(A1),A3 ; A3 <- Ptr to private storage
MOVE.L (A3),D0 ;
_StripAddress ;
MOVE.L D0,A3 ;
BSR DAFBDisableVGuts ; call utility to deactivate interrupts
Moveq #true32b,D0 ; Set up to flip into 32-bit addressing.
_SwapMMUMode ; Flip.
Move.l saveDAFBBase(A3),A2 ; (Get DAFBBase into A2 for DAFBIdle macro.)
DAFBIdle ; Put DAFB into an idle state.
_SwapMMUMode ; Restore previous addressing mode.
MOVE.L saveSQElPtr(A3),A0 ; get the slot interrupt queue element ptr
_DisposPtr
MOVE.L saveGamDispPtr(A3),A0 ; get pointer to gamma table block
_DisposPtr ; and dispose it
Move.l saveVidPtr(A3),A0 ; Get pointer to video parameters block,
_DisposPtr ; and dispose of it.
MOVE.L dCtlStorage(A1),A0 ; dispose of the private storage
_DisposHandle ;
MOVEQ #noErr,D0 ; no error
RTS ; and return
ENDWITH
**********************************************************************
*
* Video Driver Status Call Handler. There are ten standard calls:
*
* ($00) Error
* ($01) Error
* ($02) GetMode
* ($03) GetEntries
* ($04) GetPage
* ($05) GetPageBase
* ($06) GetGray
* ($07) GetInterrupt
* ($08) GetGamma
* ($09) GetDefaultMode
*
* The following calls are DAFB-specific:
*
* ($80) GetSyncOnGreen
* ($81) Get16bpp
* ($82) GetPageMode
* ($83) GetAltSense
*
* Entry: A0 = paramblock pointer
* A1 = AuxDCE pointer
* Uses: A2 = cs parameters
* A3 = pointer to private storage
* D0-D3 = scratch (don't need to be preserved)
*
* Exit: D0 = error code
*
**********************************************************************
DAFBVidStatus
MOVEM.L A0/A1,-(SP) ; Save exit registers.
MOVE.L csParam(A0),A2 ; A2 <- Ptr to control parameters
MOVE.L dCtlStorage(A1),A3 ; A3 <- Ptr to private storage
MOVE.L (A3),D0 ;
_StripAddress ;
MOVE.L D0,A3 ;
MOVE.W csCode(A0),D0 ; get routine selector
Cmp.w #cscSyncOnGreen,D0 ; If we got the GetSyncOnGreen call,
Beq DAFBGetSyncOnGreen ; hop to it.
Cmp.w #csc16bpp,D0 ; If we got the Get16bpp call,
Beq DAFBGet16bpp ; hop to it.
Cmp.w #cscPageMode,D0 ; If we got the PageMode call,
Beq DAFBGetPageMode ; hop to it.
Cmp.w #cscAltSense,D0 ; If we got the AltSense call,
Beq DAFBGetAltSense ; hop to it.
CMP.W #9,D0 ;IF csCode NOT IN [0..9] THEN
BHI.S DAFBStatBad ; Error, csCode out of bounds.
MOVE.W DAFBStatJumpTbl(PC,D0.W*2),D0 ;Get the relative offset to the routine.
JMP DAFBStatJumpTbl(PC,D0.W) ;GOTO the proper routine.
DAFBStatJumpTbl
DC.W DAFBStatBad-DAFBStatJumpTbl ;$00 => Error
DC.W DAFBStatBad-DAFBStatJumpTbl ;$01 => Error
DC.W DAFBGetMode-DAFBStatJumpTbl ;$02 => GetMode
DC.W DAFBGetEntries-DAFBStatJumpTbl ;$03 => GetEntries
DC.W DAFBGetPage-DAFBStatJumpTbl ;$04 => GetPage
DC.W DAFBGetPageBase-DAFBStatJumpTbl ;$05 => GetPageBase
DC.W DAFBGetGray-DAFBStatJumpTbl ;$06 => GetGray
DC.W DAFBGetInterrupt-DAFBStatJumpTbl ;$07 => GetInterrupt
DC.W DAFBGetGamma-DAFBStatJumpTbl ;$08 => GetGamma
DC.W DAFBGetDefaultMode-DAFBStatJumpTbl ;$09 => GetDefaultMode
DAFBStatBad MOVEQ #statusErr,D0 ; else say we don't do this one
BRA.S DAFBStatDone ; and return
DAFBStatGood MOVEQ #noErr,D0 ; return no error
DAFBStatDone MOVEM.L (SP)+,A0/A1 ; Restore exit registers.
BRA DAFBExitDrvr
DAFBGetMode
;---------------------------------------------------------------------
;
; Return the current mode
;
; Inputs : A2 = pointer to csParams
; A3 = pointer to private storage
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVE.W saveMode(A3),csMode(A2) ; return the mode
Clr.w csPage(A2) ; return the page number (always 0)
Move.l saveScreenBase(A3),csBaseAddr(A2) ; Return the ST-corrected screen baseAddr.
BRA.S DAFBStatGood ; => return no error
ENDWITH
DAFBGetEntries
;---------------------------------------------------------------------
;
; Read the current contents of the CLUT. These values were gamma corrected
; when they were set (by DAFBSetEntries), so they may not match the source
; cSpec array.
;
; Inputs : A1 = pointer to AuxDCE
; A2 = pointer to csParams/CLUT read register (not restored to csParams)
; A3 = pointer to private storage
;
;---------------------------------------------------------------------
Movem.l D4-D6,-(Sp) ; Save work registers.
Tst.l -(Sp) ; Make some room.
Move.l csTable(A2),D0 ; If we were handed a nil pointer,
Beq @GEErr ; then hike.
_StripAddress ; Make table pointer 32-bit clean.
Move.l D0,(Sp) ; And save it.
Move.w saveMode(A3),D1 ; Get the current video mode.
Sub.w #firstVidMode,D1 ; Convert it to an index.
Move.l D1,D6 ; Save it for later.
Move.w GFlags(A3),D5 ; Get the flags for quick access.
Btst #has16bppSRsrc,D5 ; If we have a 16bpp-capable sRsrc,
Bne.s @GetXTable ; then use the extended table.
Lea DAFBClutTbl,A0 ; Otherwise, just use the normal table.
Bra.s @ChkRange ;
@GetXTable Lea DAFBXClutTbl,A0 ; Point to extended table of counts.
Cmp.w #FifthVidMode-FirstVidMode,D6 ; If this is not 16bpp mode,
Bne.s @ChkRange ; then just go on.
Tst.b hasLin16bppCLUT(A3) ; If 16bpp is linear (i.e., we have Antelope),
Bne.s @ChkRange ; then just on.
Bset #UseTrans,D5 ; Otherwise, remember to do translation.
@ChkRange Moveq #0,D3 ; Set up to get count.
Move.b (A0,D1.w),D3 ; Get clut count.
Move.w csCount(A2),D4 ; Get the number of entries to fill,
Bmi.s @GEErr ; and hike if it’s out of range.
Cmp.w D3,D4 ; If D4-D3 > 0 (count > entries),
Bhi.s @GEErr ; then hike.
Move.w D4,D2 ; Otherwise, copy the count.
Cmp.w #indexEntries,csStart(A2) ; If table accesses are to be indexed,
Beq.s @GECom ; then go on.
Move.w D4,D1 ; Otherwise, sequence thru table from
Add.w csStart(A2),D2 ; csStart thru csCount entries.
; The following code is BAD, BAD, BAD! We should build our own table here so
; as to NOT mess up the user’s data. But all the previous Apple video drivers
; have done the same thing here, so we’ll continue the trend for now.
Move.l (Sp),A0 ; Get ptr to csTable.
@TableLoop Move.w D2,value(A0,D1*colorSpecSize) ; Write the index into the table.
Subq #1,D2 ; Decrement index.
Dbra D1,@TableLoop ;
@GECom Moveq #true32b,D0 ; Save previous MMU mode and set MMU to
_SwapMMUMode ; 32-bit addressing when dealing with DAFB.
Move.l (Sp)+,A0 ; Get/restore ptr to csTable.
Move.l saveVDACBase(A3),A2 ; Get ACDC base address.
Add.l #ACDC_DataReg,A2 ; Add offset to Clut read register.
Move.w Sr,-(Sp) ; Save current interrupt level
Bsr DAFBWaitVSync ; Wait for VBL.
@Repeat Move.w value(A0),D1 ; Get the NEXT Clut position into D1.
Cmp.w D3,D1 ; If this position is out of range,
Bhi.s @Until ; then go on.
Btst #UseTrans,D5 ; If we’re not supposed to translate this index,
Beq.s @Index ; then just go on.
Bsr DAFBTrans5to8 ; Otherwise, do translation.
@Index Move.l D1,ACDC_AddrReg-ACDC_DataReg(A2) ; Tell the Clut where to read from.
Nop ; (DAFB address space is non-serial.)
Move.l (A2),D1 ; Get Red:
Move.b D1,rgb+red(A0) ; --> $rrXX
Move.b D1,rgb+red+1(A0) ; --> $rrrr
Move.l (A2),D1 ; Get Green:
Move.b D1,rgb+green(A0) ; --> $ggXX
Move.b D1,rgb+green+1(A0) ; --> $gggg
Move.l (A2),D1 ; Get Blue:
Move.b D1,rgb+blue(A0) ; --> $bbXX
Move.b D1,rgb+blue+1(A0) ; --> $bbbb
@Until Addq #colorSpecSize,A0 ; Point to next entry ColorTable.
Dbra D4,@Repeat
Move.w (Sp)+,Sr ; Restore previous interrupt level.
_SwapMMUMode ; Restore previous addressing mode.
Movem.l (Sp)+,D4-D6 ; Restore work registers.
Bra DAFBStatGood ; Return noError.
@GEErr Tst.l (Sp)+ ; Clean up stack.
Movem.l (Sp)+,D4-D6 ; Restore work registers.
Bra DAFBStatBad ; Return statError.
DAFBGetPage
;---------------------------------------------------------------------
;
; Return the number of pages in the specified mode. It's pretty simple;
; every mode has only one page. We do check if it's valid, however.
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVE csMode(A2),D1 ; get the mode
MOVE D1,D2 ; keep a copy
BSR DAFBChkMode ; is this mode OK?
BNE DAFBStatBad ; => not a valid mode
MOVE.W #1,csPage(A2) ; return page count
BRA DAFBStatGood ; => return no error
ENDWITH
DAFBGetPageBase
;---------------------------------------------------------------------
;
; Return the base address for the specified page in the current mode
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
TST.W csPage(A2) ; are we returning page zero info?
BNE DAFBStatBad ; only page 0 is valid
Move.l saveScreenBase(A3),csBaseAddr(A2) ; Return the ST-corrected screen baseAddr.
BRA DAFBStatGood ; => return no error
ENDWITH
DAFBGetGray
;---------------------------------------------------------------------
;
; Return a boolean, set true if luminance mapping is on
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVEQ #0,D1 ; set up for BFEXTU
DAFBGetFlagCom
BFEXTU GFlags(A3){D1:1},D0 ; get the state of flag
MOVE.B D0,csMode(A2) ; return value
BRA DAFBStatGood ; => and return
ENDWITH
DAFBGetInterrupt
;---------------------------------------------------------------------
;
; Return a boolean in csMode, set true if VBL interrupts are disabled
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVEQ #1,D1 ; set up BFEXTU to point at IntDisFlag
BRA.S DAFBGetFlagCom ; and use common code
ENDWITH
DAFBGetGamma
;---------------------------------------------------------------------
;
; Return the pointer to the current gamma table
;
;---------------------------------------------------------------------
WITH DAFBVidPrivates
MOVE.L saveGammaPtr(A3),csGTable(A2) ; return the pointer to the structure
BRA DAFBStatGood ; and return a good result
ENDWITH
DAFBGetDefaultMode
;---------------------------------------------------------------------
;
; Read the card default mode from slot pRAM.
;
; A1 = Ptr to AuxDCE
; A2 = Ptr to cs parameter record
; A3 = Ptr to private storage
;
;---------------------------------------------------------------------
WITH spBlock,DAFBVidPrivates,SP_Params
;
; Set up a slot parameter block on the stack.
;
SUBA #spBlockSize,SP ; make an slot parameter block on stack
MOVE.L SP,A0 ; get pointer to parm block now
MOVE.B dCtlSlot(A1),spSlot(A0) ; put slot in pBlock
CLR.B spExtDev(A0) ; external device = 0
;
; Read the slot pRAM to determine what the currently saved mode is. The first
; byte is the board ID, followed by the default mode. Built-in video keeps the last
; selected video sRsrc spID in VendorUse2.
;
SUBA #SizesPRAMRec,SP ; allocate block for pRAM record
MOVE.L SP,spResult(A0) ; point to it
_sReadPRAMRec ; read it
MOVE.B SP_LastConfig(SP),csMode(A2) ; return the result
ADDA #SizesPRAMRec+spBlockSize,SP ; release buffer
BRA DAFBStatGood ;
ENDWITH
DAFBGetSyncOnGreen
;---------------------------------------------------------------------
;
; Return a boolean in csMode, set true if sync-on-green is disabled.
;
;---------------------------------------------------------------------
With DAFBVidPrivates
Btst #syncOnGreen,GFlags(A3) ; If we’re putting sync on green,
Bne.s @IsOn ; then return enabled state.
Move.b #1,csMode(A2) ; Otherwise, return disabled.
Bra DAFBStatGood
@IsOn
Clr.b csMode(A2) ; Return enabled state.
Bra DAFBStatGood
EndWith
DAFBGet16bpp
;---------------------------------------------------------------------
;
; Return a boolean in csMode, set true if 16bpp is blocked.
;
;---------------------------------------------------------------------
With spBlock,DAFBVidPrivates,SP_Params
;
; First, set up a slot parameter block on the stack.
;
Suba #spBlockSize,Sp ; Make a SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Move.b dCtlSlot(A1),spSlot(A0) ; Set it up.
Clr.b spExtDev(A0)
;
; Next, read the current pRam so that we can tell whether an AC842A is actually
; intalled, and then return whether 16bpp is blocked or not.
;
Suba #SizesPRAMRec,Sp ; Make an sPRAM block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_sReadPRamRec ; Get pRAM.
Btst #spHas16bppACDC,SP_Flags(Sp) ; If we don’t have an AC842A,
Beq.s @BadExit ; then just blow this off.
Btst #spAllow16bpp,SP_Flags(Sp) ; If we allowing 16bpp,
Bne.s @NotBlocked ; then return non-blocked state.
Move.b #1,csMode(A2) ; Otherwise, return blocked.
Bra.s @GoodExit
@NotBlocked Clr.b csMode(A2) ; Return enabled state.
@GoodExit Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
Bra DAFBStatGood ; go home.
@BadExit Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
Bra DAFBStatBad ; return error.
EndWith
DAFBGetPageMode
;---------------------------------------------------------------------
;
; Returns a boolean in csMode, set true if page mode is disabled.
;
;---------------------------------------------------------------------
With DAFBVidPrivates
Moveq #true32b,D0 ; Set up to switch into 32-bit mode,
_SwapMMUMode ; do switch, and
Move.b D0,-(Sp) ; save previous mode.
Move.l saveDAFBBase(A3),A0 ; Get DAFBBase into A0.
Move.l DAFB_PgMdEn(A0),D0 ; Get page mode.
Btst #0,D0 ; If page mode is on,
Bne.s @IsOn ; then return enabled state.
Move.b #1,csMode(A2) ; Otherwise, return disabled,
Bra.s @EndPageMode ; and leave.
@IsOn Clr.b csMode(A2) ; Return enabled state.
@EndPageMode Move.b (Sp)+,D0 ; Set up to switch back into previous mode,
_SwapMMUMode ; do switch, and
Bra DAFBCtlGood ; leave.
EndWith
DAFBGetAltSense
;---------------------------------------------------------------------
;
; Returns the alternate senseID code that’s in use. It
; should be noted that we cannot disguish between PAL &
; NTSC monitors & encoder boxes once DAFBSetAltSense has
; been called (because both the monitor & box codes are
; mapped into the same indexedSense code).
;
;---------------------------------------------------------------------
With spBlock,DAFBVidPrivates,SP_Params
;
; First, set up a slot parameter block on the stack.
;
Suba #spBlockSize,Sp ; Make a SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Move.b dCtlSlot(A1),spSlot(A0) ; Set it up.
Clr.b spExtDev(A0)
;
; Next, read the current pRam so that we can determine whether the
; alternate senseID code is valid or not.
;
Suba #SizesPRAMRec,Sp ; Make an sPRAM block on the stack.
Move.l Sp,spResult(A0) ; Point to it.
_sReadPRamRec ; Get pRAM.
Clr.b csMode+1(A2) ; Assume the code already indexed for now.
Move.b SP_AltSense(Sp),D0 ; Get the alternate senseID byte.
Andi.b #spAltSenseValidMask,D0 ; If it is valid,
Bne.s @Valid ; return it.
Move.b #indexedNoConnect,csMode(A2) ; Otherwise, return the indexed no-connect code,
Bra.s @Exit ; and leave.
@Valid Move.b SP_AltSense(Sp),D0 ; Get the no-connect byte again.
Andi.b #spAltSenseMask,D0 ; Strip the validation code.
Cmp.b #indexedSenseVGA,D0 ; Is it the VGA code?
Bne.s @TryPal ; Nope, try PAL.
Move.b #extendedSenseVGA,D0
Bra.s @WriteExtended
@TryPal Cmp.b #indexedSensePAL,D0 ; Is it the PAL code?
Bne.s @TryLP ; Nope, try GoldFish.
Move.b #extendedSensePAL,D0
Bra.s @WriteExtended
@TryLP Cmp.b #indexedSenseLP,D0 ; Is it the GoldFish code?
Bne.s @Try19 ; Nope, try 19”.
Move.b #extendedSenseLP,D0
Bra.s @WriteExtended
@Try19 Cmp.b #indexedSense19,D0 ; Is it the 19” code?
Bne.s @TryRdRGB ; No, try the Radius ColorTPD.
Move.b #extendedSense19,D0
Bra.s @WriteExtended
@TryRdRGB Cmp.b #extended2PRdRGB,D0 ; Is it the ColorTPD.
Bne.s @TryRDMono ; Nope, try the Mono.
Bra.s @Write2PExtended
@TryRdMono Cmp.b #extended2PRdMono,D0 ; Is it the MonoTPD.
Bne.s @WriteIt ; Nope, assume indexed.
@Write2PExtended
Move.b #indexedSense2P,csMode+1(A2) ; Say code is type 3.
Bra.s @WriteIt
@WriteExtended Move.b #indexedNoConnect,csMode+1(A2) ; Say code is type 7.
@WriteIt Move.b D0,csMode(A2) ; Return valid monID.
@Exit Adda #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
Bra DAFBStatGood ; go home.
Endwith
;---------------------------------------------------------------------
;
; Exit from Control or Status.
;
; A0 = Ptr to param block.
; A1 = Ptr to AuxDCE.
; D0 = error code.
;
;---------------------------------------------------------------------
DAFBExitDrvr BTST #NoQueueBit,ioTrap(A0) ; no queue bit set?
BEQ.S DAFBGoIODone ; => no, not immediate
RTS ; otherwise, it was an immediate call
DAFBGoIODone MOVE.L JIODone,-(Sp) ; Get the IODone address,
Rts ; and go there.
;=====================================================================
;
; Utilities
;
;=====================================================================
;---------------------------------------------------------------------
;
; CalcScreenBaseAddr
;
; Returns the proper screen base address for the current page
; and mode.
;
; -> A3: Pointer to driver privates, saveMode(A3) must be set up!
;
DAFBCalcScreenBaseAddr
With DAFBVidPrivates,SpBlock,VPBlock
Movem.l A0-A1/D0,-(Sp) ; Save work registers.
Suba #spBlockSize,Sp ; Make a SpBlock on the stack.
Move.l Sp,A0 ; Get a pointer to it into A0.
Clr.b spSlot(A0) ; Say we want Slot 0.
Clr.b spID(A0) ; Start looking at spID 0.
Clr.b spExtDev(A0) ; (No external devices.)
Clr.b spTBMask(A0) ; Only look for DAFB video sResources.
Move.w #catDisplay,spCategory(A0) ; Look for: catDisplay,
Move.w #typVideo,spCType(A0) ; typVideo,
Move.w #drSwApple,spDrvrSW(A0) ; drSwApple,
Move.w #drHwDAFB,spDrvrHW(A0) ; drHWDAFB.
Clr.l spParamData(A0) ; (The video sResource must be enabled.)
Bset #foneslot,spParamData+3(A0) ; Limit search to slot 0.
_GetTypeSRsrc ; Get the spsPointer.
Move.w saveMode(A3),D0 ; Get the ID of the mode we’re looking for.
Move.b D0,spID(A0) ; Look for this mode’s parameters.
_sFindStruct ; Get the spsPointer.
Move.b #mVidParams,spID(A0) ; Look for the mVidParams.
_sGetBlock ; Grap ’em
Move.l spResult(A0),A0 ; Save a pointer the mVidParams.
Move.l saveBaseAddr(A3),A1 ; Get the active vRam base address.
Adda.l vpBaseOffset(A0),A1 ; Point to the base of the screen.
Move.l A1,saveScreenBase(A3) ; Save it.
_DisposPtr ; Dispose the mVidParams.
Adda #spBlockSize,Sp ; Restore the stack.
Movem.l (Sp)+,A0-A1/D0 ; Restore work registers.
Rts
Endwith
;---------------------------------------------------------------------
;
; Trans5to8
;
; The ACDC that supports 16bpp (AC842A) does so in a somewhat unique
; fashion. That is, it uses a sparse 8-bit CLUT. The
; translation forumla is as follows:
;
; 5-bits [4..0] -> 8-bits [4..04..2].
;
; <-> D1: 5-bit value to be converted into an 8-bit index.
;
DAFBTrans5to8
Move.l D0,-(Sp) ; Save D0 as scratch.
Moveq #0,D0 ; Clear it.
Move.w D1,D0 ; D1 = ---43210, D0 = ---43210.
Lsl.w #3,D1 ; D1 = 43210---, D0 = ---43210.
Lsr.w #2,D0 ; D1 = 43210---, D0 = -----432.
Or.w D0,D1 ; D1 = 43210432.
Move.l (Sp)+,D0 ; Restore D0.
Rts
;---------------------------------------------------------------------
;
; ChkMode
;
; Verifies the requested mode is legal. Converts spID in D1 into
; zero-based mode number since lots of people want it that way.
;
; <-> D1: Mode
; -> A3: Pointer to driver privates
;
; All registers preserved
;
; Returns EQ if mode is valid.
;
With DAFBVidParams
DAFBChkMode
Movem.l A0/D0/D2,-(Sp) ; Save work registers.
Sub.w #FirstVidMode,D1 ; Make mode zero-based.
Blt.s @ModeBad ; If the passed-in mode is < 0,
; then punt.
Btst #IsMono,GFlags(A3) ; If we don’t have a mono-only display,
Beq.s @EndMonoChk ; then just go on.
Cmp.w #FifthVidMode-FirstVidMode,D1 ; If we’re not trying for a direct mode,
Blt.s @EndMonoChk ; then just go on.
Bra.s @ModeBad ; Otherwise, punt.
@EndMonoChk
; For DAFB, all the ‘a’ modes are even and all the ‘b’ modes are odd, except
; for the convolved modes. So, if we’re not a convolved mode, we just check
; the oddness or evenness of the spID to determine whether the passed in
; mode is OK. If it’s a convolved mode, we will always be in the ‘b’ configuration,
; but we just endcode that information into the vidParams table.
;
Move.l saveVidPtr(A3),A0 ; Get pointer to video params.
Adda.w #DVPMaxModeBase,A0 ; Point to MiscParams.
Move.b saveSlotID(A3),D0 ; Get functional sRsrcID of display.
Btst #0,D0 ; If the display is in ‘a’ mode,
Beq.s @MakeA ; then say so.
Bra.s @MakeB ; Otherwise, make it a ‘b’ mode.
@MakeA Moveq #0,D0 ; Say it’s an ‘a’ mode.
Bra.s @MaxMode
@MakeB Moveq #1,D0 ; Say it’s a ‘b’ mode.
@MaxMode Move.b D0,D2 ; Remember which mode we have.
Move.b (A0,D0),D0 ; Get maximum mode for the current display.
Cmp.b #FirstVidMode,D0 ; If it’s already indexed,
Blt.s @ChkMode ; then just check it now.
Sub.b #FirstVidMode,D0 ; Otherwise, make max mode indexed.
Tst.b wombatFlag(A3) ; If we aren’t on a Wombat,
Beq.s @16BppChk ; then just go on.
Cmp.w #indexedSenseRubik,saveMonID(A3) ; If we don’t have a Rubik,
Bne.s @16BppChk ; then just go on.
Tst.b hasLin16BppCLUT(A3) ; If we don’t have an Antelope,
Beq.s @16bppChk ; then just go on.
Subq #1,D0 ; Otherwise, adjust max-mode value
Bra.s @ChkMode ;
@16BppChk Btst #Has16bppSRsrc,GFlags(A3) ; If we have a 16bpp-capable sRsrc list
Bne.s @ChkMode ; then just go on.
Subq #1,D0 ; Otherwise, adjust max-mode value.
Tst.b D2 ; If we’ve got a ‘b’ mode,
Bne.s @ChkMode ; then just go on.
Cmp.w #indexedSenseRubik,saveMonID(A3) ; If we don’t have a Rubik,
Bne.s @ChkMode ; then just go on.
Subq #1,D0 ; Otherwise, adjust max-mode value.
@ChkMode Cmp.w D0,D1 ; If the passed in mode is > max mode,
Bgt.s @ModeBad ; then punt.
@ModeOK Cmp.w D1,D1 ; Set Eq when OK.
Bra.s @EndChkMode
@ModeBad Moveq #-1,D1 ; Set NEq when bad and invalidate D1.
@EndChkMode Movem.l (Sp)+,A0/D0/D2 ; Restore work registers.
Rts
Endwith
;---------------------------------------------------------------------
;
; Wait for vertical blanking. Interrupts are raised to level-2 around
; this routine.
;
; IMPORTANT! - This routine expects to be called in 32-bit addressing mode!!!!
;
; A1 = AuxDCE POINTER
; A3 = pointer to private storage
;---------------------------------------------------------------------
DAFBWaitVSync
MOVE.L A0,-(SP) ; Save work registers.
MOVE.L D0,-(SP) ; (Two MOVEs are faster than a MOVEM.)
MOVE.W SR,-(SP) ; Get the status register on stack.
MOVEQ #7,D0 ; Get mask into D0.
AND.B (SP),D0 ; Get the interrupt level.
SUBQ.B #2,D0 ;
BGE.S @OK ; If ≥, then don't change.
ORI.W #$0200,SR ; Raise above level-2.
ANDI.W #$FAFF,SR ; Make it level-2
@OK
Tst.w (Sp)+ ; Restore stack.
MOVE.L saveDAFBBase(A3),A0 ; Point to DAFB.
CLR.L Swatch_ClrCrsrInt(A0) ; Otherwise, clear the interrupt, just in case,
; since the interrupt handler
; can’t get called here.
@WaitForVBL MOVE.L Swatch_IntStat(A0),D0 ; Get the VBL status.
BTST #dafbIntStatusBit,D0 ; If VBL has NOT occurred,
BEQ.S @WaitForVBL ; then just spin.
@Done MOVE.L (SP)+,D0 ; Restore work registers.
MOVE.L (SP)+,A0 ; (Two MOVEs are faster than a MOVEM.)
RTS
;---------------------------------------------------------------------
;
; SetDepth sets the DAFB frame buffer depth, and returns the
; frame buffer base in driver privates
;
; D1 contains the spID of the depth - $80 (the zero based mode ID)
; A1 = AuxDCE POINTER
; A2 = parameter block pointer
; A3 = dCtlStorage pointer
;
; Preserves all registers
;
;---------------------------------------------------------------------
DAFBSetDepth
WITH DAFBVidPrivates,DAFBVidParams,DAFBBppParams,SC_Params
MOVEM.L D0-D2/A0-A2,-(SP) ; save regs we are using
MOVE.L saveDAFBBase(A3),A2 ; get the DAFB base address
MOVE.L saveVidPtr(A3),A1 ; get a pointer to the screen depth parameters
MOVE.W D1,D2 ; copy the index
Btst #Has16bppSRsrc,GFlags(A3) ; If we have a 16bpp-capable sRsrc list
Bne.s @IndexOK ; then just go on.
Cmp.w #FifthVidMode-FirstVidMode,D2 ; If we’re not trying to do 32bpp,
Bne.s @IndexOK ; then just go on.
Addq #1,D2 ; Otherwise, skip the 16bpp params.
@IndexOk MULU #DBPSize+SC_Size,D2 ; index to the correct parameter group
LEA DVPHdrSize(A1,D2),A1 ; point to the setup parameters
MOVEQ #true32b,D0 ; flip to 32-bit mode
_SwapMMUMode ;
MOVE.B D0,-(SP) ; save previous addressing mode
; Setup DAFB…
;
Tst.b wombatFlag(A3) ; If we’re on a Wombat,
Bne.s @SetupDAFB ; then just go on.
Cmp.w #indexedSenseRubik,saveMonID(A3) ; If don’t have a Rubik,
Bne.s @SetupDAFB ; then just go on.
Cmp.w #FirstVidMode-FirstVidMode,D1 ; If we’re doing 1bpp,
Beq.s @Rubik1bpp ; set the weird base address.
Move.l #8,DAFB_VidBaseHi(A2) ; 2,4,8,16,32bpp-Rubik are std.
Bra.s @SetupDAFB
@Rubik1bpp
Move.l #7,DAFB_VidBaseHi(A2) ; 1bpp-Rubik is weird.
@SetupDAFB
DAFBWWrite dbpRowWords,DAFB_RowWords ; Set up the RowWords.
DAFBWWrite dbpConfig,DAFB_Config ; Set up the controller.
Move.l DAFB_ClkCfg(A2),D0 ; Pick up the ClkCfg reg.
Andi.l #$00000100,D0 ; Clear everything but the ClkSel bit.
DAFBWWrite dbpClkCfg,DAFB_ClkCfg ; Set up the clocking.
Or.l D0,DAFB_ClkCfg(A2) ; Make sure ClkSel is correct.
DAFBSpeedDR ; Reconfigure DAFB for the right CPU speed.
; Setup Swatch…
;
DAFBWWrite dbpTimingAdj,Swatch_TimeAdj ; Set up timing adjustments.
DAFBWWrite dbpHSerr,Swatch_HSerr ; Set up horizontal timing.
DAFBWWrite dbpHlfLn,Swatch_HlfLn ;
DAFBWWrite dbpHEq,Swatch_HEq ;
DAFBWWrite dbpHSP,Swatch_HSP ;
DAFBWWrite dbpHBWay,Swatch_HBWay ;
DAFBWWrite dbpHBrst,Swatch_HBrst ;
DAFBWWrite dbpHBP,Swatch_HBP ;
DAFBWWrite dbpHAL,Swatch_HAL ;
DAFBWWrite dbpHFP,Swatch_HFP ;
DAFBWWrite dbpHPix,Swatch_HPix ;
; Setup ACDC…
;
Clr.l ACDC_AddrReg(A2) ; Tell ACDC to use PCBR0.
DAFBWWrite dbpACDCPCBR,ACDC_ConfigReg ; Set up ADCD config register.
Nop ; (DAFB’s address space is non-serial.)
Tst.l ACDC_AddrReg(A2) ; Read the addr reg to make it stick (AC842A).
Btst #has16bppSRsrc,GFlags(A3) ; If we don’t have a 16bpp-capable sRsrc,
Beq.s @EndDAFB16bpp ; then skip the 16bpp setup.
Cmp.w #FifthVidMode-FirstVidMode,D1 ; If we aren’t doing 16bpp, then
Bne.s @EndDAFB16bpp ; just go on.
Move.l #1,ACDC_AddrReg(A2) ; Tell ACDC to use PCBR1.
Move.l #$C0,ACDC_ConfigReg(A2) ; Switch to 16bpp.
Nop ; (DAFB’s address space is non-serial.)
Tst.l ACDC_AddrReg(A2) ; Read the addr reg to make it stick (AC842A).
Clr.l ACDC_AddrReg(A2) ; Tell ACDC to use PCBR0 again.
@EndDAFB16bpp
; AC842A adjustments. There are a bunch of NOPs in the code below, and there’s a good reason for
; them. It turns out that DAFB’s address space on the Quadras is non-serial, which means
; the order of reads and writes is somewhat non-deterministic. Unfortunately, in order
; to program the AC842A, certain writes MUST precede certain reads, and vice-versa. So,
; to get around this problem, I have strategically placed various NOPs below. On ’040’s,
; the NOP actually has a function, which is to force pending writes to occur before
; reads. Cool, huh!
;
Tst.b has16bppACDC(A3) ; If we don’t have an AC842A,
Beq @DoReset ; then just go on.
Move.l DAFB_ClkCfg(A2),D0 ; Get the current clock configuration.
Bfextu D0{dafbPixSel1:1},D2 ; Get PIXSEL1 (PIXSEL1 -> ~acdcPCS).
Not.l D2 ; Invert it.
Clr.l ACDC_AddrReg(A2) ; Tell ACDC to use PCBR0.
Nop ; (DAFB’s address space is non-serial.)
Move.l ACDC_ConfigReg(A2),-(Sp) ; Save PCBR0 for later.
Move.l #6,ACDC_ConfigReg(A2) ; Put ACDC into indirect mode.
Move.l #1,ACDC_AddrReg(A2) ; Tell ACDC to use PCBR1.
Nop ; (DAFB’s address space is non-serial.)
Move.l ACDC_ConfigReg(A2),D0 ; Save the current configuration.
Bfins D2,D0{acdcPCS:1} ; Set up to select the right clock.
Move.l D0,ACDC_ConfigReg(A2) ; Write PCBR1 back out with correct clock set.
Nop ; (DAFB’s address space is non-serial.)
Tst.l ACDC_AddrReg(A2) ; Read the addr reg to make it stick (AC842A).
Clr.l ACDC_AddrReg(A2) ; Tell ACDC to use PCBR0 again.
Move.l (Sp)+,ACDC_ConfigReg(A2) ; Restore PCBR0.
Tst.b wombatFlag(A3) ; If we have a WombatDAFB, then just
Bne.s @DoSwatchAdj ; go on (because we ONLY use the programmble clock).
Btst #0,D2 ; If PIXSEL1 was NOT zero,
Beq.s @DoSwatchAdj ; then just go on.
Move.l DAFB_ClkCfg(A2),D0 ; Get the current clock configuration.
Bfins D2,D0{dafbPixSel0:1} ; Set up PIXSEL0 so that…
Move.l D0,DAFB_ClkCfg(A2) ; …the programmable clock is used.
@DoSwatchAdj
Tst.b wombatFlag(A3) ; If we’re on a Wombat,
Bne.s @StrtAdj1 ; then just go on.
Move.l saveVidPtr(A3),A0 ; Pick up the vidParams pointer.
Cmp.b dvpBadDepth(A0),D1 ; If we’re not switching to a “bad” depth,
Bne.s @StrtAdj1 ; then just go on.
DAFBWWrite dbpTimingAdjAMD,Swatch_TimeAdj ; Adjust TimingAdj.
Move.l Swatch_TimeAdj(A2),D0 ; Get the adjusted value.
Add.b dvpFudge(A0),D0 ; Adjust it some more.
Move.l D0,Swatch_TimeAdj(A2) ; Write it back out.
Bra.s @StrtAdj2 ; And go on.
@StrtAdj1 DAFBWWrite dbpTimingAdjAMD,Swatch_TimeAdj ; Adjust TimingAdj,
@StrtAdj2 DAFBWWrite dbpHALAMD,Swatch_HAL ; HAL,
DAFBWWrite dbpHFPAMD,Swatch_HFP ; HFP
Tst.b wombatFlag(A3) ; If we’re not on a Wombat,
Beq.s @DoReset ; then just go on
Moveq #0,D0 ; Clear this reg.
Move.w dbpACDCPCBR(A1),D0 ; Pick up the PCBR value.
Bclr #7,D0 ; Strip off the IRE-value.
Lsr.w #5,D0 ; Keep just the VidClk bits.
Move.w D0,D2 ; And save them for later.
Lea DAFBWombatTimingAdjTbl,A0 ; Point to the Wombat TimingAdj table.
Mulu #DAFBWombatTSize,D0 ; Figure out the offset value.
Adda.w D0,A0 ; Point to the right entry.
Move.w (A0,D1*2),D0 ; Pick up the appropriate value.
Add.l D0,Swatch_TimeAdj(A2) ; Add it in.
Tst.b hasLin16BppCLUT(A3) ; If we don’t have an Antelope,
Beq.s @EndSwatchAdj ; then just go on.
Lea DAFBAntelopeTbl,A0 ; Point to the table of Antelope adjustment values.
Move.w (A0,D2*2),D0 ; Get the appropriate adjustment value.
Add.l D0,Swatch_TimeAdj(A2) ; Adjust TimingAdj,
Add.l D0,Swatch_HAL(A2) ; HAL,
Add.l D0,Swatch_HFP(A2) ; HFP.
Cmp.w #FifthVidMode-FirstVidMode,D1 ; If we aren’t doing 16bpp, then
Bne.s @EndSwatchAdj ; just go on.
Cmp.w #indexedSensePAL,saveMonID(A3) ; If we aren’t doing PAL FF/ST, then
Bne.s @EndSwatchAdj ; just go on.
Addi.l #1,Swatch_TimeAdj(A2) ; Otherwise, adjust TimingAdj again.
@EndSwatchAdj
; Sync On Green… (Wombat only)
;
Move.l DAFB_ClkCfg(A2),D0 ; Get the current Clock config value.
Btst #syncOnGreen,GFlags(A3) ; If we’re supposed to put sync on green,
Bne.s @EnableSyncOnGreen ; then hop to it.
Moveq #0,D1 ; Otherwise, set up for disabling.
Bra.s @SyncOnGreenCommon
@EnableSyncOnGreen
Moveq #1,D1 ; Set up for enabling.
@SyncOnGreenCommon
Bfins D1,D0{dafbSyncOnGreen:1} ; Toggle the sync-on-green bit appropriately,
Move.l D0,DAFB_ClkCfg(A2) ; apply it.
; Everything's configured, so do the DAFB reset sequence after waiting for vSync to happen.
;
@DoReset
Move.w Sr,-(Sp) ; Save the current interrupt level.
BSR DAFBWaitVSync ; Wait for the next VBL.
Move.w (Sp)+,Sr ; Restore the interrupt level.
DAFBReset ; Reset DAFB.
MOVE.B (SP)+,D0 ; get the previous addressing mode back
_SwapMMUMode ;
MOVEM.L (SP)+,D0-D2/A0-A2 ; restore all regs
RTS ; return
ENDWITH
;---------------------------------------------------------------------
;
; Fill the screen with a 50% dithered gray pattern. To have gotten here
; we must have had a valid display connected, so there are not tests
; for inactive displays here.
;
; D1 = spID of screen depth - FirstVidMode
; A3 = driver private storage
;
; All registers are preserved
;
With DAFBVidParams,DAFBBppParams,SC_Params
DAFBGrayScreen
MOVEM.L A0-A2/D0-D7,-(SP)
MOVE.L saveBaseAddr(A3),A2 ; Get the screen base address into A2.
Move.w D1,D7 ; Save the vidMode for later.
Move.b saveSlotId(A3),D3 ; Get the functional sRsrcID.
Btst #has16bppSRsrc,GFlags(A3) ; If we have a 16bpp sRsrc,
Bne.s @GetXPats ; then get the extended patterns.
Bra.s @NormPats ; Otherwise, just use the normal patterns.
@GetXPats Lea DAFBXPats,A0 ; Point to the table of patterns,
Move.l (A0,D1*4),D4 ; and load the right one.
Move.l D4,D5 ; Copy the pattern for the double-long stuff.
MOVEQ #IndexedBlack,D6 ; assume an indexed mode for now
Cmp.w #FifthVidMode-FirstVidMode,D1 ; If this is not a direct mode,
Blt.s @StartGray ; just go on.
Cmp.w #FifthVidMode-FirstVidMode,D1 ; If this is 16bpp mode, then
Beq.s @Skip32bpp ; the data fits into one long.
Not.l D5 ; Otherwise, invert this half for white.
@Skip32bpp Moveq #DirectBlack,D6 ; Set black as direct.
Cmp.b #sRsrc_Vid_DAFB_NTSCSTax,D3 ; If this is an NTSC ST (non-convolved) display,
Beq.s @StartGray ; then don’t alter the baseAddr.
Cmp.b #sRsrc_Vid_DAFB_NTSCSTbx,D3 ;
Beq.s @StartGray ;
Cmp.b #sRsrc_Vid_DAFB_PALSTax,D3 ; If this is a PAL ST (non-convolved) display,
Beq.s @StartGray ; then don’t alter the baseAddr.
Cmp.b #sRsrc_Vid_DAFB_PALSTbx,D3 ;
Beq.s @StartGray ;
@AdjBase Move.l saveScreenBase(A3),A2 ; Get the (offset, ugh!) screen base address,
Bra.s @StartGray ; and start graying.
@NormPats LEA DAFBPats,A0 ; point to the pattern table
MOVE.L (A0,D1*4),D4 ; get the graying pattern
MOVE.L D4,D5 ; copy it
MOVEQ #IndexedBlack,D6 ; assume an indexed mode for now
CMP.W #FifthVidMode-FirstVidMode,D1 ; is this Millions mode?
BNE.S @StartGray ; if so, use the special graying routine
NOT.L D5 ; invert this half to make white
MOVEQ #DirectBlack,D6 ; nope, get direct instead
@StartGray MOVE.L saveVidPtr(A3),A1 ; point to video parameters
Move.l A1,A0 ; Make a copy.
Btst #has16bppSRsrc,GFlags(A3) ; If we have a 16bpp-capable sRsrc list
Bne.s @IndexOK ; then just go on.
Cmp.w #FifthVidMode-FirstVidMode,D1 ; If we’re not trying to do 32bpp,
Bne.s @IndexOK ; then just go on.
Addq #1,D1 ; Otherwise, skip the 16bpp params.
@IndexOK MULU #DBPSize+SC_Size,D1 ; index to the correct parameter group
LEA DVPHdrSize+DBPSize(A1,D1),A1 ; point to the screen graying parameters
MOVEQ #true32b,D0 ; flip to 32-bit mode
_SwapMMUMode ;
MOVE.B D0,D2 ; save previous addressing mode
; Do top of screen…
;
; Note that SC_BorderHeight is adjusted to work correctly for both bordered and non-bordered screens.
; Specifically, this constant is not “-1”-adjusted for Dbra, so we jump into the tail end of the Dbra
; loop and therefore have the “right” thing happen. My head hurts now, and I hope yours does.
;
Cmp.w #indexedSenseRubik,saveMonID(A3) ; If we’re on a Rubik display, then
Beq.s @FixRubik1bpp ; see if wee need to do fix.
Cmp.b #sRsrc_Vid_DAFB_NTSCconvST,D3 ; If we’re on an NTSC convolved display,
Beq.s @FixNTSCPALTop ; then apply fix.
Cmp.b #sRsrc_Vid_DAFB_NTSCconvFF,D3
Beq.s @FixNTSCPALTop
Cmp.b #sRsrc_Vid_DAFB_NTSCconvSTx,D3
Beq.s @FixNTSCPALTop
Cmp.b #sRsrc_Vid_DAFB_NTSCconvFFx,D3
Beq.s @FixNTSCPALTop
Cmp.b #sRsrc_Vid_DAFB_PALconvST,D3 ; If we’re on a PAL convolved display,
Beq.s @FixNTSCPALTop ; then apply fix.
Cmp.b #sRsrc_Vid_DAFB_PALconvFF,D3
Beq.s @FixNTSCPALTop
Cmp.b #sRsrc_Vid_DAFB_PALconvSTx,D3
Beq.s @FixNTSCPALTop
Cmp.b #sRsrc_Vid_DAFB_PALconvFFx,D3
Beq.s @FixNTSCPALTop
Bra.s @ScreenStart
@FixRubik1bpp
Move.w #DAFB_512_RB,D0 ; Fix first-line problem on Rubik displays.
Bra.s @FixRow ; (Only really need to this in 1bpp mode, but doesn’t hurt others.)
@FixNTSCPALTop
Move.w #DAFB_1024_RB,D0 ; Create “false” first line on NTSC/PAL convolved displays.
@FixRow Suba D0,A2 ; Point back one full line.
Lsr.w #2,D0 ; Make loop counter long-word based.
Subq #1,D0 ; Subtract 1 for Dbra.
@BlastRow Move.l D6,(A2)+ ; Write black out.
Dbra D0,@BlastRow
@ScreenStart
Move.w SC_BorderHeight(A1),D1 ; get number of rows (not -1) to blast back on top
Bra.s @TopSecPrime ;
@TopSecFill_V
Move.w SC_BorderWidth(A1),D0 ; get number of longs (-1) to blast black in row
@TopSecFill_H
Move.l D6,(A2)+ ; blast black to screen
Dbra D0,@TopSecFill_H
Adda.w SC_SkipFactor(A1),A2 ; skip to start of next row
@TopSecPrime
Dbra D1,@TopSecFill_V
; Do middle of screen…
;
; Unlike the top part, there is always a “middle.” However, there might be a left and right side (when the
; border is appropriate), so the not “-1”-adjusted for Dbra comments that are listed above apply horizontally
; here.
;
Move.w dvpNumRows(A0),D1 ; get number of rows (-1) in middle of screen
@MidSecFill_V
Move.w SC_BorderSide(A1),D0 ; get number of longs (not -1) to blast black in row
Bra.s @MidSecPrime_L
@MidSecFill_L
Move.l D6,(A2)+ ; blast black to screen
@MidSecPrime_L
Dbra D0,@MidSecFill_L
Move.w SC_ActiveWidth(A1),D0 ; get the number of doublelongs (-1) for active middle
@MidActFill_H
Move.l D4,(A2)+ ; Fill the active section with gray
Cmp.b #sRsrc_Vid_DAFB_SVGAa,D3 ; Skip if SuperVGA (800x600 is not an
Beq.s @ChkMode ; even multiple of 64, but it is an)
Cmp.b #sRsrc_Vid_DAFB_SVGAb,D3 ; even multiple of 32).
Beq.s @ChkMode ;
Cmp.b #sRsrc_Vid_DAFB_SVGAax,D3 ;
Beq.s @ChkMode ;
Cmp.b #sRsrc_Vid_DAFB_SVGAbx,D3 ;
Beq.s @ChkMode ;
Bra.s @DoDouble ;
@ChkMode Btst #has16bppSRsrc,GFlags(A3) ; If we have a 16bpp-capable sRsrc,
Bne.s @16bppSRsrc ; then go there.
Cmp.w #FifthVidMode-FirstVidMode,D7 ; If we’re not doing 32bpp,
Bne.s @SkipDouble ; then really skip.
Bra.s @DoDouble ; Otherwise, do second half.
@16bppSRsrc Cmp.w #SixthVidMode-FirstVidMode,D7 ; If we’re not doing 32bpp,
Bne.s @SkipDouble ; then really skip.
@DoDouble Move.l D5,(A2)+ ; Otherwise, do second half where applicable.
@SkipDouble Dbra D0,@MidActFill_H
Not.l D4 ; Invert for next line, and
Not.l D5 ; second half if applicable.
Move.w SC_BorderSide(A1),D0 ; get number of longs (not -1) to blast black in row
Bra.s @MidSecPrime_R
@MidSecFill_R
Move.l D6,(A2)+ ; blast black to screen
@MidSecPrime_R
Dbra D0,@MidSecFill_R
Add.w SC_SkipFactor(A1),A2 ; move to NEXT line
Dbra D1,@MidSecFill_V
; Do bottom of screen…
;
Move.w SC_BorderHeight(A1),D1 ; Get number of rows (not -1) to blast back on bottom.
Cmp.b #sRsrc_Vid_DAFB_NTSCconvST,D3 ; If we’re on an NTSC convolved display,
Beq.s @FixNTSCPALBot ; then apply fix.
Cmp.b #sRsrc_Vid_DAFB_NTSCconvFF,D3
Beq.s @FixNTSCPALBot
Cmp.b #sRsrc_Vid_DAFB_NTSCconvSTx,D3
Beq.s @FixNTSCPALBot
Cmp.b #sRsrc_Vid_DAFB_NTSCconvFFx,D3
Beq.s @FixNTSCPALBot
Cmp.b #sRsrc_Vid_DAFB_PALconvST,D3 ; If we’re on a PAL convolved display,
Beq.s @FixNTSCPALBot ; then apply fix.
Cmp.b #sRsrc_Vid_DAFB_PALconvFF,D3
Beq.s @FixNTSCPALBot ; then apply fix.
Cmp.b #sRsrc_Vid_DAFB_PALconvSTx,D3
Beq.s @FixNTSCPALBot
Cmp.b #sRsrc_Vid_DAFB_PALconvFFx,D3
Beq.s @FixNTSCPALBot
Bra.s @BotStart
@FixNTSCPALBot
Addq #1,D1 ; For convolved interlace displays, we need to
; blacken the “false” bottom.
@BotStart
Bra.s @BotSecPrime ;
@BotSecFill_V
Move.w SC_BorderWidth(A1),D0 ; get number of longs (-1) to blast black in row
@BotSecFill_H
Move.l D6,(A2)+ ; blast black to screen
Dbra D0,@BotSecFill_H
Adda.w SC_SkipFactor(A1),A2 ; skip to start of next row
@BotSecPrime
Dbra D1,@BotSecFill_V
MOVE.B D2,D0 ; get the previous addressing mode back
_SwapMMUMode ;
@GrayExit
MOVEM.L (SP)+,A0-A2/D0-D7 ; restore all regs
RTS ; and return
Endwith
;---------------------------------------------------------------------
;
; DAFBDirectCLUTSet writes gamma-corrected ascending grayscale ramps into
; the CLUT
;
; A3 = dCtlStorage pointer
;
; Preserves all registers used.
;
;---------------------------------------------------------------------
DAFBDirectCLUTSet
MOVEM.L D0-D3/D5/A0/A4-A6,-(SP) ; save registers
MOVE.L saveGammaPtr(A3),A0 ; get pointer to gamma data structure
MOVE.W gFormulaSize(A0),D0 ; get the size of formula data
LEA gFormulaData(A0),A4 ; point to formula data
ADD D0,A4 ; red correction table starts here
MOVE.L A4,A5 ; get default pointer to green data
MOVE.L A4,A6 ; get default pointer to blue data
CMP.W #1,gChanCnt(A0) ; if only only one table, we're set
BEQ.S @OneTbl ; => just one table
MOVE gDataWidth(A0),D1 ; get width of each entry in bits
ADDQ #7,D1 ; round to nearest byte
LSR #3,D1 ; get bytes per entry
MULU gDataCnt(A0),D1 ; get size of table in bytes
ADDA D1,A5 ; calc base of green
ADDA D1,A6 ; calc base…
ADDA D1,A6 ; …of blue
@OneTbl MOVE.W gDataCnt(A0),D2 ; Get number of entries.
Subq #1,D2 ; Make it zero based.
MOVEQ #true32b,D0 ; flip to 32-bit mode
_SwapMMUMode ;
MOVE.L saveVDACBase(A3),A0 ; point to the hardware
ADDA #ACDC_DataReg,A0 ; point to data register
CLR.L ACDC_AddrReg-ACDC_DataReg(A0) ; start at the beginning of CLUT
Move.w GFlags(A3),D5 ; Get the flags for quick access.
Btst #has16bppSRsrc,D5 ; If we have a 16bpp-capable sRsrc,
Bne.s @Chk16bpp ; then check for 16bpp.
Bra.s @Normbpp ; Otherwise, just do the normal stuff.
@Chk16bpp Move.w saveMode(A3),D1 ; Get the current mode.
Cmp.b #FifthVidMode,D1 ; If we’re not doing 16bpp,
Bne.s @Normbpp ; then go on.
Bset #UseTrans,D5 ; Remember to do 5-to-8 bit translation stuff.
Move.w #$1F,D2 ; There are only 32 entries to whack in 16bpp mode.
@Normbpp MOVE.W SR,-(SP) ; preserve the status register
BSR DAFBWaitVSync ; wait for next blanking period (preserves A0/D0)
; Write an incrementing grayscale ramp.
Moveq #0,D3 ; Init ramp start.
Moveq #0,D1 ; Init trans index (will be used as a long).
@Repeat Move.w D3,D1 ; Get the current ramp/index value.
Btst #UseTrans,D5 ; If we don’t need to translate this value,
Beq.s @Index ; then just go on.
Bsr DAFBTrans5to8 ; Otherwise, translate from 5-bits to 8.
Tst.b hasLin16BppCLUT(A3) ; If the CLUT/DAC itself doesn’t need translating,
Bne.s @Index ; then just go on.
Move.l D1,ACDC_AddrReg-ACDC_DataReg(A0) ; Otherwise, use the 5-to-8 index for the Clut address.
@Index MOVE.B (A4,D1),3(A0) ; Write gamma-corrected red,
MOVE.B (A5,D1),3(A0) ; green, and
MOVE.B (A6,D1),3(A0) ; blue.
ADDQ #1,D3 ; increment ramp/index value
DBRA D2,@Repeat ;
MOVE.W (SP)+,SR ; restore the status reg
_SwapMMUMode ;
MOVEM.L (SP)+,D0-D3/D5/A0/A4-A6 ; restore saved registers
RTS
;-------------------------------------------------------------
; The Interrupt handler for the DAFB Built-In Video
;-------------------------------------------------------------
; On entry A1 contains the pointer to the driver's private storage
DAFBBeginIH
Move.l A0,-(Sp) ; Save A0/D1 due to direct jump to SwapMMUMode.
Move.l D1,-(Sp) ; (Two Moves are faster than a Movem.)
Moveq #true32b,D0 ; Set up to swap into 32-bit mode.
Jsr ([jSwapMMU]) ; Do fast swap.
Move.b D0,-(Sp) ; Save the previous addressing mode.
Move.l saveDAFBBase(A1),A0 ; Point to the DAFB baseAddr.
@WaitForClr Clr.l Swatch_ClrCrsrInt(A0) ; Clear this interrupt.
Move.l Swatch_IntStat(A0),D0 ; Get its status.
Btst #dafbIntStatusBit,D0 ; If it’s not cleared yet,
Bne.s @WaitForClr ; then just spin.
Move.b (Sp)+,D0 ; Set up to swap back into previous addressing mode.
Jsr ([jSwapMMU]) ; Do fast swap.
Moveq #0,D0 ; Set up for Slot $0…
Jsr ([jVBLTask]) ; …and call the VBL Task Manager.
Moveq #1,D0 ; Signal that the interrupt was serviced
Move.l (Sp)+,D1 ; Restore A0/D1 registers.
Move.l (Sp)+,A0 ; (Two Moves are faster than a Movem.)
Rts ; Return to caller.
END
Reference in New Issue View Git Blame Copy Permalink