egaint10.inc

[随书类]Dos6.0源代码

WriteReg        proc    near                    ;3c0h assumed to be ok state
                mov     ax,bx
                mov     si,dx
                cmp     dx,NumPtrData * size PortRec
                mov     dx,PortTable[si].PRPortAddr
                mov     byte ptr PortTable[si].PRModFlag,1
                mov     si,PortTable[si].PRCurrTable
                jge     WRegNoPtr
                xor     bh,bh
                mov     [si+bx],ah
                out     dx,ax
                ret
WRegNoPtr:      mov     [si],al
                mov     [SingleRegMod],1
                out     dx,al
                ret
WriteReg        endp


ReadRange       proc    near            ;should only be called for ptr/data regs
                sti
                cld                     ;cl must be > 1
                push    di
                mov     di,bx
                mov     si,dx
                mov     si,PortTable[si].PRCurrTable
                xor     ax,ax
                xchg    al,ch
                add     si,ax
		shr	cx,1
		rep	movsw
		rcl	cx,1
		rep	movsb
                pop     di
                ret
ReadRange       endp


WriteRange      proc    near
                sti
                cld
                push    di
                push    es
                mov     si,bx
                mov     di,dx
                mov     byte ptr PortTable[di].PRModFlag,1
                mov     dx,PortTable[di].PRPortAddr
                mov     di,PortTable[di].PRCurrTable
                mov     ax,es
                mov     bx,ds
                mov     es,bx
                mov     ds,ax
                xor     ax,ax
                xchg    al,ch
                add     di,ax
                push    cx
                shr     cx,1
		rep	movsw
		rcl	cx,1
		rep	movsb
                mov     ds,bx
                pop     cx
                sub     di,cx
WRangeNextReg:  mov     ah,[di]
                out     dx,ax           ;al initially contains starting reg
                inc     di
                inc     al
                loop    WRangeNextReg
                pop     es
                pop     di
                ret
WriteRange      endp


ReadSet         proc    near
                sti
                cld
                push    di
                mov     di,bx
RSetNextEntry:  mov     si,es:[di].SRPortNum
                mov     si,PortTable[si].PRCurrTable
                mov     al,es:[di].SRPtr
                cbw
                add     si,ax
                add     di,offset SRData
                movsb
                loop    RSetNextEntry
                pop     di
                ret
ReadSet         endp


WriteSet        proc    near
                sti
                cld
                push    di
                push    dx
                mov     di,bx
WSetNextEntry:  mov     si,es:[di].SRPortNum
                mov     byte ptr PortTable[si].PRModFlag,1
                mov     dx,PortTable[si].PRPortAddr
                mov     si,PortTable[si].PRCurrTable
                mov     al,es:[di].SRPtr
                cbw
                add     si,ax
                mov     ah,es:[di].SRData
                mov     [si],ah
                out     dx,ax
                add     di,size SetRec
                loop    WSetNextEntry
                pop     dx
                pop     di
                ret
WriteSet        endp


RevertDefault   proc    near
                sti
                cld
                push    di
                push    es
                push    dx
                push    cx
                push    bx
                mov     ax,ds
                mov     es,ax
                mov     bx,offset PortTable
                xor     cx,cx
RDefNextPtrData:cmp     byte ptr [bx].PRModFlag,ch
                je      RDefNotModified
                mov     byte ptr [bx].PRModFlag,ch
                mov     cl,byte ptr [bx].PRNumRegs
                mov     di,[bx].PRCurrTable
                mov     si,[bx].PRDefTable
                mov     dx,cx
                shr     cx,1
		rep	movsw
		rcl	cx,1
		rep	movsb
                mov     cx,dx
		sub	si,cx
                mov     dx,[bx].PRPortAddr

		cmp	dx,3C0h 		;attribute controller?
		jne	RDef1			;no
		sub	ax,ax			;yes, so update bios areas
		mov	es,ax			;they don't need es anymore
		mov	al,[si+16]		;fetch new mode ctrl
		and	al,00001000b		;isolate blink bit
		and	byte ptr es:[0465h],11011111b
;[1]		shl	al,2
		shl	al,1
		shl	al,1
		or	es:[0465h],al		;store new blink bit
		les	di,es:[04A8h]		;get save area address
		les	di,es:[di+4]		;get 2nd dword ptr there
		mov	ax,es
		or	ax,di			;anything there?
		jz	RDef1			;no
		mov	ax,cx			;save count
		mov	cx,16/2 		;copy 16 palette registers
		rep	movsw			;done!
		inc	si			;skip to the overscan value
		movsb				;copied!
		sub	si,18			;rewind src pointer
		mov	cx,ax			;restore count

RDef1:		mov	al,ch
RDefNextOut:    mov     ah,[si]
                cmp     dx,SequencerAddr                ; SAS 06/09/86
                jne     RDefNextOut1                    ; SAS 06/09/86
                cmp     al,SequencerClMReg              ; SAS 06/09/86
                je      DontRDefOut                     ; SAS 06/09/86
RDefNextOut1:   cmp     dx,GraphicsAddr
                jne     RDefOut
                cmp     al,GraphicsMiscReg
                je      DontRDefOut
RDefOut:        out     dx,ax
DontRDefOut:    inc     si
                inc     al
                loop    RDefNextOut

RDefNotModified:add     bx,size PortRec
                cmp     bx,offset PortTable + (NumPtrData * size PortRec)
		jae	RDef2
		jmp	RDefNextPtrData
RDef2:		cmp	[SingleRegMod],ch
                je      RDEFSinglesOK
                mov     [SingleRegMod],ch
                mov     dx,[bx+size PortRec].PRPortAddr
                mov     al,[DefFeatureReg]
                mov     [FeatureReg],al
                out     dx,al
                mov     dx,3c2h
                mov     al,[DefMiscOutReg]
                mov     [MiscOutReg],al
                out     dx,al
                mov     dx,3cch
                mov     al,[DefGR1PosReg]
                mov     [GR1PosReg],al
                out     dx,al
                mov     dx,3cah
                mov     al,[DefGR2PosReg]
                mov     [GR2PosReg],al
                out     dx,al

RDefSinglesOK:  mov     dx,3c0h
                mov     al,20h
                out     dx,al
                mov     dx,PortTable[5 * size PortRec].PRPortAddr
                in      al,dx
                pop     bx
                pop     cx
                pop     dx
                pop     es
                pop     di
                ret
RevertDefault   endp


DefineDefault   proc    near
                sti
                cld
                push    di
                push    cx
                mov     si,bx
                mov     di,dx
                xor     ch,ch
                mov     cl,byte ptr PortTable[di].PRNumRegs
                mov     byte ptr PortTable[di].PRModFlag,cl
                mov     [SingleRegMod],cl
                mov     di,PortTable[di].PRDefTable
                mov     ax,es
                mov     bx,ds
                mov     es,bx
                mov     ds,ax
                shr     cx,1
		rep	movsw
		rcl	cx,1
		rep	movsb
		mov	es,ax
                mov     ds,bx
                pop     cx
                pop     di
                ret
DefineDefault   endp


GetDefault      proc    near
                sti
                cld
                push    si
                push    di
                push    cx
                mov     di,bx
                mov     si,dx
                xor     ch,ch
                mov     cl,byte ptr PortTable[si].PRNumRegs
                mov     si,PortTable[si].PRDefTable
                shr     cx,1
		rep	movsw
		rcl	cx,1
		rep	movsb
		pop	cx
                pop     di
                pop     si
                ret
GetDefault      endp


InquireDriver   proc    near
                mov     ax,ds
                mov     es,ax
                mov     bx,offset EgaStateVars
		ret
InquireDriver   endp


CallInt10	proc	near			;very dependent on stack!
                push    bp
                mov     bp,sp
                mov     ax,[bp].8
                mov     ds,ax
                mov     si,[bp].6
                mov     ax,[bp].4
                pop     bp
                pushf
                call    cs:[Int10Vector]
                push    bp
                mov     bp,sp
                mov     [bp].4,ax
                mov     [bp].6,si
                mov     ax,ds
                mov     [bp].8,ax
                pop     bp
                ret
CallInt10       endp