2666 lines
100 KiB
Plaintext
2666 lines
100 KiB
Plaintext
;
|
|
; File: SonoraDriver.a
|
|
;
|
|
; Contains: This file contains the video driver for use by the Macintosh
|
|
; OS for the Sonora hardware.
|
|
;
|
|
; Written by: Mike Puckett, December 3, 1991.
|
|
;
|
|
; Copyright: © 1991-1993 by Apple Computer, Inc. All rights reserved.
|
|
;
|
|
; Change History (most recent first):
|
|
;
|
|
; <SM20> 10/6/93 RC Added Dark Star Support by adding the Control call SetSync and
|
|
; the Status call GetSync
|
|
; <SM19> 09-23-93 jmp Made the SetDefaultMode call more Display Manager friendly.
|
|
; <SM18> 08-06-93 jmp Updated the GetConnection call to support all three types of
|
|
; multiscan display codes.
|
|
; <SM17> 08-03-93 jmp Began cleaning up the support for dynamically allocating RAM in
|
|
; PDM for video, as well as added initial support for the three
|
|
; new Apple multiscan displays.
|
|
; <16> 7/2/93 IH #1096920: Slot Manager not correctly updated in set resolution
|
|
; call. Added SUpdateSRT call.
|
|
; <15> 6/25/93 IH As per Mike's suggestion, make new Display Manager control and
|
|
; status calls clear only those fields that they use.
|
|
; <14> 6/22/93 IH Fix connection info status call.
|
|
; <SM13> 6/1/93 IH Update mode switch calls to VDSWitchInfo record and add more
|
|
; support for mode timings.
|
|
; <SM12> 5/28/93 IH Added VGA mode to MultiSync family.
|
|
; <SM11> 04-07-93 jmp Added initial low-level support for the Display Manager.
|
|
; <SM10> 04-01-93 jmp Fixed yet another bug in the GetEntries code.
|
|
; <SM9> 04-01-93 jmp Beefed-up the SetDefaultMode call to support the (hopefully)
|
|
; temporary interface to the RAM allocation on boot for video in
|
|
; PDM.
|
|
; <SM8> 3/9/93 jmp Fixed a couple of long-standing out-of-range bugs in
|
|
; Get/SetEntries, and now turn video blanking on when the video
|
|
; driver is closed.
|
|
; <SM7> 1/12/93 SAM Disabled VRAM cache flushing at every VBL on PDMs. Copyback
|
|
; VRAM just doesn't look good.
|
|
; <SM6> 11/6/92 jmp Added a little more PDM bring-up code.
|
|
; <SM5> 11/5/92 SWC Changed VideoEqu.a->Video.a and ShutdownEqu.a->Shutdown.a.
|
|
; <SM4> 11/2/92 kc Don't include SonicEqu.a.
|
|
; <SM3> 10-21-92 jmp Added code to effectively flush the copyback framebuffer for
|
|
; PDM.
|
|
; <SM2> 10-17-92 jmp Added temporary hack to support PDMÕs (broken) bring-up
|
|
; hardware.
|
|
; <SM1> 10/6/92 GDW New location for ROMLink tool.
|
|
; ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
|
|
; Pre-ROMLink comments begin here.
|
|
; ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
|
|
; <SM5> 09-29-92 jmp (jmp,H16) Fixed a problem in SetGamma where various randomly bad
|
|
; things could have occurred when going from a 3-to-1 or 1-to-3
|
|
; channel gamma tables (not something thatÕs done very often, but
|
|
; still...).
|
|
; <SM4> 09-03-92 jmp (jmp,H15) Corrected .s vs. non-.s branches and odd-alignment
|
|
; problems.
|
|
; <SM3> 6/18/92 KW (jmp,H14) Updated the Rubik 512<->560 routine to accomodate the
|
|
; Omega-2 parameters.
|
|
; <SM2> 6/4/92 KW (NJV,H13) Added new sndSonoraReverseDFAC equate in place of
|
|
; hard-coded value
|
|
; (jmp,H12) Fixed a problem where I wasnÕt always returning the
|
|
; correct frame buffer base address where I was supposed to.
|
|
; (NJV,H11) Temporarily using hard-coded $57 for DFAC Sound
|
|
; initialization to get rid of annoying playthrough.
|
|
; (NJV,H10) Fixed bug with DFAC setup for sound
|
|
; (jmp,H9) Added a small optimization to the interrupt handler.
|
|
; (JC,H8) Fix problem in Uncorrected Gamma in 16-bit mode.
|
|
; <SM1> 5/2/92 kc Roll in Horror. Comments follow:
|
|
; <H7> 04/24/92 jmp Added constants to support for the Òswitch-on-the-flyÓ Rubik-512
|
|
; to Rubik-560 and vice-versa call for DoubleExposure.
|
|
; <H6> 04/20/92 jmp In order to fully support family modes, changed the way I was
|
|
; dealing with the Rubik-560 mode in GrayScreen.
|
|
; <H5> 4/13/92 JC Replace references to SonoraAddr (it is going away) with
|
|
; references to VIA1Addr.
|
|
; <H4> 01/22/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.Ó
|
|
; <H3> 01/11/92 jmp Eliminated a BoxFlag dependency.
|
|
; <H2> 12/19/91 jmp Added the initial support for Rubik-560 mode for Sonora.
|
|
; <1> 12/12/91 jmp first checked in
|
|
|
|
STRING C
|
|
|
|
PRINT OFF
|
|
LOAD 'StandardEqu.d'
|
|
|
|
INCLUDE 'IOPrimitiveEqu.a'
|
|
|
|
INCLUDE 'HardwarePrivateEqu.a'
|
|
INCLUDE 'EgretEqu.a'
|
|
INCLUDE 'ROMEqu.a'
|
|
INCLUDE 'Video.a'
|
|
INCLUDE 'GestaltEqu.a'
|
|
INCLUDE 'SlotMgrEqu.a'
|
|
INCLUDE 'UniversalEqu.a'
|
|
|
|
INCLUDE 'DepVideoEqu.a'
|
|
PRINT ON
|
|
|
|
SEG '_sSonoraDriver'
|
|
|
|
BLANKS ON
|
|
STRING ASIS
|
|
MACHINE MC68020
|
|
|
|
; This is device storage which is stored in the dCtlStorage field of the AuxDCE.
|
|
|
|
SonoraVidPrivates RECORD 0
|
|
saveBaseAddr DS.L 1 ; the screen base address
|
|
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
|
|
saveVidPtr Ds.l 1 ; the pointer to the vidParams block
|
|
saveVDACBase DS.L 1 ; the base addr of the VDAC
|
|
saveSonoraBase Ds.l 1 ; the base addr of Sonora
|
|
GFlags DS.B 1 ; flags word (hi-order byte, actually)
|
|
noVRAM Ds.b 1 ; the no real VRAM flag
|
|
saveMode DS.W 1 ; the current mode setting
|
|
saveMonID DS.W 1 ; monitor type ID
|
|
saveSizeVRAM Ds.b 1 ; amount of vRAM/RAM
|
|
SonoraVidPrivSize EQU *
|
|
ENDR
|
|
|
|
LSonoraDriver MAIN EXPORT
|
|
;-------------------------------------------------------------------
|
|
; Video Driver Header
|
|
;-------------------------------------------------------------------
|
|
;
|
|
SonoraVidDrvr
|
|
DC.W $4C00 ; ctl,status,needsLock
|
|
DC.W 0,0,0 ; not an ornament
|
|
|
|
; Entry point offset table
|
|
|
|
DC.W SonoraVidOpen-SonoraVidDrvr ; open routine
|
|
DC.W SonoraVidDrvr-SonoraVidDrvr ; no prime in normal video drivers
|
|
DC.W SonoraVidCtl-SonoraVidDrvr ; control
|
|
DC.W SonoraVidStatus-SonoraVidDrvr ; status
|
|
DC.W SonoraVidClose-SonoraVidDrvr ; close
|
|
|
|
STRING Pascal
|
|
SonoraVidTitle
|
|
DC.B '.Display_Video_Apple_Sonora'
|
|
|
|
ALIGN 2 ; make sure we're aligned
|
|
DC.W CurSonoraDrvrVersion ; current version
|
|
|
|
STRING ASIS
|
|
|
|
;
|
|
; SonoraCLUTTbl contains information required to write to the CLUT in the different screen depths.
|
|
; Each depth's information has three values. The first is the number of entries-1 in this depth
|
|
; for range checking. The second is the address of the first active CLUT position for that
|
|
; screen depth. The last number is the ÒskipÓ factor. This is required because, in 1-4bpp, the
|
|
; entries are distributed throughout the CLUT address space. As a result, we use sequential CLUT mode
|
|
; ONLY in 8/16bpp modes. The skip factor is the address difference between adjacent active positions
|
|
; in each mode.
|
|
;
|
|
; Generally, these rules are true for any particular depth:
|
|
; #entries = (2^^depth)-1
|
|
; startposition = (256 / (2^^depth))-1
|
|
; skipfactor = 256 / (2^^depth)
|
|
|
|
SonoraCLUTTbl
|
|
DC.B $01,$7F,$00,$80 ; for one-bit mode
|
|
DC.B $03,$3F,$00,$40 ; for two-bit mode
|
|
DC.B $0F,$0F,$00,$10 ; for four-bit mode
|
|
DC.B $FF,$00,$00,$01 ; for eight-bit mode
|
|
DC.B $1F,$00,$00,$01 ; for sixteen-bit mode
|
|
|
|
SonoraCLUTRec RECORD 0 ;
|
|
scRange DS.B 1 ; maximum index value in this depth
|
|
scStart DS.B 1 ; lowest active CLUT address
|
|
scSkip DS.W 1 ; skip value between active addresses
|
|
SonoraCLUTSize Equ *
|
|
ENDR
|
|
|
|
;
|
|
; These are the bit patterns for grays in each depth
|
|
;
|
|
SonoraPats Dc.l OneBitGray,TwoBitGray,FourBitGray,EightBitGray,SixteenBitGray
|
|
|
|
;
|
|
; The following table is used by the SwitchMode call to determine two things. First,
|
|
; it must decide whether the requested mode to switch to is valid or not. If
|
|
; the requested mode is not in the SwitchTable, the call will fail. Also, even
|
|
; if the requested mode is in table, if the current bit depth is too large
|
|
; for the requested mode, SwitchMode must still fail.
|
|
;
|
|
|
|
SwitchTable
|
|
Dc.b sRsrc_Vid_Sonora_GSM, FifthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_MSB1, FifthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_MSB2, FourthVidMode
|
|
Dc.w -1
|
|
|
|
;
|
|
; The following tables are used to support the Get/SetAltSense codes. The first set of
|
|
; tables are pairs of codes and indices, terminated by a -1. Each of these tables
|
|
; is composed of a particular sense-code types (i.e., 3, 5, 6, and 7). The final
|
|
; table is also composed of pairs -- the first value is the sense-code type, and
|
|
; the corresponding second value is an offset to the sense-code index tables.
|
|
;
|
|
|
|
Type_0_MonIDs
|
|
Dc.b indexedSenseFP, indexedSenseFP
|
|
Dc.b indexedSenseRubik, indexedSenseRubik
|
|
Dc.b indexedSenseRGBFP, indexedSenseRGBFP
|
|
Dc.b indexedSenseHR, indexedSenseHR
|
|
Dc.b indexedNoConnect, indexedNoConnect
|
|
Dc.w -1
|
|
|
|
Type_6_MonIDs
|
|
Dc.b extendedMSB1, indexedSenseMSB1
|
|
Dc.b extendedMSB2, indexedSenseMSB2
|
|
Dc.b extendedMSB3, indexedSenseMSB3
|
|
Dc.w -1
|
|
|
|
Type_7_MonIDs
|
|
Dc.b extendedSenseVGA, indexedSenseVGA
|
|
Dc.b extendedSenseGF, indexedSenseGF
|
|
Dc.b extendedNoConnect, indexedNoConnect
|
|
Dc.w -1
|
|
|
|
MonIDsTbl Dc.w 0, Type_0_MonIDs-MonIDsTbl
|
|
Dc.w 3, 0
|
|
Dc.w 5, 0
|
|
Dc.w 6, Type_6_MonIDs-MonIDsTbl
|
|
Dc.w 7, Type_7_MonIDs-MonIDsTbl
|
|
Dc.w -1
|
|
|
|
;
|
|
; Unlike the SwitchTable above, the DepthTable tells SetDefaultMode what to write in the SP_Depth
|
|
; field of sPRAM. If the depth value is zero, SetDefaultMode is just supposed to leave
|
|
; the SP_Depth field alone. If the depth values is negative one, then SetDefaultMode is
|
|
; supposed to check to see if the current mode is valid or not.
|
|
;
|
|
|
|
DepthTable
|
|
Dc.b sRsrc_Vid_Sonora_FP, FirstVidMode
|
|
Dc.b sRsrc_Vid_Sonora_FPc, FourthVidMode
|
|
|
|
Dc.b sRsrc_Vid_Sonora_GS, FirstVidMode
|
|
Dc.b sRsrc_Vid_Sonora_GSa, FourthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_GSb, FifthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_GSM, 0
|
|
|
|
Dc.b sRsrc_Vid_Sonora_RGBFP, FirstVidMode
|
|
Dc.b sRsrc_Vid_Sonora_RGBFPc, FourthVidMode
|
|
|
|
Dc.b sRsrc_Vid_Sonora_HR, FirstVidMode
|
|
Dc.b sRsrc_Vid_Sonora_HRb, FourthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_HRc, FifthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_MSB1, 0
|
|
|
|
Dc.b sRsrc_Vid_Sonora_VGA, FirstVidMode
|
|
Dc.b sRsrc_Vid_Sonora_VGAb, FourthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_VGAc, FifthVidMode
|
|
|
|
Dc.b sRsrc_Vid_Sonora_GF, FirstVidMode
|
|
Dc.b sRsrc_Vid_Sonora_GFb, FourthVidMode
|
|
Dc.b sRsrc_Vid_Sonora_MSB2, -1
|
|
|
|
Dc.w -1
|
|
|
|
**********************************************************************
|
|
*
|
|
* VidOpen allocates private storage for the device in the AuxDCE and locks
|
|
* it down for perpetuity. Also, it installs the interrupt handler and enables
|
|
* the (VBL) interrupts.
|
|
*
|
|
* Entry: A0 = param block pointer
|
|
* A1 = AuxDCE pointer
|
|
*
|
|
* Locals: A3 = pointer to private storage
|
|
*
|
|
* A4/D2/D3 used as scratch
|
|
*
|
|
**********************************************************************
|
|
|
|
WITH VDPageInfo,SlotIntQElement,SonoraVidPrivates
|
|
SonoraVidOpen
|
|
;
|
|
; Allocate private storage (since block is CLEAR, GFlags are zeroed) and get
|
|
; a pointer to it in A3
|
|
;
|
|
|
|
MOVEQ #SonoraVidPrivSize,D0 ; get size of parameters
|
|
_ResrvMem ,SYS ; make room as low as possible
|
|
MOVEQ #SonoraVidPrivSize,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, Sonora, and framebuffer base addresses since they're non-trivial to
|
|
; look up.
|
|
;
|
|
WITH ProductInfo,DecoderInfo,VideoInfo
|
|
|
|
MOVE.L UnivInfoPtr,A0 ; get a pointer to universal data
|
|
ADDA.L DecoderInfoPtr(A0),A0 ; point to the base address table
|
|
MOVE.L VDACAddr(A0),saveVDACBase(A3) ; save VDACÕs base address
|
|
Move.l VIA1Addr(A0),saveSonoraBase(A3) ; save SonoraÕs base address (same as VIA1)<H5>
|
|
|
|
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 the 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.
|
|
|
|
; If the video driver was closed, letÕs ensure that video is unblanked before we
|
|
; re-enable interrupts.
|
|
;
|
|
Movea.l saveSonoraBase(A3),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVdCtlBase,A0 ; Point to the video control register space.
|
|
Bclr #SonoraVidBlnkBit,SonoraVdModeReg(A0) ; Turn off video blanking.
|
|
|
|
BSR SonoraEnableVGuts ; do it
|
|
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 #drHwSonora,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.
|
|
;
|
|
|
|
@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.s @OpError4 ; If failed, quit.
|
|
|
|
MOVE.B dCtlSlotId(A1),spID(A0) ; look in the directory for this config's parameters
|
|
_sGetBlock ; Try to load it.
|
|
Bne.s @OpError4 ; If failed, quit.
|
|
|
|
MOVE.L spResult(A0),saveVidPtr(A3) ; get pointer to it
|
|
;
|
|
; 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.s @OpError5 ; If failed quit.
|
|
|
|
Moveq #0,D2 ; Clear D2.w.
|
|
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 D2,saveMonID(A3) ; Save the monID for later.
|
|
Btst #spNoVRAM,D1 ; Test for real VRAM or not.
|
|
Sne noVRAM(A3) ; Remeber it for later.
|
|
Bfextu D1{spVRamBits:numSPVRamBits},D1 ; Extract the vRAM/RAM size from the flags byteÉ
|
|
Move.b D1,saveSizeVRAM(A3) ; É and save it for later.
|
|
|
|
;
|
|
; 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.
|
|
Bra.s @ChkRubik560 ; Otherwise, skip.
|
|
|
|
@SetMonoFlags Bset #IsMono,GFlags(A3) ; Turn on the IsMono and
|
|
Bset #GrayFlag,GFlags(A3) ; GrayFlag flags.
|
|
|
|
;
|
|
; Set GFlags to reflect whether we started up in Rubik-560 mode or not.
|
|
;
|
|
@ChkRubik560
|
|
Cmp.b #sRsrc_Vid_Sonora_GS560a,dCtlSlotId(A1) ; If weÕre in Rubik-560a mode,
|
|
Beq.s @SetRubik560 ; then say so.
|
|
Cmp.b #sRsrc_Vid_Sonora_GS560b,dCtlSlotId(A1) ; If weÕre not in Rubik-560b mode,
|
|
Bne.s @AllDone ; then just go on.
|
|
|
|
@SetRubik560 Bset #InRubik560Mode,GFlags(A3) ; Remember that we started up in Rubik-560 mode.
|
|
|
|
;
|
|
; All done!
|
|
;
|
|
|
|
@AllDone MOVEQ #noErr,D0 ; no error
|
|
@EndOpen RTS ; return
|
|
|
|
@OpError5 Adda #sizeSPRamRec,Sp ; Release the SPRam block.
|
|
@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 11 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);
|
|
* ($0A) SwitchMode(csMode, csData, csPage, csBaseAddr);
|
|
*
|
|
* The following calls are Sonora-specific:
|
|
*
|
|
* ($81) SetRubik560Mode (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É
|
|
;
|
|
SonoraVidCtl
|
|
|
|
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 #cscRubik560,D0 ; If we got the Rubik560 mode call,
|
|
Beq SonoraSetRubik560Mode ; hop to it.
|
|
|
|
Cmp.w #cscAltSense,D0 ; If we got the alternate senseID call,
|
|
Beq SonoraSetAltSense ; hop to it.
|
|
|
|
CMP.W #$0B,D0 ; IF csCode NOT IN [0..$0A] THEN ; <sm20>
|
|
BHI.S SonoraCtlBad ; Error, csCode out of bounds.
|
|
MOVE.W SonoraCtlJumpTbl(PC,D0.W*2),D0 ; Get the relative offset to the routine.
|
|
JMP SonoraCtlJumpTbl(PC,D0.W) ; GOTO the proper routine.
|
|
|
|
SonoraCtlJumpTbl
|
|
DC.W SonoraVidReset-SonoraCtlJumpTbl ; $00 => VidReset
|
|
DC.W SonoraCtlGood-SonoraCtlJumpTbl ; $01 => CtlGood (no async routines here)
|
|
DC.W SonoraSetVidMode-SonoraCtlJumpTbl ; $02 => SetVidMode
|
|
DC.W SonoraSetEntries-SonoraCtlJumpTbl ; $03 => SetEntries
|
|
DC.W SonoraSetGamma-SonoraCtlJumpTbl ; $04 => SetGamma
|
|
DC.W SonoraGrayPage-SonoraCtlJumpTbl ; $05 => GrayPage
|
|
DC.W SonoraSetGray-SonoraCtlJumpTbl ; $06 => SetGray
|
|
DC.W SonoraSetInterrupt-SonoraCtlJumpTbl ; $07 => SetInterrupt
|
|
DC.W SonoraDirectSetEntries-SonoraCtlJumpTbl ; $08 => DirectSetEntries
|
|
DC.W SonoraSetDefaultMode-SonoraCtlJumpTbl ; $09 => SetDefaultMode
|
|
DC.W SonoraSwitchMode-SonoraCtlJumpTbl ; $0A => SwitchMode
|
|
DC.W SonoraSetSync-SonoraCtlJumpTbl ; $0B => SetSync ; <sm20>
|
|
|
|
SonoraCtlBad MOVEQ #controlErr,D0 ; else say we don't do this one
|
|
BRA.S SonoraCtlDone ; and return
|
|
|
|
SonoraCtlGood MOVEQ #noErr,D0 ; return no error
|
|
|
|
SonoraCtlDone MOVEM.L (SP)+,A0/A1 ; Restore Exit registers.
|
|
BRA SonoraExitDrvr
|
|
|
|
SonoraVidReset
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Reset the card to its default
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
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 SonoraSetDepth ; set the depth from D1
|
|
BCLR #IsDirect,GFlags(A3) ; turn off direct mode bit
|
|
Move.l saveBaseAddr(A3),csBaseAddr(A2) ; return the base address
|
|
BSR SonoraGrayScreen ; paint the screen gray
|
|
BRA.S SonoraCtlGood ; => no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraSetVidMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates
|
|
|
|
MOVE.W csMode(A2),D1 ; D1 = mode
|
|
BSR SonoraChkMode ; check mode and convert
|
|
BNE.S SonoraCtlBad ; => not a valid mode
|
|
|
|
TST.W csPage(A2) ; only page zero is valid
|
|
BNE.S SonoraCtlBad ; => not a valid page
|
|
|
|
; Only set if mode has changed.
|
|
|
|
SonoraSetVidModeGuts
|
|
|
|
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,-(Sp) ; Save gamma-table 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.
|
|
|
|
MOVE.L saveVDACBase(A3),A0 ; get the VDAC base addr
|
|
ADDA #ArielDataReg,A0 ; point to data register
|
|
CLR.B ArielAddrReg-ArielDataReg(A0) ; start at the beginning of CLUT
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
BSR SonoraWaitVSync ; wait for next blanking period (preserves A0)
|
|
|
|
; Write out gamma-corrected true-gray CLUTÉ
|
|
;
|
|
Move.w D3,D0 ; Init loop counter.
|
|
Subq #1,D0 ; Zero base it.
|
|
|
|
Move.w GFlags(A3),D2 ; Get the GFlags into a convenient register.
|
|
Lsr.w #1,D3 ; Get midpoint of table(s).
|
|
|
|
@Repeat Btst #IsMono,D2 ; If this is not a mono-only display
|
|
Beq.s @DoRGB ; then 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
|
|
|
|
MOVE (SP)+,SR ; restore the status reg
|
|
|
|
Movem.l (Sp)+,A4-A6 ; Restore gamma-table registers.
|
|
BSR SonoraSetDepth ; set the depth from D1
|
|
|
|
; Finish up the bookkeeping.
|
|
|
|
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 Move.l saveBaseAddr(A3),csBaseAddr(A2) ; return the base addr
|
|
BRA SonoraCtlGood ; return no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraSetEntries
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates,SonoraCLUTRec
|
|
|
|
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
|
|
BNE SonoraCtlBad ; error if so
|
|
|
|
SonoraSEGuts
|
|
TST.L csTable(A2) ; Check for a nil pointer
|
|
BEQ SonoraCtlBad ;
|
|
|
|
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 #PsuedoIndex,D5 ; turn on the bit that denotes a seq write that was xlated to indexed
|
|
Cmp.w #FourthVidMode,saveMode(A3) ; If itÕs not 8bbp or 16bpp,
|
|
Blt.s @SkipSeq ; need to use ÒindexedÓ.
|
|
BSET #UseSeq,D5 ; otherwise, 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 a index
|
|
|
|
Moveq #0,D4 ; clear all of D4 for .w compare.
|
|
Lea SonoraCLUTTbl,A0 ; Point to the table of CLUT data.
|
|
Lea (A0,D1*SonoraCLUTSize),A0 ; Point to the right entry.
|
|
Move.b scRange(A0),D4 ; Get the range.
|
|
|
|
;
|
|
; 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),D3 ; Get the number of entries to change,
|
|
Bmi SonoraSEBadExit ; and hike if itÕs out of range.
|
|
Cmp.w D4,D3 ; If D3-D4 > 0 (count - range > 0),
|
|
Bhi SonoraSEBadExit ; then hike.
|
|
Tst.w csStart(A2) ; If weÕre doing indexed entries (-1),
|
|
Bmi.s @skipStartChk ; then just go on.
|
|
Add.w csStart(A2),D3 ; Adjust count for starting position.
|
|
Cmp.w D4,D3 ; If D3-D4 > 0 (count - range > 0),
|
|
Bhi SonoraSEBadExit ; then hike.
|
|
Move.w csCount(A2),D3 ; Otherwise, re-get the count.
|
|
|
|
@skipStartChk
|
|
|
|
Move.w D3,D4 ; Make a copy of the table size (zero-based).
|
|
Addq #1,D4 ; Make it a counting number.
|
|
Btst #UseSeq,D5 ; If weÕre not in sequential mode,
|
|
Beq.s @IsIndex ; then do the indexed stuff.
|
|
Mulu #3,D4 ; Make room for just R,G,B in sequential mode.
|
|
Bra.s @AllocIt ; And continue.
|
|
@IsIndex Asl.w #2,D4 ; Make room for i,R,G,B in indexed mode.
|
|
@AllocIt Sub.w D4,Sp ; Allocate the table on the stack.
|
|
|
|
;
|
|
; 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).
|
|
;
|
|
|
|
Move.l A3,D6 ; WeÕre about to torch A3, so save it for later.
|
|
Move.l A0,A3 ; Save the CLUT table entry pointer.
|
|
|
|
MOVE.L SP,A0 ; copy the stack buffer pointer
|
|
MOVE.L csTable(A2),A1 ; get colorSpec pointer into A1
|
|
|
|
; Death! Totally out of registers in this routine, so I'm using the top half of D4 (the temp buffer
|
|
; size) as the sequence counter used in most video modes to translate sequential requests into
|
|
; the indexed write that the hardware needs.
|
|
|
|
SWAP D4 ; flip the buffer size to the top half
|
|
MOVE.W csStart(A2),D4 ; pick up the sequential start position. It might
|
|
; be -1 on a true indexed write, but we won't
|
|
; use it below if it is.
|
|
;
|
|
; Write the index if in indexed mode. If in sequential (8/16) mode, blow it off completely,
|
|
; since it won't be needed.
|
|
|
|
@SetupLoop
|
|
MOVE.W (A1)+,D0 ; get index
|
|
|
|
BTST #UseSeq,D5 ; is it sequence mode?
|
|
BNE.S @SLSeq ; yup, so go there
|
|
|
|
Btst #PsuedoIndex,D5 ; If we are doing an ÒindexedÓ mode,
|
|
Beq.s @IndexPresent ; then go there now.
|
|
|
|
; This case is a sequential request in a screen depth that does not allow sequential CLUT writes
|
|
; (any non-8/16 bit mode). In this case, we substitute the sequence counter for D0 on each
|
|
; entry.
|
|
|
|
Move.w D4,D0 ; Copy the sequence counter to D0.
|
|
Addq #1,D4 ; Increment it.
|
|
|
|
@IndexPresent Mulu.w scSkip(A3),D0 ; Calculate the new position at this depth.
|
|
Add.b scStart(A3),D0 ; Add in the first entry offset.
|
|
Move.b D0,(A0)+ ; Write out this index.
|
|
|
|
@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,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
|
|
|
|
Swap D4 ; Put the temp buffer size back in the lo-half.
|
|
|
|
;
|
|
; OK, the stack table is set up. Now let's load the hardware.
|
|
;
|
|
Move.l D6,A3 ; Get our privates pointer back into A3 (for WaitVSync).
|
|
Move.w Sr,-(SP) ; Preserve the status register.
|
|
BSR SonoraWaitVSync ; Wait for next blanking period (preserves A0/D0).
|
|
|
|
MOVE.W csCount(A2),D3 ; get the count again
|
|
MOVE.L saveVDACBase(A3),A3 ; get the VDAC base
|
|
LEA ArielDataReg(A3),A3 ; point to VDAC data register
|
|
|
|
LEA 2(SP),A0 ; point to the stack buffer again
|
|
|
|
BTST #UseSeq,D5 ; is it sequence mode?
|
|
BNE.S SonoraSeqWrite ; yup, sequence mode, so go there
|
|
|
|
;
|
|
; Here's the loop that actually writes to the hardware when in indexed mode.
|
|
;
|
|
|
|
SonoraIndexWrite
|
|
MOVE.B (A0)+,ArielAddrReg-ArielDataReg(A3) ; write the index value to the CLUT address
|
|
MOVE.B (A0)+,(A3) ; write red
|
|
MOVE.B (A0)+,(A3) ; write green
|
|
MOVE.B (A0)+,(A3) ; write blue
|
|
DBRA D3,SonoraIndexWrite ; and loop
|
|
BRA.S SonoraSEDone ;
|
|
|
|
;
|
|
; Write the translated starting position for sequence mode.
|
|
;
|
|
|
|
SonoraSeqWrite
|
|
MOVE.W csStart(A2),D0 ; get sequence start address
|
|
MOVE.B D0,ArielAddrReg-ArielDataReg(A3) ; write the sequence start position
|
|
|
|
;
|
|
; Here's the loop that actually writes to the hardware when in sequence mode.
|
|
;
|
|
|
|
@SeqLoop
|
|
MOVE.B (A0)+,(A3) ; write red
|
|
MOVE.B (A0)+,(A3) ; write green
|
|
MOVE.B (A0)+,(A3) ; write blue
|
|
DBRA D3,@SeqLoop ; and loop
|
|
|
|
;
|
|
; Clean up and go home.
|
|
;
|
|
|
|
SonoraSEDone
|
|
MOVE.W (SP)+,SR ; restore status register
|
|
|
|
ADD.W D4,SP ; release stack buffer
|
|
MOVEM.L (SP)+,A1/A4-A6/D4-D7 ; restore registers
|
|
BRA SonoraCtlGood ; return O-Tay!
|
|
|
|
SonoraSEBadExit
|
|
MOVEM.L (SP)+,A1/A4-A6/D4-D7 ; restore registers
|
|
BRA SonoraCtlBad ; return an error code
|
|
|
|
ENDWITH
|
|
|
|
SonoraSetGamma
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates
|
|
|
|
; 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 SonoraCtlBad ; => no, return error
|
|
Tst.w gType(A2) ; Test the hardwareID.
|
|
Beq.s @ChangeTable ; If 0, then accept a TFB-style gamma table.
|
|
CMP.W #drHwSonora,gType(A2) ; type = Sonora?
|
|
BNE SonoraCtlBad ; => no, return error
|
|
TST.W gFormulaSize(A2) ; if gType=Sonora, 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 SonoraCtlBad ; 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 SonoraCtlBad ; => 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 SonoraDirectCLUTSet ; if so, then set up direct CLUT ramps
|
|
|
|
@Out
|
|
BRA SonoraCtlGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraGrayPage
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates
|
|
|
|
MOVE saveMode(A3),D1 ; D1 = mode
|
|
BSR SonoraChkMode ; convert mode to depth in D1
|
|
BNE SonoraCtlBad ; => not a valid depth
|
|
|
|
MOVE csPage(A2),D0 ; D0 = page
|
|
BNE SonoraCtlBad ; => not a valid page
|
|
|
|
BSR SonoraGrayScreen ; paint the screen gray
|
|
|
|
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
|
|
BEQ.S @Out ; if not, then we're done
|
|
BSR SonoraDirectCLUTSet ; if so, then set up direct CLUT ramps
|
|
@Out
|
|
BRA SonoraCtlGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraSetGray
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates
|
|
|
|
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 SonoraSetIntCom ; call common code
|
|
BRA SonoraCtlGood ; 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.
|
|
;
|
|
|
|
SonoraSetIntCom
|
|
MOVE.B csMode(A2),D0 ; get boolean
|
|
BFINS D0,GFlags(A3){D1:1} ; set flag bit
|
|
RTS ; and return
|
|
|
|
ENDWITH
|
|
|
|
SonoraSetInterrupt
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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,SonoraVidPrivates
|
|
|
|
MOVEQ #1,D1 ; set up for BFEXTU to point to IntDisFlag
|
|
BSR.S SonoraSetIntCom ; call common code
|
|
BNE.S @DisableThem ; if zero, then enable
|
|
|
|
; This code enables interrupts and installs the interrupt handler.
|
|
;
|
|
BSR.S SonoraEnableVGuts ; call common code
|
|
BNE SonoraCtlBad ; error, flag problem
|
|
BRA SonoraCtlGood ; and go home
|
|
|
|
; This code disables VBL interrupts, then removes the interrupt handler.
|
|
;
|
|
@DisableThem
|
|
BSR.S SonoraDisableVGuts ; jump to the disabling utility
|
|
BRA SonoraCtlGood ; all done
|
|
|
|
; The following two routines are common code shared between the Open/Close calls
|
|
; and the SetInterrupt control call.
|
|
;
|
|
SonoraDisableVGuts
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
BSR SonoraWaitVSync ; to be safe, wait for the next VBL
|
|
|
|
Move.l saveSonoraBase(A3),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVIA2Base,A0 ; Point to the interrupt register space.
|
|
Move.b #$40,SonoraSlotIER(A0) ; Disable Slot $0 interrupts.
|
|
MOVE (SP)+,SR ; re-enable cursor interrupts
|
|
|
|
CLR D0 ; setup slot # for _SIntRemove (slot zero!)
|
|
MOVE.L saveSQElPtr(A3),A0 ; get the SQ element pointer
|
|
_SIntRemove ; remove the interrupt handler
|
|
RTS
|
|
|
|
SonoraEnableVGuts
|
|
|
|
MOVE.L saveSQElPtr(A3),A0 ; get the queue element
|
|
LEA SonoraBeginIH,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
|
|
|
|
Move.l A0,-(Sp) ; Save the queue element pointer.
|
|
Move.l saveSonoraBase(A3),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVIA2Base,A0 ; Point to the interrupt register space.
|
|
Move.b #$C0,SonoraSlotIER(A0) ; Enable Slot $0 interrupts.
|
|
Move.l (Sp)+,A0 ; Restore the queue elemetn pointer.
|
|
|
|
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
|
|
|
|
SonoraDirectSetEntries
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraCtlBad ; error if not
|
|
BRA SonoraSEGuts ; jump to SetEntries internals if it's OK
|
|
|
|
SonoraSetDefaultMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Write the card default mode into slot pRAM.
|
|
;
|
|
; A1 = Ptr to AuxDCE (but trashed on exit)
|
|
; 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,SonoraVidPrivates,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 @BadExit ; If failed, quit.
|
|
|
|
Move.w spCategory(A0),D0 ; Get the category.
|
|
Cmp.w #catDisplay,D0 ; If itÕs not catDisplay,
|
|
Bne @BadExit ; then quit.
|
|
Move.w spCType(A0),D0 ; Get the type.
|
|
Cmp.w #typVideo,D0 ; If itÕs not typVideo,
|
|
Bne @BadExit ; then quit.
|
|
Move.w spDrvrSw(A0),D0 ; Get the software kind.
|
|
Cmp.w #drSwApple,D0 ; If itÕs not drSwApple,
|
|
Bne @BadExit ; then quit.
|
|
Move.w spDrvrHw(A0),D0 ; Get the hardware ID.
|
|
Cmp.w #drHwSonora,D0 ; If itÕs not drHwSonora,
|
|
Bne @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.
|
|
;
|
|
Move.b csMode(A2),D1 ; Copy the desired family mode.
|
|
Cmp.b SP_LastConfig(Sp),D1 ; If weÕre already going to this mode,
|
|
Beq.s @GoodExit ; then just go on.
|
|
|
|
Movea.l A0,A1 ; Save the SpBlockPtr.
|
|
Tst.b noVRAM(A3) ; If we have real VRAM, then
|
|
Beq.s @WriteIt ; just go on.
|
|
|
|
Move.l #gestaltDisplayMgrAttr,D0 ; We need to know if the Display Manager is around.
|
|
_Gestalt ; Ask, and ye shall receive.
|
|
Bne.s @NoDM ; Oops, got an error.
|
|
Move.l A0,D0 ; Get the result into D0.
|
|
Btst #gestaltDisplayMgrPresent,D0 ; If the Display Manager is not around,
|
|
Beq.s @NoDM ; then do the non-dynamic stuff.
|
|
Cmpi.w #indexedSenseMSB1,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @WriteIt ; then skip the non-dynamic stuff.
|
|
Cmpi.w #indexedSenseMSB2,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @WriteIt ; then skip the non-dynamic stuff.
|
|
Cmpi.w #indexedSenseMSB3,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @WriteIt ; then skip the non-dynamic stuff.
|
|
|
|
@NoDM Bset #spFamilyChanged,SP_Flags(Sp) ; Say that weÕre changing the mode.
|
|
Lea DepthTable,A1 ; Point to table of depths.
|
|
@DepthLoop Move.b (A1)+,D0 ; Get the next sRsrcID.
|
|
Cmpi.b #-1,D0 ; If weÕre at the end of the table,
|
|
Beq.s @WriteIt ; then just go on.
|
|
Move.b (A1)+,D2 ; Save the depth.
|
|
Cmp.b D0,D1 ; Otherwise, if the sRsrcIDs donÕt match,
|
|
Bne.s @DepthLoop ; then keep looping.
|
|
Tst.b D2 ; If the depth byte is zero,
|
|
Beq.s @WriteIt ; then just leave things alone.
|
|
Cmpi.b #-1,D2 ; If the depth byte is negative one,
|
|
Beq.s @ChkDepth ; then check the current depth.
|
|
Move.b D2,SP_Depth(Sp) ; Otherwise, write it out.
|
|
Bra.s @WriteIt
|
|
|
|
@ChkDepth Cmpi.b #FifthVidMode,SP_Depth(Sp) ; If were not set for 16bpp mode,
|
|
Bne.s @WriteIt ; then just go on.
|
|
Move.b #FourthVidMode,SP_Depth(Sp) ; Otherwise, say we want 8bpp instead.
|
|
|
|
@WriteIt Movea.l A1,A0 ; Restore the SpBlockPtr.
|
|
MOVE.B D1,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 SonoraCtlGood ; return good result.
|
|
|
|
@BadExit Adda #SizesPRAMRec+spBlockSize,SP ; Deallocate buffer and
|
|
Bra SonoraCtlBad ; return bad result.
|
|
|
|
ENDWITH
|
|
|
|
SonoraSwitchMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; When driving a multiscan-capable display, this routine allows
|
|
; the various modes to swapped out both from a low-level software
|
|
; (i.e., Driver & Slot Manager) and hardware point of view.
|
|
;
|
|
; A1 = Ptr to AuxDCE
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraVidPrivates,SpBlock,VDPageInfo
|
|
|
|
; Check to see if we even need to be here or notÉ
|
|
;
|
|
Cmpi.w #indexedSenseMSB1,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB2,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB3,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Bra SonoraCtlBad ; Otherwise, just go away.
|
|
@EndMSChk
|
|
|
|
; Check to see if we can even do what was requestedÉ
|
|
;
|
|
Tst.w csPage(A2) ; If requested page is not zero,
|
|
Bne.s SonoraCtlBad ; then we canÕt help Õem.
|
|
|
|
Move.l csData(A2),D2 ; Get the requested SpID.
|
|
Moveq #0,D0 ; Clear hi-half of mode/depth register.
|
|
Lea SwitchTable,A0 ; Point to the SwitchMode table.
|
|
@ChkLoop Move.b (A0)+,D1 ; Get the next sRsrcID.
|
|
Cmpi.b #-1,D1 ; If weÕre at the end of the table,
|
|
Beq SonoraCtlBad ; then somethingÕs wrong.
|
|
Move.b (A0)+,D0 ; Get the max mode for this config.
|
|
Cmp.b D1,D2 ; If this is not the requested mode,
|
|
Bne.s @ChkLoop ; then keep looping.
|
|
|
|
; Make sure the new depth is okay for switchingÉ
|
|
;
|
|
Move.w csMode(A2),D1 ; Get the requested mode (depth).
|
|
Subi.w #FirstVidMode,D1 ; Make it indexed.
|
|
Subi.w #FirstVidMode,D0 ; Make the new max mode indexed.
|
|
Cmp.w D0,D1 ; If the current mode is > new max mode,
|
|
Bgt SonoraCtlBad ; then punt.
|
|
Move.w D1,D0 ; Save the indexed mode.
|
|
|
|
; Switch to the new resolutionÉ
|
|
;
|
|
Cmp.b dCtlSlotID(A1),D2 ; If weÕre already in the requested resolution,
|
|
Beq SonoraSetVidModeGuts ; then go try the depth switch.
|
|
|
|
Move.b D2,D1 ; Set up to do the resolution switch.
|
|
Bsr SonoraSetResolution ; Switch to the new resolution.
|
|
Move.w D0,D1 ; Set up to do the depth switch.
|
|
Bra SonoraSetVidModeGuts ; Switch to the new depth.
|
|
|
|
Endwith
|
|
|
|
SonoraSetSync ; <sm20>
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Enable (csMode = 0) or disable (csMode = 1) the DB15 Sync
|
|
;
|
|
; This routine will disable the sync lines going to the DB15 connector
|
|
; so that "green-aware" monitors can go into power-saving mode. If we
|
|
; are not driving a monitor out of that port, it will return an error.
|
|
;
|
|
; Note: It might be that in the future, there will be several levels of
|
|
; power-saving; Dropping CSYNC- will be one, HSYNC-, another, and
|
|
; both syncs another. Since Civic can only drop both, I will ignore
|
|
; a second undefined parameter.
|
|
;
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
WITH SonoraVidPrivates ; <sm20>
|
|
; <sm20>
|
|
movea.l saveSonoraBase(a3),a0 ; Get Sonora Base (VIA1 base $50f00000) ; <sm20>
|
|
adda.l #SonoraVdCtlBase,a0 ; add the difference to get Vid Reg ($28000) ; <sm20>
|
|
Move.b SonoraVdModeReg(A0),D0 ; Get the appropriate monitor code. ; <sm20>
|
|
; <sm20>
|
|
Bset #SonoraVidBlnkBit,D0 ; Set up for SonoraWrite ; <sm20>
|
|
MOVE.b csMode(A2),D1 ; get the mode ; <sm20>
|
|
Bne.s @WriteToSyncs ; To disable, write a 1 to SonoraSyncEnable ; <sm20>
|
|
Bclr #SonoraVidBlnkBit,D0 ; else, write a 0 to enable ; <sm20>
|
|
@WriteToSyncs ; <sm20>
|
|
Move.b D0,SonoraVdModeReg(A0) ; And disable or enable the sycns ; <sm20>
|
|
; <sm20>
|
|
BRA SonoraStatGood ; => return no error ; <sm20>
|
|
; <sm20>
|
|
ENDWITH ; <sm20>
|
|
|
|
|
|
SonoraSetRubik560Mode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Enable (csMode = 0) or disable (csMode = non-zero) Rubik-560 mode.
|
|
;
|
|
; Note: ÒEnableÓ means Òswitch from 512 to 560Ó if youÕre
|
|
; not already in 560 mode, and ÒdisableÓ means Òswitch
|
|
; from Ò560 to 512Ó if youÕre not already in 512 mode.
|
|
;
|
|
; Also, note that this call will do nothing if we
|
|
; were Òstarted upÓ in 560 mode.
|
|
;
|
|
; Finally, this call only switches the Slot Manager,
|
|
; video driver, and hardware data and data structures.
|
|
; It is up to the calling application to inform the
|
|
; graphics environment (e.g., QuickDraw) that things
|
|
; have changed.
|
|
;
|
|
; A1 = Ptr to AuxDCE
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraVidPrivates,SpBlock
|
|
|
|
; Check to see if we even need to be here or notÉ
|
|
;
|
|
Btst #InRubik560Mode,GFlags(A3) ; If we Òstarted upÓ in Rubik-560 mode,
|
|
Bne SonoraCtlGood ; then thereÕs nothing to do here.
|
|
|
|
; Check to see if we can even do what was requestedÉ
|
|
;
|
|
Tst.b csMode(A2) ; If weÕre supposed to be ÒenablingÓ 560 mode,
|
|
Beq.s @Chk512 ; check to see if weÕre in 512 mode.
|
|
|
|
Cmp.b #sRsrc_Vid_Sonora_GS560a,dCtlSlotID(A1) ; If weÕre in 560a mode then,
|
|
Beq.s @Setup512a ; set up to switch back to 512a mode.
|
|
Cmp.b #sRsrc_Vid_Sonora_GS560b,dCtlSlotID(A1) ; If weÕre in 560b mode then,
|
|
Beq.s @Setup512b ; set up to switch back to 512b mode.
|
|
Bra SonoraCtlBad ; Otherwise, weÕre not supposed to be here!
|
|
|
|
@Chk512 Cmp.b #sRsrc_Vid_Sonora_GSa,dCtlSlotId(A1) ; If weÕre in 512a mode then,
|
|
Beq.s @Setup560a ; set up to switch to 560a mode.
|
|
Cmp.b #sRsrc_Vid_Sonora_GSb,dCtlSlotId(A1) ; If weÕre in 512b mode then,
|
|
Beq.s @Setup560b ; set up to switch to 560b mode.
|
|
Bra SonoraCtlBad ; Otherwise, weÕre not supposed to here!
|
|
|
|
; Do the required switchÉ
|
|
;
|
|
@Setup512a Move.b #sRsrc_Vid_Sonora_GSa,D1 ; Set up for 512a mode.
|
|
Bra.s @DoIt
|
|
@Setup512b Move.b #sRsrc_Vid_Sonora_GSb,D1 ; Set up for 512b mode.
|
|
Bra.s @DoIt
|
|
@Setup560a Move.b #sRsrc_Vid_Sonora_GS560a,D1 ; Set up for 560a mode.
|
|
Bra.s @DoIt
|
|
@Setup560b Move.b #sRsrc_Vid_Sonora_GS560b,D1 ; Set up for 560b mode.
|
|
|
|
@DoIt Bsr SonoraSetResolution ; Switch to the desired mode.
|
|
Bra SonoraCtlGood ; Return good result.
|
|
|
|
Endwith
|
|
|
|
SonoraSetAltSense
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 MonIDs table (not restored)
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SpBlock,SonoraVidPrivates,SP_Params
|
|
|
|
;
|
|
; First, set up a slot parameter block on the stack.
|
|
;
|
|
|
|
Suba.w #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.w #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É
|
|
;
|
|
|
|
Moveq #0,D0 ; Clear D0 for good measure.
|
|
Move.b csMode+1(A2),D0 ; Get the sense-code type.
|
|
Lea MonIDsTbl,A1 ; Point to the MonIDs table.
|
|
|
|
@TypeLoop Cmp.w (A1)+,D0 ; If weÕve come to the end of the table,
|
|
Bmi.s @MonIDNotValid ; then leave with an error.
|
|
Beq.s @ChkOffset ; If weÕve found a match, then check it.
|
|
Tst.w (A1)+ ; Otherwise, skip the offset.
|
|
Bra.s @TypeLoop ; And keep looping until weÕre done.
|
|
|
|
@ChkOffset Move.w (A1)+,D1 ; If the offset to the code table is nil,
|
|
Beq.s @MonIDNotValid ; then leave with an error.
|
|
Lea MonIDsTbl,A1 ; Otherwise, re-point to the MonIDsTbl.
|
|
Adda.w D1,A1 ; And point to the appropriate sense-code table.
|
|
|
|
Move.b csMode(A2),D0 ; Get the sense code.
|
|
@CodeLoop Cmp.b (A1)+,D0 ; If weÕve come to the end of the table,
|
|
Bmi.s @MonIDNotValid ; then leave with an error.
|
|
Beq.s @ChkIt ; If weÕve found a match, then check it.
|
|
Tst.b (A1)+ ; Otherwise, skip the indexed code.
|
|
Bra.s @CodeLoop ; And keep looping until weÕre done.
|
|
|
|
@ChkIt Move.b (A1)+,D1 ; Get the indexed ID for this code.
|
|
Cmpi.b #indexedNoConnect,D1 ; If itÕs the no-connect code,
|
|
Beq.s @ClearIt ; then say so.
|
|
|
|
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.w #SizesPRAMRec+spBlockSize,Sp ; Restore stackÉ
|
|
Bra SonoraCtlGood ; Éand leave.
|
|
|
|
@MonIDNotValid Adda.w #SizesPRAMRec+spBlockSize,Sp ; Restore stackÉ
|
|
Bra SonoraCtlBad ; É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
|
|
*
|
|
**********************************************************************
|
|
|
|
SonoraVidClose
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
MOVE.L dCtlStorage(A1),A3 ; A3 <- Ptr to private storage
|
|
MOVE.L (A3),D0 ;
|
|
_StripAddress ;
|
|
MOVE.L D0,A3 ;
|
|
|
|
; Disable interruptsÉ
|
|
;
|
|
BSR SonoraDisableVGuts ; call utility to deactivate interrupts
|
|
|
|
; Blank the screenÉ
|
|
;
|
|
Movea.l saveSonoraBase(A3),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVdCtlBase,A0 ; Point to the video control register space.
|
|
Bset #SonoraVidBlnkBit,SonoraVdModeReg(A0) ; Turn on video blanking.
|
|
|
|
; Dispose of storageÉ
|
|
;
|
|
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 ;
|
|
|
|
; Return no errorÉ
|
|
;
|
|
MOVEQ #noErr,D0 ; no error
|
|
RTS ; and return
|
|
|
|
ENDWITH
|
|
|
|
**********************************************************************
|
|
*
|
|
* Video Driver Status Call Handler. There are eleven standard calls:
|
|
*
|
|
* ($00) Error
|
|
* ($01) Error
|
|
* ($02) GetMode
|
|
* ($03) GetEntries
|
|
* ($04) GetPage
|
|
* ($05) GetPageBase
|
|
* ($06) GetGray
|
|
* ($07) GetInterrupt
|
|
* ($08) GetGamma
|
|
* ($09) GetDefaultMode
|
|
* ($0A) GetCurMode
|
|
*
|
|
* The following calls are Sonora-specific:
|
|
*
|
|
* ($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
|
|
*
|
|
**********************************************************************
|
|
|
|
SonoraVidStatus
|
|
|
|
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 #cscAltSense,D0 ; If we got the AltSense call,
|
|
Beq SonoraGetAltSense ; hop to it.
|
|
|
|
CMP.W #$0D,D0 ;IF csCode NOT IN [0..$0A] THEN
|
|
BHI.S SonoraStatBad ; Error, csCode out of bounds.
|
|
MOVE.W SonoraStatJumpTbl(PC,D0.W*2),D0 ;Get the relative offset to the routine.
|
|
JMP SonoraStatJumpTbl(PC,D0.W) ;GOTO the proper routine.
|
|
|
|
SonoraStatJumpTbl
|
|
DC.W SonoraStatBad-SonoraStatJumpTbl ;$00 => Error
|
|
DC.W SonoraStatBad-SonoraStatJumpTbl ;$01 => Error
|
|
DC.W SonoraGetMode-SonoraStatJumpTbl ;$02 => GetMode
|
|
DC.W SonoraGetEntries-SonoraStatJumpTbl ;$03 => GetEntries
|
|
DC.W SonoraGetPage-SonoraStatJumpTbl ;$04 => GetPage
|
|
DC.W SonoraGetPageBase-SonoraStatJumpTbl ;$05 => GetPageBase
|
|
DC.W SonoraGetGray-SonoraStatJumpTbl ;$06 => GetGray
|
|
DC.W SonoraGetInterrupt-SonoraStatJumpTbl ;$07 => GetInterrupt
|
|
DC.W SonoraGetGamma-SonoraStatJumpTbl ;$08 => GetGamma
|
|
DC.W SonoraGetDefaultMode-SonoraStatJumpTbl ;$09 => GetDefaultMode
|
|
DC.W SonoraGetCurMode-SonoraStatJumpTbl ;$0A => GetCurMode
|
|
DC.W SonoraGetSyncs-SonoraStatJumpTbl ;$0B => cscGetSync ; <sm20>
|
|
DC.W SonoraGetConnection-SonoraStatJumpTbl ;$0C => cscGetConnection
|
|
DC.W SonoraGetModeTiming-SonoraStatJumpTbl ;$0D => cscGetModeTiming
|
|
|
|
SonoraStatBad MOVEQ #statusErr,D0 ; else say we don't do this one
|
|
BRA.S SonoraStatDone ; and return
|
|
|
|
SonoraStatGood MOVEQ #noErr,D0 ; return no error
|
|
|
|
SonoraStatDone MOVEM.L (SP)+,A0/A1 ; Restore exit registers.
|
|
BRA SonoraExitDrvr
|
|
|
|
SonoraGetMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return the current mode
|
|
;
|
|
; Inputs : A2 = pointer to csParams
|
|
; A3 = pointer to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
MOVE.W saveMode(A3),csMode(A2) ; return the mode
|
|
Clr.w csPage(A2) ; return the page number (always 0)
|
|
|
|
Move.l saveBaseAddr(A3),csBaseAddr(A2) ; Return the screen baseAddr.
|
|
BRA.S SonoraStatGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetEntries
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Read the current contents of the CLUT. These values were gamma corrected
|
|
; when they were set (by SonoraSetEntries), 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
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraCLUTRec
|
|
|
|
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.
|
|
Subi.w #firstVidMode,D1 ; Convert it to an index.
|
|
|
|
Moveq #0,D3 ; clear all of D3 for .w compare.
|
|
Lea SonoraCLUTTbl,A0 ; Point to the table of CLUT data.
|
|
Lea (A0,D1*SonoraCLUTSize),A0 ; Point to the right entry.
|
|
Move.b scRange(A0),D3 ; Get the CLUT range.
|
|
|
|
Move.w csCount(A2),D4 ; Get the number of entries to change,
|
|
Bmi @GEErr ; and hike if itÕs out of range.
|
|
Cmp.w D3,D4 ; If D4-D3 > 0 (count - range > 0),
|
|
Bhi @GEErr ; then hike.
|
|
Tst.w csStart(A2) ; If weÕre doing indexed entries (-1),
|
|
Bmi.s @skipStartChk ; then just go on.
|
|
Add.w csStart(A2),D4 ; Adjust count for starting position.
|
|
Cmp.w D3,D4 ; If D4-D3 > 0 (count - range > 0),
|
|
Bhi @GEErr ; then hike.
|
|
|
|
@skipStartChk
|
|
|
|
Move.b scStart(A0),D2 ; Get the starting position.
|
|
Move.w scSkip(A0),D5 ; Get the inter-entry skip factor.
|
|
Move.w csCount(A2),D6 ; Remember the csCount.
|
|
|
|
Cmpi.w #indexEntries,csStart(A2) ; If table accesses are to be indexed,
|
|
Beq.s @GECom ; then go on.
|
|
|
|
; 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.
|
|
Move.w D6,D1 ; Get count.
|
|
|
|
@TableLoop Move.w D4,value(A0,D1*colorSpecSize) ; Write the index into the table.
|
|
Subq #1,D4 ; Decrement index.
|
|
Dbra D1,@TableLoop ;
|
|
|
|
@GECom Move.l (Sp)+,A0 ; Get/restore ptr to csTable.
|
|
|
|
Move.l saveVDACBase(A3),A2 ; Get VDAC base address.
|
|
Add.w #ArielDataReg,A2 ; Add offset to Palette read register.
|
|
|
|
Move.w Sr,-(Sp) ; Save current interrupt level
|
|
Bsr SonoraWaitVSync ; 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.
|
|
|
|
Mulu.w D5,D1 ; Multiply index by skip value.
|
|
Add.b D2,D1 ; Add in the starting posistion.
|
|
Move.b D1,ArielAddrReg-ArielDataReg(A2) ; Tell the Clut where to read from.
|
|
|
|
Move.b (A2),D1 ; Get Red:
|
|
Move.b D1,rgb+red(A0) ; --> $rrXX
|
|
Move.b D1,rgb+red+1(A0) ; --> $rrrr
|
|
|
|
Move.b (A2),D1 ; Get Green:
|
|
Move.b D1,rgb+green(A0) ; --> $ggXX
|
|
Move.b D1,rgb+green+1(A0) ; --> $gggg
|
|
|
|
Move.b (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 D6,@Repeat
|
|
|
|
Move.w (Sp)+,Sr ; Restore previous interrupt level.
|
|
|
|
Movem.l (Sp)+,D4-D6 ; Restore work registers.
|
|
Bra SonoraStatGood ; Return noError.
|
|
|
|
@GEErr Tst.l (Sp)+ ; Clean up stack.
|
|
Movem.l (Sp)+,D4-D6 ; Restore work registers.
|
|
Bra SonoraStatBad ; Return statError.
|
|
|
|
SonoraGetPage
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates
|
|
|
|
MOVE csMode(A2),D1 ; get the mode
|
|
BSR SonoraChkMode ; is this mode OK?
|
|
BNE SonoraStatBad ; => not a valid mode
|
|
|
|
MOVE.W #1,csPage(A2) ; return page count
|
|
BRA SonoraStatGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetPageBase
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return the base address for the specified page in the current mode
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
TST.W csPage(A2) ; are we returning page zero info?
|
|
BNE SonoraStatBad ; only page 0 is valid
|
|
|
|
Move.l saveBaseAddr(A3),csBaseAddr(A2) ; Return the screen baseAddr.
|
|
BRA SonoraStatGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetGray
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return a boolean, set true if luminance mapping is on
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
MOVEQ #0,D1 ; set up for BFEXTU
|
|
|
|
SonoraGetFlagCom
|
|
|
|
BFEXTU GFlags(A3){D1:1},D0 ; get the state of flag
|
|
MOVE.B D0,csMode(A2) ; return value
|
|
BRA SonoraStatGood ; => and return
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetInterrupt
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return a boolean in csMode, set true if VBL interrupts are disabled
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
MOVEQ #1,D1 ; set up BFEXTU to point at IntDisFlag
|
|
BRA.S SonoraGetFlagCom ; and use common code
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetGamma
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return the pointer to the current gamma table
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates
|
|
|
|
MOVE.L saveGammaPtr(A3),csGTable(A2) ; return the pointer to the structure
|
|
BRA SonoraStatGood ; and return a good result
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetDefaultMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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,SonoraVidPrivates,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 SonoraStatGood ;
|
|
|
|
ENDWITH
|
|
|
|
SonoraGetCurMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; This call will generally be used in conjuntion with the
|
|
; the SwitchMode control call. Its function is
|
|
; basically to fill out the VDPageInfo with the
|
|
; current status. Note that, here, csData, is the
|
|
; current SlotID (sResource number) in use.
|
|
;
|
|
; Note: The implementation of this Status call can be used to
|
|
; determine whether the SwitchMode control call is
|
|
; implemented or currently accessible.
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraVidPrivates,VDSwitchInfo
|
|
|
|
; Check to see if we even need to be here or notÉ
|
|
;
|
|
Cmpi.w #indexedSenseMSB1,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB2,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB3,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Bra SonoraStatBad ; Otherwise, just go away.
|
|
@EndMSChk
|
|
|
|
; Return the appropriate information if all is wellÉ
|
|
;
|
|
Move.w saveMode(A3),csMode(A2) ; Return the current mode (bit depth).
|
|
|
|
Moveq #0,D0 ; Clear out return-value register.
|
|
Move.b dCtlSlotID(A1),D0 ; Get the byte-sized spID.
|
|
Move.l D0,csData(A2) ; Make it long.
|
|
|
|
Move.l saveBaseAddr(A3),csBaseAddr(A2) ; Return the base address for this page.
|
|
Clr.w csPage(A2) ; But we only support page #0.
|
|
|
|
Bra SonoraStatGood ; Vamoose.
|
|
|
|
Endwith
|
|
|
|
SonoraGetSyncs ; <sm20>
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return a boolean, set true if RGB Syncs are OFF
|
|
; Clear the 2nd byte, saying we don't support levels of power-saving.
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH SonoraVidPrivates ; <sm20>
|
|
; <sm20>
|
|
movea.l saveSonoraBase(a3),a0 ; Get Sonora Base (VIA1 base $50f00000) ; <sm20>
|
|
adda.l #SonoraVdCtlBase,a0 ; add the difference to get Vid Reg ($28000) ; <sm20>
|
|
Move.b SonoraVdModeReg(A0),D0 ; Get the appropriate monitor code. ; <sm20>
|
|
; <sm20>
|
|
Andi.l #$80,D0 ; and look at bit 7 ; <sm20>
|
|
Sne csMode(A2) ; if bit is 1, RGB Syncs are OFF, return true ; <sm20>
|
|
Clr.b csMode+1(A2) ; and the next byte for good measure. ; <sm20>
|
|
BRA SonoraStatGood ; => and return ; <sm20>
|
|
; <sm20>
|
|
ENDWITH ; <sm20>
|
|
|
|
SonoraGetModeTiming
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; This call is used by Display Mgr to determine if a mode is
|
|
; valid on a given display. There are 5 possible results
|
|
;
|
|
; (1) The driver has no idea what this call is and returns statErr.
|
|
; This does not apply to the sonora driver
|
|
;
|
|
; (2) The driver knows with certainty (via sense codes) or via a
|
|
; direct connection to the display that the mode in question
|
|
; is good. In this case the timing need not be checked with
|
|
; an external component for the display. This is the case with
|
|
; non-multisync devices and panel displays directly connected by Apple.
|
|
;
|
|
; (3) The driver is multimode aware and knows there is a multimode monitor
|
|
; attached. The driver does not know the exact range of frequencies
|
|
; supported by the display and does not know if this mode is supported.
|
|
;
|
|
; (4) The driver is modeless (many many mode) aware and
|
|
;
|
|
; (5) The driver gives up control of mode searching to a table in the
|
|
; decl ROM. This will be the case for sonora driver.
|
|
;
|
|
;
|
|
; Note: This is a driver call so that
|
|
; (1) patches cannot easily be made to the decl data, but can be
|
|
; made to the driver. If we want to replace information,
|
|
; we can do so in the driver.
|
|
; (2) we are not tied to a decl data table format for modeless (many
|
|
; many mode) drivers in the future. And if we go to a different
|
|
; bus architeture (as people seem to want to) we will not be
|
|
; hosed by table based implementations. We may however be
|
|
; hosed by driver based implementations, but we can only do
|
|
; so much planning for the future and still ship product.
|
|
;
|
|
;---------------------------------------------------------------------
|
|
With SonoraVidPrivates,VDTimingInfo
|
|
|
|
Cmpi.w #indexedSenseMSB1,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB2,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB3,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk ; then just keep going.
|
|
Bra SonoraStatBad ; Otherwise, just go away.
|
|
@EndMSChk
|
|
Move.l #kDeclROMtables,csTimingFormat(A2)
|
|
Clr.l csTimingData(A2)
|
|
Clr.l csTimingFlags(A2)
|
|
|
|
Bra SonoraStatBad ; Bail Anyway (so DisplayMgr will look in decl ROM).
|
|
ENDWITH
|
|
|
|
SonoraGetConnection
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; This call is used by Display Mgr to get information about the connection
|
|
; betrween the display card and the display.
|
|
;
|
|
; The assumption is that GetConnetion only alters those fields in the
|
|
; VDDisplayConnectInfo record for which it has actual information.
|
|
; In this case for example, I do not know what the display component
|
|
; is so I do not touch it. Same for the csConnectReserved field
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraVidPrivates,VDDisplayConnectInfo
|
|
; ¥¥¥
|
|
; For now if we donÕt have a multiscan display we just say that its fixed. (Note: If we really
|
|
; wanted to support the Vail-specific family modes here, weÕd want to denote the GS/GS-560
|
|
; and the HR/HR-560 display types. Maybe someday.)
|
|
;
|
|
Move.w #kFixedModeCRTConnect,csDisplayType(A2)
|
|
|
|
Clr.l csConnectFlags(A2) ; ¥¥¥ Danger: Tagging stuff not complete! ¥¥¥
|
|
Clr.w csConnectTagged(A2) ;
|
|
; ¥¥¥
|
|
Cmpi.w #indexedSenseMSB1,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk1 ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB2,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk2 ; then just keep going.
|
|
Cmpi.w #indexedSenseMSB3,saveMonID(A3) ; If weÕre driving a multiscan display,
|
|
Beq.s @EndMSChk3 ; then just keep going.
|
|
Bra SonoraStatGood ; Otherwise, just go away.
|
|
|
|
@EndMSChk1 Move.w #kMultiModeCRT1Connect,csDisplayType(A2)
|
|
Bra.s @EndMSChk
|
|
@EndMSChk2 Move.w #kMultiModeCRT2Connect,csDisplayType(A2)
|
|
Bra.s @EndMSChk
|
|
@EndMSChk3 Move.w #kMultiModeCRT3Connect,csDisplayType(A2)
|
|
@EndMSChk
|
|
Move.l #(1<<kAllModesValid),csConnectFlags(A2)
|
|
Bra SonoraStatGood
|
|
|
|
Endwith
|
|
|
|
SonoraGetAltSense
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Returns the alternate senseID code thatÕs in use. It
|
|
; should be noted that we cannot disguish between PAL &
|
|
; NTSC monitors & encoder boxes once SetAltSense has
|
|
; been called (because both the monitor & box codes are
|
|
; mapped into the same indexedSense code). We pas back
|
|
; this information in csMode (byte 0 is the sense code,
|
|
; byte 1 is the type).
|
|
;
|
|
; A1 = Ptr to AuxDCE/Ptr to MonIDs table (not restored)
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;---------------------------------------------------------------------
|
|
|
|
With SpBlock,SonoraVidPrivates,SP_Params
|
|
|
|
;
|
|
; First, set up a slot parameter block on the stack.
|
|
;
|
|
|
|
Suba.w #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.w #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 is type-0 for now.
|
|
Move.b SP_AltSense(Sp),D1 ; Get the alternate senseID byte.
|
|
Andi.b #spAltSenseValidMask,D1 ; 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),D1 ; Get the no-connect byte again.
|
|
Andi.b #spAltSenseMask,D1 ; Strip the validation code.
|
|
|
|
Lea Type_0_MonIDs,A1 ; Point to the Type_0_MonIDs.
|
|
Bsr @ValidLoop ; Search there.
|
|
|
|
Move.b #6,csMode+1(A2) ; Assume weÕll find a type-6 sense code.
|
|
Lea Type_6_MonIDs,A1 ; Point to the Type_6_MonIDs.
|
|
Bsr @ValidLoop ; Search there.
|
|
|
|
Move.b #7,csMode+1(A2) ; Assume weÕll find a type-7 sense code.
|
|
Lea Type_7_MonIDs,A1 ; Point to the Type_7_MonIDs.
|
|
Bsr @ValidLoop ; Search there.
|
|
|
|
Clr.b csMode+1(A2) ; Nothing matchedÉ
|
|
Moveq #indexedNoConnect,D0 ; Éso just say no-connect.
|
|
|
|
@WriteIt Move.b D0,csMode(A2) ; Return valid sense code.
|
|
@Exit Adda.w #SizesPRAMRec+spBlockSize,Sp ; Restore stack, and
|
|
Bra SonoraStatGood ; go home.
|
|
|
|
@ValidLoop Move.b (A1)+,D0 ; Get the sense code.
|
|
Cmp.b (A1)+,D1 ; If the index matches whatÕs in PRAM,
|
|
Beq.s @WriteItOut ; then return the sense code.
|
|
Tst.b (A1) ; If weÕre at the end of the list,
|
|
Bmi.s @ChkNextType ; then move on.
|
|
Bra.s @ValidLoop ; Otherwise, loop away.
|
|
|
|
@WriteItOut Addq #4,Sp ; Clean up the stack.
|
|
Bra.s @WriteIt ; And leave.
|
|
|
|
@ChkNextType Rts
|
|
|
|
Endwith
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Exit from Control or Status.
|
|
;
|
|
; A0 = Ptr to param block.
|
|
; A1 = Ptr to AuxDCE.
|
|
; D0 = error code.
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
SonoraExitDrvr BTST #NoQueueBit,ioTrap(A0) ; no queue bit set?
|
|
BEQ.S SonoraGoIODone ; => no, not immediate
|
|
RTS ; otherwise, it was an immediate call
|
|
|
|
SonoraGoIODone MOVE.L JIODone,-(Sp) ; Get the IODone address,
|
|
Rts ; and go there.
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 SonoraVidPrivates,SonoraVidParams
|
|
|
|
SonoraChkMode
|
|
|
|
Movem.l A0/D0,-(Sp) ; Save work registers.
|
|
|
|
Sub.w #FirstVidMode,D1 ; Make mode zero-based.
|
|
Blt.s @ModeBad ; If the passed-in mode is < 0,
|
|
; then punt.
|
|
|
|
Move.l saveVidPtr(A3),A0 ; Get a pointer to the video params.
|
|
Tst.b noVRAM(A3) ; If we donÕt have VRAM, then
|
|
Bne.s @NoVRAM ; say so.
|
|
Adda.w #svpMaxModeBase,A0 ; Point to the base of the max mode values.
|
|
Bra.s @GetSize ; Skip the no-VRAM case.
|
|
@NoVRAM Adda.w #svpNoRAMMaxBase,A0 ; Point to the base of the no-VRAM modes.
|
|
@GetSize Move.b saveSizeVRAM(A3),D0 ; Get the vRAM size index.
|
|
Move.b (A0,D0),D0 ; Get the maximum mode for this config.
|
|
Sub.w #FirstVidMode,D0 ; Make the max mode zero-based.
|
|
Cmp.w D0,D1 ; If the passed-in mode is > max mode,
|
|
Bgt.s @ModeBad ; then punt.
|
|
|
|
Cmp.w D1,D1 ; Set Eq when okay.
|
|
@ModeBad Movem.l (Sp)+,A0/D0 ; Restore work registers.
|
|
Rts
|
|
|
|
Endwith
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Wait for vertical blanking. Interrupts are set to level-2 in
|
|
; this routine.
|
|
;
|
|
; A3 = pointer to private storage
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraVidPrivates
|
|
|
|
SonoraWaitVSync
|
|
|
|
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 saveSonoraBase(A3),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVIA2Base,A0 ; Point to the interrupt register space.
|
|
Move.b #$40,SonoraSlotIFR(A0) ; Clear any pending interrupts.
|
|
|
|
Adda.w #SonoraSlotIFR,A0 ; Point to the interrupt flag register.
|
|
@SyncLoop Move.b (A0),D0 ; Read the VBL state.
|
|
Btst #6,D0 ; If itÕs none pending (0=pending),
|
|
Bne.s @SyncLoop ; then keep looping.
|
|
|
|
@Done MOVE.L (SP)+,D0 ; Restore work registers.
|
|
MOVE.L (SP)+,A0 ; (Two MOVEs are faster than a MOVEM.)
|
|
RTS
|
|
|
|
Endwith
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; SetDepth sets the depth in the DAC and the framebuffer.
|
|
;
|
|
; 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
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
SonoraSetDepth
|
|
|
|
With SonoraVidPrivates
|
|
|
|
Movem.l A0/D0-D2,-(Sp) ; Save our work registers.
|
|
|
|
; Wait for the next VBL before trying to switch depths.
|
|
;
|
|
Move.w Sr,-(Sp) ; Save the current interrupt level.
|
|
Bsr.s SonoraWaitVSync ; Wait for the next VBL.
|
|
|
|
; Switch the framebufferÕs depth.
|
|
;
|
|
Move.l saveSonoraBase(A3),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVdCtlBase,A0 ; Point to the video control register space.
|
|
Move.b D1,SonoraVdColrReg(A0) ; Set the depth.
|
|
|
|
; Switch the CLUT/DACÕs depth.
|
|
;
|
|
Move.l saveVDACBase(A3),A0 ; Point to Ariel.
|
|
Move.b ArielConfigReg(A0),D0 ; Save the current state.
|
|
Andi.b #ClrDepthBitsMask,D0 ; Clear the depth bits.
|
|
Or.b D1,D0 ; Turn on the depth bits.
|
|
Move.b D0,ArielConfigReg(A0) ; Set the depth.
|
|
|
|
; Go home.
|
|
;
|
|
Move.w (Sp)+,Sr ; Restore the interrupt level.
|
|
Movem.l (Sp)+,A0/D0-D2 ; Restore the work registers.
|
|
Rts ; Return to caller.
|
|
|
|
Endwith
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; SetResolution gets the video driver and the framebuffer controller
|
|
; set up for being switched to a different resolution.
|
|
;
|
|
; D1 containts the spID to the resolution (mode) to enable.
|
|
; A1 = AuxDCE POINTER
|
|
; A2 = parameter block pointer
|
|
; A3 = dCtlStorage pointer
|
|
;
|
|
; Preserves all registers
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
SonoraSetResolution
|
|
|
|
With SonoraVidParams,SpBlock,EgretPB,SonoraOmega
|
|
|
|
Movem.l D0-D1/A0/A4-A6,-(Sp) ; Save work registers.
|
|
|
|
Move.b dCtlSlotId(A1),D0 ; Remember which sRsrc to disable.
|
|
Move.b D1,dCtlSlotId(A1) ; Remember which sRsrc to enable.
|
|
|
|
; Do the Slot Manager changesÉ
|
|
;
|
|
Suba.w #spBlockSize,Sp ; Allocate a slot parameter block on the stack.
|
|
Move.l Sp,A0 ; Point to it with A0.
|
|
Clr.b spSlot(A0) ; Say that weÕre Slot $0.
|
|
Clr.b spExtDev(A0) ; DonÕt ask why, just clear this guy.
|
|
|
|
Move.b D0,spID(A0) ; Write out the spID of the sRsrc.
|
|
_SRsrcInfo ; Update our SpBlock for SUpdateSRT call below.
|
|
Move.l #1,spParamData(A0) ; Say that we want it disabled.
|
|
_SetSRsrcState ; Do it.
|
|
|
|
Move.b dCtlSlotId(A1),spID(A0) ; Write out the spID of the sRsrc.
|
|
Move.l #0,spParamData(A0) ; Say that we want it enabled.
|
|
_SetSRsrcState ; Do it.
|
|
_SUpdateSRT ; Tell Slot Manager to update itself (it should really know, but it does not).
|
|
|
|
; Load the ÒnewÓ video hardware setup blockÉ
|
|
;
|
|
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.
|
|
|
|
Move.b #sVidParmDir,spID(A0) ; Look for the video parameters dir.
|
|
_sFindStruct ; Load it.
|
|
|
|
Move.b dCtlSlotId(A1),spID(A0) ; Look in the directory for this config's parameters.
|
|
_sGetBlock ; Load it.
|
|
|
|
Move.l spResult(A0),-(Sp) ; Save the new privates.
|
|
Movea.l saveVidPtr(A3),A0 ; Point to the old privates.
|
|
_DisposPtr ; Dispose them.
|
|
Move.l (Sp)+,saveVidPtr(A3) ; Start using the new ones.
|
|
|
|
Adda.w #spBlockSize,Sp ; De-allocate the slot parameter block.
|
|
|
|
; Change the hardwareÉ
|
|
;
|
|
Movea.l saveVidPtr(A3),A4 ; Point to vidParams.
|
|
|
|
Move.l UnivInfoPtr,A6 ; Get a pointer to the ProductInfo table.
|
|
Adda.l ProductInfo.DecoderInfoPtr(A6),A6 ; Point to the base address table.
|
|
Move.l DecoderInfo.VIA1Addr(A6),A6 ; Get the Sonora base address.
|
|
Adda.l #SonoraVdCtlBase,A6 ; Point to the video control address space.
|
|
Bset #SonoraVidBlnkBit,SonoraVdModeReg(A6) ; Blank video (to eliminate visual artifacts).
|
|
|
|
Adda.l #SonoraVIA2Base-SonoraVdCtlBase,A6 ; Point to the VIA2.
|
|
Move.b SonoraVRAMSize(A6),D0 ; Pick up the VRAM Sizing parameters.
|
|
Adda.l #SonoraVdCtlBase-SonoraVIA2Base,A6 ; Point to the video control address space.
|
|
|
|
Move.w Sr,-(Sp) ; Save current interrupt level
|
|
Bsr SonoraWaitVSync ; Wait for next VBL.
|
|
|
|
Tst.b noVRAM(A3) ; If we donÕt have real VRAM, then
|
|
Bne.s @SkipDotClock ; skip the dot-clock setup.
|
|
|
|
Movea.l A4,A5 ; Copy the vidParams Ptr.
|
|
|
|
Cmpi.b #Sonora512Kb,D0 ; If weÕve got 512K on the motherboard
|
|
Beq.s @Omega2 ; then weÕve got a new Omega.
|
|
Cmpi.b #Sonora768Kb,D0 ;
|
|
Bne.s @SetOmega ;
|
|
|
|
@Omega2 Addq #SOmegaSize,A5 ; Skip past the Omega-1 parameters.
|
|
|
|
@SetOmega Moveq #0,D0 ; n d p <- 0000000 0000000 00
|
|
Move.b SOmegaN(A5),D0 ; n d p <- 0000000 00NNNNN NN
|
|
Lsl.w #OmegaDBits,D0 ; n d p <- 00NNNNN NN00000 00
|
|
Move.b SOmegaD(A5),D1 ; n d p <- 00NNNNN NN00000 00 (0DDDDDDD)
|
|
Or.b D1,D0 ; n d p <- 00NNNNN NNDDDDD DD
|
|
Move.b SOmegaP(A5),D1 ; n d p <- 00NNNNN NNDDDDD DD (000000PP)
|
|
Lsl.w #OmegaPBits,D0 ; n d p <- NNNNNNN DDDDDDD 00 (000000PP)
|
|
Or.b D1,D0 ; n d p <- NNNNNNN DDDDDDD PP
|
|
Swap D0 ; Move the ndp value into the MSW.
|
|
Or.b #sndSonoraReverseDFAC,D0 ; Move our sound value in.
|
|
|
|
Suba.w #EgretPBSize,Sp ; Allocate space for the Egret param block on the stack.
|
|
Move.l Sp,A0 ; Point to it with A0.
|
|
Move.w #(PseudoPkt<<8)+WrDFAC,pbCmdType(A0) ; Say that weÕre writing DFAC.
|
|
Move.l D0,pbParam(A0) ; Put out the DFAC data.
|
|
Move.w #4,pbByteCnt(A0) ; WeÕre sending 4 bytes.
|
|
Clr.w pbResult(A0) ; Clear the result word.
|
|
Clr.l pbCompletion(A0) ; No completion routines here.
|
|
_EgretDispatch ; Do it.
|
|
Adda.w #EgretPBSize,Sp ; De-allocate the Egret parameter block.
|
|
@SkipDotClock
|
|
Move.b svpMonitorCode(A4),SonoraVdModeReg(A6) ; Write out the appropriate monitor code.
|
|
Bsr SonoraWaitVSync ; Wait for next VBL.
|
|
Bclr #SonoraVidBlnkBit,SonoraVdModeReg(A6) ; Unblank display.
|
|
|
|
Move.w (Sp)+,Sr ; Restore the previous interrupt level.
|
|
Movem.l (Sp)+,D0-D1/A0/A4-A6 ; Restore the work register.
|
|
|
|
Rts
|
|
|
|
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
|
|
; A1 = Ptr to AuxDCE
|
|
; A3 = driver private storage
|
|
;
|
|
; All registers are preserved
|
|
;
|
|
|
|
With SonoraVidPrivates,SonoraVidParams
|
|
|
|
SonoraGrayScreen
|
|
|
|
Movem.l D0-D5/A1-A2,-(Sp) ; Save our work registers.
|
|
|
|
Move.l saveBaseAddr(A3),A2 ; Get the base address of the screen.
|
|
Move.b dCtlSlotId(A1),D5 ; Get the slotID (which is non-zero).
|
|
|
|
Cmp.b #sRsrc_Vid_Sonora_GS560a,D5 ; If weÕre driving the Rubik-560a,
|
|
Beq.s @Chk1bpp ; then check for 1bpp.
|
|
Cmp.b #sRsrc_Vid_Sonora_GS560b,D5 ; If weÕre not driving the Rubik-560b,
|
|
Bne.s @GetParms ; then just go on
|
|
@Chk1bpp Tst.b D1 ; If weÕre not in 1bpp,
|
|
Bne.s @GetParms ; then just go on.
|
|
Clr.b D5 ; Otherwise, say rowbytes is wrong.
|
|
|
|
@GetParms Move.l saveVidPtr(A3),A1 ; Get a pointer to the vidParams.
|
|
Move.w svpNumRows(A1),D4 ; Get the number of rows to gray.
|
|
Adda.w #SVPHdrSize,A1 ; Skip past the header info.
|
|
Move.w (A1,D1*2),D3 ; Get the number of longwords/row.
|
|
|
|
Lea SonoraPats,A1 ; Point to the table of gray patterns.
|
|
Move.l (A1,D1*4),D2 ; Get the gray pattern.
|
|
|
|
Moveq #true32b,D0 ; Set up to flip into 32-bit addressing mode.
|
|
_SwapMMUMode ; Do flip.
|
|
|
|
@NxtRow Move.l D3,D1 ; Get the number of longswords/row.
|
|
@NxtLong Move.l D2,(A2)+ ; Write out gray to the frame bufferÉ
|
|
Dbra D1,@NxtLong ; Éfor each scanline.
|
|
Tst.b D5 ; If this is not a Rubik-560 at 1bpp,
|
|
Bne.s @Skip560 ; then just go on.
|
|
Move.w D2,(A2)+ ; Otherwise, write out 16 more pixels.
|
|
@Skip560 Not.l D2 ; Invert the pattern for the next row.
|
|
Dbra D4,@NxtRow ; Repeat for each row.
|
|
|
|
_SwapMMUMode ; Switch back to the previous addressing mode.
|
|
Movem.l (Sp)+,D0-D5/A1-A2 ; Restore the work registers.
|
|
Rts ; Return to caller.
|
|
|
|
Endwith
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Trans5to8
|
|
;
|
|
; <-> D1: 5-bit value to be converted into an 8-bit index.
|
|
;
|
|
|
|
SonoraTrans5to8
|
|
|
|
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
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; DirectCLUTSet writes gamma-corrected ascending grayscale-like ramps
|
|
; into the CLUT
|
|
;
|
|
; A3 = dCtlStorage pointer
|
|
;
|
|
; Preserves all registers used.
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
With SonoraVidPrivates
|
|
|
|
SonoraDirectCLUTSet
|
|
|
|
MOVEM.L D0-D2/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.
|
|
|
|
MOVE.L saveVDACBase(A3),A0 ; point to the hardware
|
|
ADDA #ArielDataReg,A0 ; point to data register
|
|
CLR.B ArielAddrReg-ArielDataReg(A0) ; start at the beginning of CLUT
|
|
|
|
Move.w #$1F,D2 ; There are only 32 entries to whack in 16bpp mode.
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
BSR SonoraWaitVSync ; wait for next blanking period (preserves A0)
|
|
|
|
; Write an incrementing grayscale ramp.
|
|
|
|
Moveq #0,D0 ; Start the ramp at zero.
|
|
|
|
@Repeat Move.w D0,D1 ; Copy the current index. <H8>
|
|
Bsr.s SonoraTrans5to8 ; Translate from 5-bits to 8.
|
|
|
|
MOVE.B (A4,D1),(A0) ; Write gamma-corrected red.
|
|
MOVE.B (A5,D1),(A0) ; Write gamma-corrected green
|
|
MOVE.B (A6,D1),(A0) ; Write gamma-corrected blue.
|
|
|
|
Addq #1,D0 ; Increment the ramp index.
|
|
DBRA D2,@Repeat ; Loop until done.
|
|
|
|
MOVE.W (SP)+,SR ; restore the status reg
|
|
MOVEM.L (SP)+,D0-D2/A0/A4-A6 ; restore saved registers
|
|
RTS
|
|
|
|
Endwith
|
|
|
|
;-------------------------------------------------------------
|
|
; The Interrupt handler for the Sonora Built-In Video
|
|
;-------------------------------------------------------------
|
|
; On entry A1 contains the pointer to the driver's private storage.
|
|
;
|
|
With SonoraVidPrivates
|
|
|
|
SonoraBeginIH
|
|
|
|
Move.l saveSonoraBase(A1),A0 ; Get the Sonora base address.
|
|
Adda.l #SonoraVIA2Base,A0 ; Point to the interrupt register space.
|
|
Move.b #$40,SonoraSlotIFR(A0) ; Clear this interrupt.
|
|
|
|
Moveq #0,D0 ; Set up for Slot $0É
|
|
Jsr ([jVBLTask]) ; Éand call the VBL Task Manager.
|
|
|
|
MOVEQ #1,D0 ; signal that int was serviced
|
|
RTS ; and return to caller
|
|
|
|
Endwith
|
|
|
|
END |