1830 lines
60 KiB
Plaintext
1830 lines
60 KiB
Plaintext
;
|
|
; File: V8Driver.a
|
|
;
|
|
; Contains: This file contains the video driver for use by the Macintosh
|
|
; OS for the Elsie/V8 hardware.
|
|
;
|
|
; Written by: David Fung/Mike Puckett
|
|
;
|
|
; Copyright: © 1990-1993 by Apple Computer, Inc. All rights reserved.
|
|
;
|
|
; Change History (most recent first):
|
|
;
|
|
; <SM5> 01-08-93 jmp Updated the version number from 0.0 (LC/LC II) to 0.1 (LC930).
|
|
; <SM4> 01-07-93 jmp Fixed a problem where plugging in a VGA-sensed would cause the
|
|
; death-chimes to play (had to do with the fact that we donÕt
|
|
; support gamma tables on VGA displays).
|
|
; <SM3> 11/5/92 SWC Changed VideoEqu.a->Video.a and ShutdownEqu.a->Shutdown.a.
|
|
; <SM2> 11/2/92 kc Don't include SonicEqu.a.
|
|
; <1> 10/6/92 GDW New location for ROMLink tool.
|
|
; <SM4> 09-03-92 jmp (jmp,H6) A couple of labels in the GetEntries code we exiting
|
|
; thru StatGood/StatBad instead of their respective V8
|
|
; counterparts.
|
|
; (jmp,H5) Corrected .s vs. non-.s branches and odd-alignment
|
|
; problems.
|
|
; <SM3> 6/4/92 KW (jmp,H4) Eliminated support for the no-vRAM case.
|
|
; (jmp,H3) Changed the way the base address is gotten and saved.
|
|
; (Use the dCtlDevBase instead of VideoInfo due to the differences
|
|
; between the video base with and without vRAM installed.)
|
|
; (jmp,H1) Roll-in LC II changes. In routine "V8SetEntries" we
|
|
; should have been exiting through V8SEDone instead of SEDone.
|
|
; ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
|
|
; Pre-SM ROM comments begin here.
|
|
; ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
|
|
; <2> 3/31/92 JSM Rolled this file into Reality.
|
|
; <1> 12/8/90 HJR First time for Terror.
|
|
; <8> 9/17/90 DAF Integrated code review changes. Relocated fake prime installing
|
|
; routine to Open call, fixed 16-bit gray pattern for alpha,
|
|
; corrected error code ordering in Open, optimized graying loops
|
|
; in two places, improved status flag setting in V8DisableGuts
|
|
; <7> 9/5/90 JJ Rex V8: Fix bug in VDAC equates used in GetEntries.
|
|
; <6> 9/5/90 JJ Fixed screen graying bug in non-vRAM HiRes mode
|
|
; <5> 9/5/90 JJ Corrected bug in screen graying utility (incorrect offset
|
|
; between 256K and 512K tables).
|
|
; <4> 8/30/90 DAF Fix Apple // mode setting in V8SetDepth
|
|
; <3> 8/16/90 JJ Added GetEntries, updated various routines for all vRAM
|
|
; configurations, updated equate names / DAF
|
|
; <2> 8/8/90 JJ Fixed CLUT graying in direct (16-bit) mode
|
|
; <1> 8/7/90 JJ Added Elsie/V8 video driver
|
|
|
|
|
|
STRING C
|
|
|
|
PRINT OFF
|
|
LOAD 'StandardEqu.d'
|
|
|
|
INCLUDE 'DockingEqu.a'
|
|
INCLUDE 'EgretEqu.a'
|
|
INCLUDE 'GestaltEqu.a'
|
|
INCLUDE 'GestaltPrivateEqu.a'
|
|
INCLUDE 'HardwarePrivateEqu.a'
|
|
INCLUDE 'IOPrimitiveEqu.a'
|
|
INCLUDE 'PowerPrivEqu.a'
|
|
INCLUDE 'ROMEqu.a'
|
|
INCLUDE 'Video.a'
|
|
INCLUDE 'SlotMgrEqu.a'
|
|
INCLUDE 'ShutDown.a'
|
|
; INCLUDE 'SonicEqu.a'
|
|
INCLUDE 'UniversalEqu.a'
|
|
|
|
INCLUDE 'DepVideoEqu.a'
|
|
PRINT ON
|
|
|
|
SEG '_sV8Driver'
|
|
|
|
BLANKS ON
|
|
STRING ASIS
|
|
MACHINE MC68020
|
|
|
|
|
|
; This is device storage which is stored in the dCtlStorage field of the DCE.
|
|
|
|
V8VidPrivates 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
|
|
saveVDACBase DS.L 1 ; the base addr of the VDAC
|
|
GFlags DS.W 1 ; flags word
|
|
saveMode DS.W 1 ; the current mode setting
|
|
saveID DS.W 1 ; monitor type ID
|
|
saveSlotId DS.W 1 ; spID of video sRsrc (hi-order byte only!)
|
|
V8VidPrivSize EQU *
|
|
ENDR
|
|
|
|
LV8Driver MAIN EXPORT
|
|
|
|
;-------------------------------------------------------------------
|
|
; Video Driver Header
|
|
;-------------------------------------------------------------------
|
|
|
|
|
|
V8Drvr DC.W $4C00 ; ctl,status,needsLock
|
|
DC.W 0,0,0 ; not an ornament
|
|
|
|
; Entry point offset table
|
|
|
|
DC.W V8VidOpen-V8Drvr ; open routine
|
|
DC.W V8Drvr-V8Drvr ; no prime in normal video drivers
|
|
DC.W V8VidCtl-V8Drvr ; control
|
|
DC.W V8VidStatus-V8Drvr ; status
|
|
DC.W V8VidClose-V8Drvr ; close
|
|
|
|
|
|
STRING Pascal
|
|
V8VidTitle DC.B '.Display_Video_Apple_V8'
|
|
ALIGN 2 ; make sure we're aligned
|
|
DC.W CurV8DrvrVersion ; current version
|
|
|
|
STRING ASIS
|
|
|
|
;
|
|
; V8CLUTTbl 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. Unlike the Bt478 vDAC in the ci and Erickson,
|
|
; the Ariel only has adjacent active positions in eight-bit mode. In the lesser depths, the active
|
|
; entries are distributed throughout the CLUT address space. As a result, we use sequential CLUT mode
|
|
; ONLY in eight-bit mode! 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)
|
|
|
|
V8CLUTTbl
|
|
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
|
|
|
|
CLUTDatRec RECORD 0 ;
|
|
Range DS.B 1 ; maximum index value in this depth
|
|
Start DS.B 1 ; lowest active CLUT address
|
|
Skip DS.W 1 ; skip value between active addresses
|
|
; (it's a .W to simplify multiplies!)
|
|
ENDR
|
|
|
|
**********************************************************************
|
|
*
|
|
* V8VidOpen allocates private storage for the device in the DCE and locks
|
|
* it down for perpetuity. Also, install the interrupt handler and enable
|
|
* the interrupts.
|
|
*
|
|
* Entry: A0 = param block pointer
|
|
* A1 = DCE pointer
|
|
*
|
|
* Locals: A3 = pointer to private storage
|
|
*
|
|
**********************************************************************
|
|
|
|
WITH VDPageInfo,SlotIntQElement,V8VidPrivates
|
|
|
|
V8VidOpen
|
|
;
|
|
; Allocate private storage (since block is CLEAR, GFlags are zeroed) and get
|
|
; a pointer to it in A3
|
|
;
|
|
|
|
MOVEQ #V8VidPrivSize,D0 ; get size of parameters
|
|
_ResrvMem ,SYS ; make room as low as possible
|
|
MOVEQ #V8VidPrivSize,D0 ; get size of parameters
|
|
_NewHandle ,SYS,CLEAR ; get some memory for private storage
|
|
BNE @OpErrorC ; => return an error in open
|
|
MOVE.L A0,dCtlStorage(A1) ; save returned handle in DCE
|
|
_HLock ; and lock it down forever (this includes a Time Mgr QElem)
|
|
|
|
MOVE.L (A0),A3 ; get a pointer to it
|
|
|
|
;
|
|
; remember the VDAC base address since it's hard to look up.
|
|
;
|
|
|
|
WITH ProductInfo,DecoderInfo,VideoInfo
|
|
MOVE.L UnivInfoPtr,A0 ; get a pointer to universal data
|
|
ADD.L DecoderInfoPtr(A0),A0 ; point to the base address table
|
|
MOVE.L VDACAddr(A0),saveVDACBase(A3) ; save pointer
|
|
ENDWITH
|
|
|
|
;
|
|
; remember the frame buffer base as well. The Open call doesn't set the video mode
|
|
; or page, but SetMode will based on this value
|
|
;
|
|
|
|
MOVE.L dCtlDevBase(A1),saveBaseAddr(A3) ; save the screen base address
|
|
MOVE.B dCtlSlotId(A1),saveSlotId(A3) ; save video sRsrc ID
|
|
|
|
;
|
|
; Get and install the interrupt handler. Call the EnableVGuts utility code to do
|
|
; this. This utility also starts the interrupts going. If there is an error
|
|
; condition, EnableVGuts returns with Z-bit cleared.
|
|
|
|
|
|
MOVEQ #sqHDSize,D0 ; allocate a slot queue element
|
|
_NewPtr ,SYS,CLEAR ; get it from system heap cleared
|
|
BNE @OpErrorB ; if not allocated, return bad
|
|
MOVE.L A0,saveSQElPtr(A3) ; save the SQ element pointer.
|
|
|
|
BSR V8EnableVGuts ; do it
|
|
BNE @OpErrorB ;
|
|
|
|
;
|
|
; read the V8 to find out what kind of monitor we have. To have gotten here, we MUST
|
|
; have a valid video device.
|
|
;
|
|
|
|
MOVE.L V8,A2 ; get the V8 base address
|
|
MOVE.B V8MonP(A2),D0 ; get the monitor type
|
|
LSR.B #3,D0 ; shift Monitor ID into the low bits
|
|
AND.W #7,D0 ; lo 3 bits only
|
|
MOVE.W D0,saveID(A3) ; remember it for later
|
|
|
|
;
|
|
; load the default gamma table from the slot resource list
|
|
;
|
|
|
|
@Gamma
|
|
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 <2.0>
|
|
CLR.B spExtDev(A0) ; <2.0>
|
|
CLR.B spHWDev(A0) ; ????
|
|
|
|
_sRsrcInfo ; get the spsPointer <2.0>
|
|
|
|
MOVE.B #sGammaDir,spID(A0) ; look for the gamma directory
|
|
_sFindStruct ; get that baby
|
|
BNE.S @DoLinear ; if failed, then do linear
|
|
|
|
MOVE.B #$80,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 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.L #0,D0 ; round it off
|
|
|
|
MOVE.L D0,saveGammaPtr(A3) ; put it in private storage
|
|
|
|
;
|
|
; 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 @OpErrorA ; 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 #drHwElsie,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.
|
|
|
|
ADDA #spBlockSize,SP ; release the parameter block
|
|
;
|
|
; all done!
|
|
;
|
|
|
|
@AllDone MOVEQ #0,D0 ; no error
|
|
@EndOpen RTS ; return
|
|
|
|
@OpErrorA ADDA #spBlockSize,SP ; release the spBlock
|
|
@OpErrorB MOVE.L dCtlStorage(A1),A0 ; get the private storage back
|
|
_DisposHandle ; release the driver private storage
|
|
@OpErrorC MOVE.L #OpenErr,D0 ; say can't open driver
|
|
BRA.S @EndOpen
|
|
|
|
ENDWITH
|
|
|
|
|
|
**********************************************************************
|
|
*
|
|
* Video Driver Control Call Handler. There are nine calls:
|
|
*
|
|
* (0) Reset (VAR mode, page: INTEGER; VAR BaseAddr: Ptr);
|
|
* (1) KillIO
|
|
* (2) SetMode(mode, page: INTEGER; VAR BaseAddr: Ptr);
|
|
* (3) SetEntries ( Table: Ptr; Start,Count : integer );
|
|
* (4) SetGamma ( Table : Ptr );
|
|
* (5) GrayPage (page);
|
|
* (6) SetGray (csMode = 0 for color, 1 for gray)
|
|
* (7) SetInterrupt ( csMode = 0 for enable, 1 for disable)
|
|
* (8) DirectSetEntries (not implemented)
|
|
* (9) SetDefaultMode
|
|
*
|
|
* Entry: A0 = param block pointer
|
|
* A1 = DCE pointer
|
|
* Uses: A2 = cs parameters (ie. A2 <- csParam(A0)) (must be preserved)
|
|
* A3 = scratch (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
|
|
;
|
|
|
|
V8VidCtl MOVE.L A0,-(SP) ; save work registers (A0 is saved because it is used by ExitDrvr)
|
|
|
|
MOVE.W csCode(A0),D0 ; get the opCode
|
|
CMP.W #128,D0 ; is it the restart graying call (id=128?)
|
|
BNE.S @0
|
|
BRA V8Goodbye ; do the graying call
|
|
@0
|
|
MOVE.L csParam(A0),A2 ; A2 <- Ptr to control parameters
|
|
MOVE.L dCtlStorage(A1),A3
|
|
MOVE.L (A3),A3 ; get pointer to private storage
|
|
|
|
CMP.W #9,D0 ; IF csCode NOT IN [0..9] THEN
|
|
BHI.S V8CtlBad ; Error, csCode out of bounds
|
|
MOVE.W V8CtlJumpTbl(PC,D0.W*2),D0 ; Get the relative offset to the routine
|
|
JMP V8CtlJumpTbl(PC,D0.W) ; GOTO the proper routine
|
|
|
|
V8CtlJumpTbl
|
|
DC.W V8VidReset-V8CtlJumpTbl ; $00 => VidReset
|
|
DC.W V8CtlGood-V8CtlJumpTbl ; $01 => CtlGood (no async routines here)
|
|
DC.W V8SetVidMode-V8CtlJumpTbl ; $02 => SetVidMode
|
|
DC.W V8SetEntries-V8CtlJumpTbl ; $03 => SetEntries
|
|
DC.W V8SetGamma-V8CtlJumpTbl ; $04 => SetGamma
|
|
DC.W V8GrayPage-V8CtlJumpTbl ; $05 => GrayPage
|
|
DC.W V8SetGray-V8CtlJumpTbl ; $06 => SetGray
|
|
DC.W V8SetInterrupt-V8CtlJumpTbl ; $07 => SetInterrupt
|
|
DC.W V8DirectSetEntries-V8CtlJumpTbl ; $08 => DirectSetEntries
|
|
DC.W V8SetDefaultMode-V8CtlJumpTbl ; $09 => SetDefaultMode
|
|
|
|
V8CtlBad MOVEQ #controlErr,D0 ; else say we don't do this one
|
|
BRA.S V8CtlDone ; and return
|
|
|
|
V8CtlGood MOVEQ #noErr,D0 ; return no error
|
|
|
|
V8CtlDone MOVE.L (SP)+,A0 ; restore registers.
|
|
BRA V8ExitDrvr
|
|
|
|
|
|
|
|
V8VidReset
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Reset the card to its default
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVE #FirstVidMode,csMode(A2) ; return default mode
|
|
MOVE #FirstVidMode,saveMode(A3) ; remember FirstVidMode as the requested mode
|
|
MOVE #1,D1 ; get default depth in D1
|
|
@2 MOVEQ #0,D0 ; get page in D0
|
|
MOVE D0,csPage(A2) ; return the page
|
|
BSR V8SetDepth ; set the depth from D1
|
|
MOVE.L saveBaseAddr(A3),csBaseAddr(A2) ; return the base address
|
|
BSR V8GrayScreen ; paint the screen gray
|
|
BRA.S V8CtlGood ; => no error
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8SetVidMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 V8VidPrivates
|
|
|
|
MOVE.W csMode(A2),D1 ; D1 = mode
|
|
BSR V8ChkMode ; check mode and convert
|
|
BNE.S V8CtlBad ; => not a valid mode
|
|
|
|
TST.W csPage(A2) ; only page zero is valid
|
|
BNE.S V8CtlBad ; => not a valid page
|
|
|
|
; Only set if mode has changed
|
|
|
|
MOVE.W csMode(A2),D2 ; get the mode spID (D1 has the zero-based mode)
|
|
CMP saveMode(A3),D2 ; has the mode changed?
|
|
BEQ.S @ModeOK1 ; if not, then skip graying get out
|
|
|
|
; 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
|
|
|
|
MOVE.L saveGammaPtr(A3),A0 ; get pointer to gamma data structure
|
|
MOVE GFormulaSize(A0),D3 ; get the size of formula data
|
|
MOVE.W GDataCnt(A0),D2 ; get number of gamma entries
|
|
LSR.W #1,D2 ; divide by two to find midpoint
|
|
LEA GFormulaData(A0),A0 ; point to formula data
|
|
ADD D3,A0 ; first correction table starts here
|
|
MOVE.B (A0,D2),D3 ; get corrected gray from middle of red table
|
|
|
|
; raise to interrupt level 2 the new, good way
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
MOVEQ #7,D2 ; get mask in D0
|
|
AND.B (SP),D2 ; get the interrupt level
|
|
SUBQ.B #2,D2 ;
|
|
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
|
|
|
|
BSR V8WaitVSync ; wait for next blanking period
|
|
|
|
; we don't need to test the entire mode here, just blank everything
|
|
|
|
MOVE.L saveVDACBase(A3),A0 ; get the VDAC base addr
|
|
ADDA #V8DACwDataReg,A0 ; point to data register
|
|
CLR.B V8DACwAddReg-V8DACwDataReg(A0) ; start at the beginning of CLUT, 4-bit mode
|
|
|
|
MOVE #(256*3)-1,D2 ; get count <8>
|
|
@Repeat MOVE.B D3,(A0) ; put component (red=green=blue) <8>
|
|
DBRA D2,@Repeat ;
|
|
MOVE (SP)+,SR ; restore the status reg
|
|
|
|
BSR V8SetDepth ; set the depth from D1, page from D0
|
|
|
|
@ModeOK1
|
|
MOVE.L saveBaseAddr(A3),csBaseAddr(A2) ; return the base address
|
|
BRA V8CtlGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8SetEntries
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 DCE
|
|
; 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 V8VidPrivates
|
|
|
|
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
|
|
BNE V8CtlBad ; error if so
|
|
|
|
SEGuts
|
|
TST.L csTable(A2) ; Check for a nil pointer
|
|
BEQ V8CtlBad
|
|
|
|
MOVEM.L A1/A4-A6/D4-D7,-(SP) ; save registers for gamma
|
|
|
|
MOVE.W GFlags(A3),D5 ; get GFlags word in D5 (sequence bits are always cleared here)
|
|
|
|
CMP.W #-1,csStart(A2) ; is it sequence mode?
|
|
BEQ.S @5 ; nope, it's index
|
|
BSET #PsuedoIndex,D5 ; turn on the bit that denotes a seq write that was xlated to indexed
|
|
CMP.W #FourthVidMode,saveMode(A3) ; is it 8- or 16-bit mode?
|
|
BLT.S @5 ; if not, need to use indexed mode
|
|
BSET #UseSeq,D5 ; if sequence then set bit
|
|
@5
|
|
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
|
|
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
|
|
ADD #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
|
|
ASL #1,D0 ; mulu times 2
|
|
ADDA D0,A6 ; calc base of blue
|
|
|
|
@OneTbl
|
|
|
|
; save the VDAC base address for later. We're going to torch the privates reg (A3) now
|
|
|
|
MOVE.L saveVDACBase(A3),D6 ; save VDAC base from driver privates
|
|
|
|
; get the maximum number of entries, zero based from a convenient table
|
|
|
|
MOVE.W saveMode(A3),D1 ; get the current video mode
|
|
SUB.W #FirstVidMode,D1 ; convert to index
|
|
|
|
WITH CLUTDatRec
|
|
|
|
LEA (V8CLUTTbl,PC,D1*4),A3 ; point to table of CLUT data
|
|
|
|
;
|
|
; 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
|
|
CMP.B Range(A3),D3 ; is it in the allowable range?
|
|
BHI V8BadExit ; if outside, then exit w/bad result
|
|
|
|
MOVE.L D3,D4 ; make a copy of the table size (zero-based!)
|
|
ADDQ #1,D4 ; make it a counting number
|
|
BTST #UseSeq,D5 ; are we in index or sequential mode?
|
|
BEQ.S @isIndex ; if equal, we're indexed
|
|
@isSeq MULU #3,D4 ; multiply times 3 for sequential mode
|
|
BRA.S @allocIt ; and continue
|
|
@isIndex ASL #2,D4 ; multiply times 4 (always less than 1024)
|
|
@allocIt SUB.W D4,SP ; allocate the buffer
|
|
|
|
;
|
|
; construct the stack version of the color table. It looks like a color table, but each of the
|
|
; four components is only eight bits (rather than 16).
|
|
;
|
|
|
|
MOVE.L SP,A0 ; copy the stack buffer pointer
|
|
MOVE.L csTable(A2),A1 ; get colorSpec pointer in 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 eight 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 ; was this an indexed request, or is it a non-8bit sequenc
|
|
BEQ.S @IndexPresent ;
|
|
|
|
; 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 sequence counter to D0
|
|
ADDQ.W #1,D4 ; increment sequence counter
|
|
|
|
@IndexPresent
|
|
MULU.W Skip(A3),D0 ; calc the new position at this depth
|
|
ADD.B Start(A3),D0 ; add the first entry offset
|
|
|
|
MOVE.B D0,(A0)+ ; put in stack table
|
|
|
|
@SLSeq
|
|
MOVE.W (A1)+,D0 ; get red
|
|
MOVE.W (A1)+,D1 ; get green
|
|
MOVE.W (A1)+,D2 ; get blue
|
|
|
|
TST D5 ; test hi bit of the flags
|
|
BPL.S @NoGray ; if not set, don't luminence map
|
|
|
|
BTST #IsDirect,D5 ; test for direct mode as well
|
|
BNE.S @NoGray ; don't allow luminence mapping in direct mode
|
|
|
|
|
|
; we're luminence mapping here
|
|
|
|
MULU #$4CCC,D0 ; multiply by red weight (0.30)
|
|
MULU #$970A,D1 ; multiply by green weight (0.59)
|
|
MULU #$1C29,D2 ; multiply by blue weight (0.11)
|
|
ADD.L D1,D0 ; sum red and green
|
|
ADD.L D2,D0 ; blue also
|
|
BFEXTU D0{0:D7},D1 ; get gChanWidth bits for gamma table lookup
|
|
MOVE.W D1,D0 ; copy into red register
|
|
MOVE.W D1,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
|
|
MOVE.B (A4,D0),(A0)+ ; write gamma corrected red
|
|
MOVE.B (A5,D1),(A0)+ ; write gamma corrected green
|
|
MOVE.B (A6,D2),(A0)+ ; write gamma corrected blue
|
|
DBRA D3,@SetupLoop ; and loop for each entry
|
|
|
|
ENDWITH
|
|
|
|
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.W csCount(A2),D3 ; get the count again
|
|
|
|
MOVE.L D6,A3 ; get VDAC base that we pushed above
|
|
|
|
LEA V8DACwDataReg(A3),A3 ; point to vDAC data write register
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register <2>
|
|
MOVEQ #7,D0 ; get mask in D0 <2>
|
|
AND.B (SP),D0 ; get the interrupt level <2>
|
|
SUBQ.B #2,D0 ; <2>
|
|
BGE.S @OK ; if ³, then don't change <2>
|
|
ORI.W #$0200,SR ; raise above level-2 <2>
|
|
ANDI.W #$FAFF,SR ; make it level-2 <2>
|
|
@OK
|
|
|
|
BSR V8WaitVSync ; wait for next blanking period (preserves A0)
|
|
|
|
LEA 2(SP),A0 ; point to the stack buffer again
|
|
|
|
BTST #UseSeq,D5 ; is it sequence mode?
|
|
BNE.S @SeqWrite ; yup, sequence mode, so go
|
|
|
|
;
|
|
; here's the loop that actually writes to the hardware when in indexed mode
|
|
;
|
|
|
|
@IndexWrite
|
|
MOVE.B (A0)+,V8DACwAddReg-V8DACwDataReg(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,@IndexWrite ; and loop
|
|
BRA.S V8SEDone ; <H1>
|
|
|
|
; write the translated starting position for sequence mode
|
|
|
|
@SeqWrite
|
|
|
|
MOVE.W csStart(A2),D0 ; get sequence start address (exact since it has to be 8-bit mode)
|
|
MOVE.B D0,V8DACwAddReg-V8DACwDataReg(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) ; get red
|
|
MOVE.B (A0)+,(A3) ; get green
|
|
MOVE.B (A0)+,(A3) ; write blue
|
|
DBRA D3,@SeqLoop ; and loop
|
|
|
|
;
|
|
; clean up and go home
|
|
;
|
|
|
|
V8SEDone
|
|
MOVE (SP)+,SR ; restore status register
|
|
ADD D4,SP ; release stack buffer
|
|
MOVEM.L (SP)+,A1/A4-A6/D4-D7 ; restore registers
|
|
BRA V8CtlGood ; return O-Tay!
|
|
|
|
V8BadExit
|
|
ADDA #4,SP ; kill pushed vDAC address
|
|
MOVEM.L (SP)+,A1/A4-A6/D4-D7 ; restore registers
|
|
BRA V8CtlBad ; return an error code
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8SetGamma
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 DCE
|
|
; A2 = Ptr to cs parameter record
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
; get new gamma table and check that we know how to handle it
|
|
|
|
MOVE.L csGTable(A2),D0 ; test for a NIL pointer
|
|
BEQ V8LinearTab ; 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 V8CtlBad ; => no, return error
|
|
TST.W GType(A2) ; test the hardware ID
|
|
BEQ.S V8ChangeTable ; if 0, then accept a TFB gamma table
|
|
CMP.W #drHwElsie,GType(A2) ; type = Elsie?
|
|
BNE V8CtlBad ; => no, return error
|
|
TST.W gFormulaSize(A2) ; if gType=Aurora, then check for monID in gFormulaData
|
|
BEQ.S V8ChangeTable ; if zero, then generic, so continue
|
|
|
|
MOVE.W gFormulaData(A2),D0 ; get the monitor ID this table was intended for
|
|
CMP.W saveID(A3),D0 ; is this the monitor?
|
|
BEQ.S V8ChangeTable ; yes, so do it
|
|
ADDQ #1,D0 ; was it -1?
|
|
BNE V8CtlBad ; nope, so must be wrong monitor
|
|
|
|
; if new table is different size, reallocate memory
|
|
|
|
V8ChangeTable
|
|
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 _DisposPtr ; if new one smaller, dispose old one
|
|
CLR.L saveGammaPtr(A3) ; flag it's been disposed
|
|
|
|
@GetNew 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 V8CtlBad ; => unable to allocate storage
|
|
|
|
MOVE.L saveGammaPtr(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
|
|
|
|
; 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
|
|
|
|
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
|
|
BEQ.S @Out ; if not, then we're done
|
|
BSR V8DirectCLUTSet ; is so, then set up direct CLUT ramps
|
|
|
|
@Out
|
|
BRA V8CtlGood ; => return no error
|
|
|
|
;
|
|
; set up a linear gamma table. To prevent memory thrash, build this new one <7>
|
|
; the same size as the existing one (one or three channel).
|
|
;
|
|
|
|
V8LinearTab
|
|
MOVE.L saveGammaPtr(A3),A0 ; get current gamma in A2
|
|
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
|
|
ADDA #GFormulaData,A0 ; point to tables
|
|
ADDA D0,A0 ; point past monID, if present
|
|
@ChanLoop MOVE.W #$FF,D0 ; loop count within each channel
|
|
@entryLoop MOVE.B D0,(A0,D0) ; write this value out
|
|
DBRA D0,@entryLoop ; for each entry in channel
|
|
DBRA D2,@ChanLoop ; and each channel
|
|
BRA V8CtlGood ; all done
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GrayPage
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Clear the specified page in the current mode to gray
|
|
;
|
|
; A0 = Ptr to private storage
|
|
; A1 = Ptr to DCE
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to driver privates
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVE saveMode(A3),D1 ; D1 = mode
|
|
MOVE D1,csMode(A2) ; force current mode, just in case for ChkPage
|
|
BSR V8ChkMode ; convert mode to depth in D1
|
|
BNE V8CtlBad ; => not a valid depth
|
|
|
|
MOVE csPage(A2),D0 ; D0 = page
|
|
BNE V8CtlBad ; => not a valid page
|
|
|
|
BSR V8GrayScreen ; paint the screen gray
|
|
|
|
BTST #IsDirect,GFlags(A3) ; are we in a direct mode?
|
|
BEQ.S @Out ; if not, then we're done
|
|
BSR V8DirectCLUTSet ; is so, then set up direct CLUT ramps
|
|
@Out
|
|
BRA V8CtlGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8SetGray
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 DCE
|
|
; A2 = Ptr to cs parameter record
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVEQ #0,D1 ; set up for BFEXTU to point to GrayFlag
|
|
BSR.S V8SetIntCom ; call common code
|
|
BRA V8CtlGood ; 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
|
|
;
|
|
|
|
V8SetIntCom
|
|
MOVE.B csMode(A2),D0 ; get boolean
|
|
BFINS D0,GFlags(A3){D1:1} ; set flag bit
|
|
RTS ; and return
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8SetInterrupt
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 DCE
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH VDPageInfo,SlotIntQElement,V8VidPrivates
|
|
|
|
MOVEQ #1,D1 ; set up for BFEXTU to point to IntDisFlag
|
|
BSR.S V8SetIntCom ; call common code
|
|
BNE.S V8DisableThem ; if zero, then enable
|
|
|
|
;
|
|
; this code enables interrupts and installs the interrupt handler
|
|
;
|
|
|
|
BSR.S V8EnableVGuts ; call common code
|
|
BNE V8CtlBad ; error, flag problem
|
|
BRA V8CtlGood ; and go home
|
|
|
|
;
|
|
; this code disables VBL interrupts, then removes the interrupt handler
|
|
;
|
|
|
|
V8DisableThem
|
|
BSR.S V8DisableVGuts ; jump to the disabling utility
|
|
BRA V8CtlGood ; all done
|
|
|
|
;
|
|
; the following two routines are common code shared between the Open/Close calls
|
|
; and the SetInterrupt control call
|
|
;
|
|
|
|
V8DisableVGuts
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
MOVEQ #7,D0 ; get mask in 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
|
|
|
|
BSR V8WaitVSync ; to be safe, wait for the next VBL
|
|
MOVE.L V8,A0 ; point to the VISA base
|
|
MOVE.B #$40,V8SEnb(A0) ; set slot 0 interrupt disabled (slot 0 bit+set/clear to 0) <1.3>
|
|
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
|
|
|
|
V8EnableVGuts ;
|
|
MOVE.L saveSQElPtr(A3),A0 ; get the queue element
|
|
LEA V8BeginIH,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 dCtlStorage(A1),A2 ; base handle to privates
|
|
MOVE.L (A2),A2 ; pointer to privates (this must stay locked!!)
|
|
MOVE.L A2,SQParm(A0) ; pass this as the parameter
|
|
CLR.W D0 ; setup slot zero
|
|
_SIntInstall ; and do install
|
|
BNE.S @IntBad
|
|
|
|
MOVE.L A0,-(SP) ; save this for a second
|
|
MOVE.L V8,A0 ; point to the RBV base
|
|
MOVE.B #$C0,V8SEnb(A0) ; set slot 0 interrupt enabled (slot 0 bit+set/clear to 1) <1.3>
|
|
MOVE.L (SP)+,A0
|
|
|
|
MOVE D0,D0 ; clear z-bit for good result
|
|
@IntBad RTS ; return home (if bad, z-bit is set above, so just leave) <8>
|
|
|
|
ENDWITH
|
|
|
|
|
|
|
|
V8DirectSetEntries
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Change the CLUT in a direct mode.
|
|
;
|
|
; A1 = Ptr to DCE
|
|
; 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 V8CtlBad ; error if not
|
|
CMP.W #31,csCount(A2) ; only 32 changeable positions in direct mode
|
|
BGT V8CtlBad ; error if not
|
|
BRA SEGuts ; jump to SetEntries internals if it's OK
|
|
|
|
|
|
|
|
V8SetDefaultMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Write the card default mode into slot pRAM.
|
|
;
|
|
; A1 = Ptr to DCE
|
|
; 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,V8VidPrivates
|
|
|
|
;
|
|
; 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. Aurora keeps the video sRsrc
|
|
; spID in VendorUse2. This guy DOESN'T check to make sure that the mode being set if
|
|
; valid for the display, but that's OK since Monitors can't see the other modes anyway
|
|
;
|
|
|
|
SUBA #SizesPRAMRec,SP ; allocate block for pRAM record
|
|
MOVE.L SP,spResult(A0) ; point to it
|
|
_sReadPRAMRec ; read it
|
|
|
|
;
|
|
; The parameter list id (identifying the screen depth) in 2(SP) will still be valid.
|
|
;
|
|
; 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),3(SP) ; write the mode into pRAM buffer
|
|
|
|
MOVE.L SP,spsPointer(A0) ; set up parameter block
|
|
_SPutPRAMRec ; write the new record out
|
|
ADDA #SizesPRAMRec+spBlockSize,SP ; deallocate buffer
|
|
BRA V8CtlGood
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8Goodbye
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Special routine to entire CLUT to 50% gray.
|
|
;
|
|
; Since the VISA can't suppress video sync, we gray out the CLUT on
|
|
; restart to hide any mode change artifacts. We could have buried this
|
|
; code in the Shutdown.a, but it's better to collect all the device
|
|
; specific code here.
|
|
;
|
|
; No parameters
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
; raise to interrupt level 2 the new, good way
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
MOVEQ #7,D2 ; get mask in D0
|
|
AND.B (SP),D2 ; get the interrupt level
|
|
SUBQ.B #2,D2 ;
|
|
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
|
|
|
|
; blank everything
|
|
|
|
WITH ProductInfo,DecoderInfo,VideoInfo
|
|
MOVE.L UnivInfoPtr,A0 ; get a pointer to universal data
|
|
ADD.L DecoderInfoPtr(A0),A0 ; point to the base address table
|
|
MOVE.L VDACAddr(A0),A0 ; get chip base address
|
|
ADDA #V8DACwDataReg,A0 ; point to data register
|
|
CLR.B V8DACwAddReg-V8DACwDataReg(A0) ; start at the beginning of CLUT, 4-bit mode
|
|
ENDWITH
|
|
|
|
MOVE.B #$7F,D3 ; get a 50% value
|
|
MOVE #($256*3)-1,D2 ; get count <8>
|
|
@Repeat MOVE.B D3,(A0) ; put component (red=green=blue) <8>
|
|
DBRA D2,@Repeat ;
|
|
MOVE (SP)+,SR ; restore the status reg
|
|
BRA V8CtlGood
|
|
|
|
|
|
**********************************************************************
|
|
*
|
|
* VideoClose releases the device's private storage and removes the
|
|
* interrupt handler.
|
|
*
|
|
*
|
|
* Entry: A0 = param block pointer
|
|
* A1 = DCE pointer
|
|
*
|
|
* Other: A2 = temporary DCE pointer copy
|
|
*
|
|
**********************************************************************
|
|
|
|
V8VidClose
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVE.L dCtlStorage(A1),A3
|
|
MOVE.L (A3),A3 ; get pointer to private storage
|
|
|
|
BSR V8DisableVGuts ; call utility to deactivate interrupts
|
|
|
|
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 dCtlStorage(A1),A0 ; Dispose of the private storage
|
|
_DisposHandle ;
|
|
|
|
MOVEQ #0,D0 ; no error
|
|
RTS ; and return
|
|
|
|
ENDWITH
|
|
|
|
|
|
**********************************************************************
|
|
*
|
|
* Video Driver Status Call Handler. Right now there are nine calls:
|
|
*
|
|
* (0) Error
|
|
* (1) Error
|
|
* (2) GetMode
|
|
* (3) GetEntries
|
|
* (4) GetPage
|
|
* (5) GetPageBase
|
|
* (6) GetGray
|
|
* (7) GetInterrupt
|
|
* (8) GetGamma
|
|
* (9) GetDefaultMode
|
|
*
|
|
* Entry: A0 = param block
|
|
* A1 = DCE pointer
|
|
* Uses: A2 = cs parameters
|
|
* A3 = pointer to private storage
|
|
* D0-D3 = scratch (don't need to be preserved)
|
|
*
|
|
* Exit: D0 = error code
|
|
*
|
|
**********************************************************************
|
|
|
|
V8VidStatus
|
|
|
|
MOVE.L A0,-(SP) ; save a register
|
|
MOVE.W csCode(A0),D0 ; get the opCode
|
|
MOVE.L csParam(A0),A2 ; A2 <- Ptr to control parameters
|
|
MOVE.L dCtlStorage(A1),A3
|
|
MOVE.L (A3),A3 ; get pointer to private storage
|
|
|
|
|
|
CMP.W #9,D0 ;IF csCode NOT IN [0..9] THEN
|
|
BHI.S V8StatBad ; Error, csCode out of bounds.
|
|
LSL.W #1,D0 ;Adjust csCode to be an index into the table.
|
|
MOVE.W V8StatJumpTbl(PC,D0.W),D0 ;Get the relative offset to the routine.
|
|
JMP V8StatJumpTbl(PC,D0.W) ;GOTO the proper routine.
|
|
|
|
V8StatJumpTbl
|
|
DC.W V8StatBad-V8StatJumpTbl ;$00 => Error
|
|
DC.W V8StatBad-V8StatJumpTbl ;$01 => Error
|
|
DC.W V8GetMode-V8StatJumpTbl ;$02 => GetMode
|
|
DC.W V8GetEntries-V8StatJumpTbl ;$03 => GetEntries
|
|
DC.W V8GetPage-V8StatJumpTbl ;$04 => GetPage
|
|
DC.W V8GetPageBase-V8StatJumpTbl ;$05 => GetPageBase
|
|
DC.W V8GetGray-V8StatJumpTbl ;$06 => GetGray
|
|
DC.W V8GetInterrupt-V8StatJumpTbl ;$07 => GetInterrupt
|
|
DC.W V8GetGamma-V8StatJumpTbl ;$08 => GetGamma
|
|
DC.W V8GetDefaultMode-V8StatJumpTbl ;$09 => GetDefaultMode
|
|
|
|
|
|
V8StatBad MOVEQ #statusErr,D0 ; else say we don't do this one
|
|
BRA.S V8StatDone ; and return
|
|
|
|
V8StatGood MOVEQ #noErr,D0 ; return no error
|
|
|
|
V8StatDone MOVE.L (SP)+,A0 ; restore registers.
|
|
BRA V8ExitDrvr
|
|
|
|
|
|
V8GetMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return the current mode
|
|
;
|
|
; Inputs : A2 = pointer to csParams
|
|
; A3 = pointer to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVE.W saveMode(A3),csMode(A2) ; return the mode
|
|
MOVE.W #0,csPage(A2) ; return the page number (always 0)
|
|
MOVE.L saveBaseAddr(A3),csBaseAddr(A2) ; and the base address
|
|
|
|
BRA.S V8StatGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GetEntries
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Read the current contents of the CLUT. These values were gamma corrected
|
|
; when they were set (by SetEntries), so they may not match the source
|
|
; cSpec array.
|
|
;
|
|
; Inputs : A2 = pointer to csParams
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
MOVE.L csTable(A2),D0 ; Check for a nil pointer
|
|
BEQ V8StatBad
|
|
|
|
MOVEM.L A1/A3-A4/D2-D5,-(SP) ; save work registers
|
|
MOVE.L D0,A4 ; A4 <- pointer to table
|
|
|
|
; get the index range in D3
|
|
|
|
WITH CLUTDatRec
|
|
LEA V8CLUTTbl,A0 ; point to CLUT parameters
|
|
MOVE.W saveMode(A3),D0 ; get the screen depth ID
|
|
SUB #FIrstVidMode,D0 ; make it an index
|
|
|
|
MOVE.B Range(A0,D0*4),D3 ; get the maximum CLUT index
|
|
MOVE.B Start(A0,D0*4),D4 ; get the starting position
|
|
MOVE.W Skip(A0,D0*4),D5 ; get the inter-entry skip value
|
|
ENDWITH
|
|
|
|
MOVE.W csCount(A2),D0 ; get the count
|
|
MOVE.W D0,D2 ; make a copy of the count
|
|
|
|
TST.W csStart(A2) ; is it index or sequence mode?
|
|
BMI.S V8GECom ; if index, then continue
|
|
|
|
MOVE.W D0,D1 ; copy count into another loop counter
|
|
ADD.W csStart(A2),D2 ; get last index
|
|
@1
|
|
MOVE.W D2,value(A4,D1*8) ; write the index into the table
|
|
SUBQ #1,D2 ; decrease index
|
|
DBRA D1,@1 ; for all indices
|
|
|
|
V8GECom
|
|
|
|
MOVE.L saveVDACBase(A3),A1 ; get base address of CLUT
|
|
ADDQ #v8DACwDataReg,A1 ; read and write data are the same register
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
MOVEQ #7,D1 ; get mask in D0
|
|
AND.B (SP),D1 ; get the interrupt level
|
|
SUBQ.B #2,D1 ;
|
|
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
|
|
|
|
@Repeat
|
|
MOVE.W (A4)+,D1 ; get the value field for from the next colorspec in D1
|
|
CMP.B D3,D1 ; Is this request in range?
|
|
BHI.S @Until ; if hi, then no, the request is invalid
|
|
|
|
MULU D5,D1 ; multiply index by skip value
|
|
ADD.B D4,D1 ; add starting offset
|
|
MOVE.B D1,V8DACrAddReg-V8DACwDataReg(A1) ; set the CLUT to read from this addr <7><daf,jj>
|
|
|
|
MOVEQ #3-1,D6 ; loop counter for # of channels
|
|
@CLUTLoop MOVE.B (A1),D1 ; get value
|
|
MOVE.B D1,(A4)+ ; byte->word in the dest cSpecArray
|
|
MOVE.B D1,(A4)+ ;
|
|
DBRA D6,@CLUTLoop ; for each channel
|
|
|
|
@Until DBRA D0,@Repeat ; and loop until done
|
|
|
|
MOVE (SP)+,SR ; restore the status register
|
|
|
|
MOVEM.L (SP)+,A1/A3-A4/D2-D5 ; restore work register
|
|
BRA V8StatGood ; => return no error
|
|
|
|
|
|
|
|
V8GetPage
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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 V8VidPrivates
|
|
|
|
MOVE csMode(A2),D1 ; get the mode
|
|
MOVE D1,D2 ; keep a copy
|
|
BSR.S V8ChkMode ; is this mode OK?
|
|
BGT V8StatBad ; => not a valid mode
|
|
|
|
MOVE.W #1,csPage(A2) ; return page count
|
|
BRA V8StatGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GetPageBase
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return the base address for the specified page in the current mode
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
TST.W csPage(A2) ; are we returning page zero info?
|
|
BNE V8StatBad ; only page 0 is valid
|
|
|
|
MOVE.L saveBaseAddr(A3),csBaseAddr(A2) ; return screen base address
|
|
BRA V8StatGood ; => return no error
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GetGray
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return a boolean, set true if luminance mapping is on
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVEQ #0,D1 ; set up for BFEXTU
|
|
V8GetFlagCom
|
|
BFEXTU GFlags(A3){D1:1},D0 ; get the state of flag
|
|
MOVE.B D0,csMode(A2) ; return value
|
|
BRA V8StatGood ; => and return
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GetInterrupt
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return a boolean in csMode, set true if VBL interrupts are disabled
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVEQ #1,D1 ; set up BFEXTU to point at IntDisFlag
|
|
BRA.S V8GetFlagCom ; and use common code
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GetGamma
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Return the pointer to the current gamma table
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVE.L saveGammaPtr(A3),csGTable(A2) ; return the pointer to the structure
|
|
BRA V8StatGood ; and return a good result
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GetDefaultMode
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Read the card default mode from slot pRAM.
|
|
;
|
|
; A1 = Ptr to DCE
|
|
; A2 = Ptr to cs parameter record
|
|
; A3 = Ptr to private storage
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
WITH spBlock,V8VidPrivates
|
|
|
|
;
|
|
; 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. Aurora 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 3(SP),csMode(A2) ; return the result
|
|
ADDA #SizesPRAMRec+spBlockSize,SP ; release buffer
|
|
BRA V8StatGood ;
|
|
|
|
ENDWITH
|
|
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Exit from control or Status.
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
V8ExitDrvr BTST #NoQueueBit,ioTrap(A0) ; no queue bit set?
|
|
BEQ.S V8GoIODone ; => no, not immediate
|
|
RTS ; otherwise, it was an immediate call
|
|
|
|
V8GoIODone MOVE.L JIODone,A0 ; get the IODone address
|
|
JMP (A0) ; invoke it
|
|
|
|
|
|
|
|
|
|
;=====================================================================
|
|
;
|
|
; Utilities
|
|
;
|
|
;=====================================================================
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; 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.
|
|
;
|
|
|
|
V8ChkMode
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVEM.L D0/D2-D3,-(SP) ; save regs
|
|
|
|
SUB.W #FirstVidMode,D1 ; make modeID zero based
|
|
MOVE.B saveSlotID(A3),D0 ; get the slot manager mode ID
|
|
|
|
BCLR #4,D0 ; if this bit is on, either A// mode or no vRAM
|
|
BEQ.S @testDepth ; if not, then do simple test
|
|
|
|
; if we are in A// emulation mode, then warp D0 to make the monitor look like a High-Res rather than a Rubik.
|
|
; We do this because the V8 has one less mode available when in A// mode (8-bit only with 512K vRAM, 4-bit
|
|
; with 256K vRAM). Note that the A// mode bit was flipped off in a test above!
|
|
|
|
@adjA2Em
|
|
BSET #2,D0 ; transmogrify A// Rubik into High-Res
|
|
|
|
; test for the greatest available depth. We'll set this up in D2 and compare to D1
|
|
|
|
@testDepth
|
|
MOVE #ThirdVidMode-FirstVidMode,D2 ; everybody at this point can do 4-bit mode
|
|
|
|
;+++ BTST #2,D0 ; Rubiks have one more possible mode over Hi-Res & VGA
|
|
MOVE.B D0,D3 ; copy the spID
|
|
AND.B #5,D3 ; Rubik = 010, HR=110, VGA=011, so we test for
|
|
; Rubik by making sure bits 0 and 2 are clear
|
|
|
|
BNE.S @vRAMTest ; if not, then continue
|
|
|
|
ADDQ #1,D2 ; reflect the additional mode
|
|
|
|
@vRAMTest
|
|
BTST #3,D0 ; 512K machines get one additional mode in all display flavors
|
|
BNE.S @ShowDown ;
|
|
|
|
ADDQ #1,D2 ; reflect the additional mode
|
|
|
|
@ShowDown CMP.B D2,D1 ; see if we're OK
|
|
BGT.S @ModeBad ; if D2>D1, it's an illegal mode
|
|
|
|
@ModeOK CMP.W D1,D1 ; get EQ
|
|
|
|
@ModeBad MOVEM.L (SP)+,D0/D2-D3 ; restore trashed regs
|
|
@ModeOut RTS ; EQ if valid depth
|
|
|
|
ENDWITH
|
|
|
|
|
|
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Wait for vertical blanking. Interrupts are raised to level-2 around
|
|
; this routine.
|
|
;
|
|
; A1 = DCE POINTER
|
|
;---------------------------------------------------------------------
|
|
|
|
V8WaitVSync
|
|
|
|
MOVE.L A0,-(SP) ; save work registers <8>
|
|
MOVE.L D0,-(SP) ; (two MOVEs are faster than a MOVEM) <8>
|
|
|
|
MOVE.L V8,A0 ; point to VISA
|
|
MOVE.B #$40,V8SInt(A0) ; clear the interrupt, just in case,
|
|
; since the intHndlr can't get
|
|
; called here
|
|
|
|
ADDA #V8SInt,A0 ; point to interrupt register
|
|
|
|
@0 MOVE.B (A0),D0 ; Read the Vert-Sync state
|
|
BTST #6,D0 ;
|
|
BNE.S @0 ; Repeat until it goes low
|
|
;
|
|
MOVE.L (SP)+,D0 ; restore work registers <8>
|
|
MOVE.L (SP)+,A0 ; (two MOVES are faster than a MOVEM) <8>
|
|
RTS
|
|
|
|
|
|
V8SetDepth
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; SetDepth sets the V8 frame buffer depth, and returns the
|
|
; frame buffer base in driver privates
|
|
;
|
|
; D0 contains the page number
|
|
; D1 contains the spID of the depth - $80 (the zero based mode ID)
|
|
; A2 = parameter block pointer
|
|
; A3 = dCtlStorage pointer
|
|
;
|
|
; Preserves all registers
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVEM.L D2/D3/A0/A1,-(SP) ; save regs we are using <1.8>
|
|
|
|
MOVE.B D1,D3 ; make a copy of the depth value
|
|
|
|
; Test for Apple // mode. If it is this mode, then we need to set the V8 to the next greater
|
|
; depth.
|
|
|
|
MOVE.B saveSlotId(A3),D2 ; get spID in a register
|
|
AND.B #$F7,D2 ; don't look at the vRAM size bit
|
|
CMP.B #sRsrc_Vid_V8_A2Ema,D2 ; compare to 512K Apple // mode
|
|
BNE.S @0
|
|
ADDQ #1,D3 ; bump the depth up by one
|
|
@0
|
|
MOVE.L V8,A0 ; point to Elsie base
|
|
MOVE.B V8MonP(A0),D2 ; get the V8 state
|
|
AND.B #ClrDepthBitsMask,D2 ; clear the lo-3 bits (depth control)
|
|
OR.B D3,D2 ; turn on the depth bits
|
|
MOVE.B D2,V8MonP(A0) ; set the mode
|
|
|
|
; set up the Ariel
|
|
|
|
MOVE.L saveVDACBase(A3),A0 ; point to the DAC
|
|
MOVE.B V8DACrCntlReg(A0),D2 ; get the Ariel control register value
|
|
AND.B #ClrDepthBitsMask,D2 ; clear the depth bits
|
|
OR.B D1,D2 ; set the new depth
|
|
MOVE.B D2,V8DACwCntlReg(A0) ; set the new control register value
|
|
@CalcBase
|
|
MOVE.W csMode(A2),saveMode(A3) ; save mode number
|
|
CMP.W #FifthVidMode,saveMode(A3) ; was it 16-bit mode?
|
|
BNE.S @BitOff ; no, so turn flag off
|
|
|
|
BSET #IsDirect,GFlags(A3) ; turn on bit
|
|
BRA.S @Out ;
|
|
@BitOff
|
|
BCLR #IsDirect,GFlags(A3) ; turn off bit
|
|
@Out
|
|
MOVEM.L (SP)+,D2/D3/A0/A1 ; restore all regs <1.8>
|
|
RTS ; return
|
|
|
|
ENDWITH
|
|
|
|
|
|
V8GrayScreen
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; Fill the screen with a 50% dithered gray pattern. To have gotten here
|
|
; we must have had a valid display connected, so there are not tests
|
|
; for inactive displays here.
|
|
;
|
|
; D1 = spID of screen depth - FirstVidMode
|
|
; A3 = driver private storage
|
|
;
|
|
; All registers are preserved
|
|
;
|
|
|
|
WITH V8VidPrivates
|
|
|
|
MOVEM.L D0-D3/A0-A1,-(SP) ; save all registers
|
|
|
|
LEA V8Pats,A1 ; get a pointer to the pattern table
|
|
MOVE.L (A1,D1*4),D3 ; D3 = the proper pattern
|
|
|
|
MOVEQ.L #$17,D0 ; make a mask for pertinent bits
|
|
AND.B saveSlotId(A3),D0 ; get the monitor+upper option bit
|
|
|
|
CMP.B #sRsrc_Vid_V8_GSa**$17,D0 ; is it a standard Rubik?
|
|
BNE.S @0 ; if not, continue
|
|
LEA V8GSParms,A1 ;
|
|
BRA.S @Blast2
|
|
|
|
@0 CMP.B #sRsrc_Vid_V8_A2Ema**$17,D0 ; is it a Rubik in A// mode?
|
|
BNE.S @1 ; if not, continue
|
|
LEA V8A2Parms,A1 ;
|
|
BRA.S @Blast2
|
|
|
|
; if it's none of the above it's either a High-Res w/vRAM or a VGA which use the same parameters
|
|
|
|
@1 LEA V8HRvRAMParms,A1 ;
|
|
|
|
@Blast2
|
|
BTST #3,saveSlotID(A3) ; if this bit is cleared, then 512K vRAM
|
|
BNE.S @ItsOK ; if bit set, then 256K vRAM so parm addr is OK
|
|
; ¥¥¥!!!¥¥¥ ADDA #LongParmShift,A1 ; advance A1 to 512K parameters
|
|
ADDA #58,A1 ; advance A1 to 512K parameters
|
|
@ItsOK
|
|
MOVE.L saveBaseAddr(A3),A0 ; get the frame buffer base address
|
|
MOVE.W (A1)+,D0 ; get the # of rows
|
|
@NxtRow
|
|
MOVE.W (A1,D1*4),D2 ; get the # of longs/row
|
|
@NxtLong MOVE.L D3,(A0)+ ; write gray
|
|
DBRA D2,@NxtLong ; for each scanline
|
|
ADD.W 2(A1,D1*4),A0 ; add the skip factor for each line
|
|
NOT.L D3 ; invert pattern on next row
|
|
DBRA D0,@NxtRow ; for each row
|
|
|
|
MOVEM.L (SP)+,D0-D3/A0-A1 ; restore registers
|
|
RTS
|
|
|
|
|
|
V8Pats DC.L OneBitGray,TwoBitGray,FourBitGray,EightBitGray,SixteenBitGray
|
|
|
|
|
|
|
|
V8DirectCLUTSet
|
|
;---------------------------------------------------------------------
|
|
;
|
|
; V8DirectCLUTSet writes gamma-corrected ascending grayscale ramps into
|
|
; the CLUT
|
|
;
|
|
; A3 = dCtlStorage pointer
|
|
;
|
|
; Preserves all registers
|
|
;
|
|
;---------------------------------------------------------------------
|
|
|
|
MOVEM.L D0-D2/A0/A4-A6,-(SP) ; save a register
|
|
|
|
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 #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
|
|
ADD #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
|
|
ASL #1,D0 ; mulu times 2
|
|
ADDA D1,A6 ; calc base of blue
|
|
|
|
@OneTbl
|
|
|
|
MOVE.L saveVDACBase(A3),A0 ; point to the hardware
|
|
ADDA #V8DACwDataReg,A0 ; point to data register
|
|
CLR.B V8DACwAddReg-V8DACwDataReg(A0) ; start at the beginning of CLUT
|
|
|
|
MOVE.W #$1F,D2 ; set up counter
|
|
|
|
MOVE.W SR,-(SP) ; preserve the status register
|
|
MOVEQ #7,D0 ; get mask in 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
|
|
|
|
; write an incrementing grayscale ramp
|
|
|
|
MOVEQ #0,D0 ; set up ramp start
|
|
|
|
@Repeat
|
|
MOVE.L D0,D1 ; copy the position pointer
|
|
SWAP D1 ; get the ÒintegerÓ part
|
|
MOVE.B (A4,D1),(A0) ; put red
|
|
MOVE.B (A5,D1),(A0) ; put green
|
|
MOVE.B (A6,D1),(A0) ; put blue
|
|
|
|
ADD.L #$00083900,D0 ; add 8 and 7/31 to the number
|
|
|
|
DBRA D2,@Repeat ;
|
|
|
|
MOVE (SP)+,SR ; restore the status reg
|
|
MOVEM.L (SP)+,D0-D2/A0/A4-A6 ; restore saved registers
|
|
RTS
|
|
|
|
|
|
|
|
;
|
|
; some simple screen size parameters. The first number is the number of scanlines to
|
|
; erase for each mode. The next numbers are in pairs. The first element of each pair is the number
|
|
; of longs to gray per scanline. The second element is the skip factor (number of bytes to skip
|
|
; to get to beginning of the next scanline). The second set of numbers are the same info for the
|
|
; 512K vRAM version (which has 1024 rowbytes rather than 512). There are more modes in the second
|
|
; set, but the code in V8GrayScreen knows how to deal with it
|
|
;
|
|
|
|
V8GSParms DC.W defmBounds_BGS-1
|
|
DC.W (((defmBounds_RGS*1)/8)/4)-1,(V8_512_RB-((defmBounds_RGS*1)/8))
|
|
DC.W (((defmBounds_RGS*2)/8)/4)-1,(V8_512_RB-((defmBounds_RGS*2)/8))
|
|
DC.W (((defmBounds_RGS*4)/8)/4)-1,(V8_512_RB-((defmBounds_RGS*4)/8))
|
|
DC.W (((defmBounds_RGS*8)/8)/4)-1,(V8_512_RB-((defmBounds_RGS*8)/8))
|
|
DC.W 0,0 ; pad out table
|
|
|
|
V8HRvRAMParms DC.W defmBounds_BHR-1
|
|
DC.W (((defmBounds_RHR*1)/8)/4)-1,(V8_512_RB-((defmBounds_RHR*1)/8))
|
|
DC.W (((defmBounds_RHR*2)/8)/4)-1,(V8_512_RB-((defmBounds_RHR*2)/8))
|
|
DC.W (((defmBounds_RHR*4)/8)/4)-1,(V8_512_RB-((defmBounds_RHR*4)/8))
|
|
DC.W 0,0 ; pad out table
|
|
|
|
V8A2Parms DC.W defmBounds_BA2Em-1
|
|
DC.W (((defmBounds_RA2Em*1)/8)/4)-1,(V8_512_RB-((defmBounds_RA2Em*1)/8))
|
|
DC.W (((defmBounds_RA2Em*2)/8)/4)-1,(V8_512_RB-((defmBounds_RA2Em*2)/8))
|
|
DC.W (((defmBounds_RA2Em*4)/8)/4)-1,(V8_512_RB-((defmBounds_RA2Em*4)/8))
|
|
DC.W 0,0 ; pad out table
|
|
|
|
V8GSParms_1024 DC.W defmBounds_BGS-1
|
|
DC.W (((defmBounds_RGS*1)/8)/4)-1,(V8_1024_RB-((defmBounds_RGS*1)/8))
|
|
DC.W (((defmBounds_RGS*2)/8)/4)-1,(V8_1024_RB-((defmBounds_RGS*2)/8))
|
|
DC.W (((defmBounds_RGS*4)/8)/4)-1,(V8_1024_RB-((defmBounds_RGS*4)/8))
|
|
DC.W (((defmBounds_RGS*8)/8)/4)-1,(V8_1024_RB-((defmBounds_RGS*8)/8))
|
|
DC.W (((defmBounds_RGS*16)/8)/4)-1,(V8_1024_RB-((defmBounds_RGS*16)/8))
|
|
|
|
V8HRvRAMParms_1024 DC.W defmBounds_BHR-1
|
|
DC.W (((defmBounds_RHR*1)/8)/4)-1,(V8_1024_RB-((defmBounds_RHR*1)/8))
|
|
DC.W (((defmBounds_RHR*2)/8)/4)-1,(V8_1024_RB-((defmBounds_RHR*2)/8))
|
|
DC.W (((defmBounds_RHR*4)/8)/4)-1,(V8_1024_RB-((defmBounds_RHR*4)/8))
|
|
DC.W (((defmBounds_RHR*8)/8)/4)-1,(V8_1024_RB-((defmBounds_RHR*8)/8))
|
|
|
|
V8A2Parms_1024 DC.W defmBounds_BA2Em-1
|
|
DC.W (((defmBounds_RA2Em*1)/8)/4)-1,(V8_1024_RB-((defmBounds_RA2Em*1)/8))
|
|
DC.W (((defmBounds_RA2Em*2)/8)/4)-1,(V8_1024_RB-((defmBounds_RA2Em*2)/8))
|
|
DC.W (((defmBounds_RA2Em*4)/8)/4)-1,(V8_1024_RB-((defmBounds_RA2Em*4)/8))
|
|
DC.W (((defmBounds_RA2Em*8)/8)/4)-1,(V8_1024_RB-((defmBounds_RA2Em*8)/8))
|
|
|
|
V8HRParms DC.W defmBounds_BHR-1
|
|
DC.W (((defmBounds_RHR*1)/8)/4)-1,(OBMHRRB-((defmBounds_RHR*1)/8))
|
|
|
|
LongParmShift EQU V8GSParms_1024-V8GSParms
|
|
|
|
ENDWITH
|
|
|
|
|
|
;-------------------------------------------------------------
|
|
; The Interrupt handler for the Elsie Built-In Video
|
|
;-------------------------------------------------------------
|
|
; On entry A1 contains the pointer to the driver's private storage
|
|
; D0-D3/A0-A3 have been preserved.
|
|
|
|
|
|
V8BeginIH
|
|
|
|
MOVE.L V8,A0 ; point to the VISA chip
|
|
MOVE.B #$40,V8SInt(A0) ; clear the interrupt
|
|
CLR.W D0 ; set slot zero in D0
|
|
|
|
MOVE.L JVBLTask,A0 ; call the VBL task manager
|
|
JSR (A0) ; with slot # in D0
|
|
|
|
@Done
|
|
MOVEQ #1,D0 ; signal that int was serviced
|
|
RTS ; and return to caller
|
|
|
|
END |