3568 lines
127 KiB
NASM
3568 lines
127 KiB
NASM
PAGE ,132
|
|
TITLE DXINTR.ASM -- Dos Extender Interrupt Reflector
|
|
|
|
; Copyright (c) Microsoft Corporation 1988-1991. All Rights Reserved.
|
|
|
|
;****************************************************************
|
|
;* *
|
|
;* DXINTR.ASM - Dos Extender Interrupt Reflector *
|
|
;* *
|
|
;****************************************************************
|
|
;* *
|
|
;* Revision History: *
|
|
;* *
|
|
;* *
|
|
;* 09/13/90 earleh Fault handlers Ring 0 *
|
|
;* 09/06/90 earleh Fault handlers DPMI compliant *
|
|
;* PIC remapping no longer required *
|
|
;* 08/08/90 earleh DOSX and client privilege ring determined *
|
|
;* by equate in pmdefs.inc *
|
|
;* 05/09/90 jimmat Started VCPI changes. *
|
|
;* 04/02/90 jimmat Added PM Int 70h handler. *
|
|
;* 01/08/90 jimmat Don't allow nested PS/2 mouse interrupts *
|
|
;* (later removed!) *
|
|
;* 09/15/89 jimmat Support for 'Classic' HP Vectras which *
|
|
;* have 3 8259 interrupt controllers *
|
|
;* 07/28/89 jimmat Save A20 state when reflecting an int to *
|
|
;* protected mode, removed Int 30h handler *
|
|
;* that did code patch-ups, point debugger *
|
|
;* to faulting instruction, not Int 3. *
|
|
;* 07/13/89 jimmat Improved termination due to faults when *
|
|
;* not running under a debugger--also ifdef'd *
|
|
;* out code to dynamically fixup code seg *
|
|
;* references on GP faults *
|
|
;* 06/05/89 jimmat Ints 0h-1Fh are now vectored through a 2nd *
|
|
;* table. This allows Wdeb386 interaction *
|
|
;* more like Windows/386. *
|
|
;* 05/23/89 jimmat Added wParam & lParam to interrupt frame. *
|
|
;* 05/07/89 jimmat Added XMScontrol function to map protected *
|
|
;* mode XMS requests to real mode driver. *
|
|
;* 05/02/89 jimmat 8259 interrupt mask saved around changing *
|
|
;* of hardware interrupt base *
|
|
;* 04/24/89 jimmat Added support for PS/2 Int 15h/C2h/07 Set *
|
|
;* Pointing Device Handler Address function *
|
|
;* 04/12/89 jimmat Added PMIntr24 routine to support PM *
|
|
;* Critical Error Handlers *
|
|
;* 03/15/89 jimmat Added INT 31h LDT/heap interface a la *
|
|
;* Windows/386 *
|
|
;* 03/14/89 jimmat Changes to run child in ring 1 with LDT *
|
|
;* 02/24/89 (GeneA): fixed problem in IntEntryVideo and *
|
|
;* IntExitVideo for processing function 10h subfunction *
|
|
;* for reading and writing the VGA palette. *
|
|
;* 02/22/89 (GeneA): added handlers for Int 10h, Int 15h, and *
|
|
;* Int 33h. Added support for more general mechanism for *
|
|
;* handling interrupts require special servicing and *
|
|
;* allowing nesting of these interrupts. Allocation and *
|
|
;* deallocation of stack frames is supported to allow *
|
|
;* nested paths through the interrupt reflection code to *
|
|
;* a depth of 8. *
|
|
;* There is still a problem that if an interrupt handler *
|
|
;* is using a static buffer to transfer data, another *
|
|
;* interrupt that uses the same static buffer could come *
|
|
;* in and trash it. Solving the problem in a completely *
|
|
;* general way would require having a buffer allocation *
|
|
;* deallocation scheme for doing the transfers between *
|
|
;* real mode memory and protected mode memory. *
|
|
;* 02/14/89 (GeneA): added code in TrapGP to print error msg *
|
|
;* and quit when running a non-debugging version. *
|
|
;* 02/10/89 (GeneA): changed Dos Extender from small model to *
|
|
;* medium model. Added function LoaderTrap to handle *
|
|
;* loader interrupts when the program contains overlays. *
|
|
;* 11/20/88 (GeneA): changed both RM and PM interrupt reflector*
|
|
;* routines to pass the flags returned by the ISR back to *
|
|
;* the originator of the interrupt, rather than returning *
|
|
;* the original flags. *
|
|
;* 10/28/88 (GeneA): created *
|
|
; 18-Dec-1992 sudeepb Changed cli/sti to faster FCLI/FSTI
|
|
;* *
|
|
;****************************************************************
|
|
|
|
.286p
|
|
.287
|
|
|
|
; -------------------------------------------------------
|
|
; INCLUDE FILE DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
.xlist
|
|
.sall
|
|
include segdefs.inc
|
|
include gendefs.inc
|
|
include pmdefs.inc
|
|
include interupt.inc
|
|
ifdef WOW_x86
|
|
include vdmtib.inc
|
|
endif
|
|
.list
|
|
include intmac.inc
|
|
include stackchk.inc
|
|
include bop.inc
|
|
include dpmi.inc
|
|
|
|
; -------------------------------------------------------
|
|
; GENERAL SYMBOL DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; EXTERNAL SYMBOL DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
extrn EnterRealMode:NEAR
|
|
extrn EnterProtectedMode:NEAR
|
|
extrn ParaToLinear:NEAR
|
|
externFP NSetSegmentDscr
|
|
ifdef NEC_98
|
|
extrn GetSegmentAddress:NEAR
|
|
endif ;NEC_98
|
|
extrn ParaToLDTSelector:NEAR
|
|
|
|
; -------------------------------------------------------
|
|
; DATA SEGMENT DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
DXDATA segment
|
|
|
|
extrn pmusrss:WORD
|
|
extrn pmusrsp:WORD
|
|
extrn npXfrBuf1:WORD
|
|
extrn rgbXfrBuf0:BYTE
|
|
extrn rgbXfrBuf1:BYTE
|
|
extrn lpfnXMSFunc:DWORD
|
|
extrn Int28Filter:WORD
|
|
extrn DpmiFlags:WORD
|
|
IFDEF WOW_x86
|
|
extrn FastBop:fword
|
|
ENDIF
|
|
|
|
;
|
|
; Variables used to store register values while mode switching.
|
|
|
|
public regUserSS, regUserSP, regUserFL, regUserAX, regUserDS
|
|
public regUserES
|
|
|
|
regUserSS dw ?
|
|
regUserSP dw ?
|
|
regUserCS dw ?
|
|
regUserIP dw ?
|
|
regUserFL dw ?
|
|
regUserAX dw ?
|
|
regUserDS dw ?
|
|
regUserES dw ?
|
|
pfnReturnAddr dw ?
|
|
|
|
Int28Count dw -1 ;Count of idle Int 28h's not reflected to RM
|
|
|
|
;
|
|
; Far pointer to the user's mouse callback function.
|
|
|
|
public lpfnUserMouseHandler
|
|
|
|
lpfnUserMouseHandler dd 0 ;Entry point to the users mouse handler
|
|
cbMouseState dw 0 ;size of mouse state buffer in bytes
|
|
|
|
|
|
; Far pointer to PS/2 Pointing device handler address
|
|
|
|
public lpfnUserPointingHandler
|
|
|
|
lpfnUserPointingHandler dd 0 ;Sel:Off to user's handler
|
|
|
|
align 2
|
|
|
|
if DEBUG
|
|
extrn StackGuard:WORD
|
|
endif
|
|
extrn pbReflStack:WORD
|
|
extrn bReflStack:WORD
|
|
;
|
|
; This buffer contains the original real mode interrupt vectors.
|
|
ifdef NEC_98
|
|
public rglpfnRmISR
|
|
endif ;NEC_98
|
|
|
|
align 2
|
|
rglpfnRmISR dd 256 dup (?)
|
|
|
|
; PMFaultVector is a table of selector:offsets for routines to process
|
|
; protected mode processor faults/traps/exceptions. If we don't handle
|
|
; the exception as an exception, we vector it through PMReservedEntryVector.
|
|
|
|
FltRtn macro off
|
|
dw DXPMCODE:off
|
|
dw 0
|
|
dw SEL_DXPMCODE or STD_RING
|
|
dw 0
|
|
endm
|
|
public PMFaultVector
|
|
|
|
align 4
|
|
|
|
PMFaultVector label DWORD
|
|
FltRtn PMFaultEntryVector+5*0h ; int 0
|
|
FltRtn PMFaultEntryVector+5*1h ; int 1
|
|
FltRtn PMFaultEntryVector+5*2h ; int 2
|
|
FltRtn PMFaultEntryVector+5*3h ; int 3
|
|
FltRtn PMFaultEntryVector+5*4h ; int 4
|
|
FltRtn PMFaultEntryVector+5*5h ; int 5
|
|
FltRtn PMFaultEntryVector+5*6h ; int 6
|
|
FltRtn PMFaultEntryVector+5*7h ; int 7
|
|
FltRtn PMFaultEntryVector+5*8h ; int 8
|
|
FltRtn PMFaultEntryVector+5*9h ; int 9
|
|
FltRtn PMFaultEntryVector+5*0Ah ; int a
|
|
FltRtn PMFaultEntryVector+5*0Bh ; int b
|
|
FltRtn PMFaultEntryVector+5*0Ch ; int c
|
|
FltRtn PMFaultEntryVector+5*0Dh ; int d
|
|
FltRtn PMFaultEntryVector+5*0Eh ; int e
|
|
FltRtn PMFaultEntryVector+5*0Fh ; int f
|
|
FltRtn PMFaultEntryVector+5*10h ; int 10h
|
|
FltRtn PMFaultEntryVector+5*11h ; int 11h
|
|
FltRtn PMFaultEntryVector+5*12h ; int 12h
|
|
FltRtn PMFaultEntryVector+5*13h ; int 13h
|
|
FltRtn PMFaultEntryVector+5*14h ; int 14h
|
|
FltRtn PMFaultEntryVector+5*15h ; int 15h
|
|
FltRtn PMFaultEntryVector+5*16h ; int 16h
|
|
FltRtn PMFaultEntryVector+5*17h ; int 17h
|
|
FltRtn PMFaultEntryVector+5*18h ; int 18h
|
|
FltRtn PMFaultEntryVector+5*19h ; int 19h
|
|
FltRtn PMFaultEntryVector+5*1Ah ; int 1ah
|
|
FltRtn PMFaultEntryVector+5*1Bh ; int 1bh
|
|
FltRtn PMFaultEntryVector+5*1Ch ; int 1ch
|
|
FltRtn PMFaultEntryVector+5*1Dh ; int 1Dh
|
|
FltRtn PMFaultEntryVector+5*1Eh ; int 1Eh
|
|
FltRtn PMFaultEntryVector+5*1Fh ; int 1Fh
|
|
|
|
|
|
extrn npEHStackLimit:word
|
|
extrn npEHStacklet:word
|
|
ifdef NEC_98
|
|
extrn fPCH98:BYTE
|
|
endif ;NEC_98
|
|
IFDEF WOW
|
|
public Wow16BitHandlers
|
|
Wow16BitHandlers dw 256 dup (0,0)
|
|
|
|
ENDIF
|
|
|
|
DXDATA ends
|
|
|
|
|
|
DXSTACK segment
|
|
|
|
public rgw0Stack, rgw2FStack
|
|
|
|
dw 64 dup (?) ; INT 2Fh handler stack
|
|
|
|
rgw2FStack label word
|
|
|
|
dw 64 dup (?) ; DOSX Ring -> Ring 0 transition stack
|
|
;
|
|
; Interrupts in the range 0-1fh cause a ring transition and leave
|
|
; an outer ring IRET frame right here.
|
|
;
|
|
Ring0_EH_DS dw ? ; place to put user DS
|
|
Ring0_EH_AX dw ? ; place to put user AX
|
|
Ring0_EH_BX dw ? ; place to put user BX
|
|
Ring0_EH_CX dw ? ; place to put user CX
|
|
Ring0_EH_BP dw ? ; place to put user BP
|
|
Ring0_EH_PEC dw ? ; lsw of error code for 386 page fault
|
|
; also near return to PMFaultEntryVector
|
|
Ring0_EH_EC dw ? ; error code passed to EH
|
|
Ring0_EH_IP dw ? ; interrupted code IP
|
|
Ring0_EH_EIP dw ? ; high half eip
|
|
Ring0_EH_CS dw ? ; interrupted code CS
|
|
dw ? ; high half of cs
|
|
Ring0_EH_Flags dw ? ; interrupted code flags
|
|
Ring0_EH_EFlags dw ? ; high half of flags
|
|
Ring0_EH_SP dw ? ; interrupted code SP
|
|
Rin0_EH_ESP dw ? ; high half of esp
|
|
Ring0_EH_SS dw ? ; interrupted code SS
|
|
dw ? ; high half of ss
|
|
rgw0Stack label word
|
|
|
|
dw 64 dup (?) ; stack for switching to ring0
|
|
public ResetStack
|
|
ResetStack label word
|
|
ifdef WOW_x86
|
|
dw 64 dup (?) ; wow stack for initial int field
|
|
public rgwWowStack
|
|
rgwWowStack label word
|
|
endif
|
|
|
|
DXSTACK ends
|
|
|
|
; -------------------------------------------------------
|
|
; CODE SEGMENT VARIABLES
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE segment
|
|
|
|
extrn selDgroup:WORD
|
|
|
|
DXCODE ends
|
|
|
|
DXPMCODE segment
|
|
|
|
extrn selDgroupPM:WORD
|
|
extrn segDXCodePM:WORD
|
|
extrn RZCall:NEAR
|
|
extrn segDXDataPM:WORD
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
page
|
|
subttl Protected Mode Interrupt Reflector
|
|
; -------------------------------------------------------
|
|
; PROTECTED MODE INTERRUPT REFLECTOR
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
; -------------------------------------------------------
|
|
; PMIntrEntryVector -- This table contains a vector of
|
|
; near jump instructions to the protected mode interrupt
|
|
; reflector. The protected mode interrupt descriptor
|
|
; table is initialized so that all interrupts jump to
|
|
; locations in this table, which transfers control to
|
|
; the interrupt reflection code for reflecting the
|
|
; interrupt to real mode.
|
|
|
|
StartBopTable macro
|
|
?intr = 0
|
|
endm
|
|
|
|
PMIntrBop macro
|
|
DPMIBOP ReflectIntrToV86
|
|
db ?intr
|
|
?intr = ?intr+1
|
|
endm
|
|
|
|
public PMIntrEntryVector
|
|
|
|
PMIntrEntryVector:
|
|
|
|
StartBopTable
|
|
rept 256
|
|
PMIntrBop
|
|
endm
|
|
|
|
|
|
FaultBop macro
|
|
DPMIBOP DpmiUnhandledException
|
|
db ?intr
|
|
?intr = ?intr+1
|
|
endm
|
|
|
|
public PMFaultEntryVector
|
|
|
|
; -------------------------------------------------------
|
|
; PMFaultEntryVector -- This table contains a vector of
|
|
; near jump instructions to the protected mode fault
|
|
; analyzer.
|
|
;
|
|
PMFaultEntryVector:
|
|
|
|
StartBopTable
|
|
rept 32
|
|
FaultBop
|
|
endm
|
|
|
|
assume ds:nothing,es:nothing,ss:nothing
|
|
|
|
public PMFaultHandlerIRET
|
|
PMFaultHandlerIRET:
|
|
DPMIBOP FaultHandlerIret
|
|
|
|
public PMFaultHandlerIRETD
|
|
PMFaultHandlerIRETD:
|
|
DPMIBOP FaultHandlerIretd
|
|
|
|
public PMIntHandlerIRET
|
|
PMIntHandlerIRET:
|
|
DPMIBOP IntHandlerIret
|
|
|
|
public PMIntHandlerIRETD
|
|
PMIntHandlerIRETD:
|
|
DPMIBOP IntHandlerIretd
|
|
|
|
public PMDosxIret
|
|
PMDosxIret:
|
|
iret
|
|
|
|
public PMDosxIretd
|
|
PMDosxIretd:
|
|
db 66h
|
|
iret
|
|
|
|
public HungAppExit
|
|
HungAppExit:
|
|
mov ax,4CFFh
|
|
int 21h
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl Real Mode Interrupt Reflector
|
|
page
|
|
; -------------------------------------------------------
|
|
; REAL MODE INTERRUPT REFLECTOR
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE segment
|
|
assume cs:DXCODE
|
|
; -------------------------------------------------------
|
|
; RMIntrEntryVector -- This table contains a vector of
|
|
; near jump instructions to the real mode interrupt
|
|
; reflector. Real mode interrupts that have been hooked
|
|
; by the protected mode application have their vector
|
|
; set to entry the real mode reflector through this table.
|
|
|
|
public RMtoPMReflector
|
|
RMtoPMReflector:
|
|
DPMIBOP ReflectIntrToPM
|
|
|
|
public RMCallBackBop
|
|
RMCallBackBop proc far
|
|
DPMIBOP RMCallBackCall
|
|
ret ;finished!
|
|
|
|
RMCallBackBop endp
|
|
DXCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl INT 24h Critical Error Mapper
|
|
page
|
|
; -------------------------------------------------------
|
|
; DOS CRITICAL ERROR MAPPER
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE segment
|
|
|
|
; -------------------------------------------------------
|
|
; RMDefaultInt24Handler -- Default action for a DOS critical
|
|
; error is to fail the call.
|
|
;
|
|
public RMDefaultInt24Handler
|
|
RMDefaultInt24Handler proc far
|
|
mov al,3
|
|
iret
|
|
RMDefaultInt24Handler endp
|
|
|
|
DXCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl INT 28h Idle Handler
|
|
page
|
|
; -------------------------------------------------------
|
|
; INT 28H IDLE HANDLER
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntr28 -- Protected mode handler for Idle Int 28h calls.
|
|
; The purpose of this routine is simply to cut down on the
|
|
; number of protected mode to real mode switches by ignoring
|
|
; many of the Int 28h idle calls made by the Windows PM
|
|
; kernel.
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntr28
|
|
|
|
PMIntr28 proc near
|
|
|
|
|
|
cld
|
|
push ds ;address our DGROUP
|
|
mov ds,selDgroupPM
|
|
assume ds:DGROUP
|
|
|
|
cmp Int28Filter,0 ;are we passing any through?
|
|
jz @f
|
|
|
|
inc Int28Count ;should this one be reflected?
|
|
jz i28_reflect
|
|
@@:
|
|
pop ds
|
|
iret ; no, just ignore it
|
|
|
|
i28_reflect: ; yes, reset count and
|
|
push ax ; reflecto to real mode
|
|
mov ax,Int28Filter
|
|
neg ax
|
|
mov Int28Count,ax
|
|
pop ax
|
|
pop ds
|
|
assume ds:NOTHING
|
|
|
|
jmp PMIntrEntryVector + 5*28h
|
|
|
|
PMIntr28 endp
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntr31 -- Service routine for the Protect Mode INT 31h
|
|
; services. These functions duplicate the
|
|
; Windows/386 VMM INT 31h services for protected
|
|
; mode applications. They were implemented to
|
|
; support a protect mode version of Windows/286.
|
|
;
|
|
; Input: Various registers
|
|
; Output: Various registers
|
|
; Errors:
|
|
; Uses: All registers preserved, other than return values
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntr31
|
|
|
|
PMIntr31 proc near
|
|
|
|
push ds
|
|
push ax
|
|
mov ax,SEL_DXDATA OR STD_RING
|
|
mov ds,ax
|
|
assume ds:DGROUP
|
|
pop ax
|
|
|
|
FBOP BOP_DPMI,Int31Entry,FastBop
|
|
int 3
|
|
; This BOP does an implicit IRET
|
|
|
|
PMIntr31 endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
subttl Ignore Interrupt Handlers
|
|
page
|
|
; -------------------------------------------------------
|
|
; IGNORE INTERRUPT HANDLER
|
|
; -------------------------------------------------------
|
|
|
|
; PMIntrIgnore -- Service routine for protected mode interrupts
|
|
; that should be ignored, and not reflected to real mode.
|
|
; Currently used for:
|
|
;
|
|
; Int 30h - used to be Win/386 Virtualize I/O, now
|
|
; unused but no int handler in real mode
|
|
; Int 41h - Wdeb386 interface, no int handler in
|
|
; real mode
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrIgnore
|
|
|
|
PMIntrIgnore proc near
|
|
|
|
iret
|
|
|
|
PMIntrIgnore endp
|
|
|
|
; -------------------------------------------------------
|
|
|
|
public PMIntr19
|
|
PMIntr19 proc near
|
|
|
|
push offset DXPMCODE:Reboot
|
|
call RZCall
|
|
|
|
bpRebootIDT df 0
|
|
|
|
Reboot:
|
|
mov ax,40h
|
|
mov es,ax
|
|
mov word ptr es:[0072h],1234h
|
|
lidt bpRebootIDT
|
|
int 3
|
|
|
|
PMIntr19 endp
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl XMS Driver Interface
|
|
page
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
; -------------------------------------------------------
|
|
; XMScontrol - This function implements a protected mode
|
|
; interface to a real mode XMS driver. Unlike other
|
|
; routines in this module, this routine is called by
|
|
; the user, not invoked via an INT instruction.
|
|
;
|
|
; Input: User's regs for XMS driver
|
|
; Output: regs from XMS driver
|
|
; Uses: none
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public XMScontrol
|
|
|
|
XMScontrol proc far
|
|
|
|
jmp short XMSentry ;'standard' XMS control function
|
|
nop ; just to be consistant
|
|
nop
|
|
nop
|
|
|
|
XMSentry:
|
|
|
|
; Modify the stack so it looks like we got here via an INT (except that
|
|
; we may still have interrupts enabled)
|
|
|
|
pushf
|
|
cld
|
|
|
|
push bp
|
|
mov bp,sp ;bp -> [BP] [FL] [IP] [CS]
|
|
push ax
|
|
push bx
|
|
|
|
mov ax,[bp+4]
|
|
mov bx,[bp+6]
|
|
xchg ax,[bp+2]
|
|
mov [bp+4],bx
|
|
mov [bp+6],ax ;bp -> [BP] [IP] [CS] [FL]
|
|
pop bx
|
|
pop ax
|
|
pop bp
|
|
|
|
; We don't support XMS function 0Bh (Move Extended Memory Block) because
|
|
; it requires mapping of data between hi/low memory. Maybe someday...
|
|
|
|
cmp ah,0Bh
|
|
jnz xms_2
|
|
xms_deny:
|
|
xor ax,ax ;if function 0Bh, return failure
|
|
mov bl,80h ; (ax = 0, bl = 80h-not implemented)
|
|
jmp short XMSret
|
|
xms_2:
|
|
|
|
; We are not really an Int handler, but close enough...
|
|
|
|
call EnterIntHandler ;build an interrupt stack frame
|
|
assume ds:DGROUP,es:DGROUP ; also sets up addressability
|
|
|
|
SwitchToRealMode
|
|
|
|
pop es ;load regs for driver
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING,ss:DGROUP
|
|
popa
|
|
npopf
|
|
|
|
call lpfnXMSFunc ;call real mode driver
|
|
|
|
pushf ;rebuild stack frame
|
|
FCLI
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
|
|
mov bp,sp ;restore stack frame pointer
|
|
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
|
|
call LeaveIntHandler
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
|
|
XMSret:
|
|
riret
|
|
|
|
XMScontrol endp
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl Special Interrupt Handler Routines
|
|
page
|
|
; -------------------------------------------------------
|
|
;
|
|
; The following sets of routines handle interrupts that
|
|
; are function call interfaces and require special servicing
|
|
; by the Dos Extender. These interrupts are such things as
|
|
; the mouse driver function call interrupt, various PC BIOS
|
|
; function call interrupts, etc. Note that INT 21h (the Dos
|
|
; function call interrupt) is not handled here. These
|
|
; interrupts typically require that register values be modified
|
|
; and parameter data be copied between real mode memory and
|
|
; extended memory. The following conventions are used for these
|
|
; interrupt function handler routines.
|
|
;
|
|
; A stack is allocated from the interrupt reflector stack for these
|
|
; routines to use. This allows nested servicing of interrupts.
|
|
; A stack frame is built in the allocated stack which contains the
|
|
; following information:
|
|
; original caller's stack address
|
|
; caller's original flags and general registers (in pusha form)
|
|
; caller's original segment registers (DS & ES)
|
|
; flags and general registers to be passed to interrupt routine
|
|
; (initially the same as caller's original values)
|
|
; segment registers (DS & ES) to be passed to interrupt routine
|
|
; (initially set to the Dos Extender data segment address)
|
|
; This stack frame is built by the routine EnterIntHandler, and its
|
|
; format is defined by the structure INTRSTACK. The stack frame is
|
|
; destroyed and the processor registers set up for return to the user
|
|
; by the function LeaveIntHandler.
|
|
;
|
|
; For each interrupt, there is an entry function and an exit function.
|
|
; The entry function performs any modifications to parameter values and
|
|
; data buffering necessary before the interrupt service routine is called.
|
|
; The exit function performs any data buffering and register value
|
|
; modifications after return from the interrupt service routine.
|
|
;
|
|
; There are two sets of general registers and two sets of segment
|
|
; registers (DS & ES) on the stack frame. One set of register values
|
|
; has member names of the form intUserXX. The values in these stack
|
|
; frame members will be passed to the interrupt service routine when
|
|
; it is called, and will be loaded with the register values returned
|
|
; by the interrupt service routine. The other set of registers values
|
|
; has member names of the form pmUserXX. These stack frame members
|
|
; contain the original values in the registers on entry from the
|
|
; user program that called the interrupt.
|
|
;
|
|
; When we return to the original caller, we want to pass back the
|
|
; general registers as returned by the interrupt routine (and possibly
|
|
; modified by the exit handler), and the same segment registers as
|
|
; on entry, unless the interrupt routine returns a value in a segment
|
|
; register. (in this case, there must be some code in the exit routine
|
|
; to handle this). This means that when we return to the caller, we
|
|
; return the general register values from the intUserXX set of stack
|
|
; frame members, but we return the segment registers from the pmUserXX
|
|
; set of frame members. By doing it this way, we don't have to do
|
|
; any work for the case where the interrupt subfuntion doesn't require
|
|
; any parameter manipulation. NOTE however, this means that when
|
|
; manipulating register values to be returned to the user, the segment
|
|
; registers are treated opposite to the way the general registers are
|
|
; treated. For general registers, to return a value to the user,
|
|
; store it in a intUserXX stack frame member. To return a segment
|
|
; value to the user, store it in a pmUserXX stack frame member.
|
|
;
|
|
; -------------------------------------------------------
|
|
subttl BIOS Video Interrupt (Int 10h) Service Routine
|
|
page
|
|
; -------------------------------------------------------
|
|
; BIOS VIDEO INTERRUPT (INT 10h) SERVICE ROUTINE
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntrVideo - Entry point into interrupt reflector code
|
|
; for IBM PC Bios video (int 10h) calls.
|
|
;
|
|
; Input: normal registers for Bios calls
|
|
; Output: normal register returns for Bios calls
|
|
; Errors: normal Bios errors
|
|
; Uses: as per Bios calls
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrVideo
|
|
|
|
PMIntrVideo:
|
|
|
|
ifdef NEC_98
|
|
cmp ah,40h
|
|
jb CRT_bios
|
|
cmp ah,4Fh ;4Bh-4Fh = Reserve
|
|
ja CRT_bios
|
|
jmp PMIntrGBIO
|
|
|
|
CRT_bios:
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
|
|
call IntEntryVideo
|
|
@@:
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*18h] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
|
|
;; test fPCH98,0FFh
|
|
;; jz NotNPCVideoExit ;for PC-H98 modelxx
|
|
;; call IntExitVideoNPC ; "
|
|
;; jmp @f ; "
|
|
;;NotNPCVideoExit: ; "
|
|
call IntExitVideo
|
|
@@:
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
iret
|
|
|
|
;/////////////////////////////////////////////////////////////////////////
|
|
; Nmode GRAPH BIOS
|
|
;/////////////////////////////////////////////////////////////////////////
|
|
; -------------------------------------------------------
|
|
; PMIntrGBIO
|
|
;--------------------------------------------------------
|
|
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrGBIO
|
|
|
|
PMIntrGBIO:
|
|
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
|
|
push ax
|
|
mov ax,[bp].pmUserDS
|
|
call GetSegmentAddress
|
|
shr dx,4
|
|
shl bx,12
|
|
or bx,dx ;bx now = seg of parent psp
|
|
mov [bp].intUserDS,bx
|
|
pop ax
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*18h] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
|
|
mov ax,ss
|
|
mov ds,ax
|
|
mov es,ax
|
|
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
push ax
|
|
mov ax,[bp].pmUserDS
|
|
mov [bp].intUserDS,ax
|
|
pop ax
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
iret
|
|
else ;!NEC_98
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntryVideo
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
sub sp,8 ; make room for stack frame
|
|
push bp
|
|
mov bp,sp
|
|
push es
|
|
push ax
|
|
|
|
xor ax,ax
|
|
mov es,ax
|
|
mov [bp + 8],cs
|
|
mov word ptr [bp + 6],offset piv_10
|
|
mov ax,es:[10h*4]
|
|
mov [bp + 2],ax
|
|
mov ax,es:[10h*4 + 2]
|
|
mov [bp + 4],ax
|
|
pop ax
|
|
pop es
|
|
pop bp
|
|
retf
|
|
|
|
piv_10: pushf
|
|
FCLI
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
call IntExitVideo
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
riret
|
|
endif ;!NEC_98
|
|
|
|
; -------------------------------------------------------
|
|
; IntEntryVideo -- This routine performs any register
|
|
; fixups and data copying needed on entry to the
|
|
; PC BIOS video interrupt (Int 10h)
|
|
;
|
|
; Input: register values on stack frame
|
|
; Output: register values on stack frame
|
|
; Errors: none
|
|
; Uses: any registers modified,
|
|
; possibly modifies buffers rgbXfrBuf0 or rgbXfrBuf1
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntryVideo
|
|
|
|
IntEntryVideo:
|
|
|
|
ifdef NEC_98
|
|
;video mode
|
|
|
|
cmp ah,0Fh
|
|
jnz ienv10
|
|
mov cx,16
|
|
jmp ienv70
|
|
ienv10:
|
|
cmp ah,14h
|
|
jnz ienv20
|
|
jmp ienv80
|
|
ienv20:
|
|
cmp ah,1Fh
|
|
jnz ienv30
|
|
jmp ienv110
|
|
ienv30:
|
|
cmp ah,1Ah
|
|
jnz ienv40
|
|
test fPCH98,0FFh
|
|
jnz H98_FontWrite_N
|
|
mov cx,34
|
|
jmp ienv70
|
|
ienv40:
|
|
cmp ah,20h
|
|
jnz ienv90
|
|
test fPCH98,0FFh
|
|
jnz @f
|
|
mov cx,72
|
|
jmp ienv100
|
|
|
|
@@:
|
|
jmp H98_FontWrite_H
|
|
|
|
ienv70:
|
|
push ds
|
|
mov si,[bp].pmUserCX ;offset address
|
|
mov ds,[bp].pmUserBX ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
ienv80:
|
|
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserBX,ax ;segment address
|
|
pop ax
|
|
|
|
mov [bp].intUserCX,offset DGROUP:rgbXfrBuf1
|
|
ienv90:
|
|
ret
|
|
|
|
ienv100:
|
|
push ds
|
|
mov si,[bp].pmUserBX ;offset address
|
|
mov ds,[bp].pmUserDS ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
ienv110:
|
|
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserDS,ax ;segment address
|
|
|
|
pop ax
|
|
|
|
mov [bp].intUserBX,offset DGROUP:rgbXfrBuf1
|
|
ienv120:
|
|
ret
|
|
|
|
H98_FontWrite_N:
|
|
|
|
cmp dx,7601h
|
|
jb @f
|
|
cmp dx,767Fh
|
|
jna WUSKZEN
|
|
cmp dx,7701h
|
|
jb @f
|
|
cmp dx,777Fh
|
|
jna WUSKZEN
|
|
cmp dx,7801h
|
|
jb @f
|
|
cmp dx,783Fh
|
|
;;;;;;;; ja ienv35
|
|
jna WUSKZEN
|
|
jmp ienv35
|
|
|
|
WUSKZEN:
|
|
mov cx,34
|
|
jmp ienv70
|
|
|
|
@@:
|
|
jmp ienv40
|
|
|
|
ienv35:
|
|
cmp dx,7840h
|
|
jb @b
|
|
cmp dx,787Fh
|
|
jna WUSKHAN
|
|
cmp dx,7D01h
|
|
jb @b
|
|
cmp dx,7D7Fh
|
|
jna WUSKHAN
|
|
cmp dx,7E01h
|
|
jb @b
|
|
cmp dx,7E7Fh
|
|
;;;;;;;; ja @b
|
|
jna WUSKHAN
|
|
jmp @b
|
|
WUSKHAN:
|
|
mov cx,18
|
|
jmp ienv70
|
|
|
|
H98_FontWrite_H:
|
|
|
|
cmp dx,7601h
|
|
jb @f
|
|
cmp dx,767Fh
|
|
jna HWUSKZEN
|
|
cmp dx,7701h
|
|
jb @f
|
|
cmp dx,777Fh
|
|
jna HWUSKZEN
|
|
cmp dx,7801h
|
|
jb @f
|
|
cmp dx,783Fh
|
|
;;;;;;;; ja @f
|
|
jna HWUSKZEN
|
|
jmp ienv45
|
|
HWUSKZEN:
|
|
;;;;;;;; mov cx,74
|
|
mov cx,72
|
|
jmp ienv100
|
|
|
|
@@:
|
|
jmp ienv90
|
|
|
|
ienv45:
|
|
cmp dx,7840h
|
|
jb @f
|
|
cmp dx,787Fh
|
|
jna HWUSKHAN
|
|
cmp dx,7D01h
|
|
jb @f
|
|
cmp dx,7D7Fh
|
|
jna HWUSKHAN
|
|
cmp dx,7E01h
|
|
jb @f
|
|
cmp dx,7E7Fh
|
|
;;;;;;;; ja @f
|
|
jna HWUSKHAN
|
|
jmp @f
|
|
HWUSKHAN:
|
|
;;;;;;;; mov cx,50
|
|
mov cx,48
|
|
jmp ienv100
|
|
@@:
|
|
ret
|
|
else ;!NEC_98
|
|
cmp ah,10h
|
|
jnz ienv20
|
|
;
|
|
; Video palette control function. Check for subfunctions that require
|
|
; special actions.
|
|
ienv10: cmp al,2 ;update all palette registers?
|
|
jnz @F
|
|
mov cx,17 ;palette data is 17 bytes long
|
|
jmp short ienv70 ;go copy the data
|
|
;
|
|
@@: cmp al,9 ;read all palette registers
|
|
jz ienv72
|
|
;
|
|
cmp al,12h ;update video DAC color registers
|
|
jnz @F
|
|
mov cx,[bp].pmUserCX ;count of table entries is in caller CX
|
|
add cx,cx ;each entry is 3 bytes long
|
|
add cx,[bp].pmUserCX
|
|
jmp short ienv70 ;go copy the data down
|
|
|
|
@@: cmp al,17h ;read a block of video DAC registers
|
|
jz ienv72
|
|
;
|
|
jmp short ienv90
|
|
;
|
|
;
|
|
ienv20: cmp ah,11h
|
|
jnz ienv30
|
|
;
|
|
; Character generator interface function.
|
|
; NOTE: a number of subfunctions of function 11h need to have munging
|
|
; and data buffering performed. However, function 30h is the only
|
|
; one used by Codeview, so this is the only one currently implemented.
|
|
; For this one, nothing needs to be done on entry, only on exit.
|
|
jmp short ienv90
|
|
;
|
|
;
|
|
ienv30: cmp ah,1Bh
|
|
jnz ienv40
|
|
;
|
|
; Video BIOS functionality/state information.
|
|
; On entry, we need to fix up ES:DI to point to our buffer.
|
|
mov [bp].intUserDI,offset DGROUP:rgbXfrBuf0
|
|
jmp short ienv90
|
|
;
|
|
;
|
|
ienv40:
|
|
jmp short ienv90
|
|
;
|
|
; Copy the buffer from the user ES:DX to our transfer buffer and set
|
|
; the value to DX passed to the interrupt routine to point to our buffer.
|
|
ienv70: cld
|
|
jcxz ienv90
|
|
push ds
|
|
mov si,[bp].pmUserDX
|
|
mov ds,[bp].pmUserES
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
;
|
|
ienv72: mov [bp].intUserDX,offset DGROUP:rgbXfrBuf1
|
|
jmp short ienv90
|
|
|
|
;
|
|
; All done
|
|
ienv90:
|
|
ret
|
|
endif ;!NEC_98
|
|
|
|
; -------------------------------------------------------
|
|
; IntExitVideo: This routine performs any register
|
|
; fixups and data copying needed on exit from the
|
|
; PC BIOS video interrupt (Int 10h).
|
|
;
|
|
; Input: register values on stack frame
|
|
; Output: register values on stack frame
|
|
; Errors: none
|
|
; Uses: any registers modified
|
|
; possibly modifies buffers rgbXfrBuf0 or rgbXfrBuf1
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitVideo
|
|
|
|
IntExitVideo:
|
|
|
|
ifdef NEC_98
|
|
;video mode
|
|
|
|
cmp ah,0Fh
|
|
jnz iexv10
|
|
jmp iexv80
|
|
iexv10:
|
|
cmp ah,14h
|
|
jnz iexv20
|
|
cmp dh,00h
|
|
jnz iexv11
|
|
mov cx,10
|
|
jmp iexv70
|
|
iexv11:
|
|
cmp dh,80h ;ANK(7*13)
|
|
jnz iexv12
|
|
mov cx,18
|
|
jmp iexv70
|
|
iexv12:
|
|
test fPCH98,0FFh
|
|
jnz @f
|
|
cmp dx,2920h
|
|
jb iexv13
|
|
cmp dx,297dh
|
|
ja iexvhan1
|
|
mov cx,18
|
|
jmp iexv70
|
|
|
|
iexvhan1:
|
|
cmp dx,2a20h
|
|
jb iexv13
|
|
cmp dx,2a5fh
|
|
ja iexv13
|
|
mov cx,18
|
|
jmp iexv70
|
|
|
|
@@:
|
|
jmp H98_FontRead_N
|
|
|
|
iexv13:
|
|
mov cx,34
|
|
jmp iexv70
|
|
|
|
iexv20:
|
|
cmp ah,1Fh
|
|
jnz iexv30
|
|
cmp dh,00h
|
|
jnz iexv21
|
|
mov cx,48
|
|
jmp iexv100
|
|
iexv21:
|
|
test fPCH98,0FFh
|
|
jnz @f
|
|
cmp dx,2920h
|
|
jb Hmode_han1
|
|
cmp dx,297dh
|
|
ja Hmode_han1
|
|
mov cx,48
|
|
jmp iexv100
|
|
|
|
Hmode_han1:
|
|
cmp dx,2a20h
|
|
jb iexv22
|
|
cmp dx,2a5fh
|
|
ja iexv22
|
|
mov cx,48
|
|
jmp iexv100
|
|
|
|
@@:
|
|
jmp H98_FontRead_H
|
|
|
|
iexv22:
|
|
mov cx,72
|
|
jmp iexv100
|
|
|
|
iexv30:
|
|
cmp ah,1Ah
|
|
jnz iexv40
|
|
jmp iexv80
|
|
|
|
iexv40:
|
|
cmp ah,20h
|
|
jnz iexv90
|
|
jmp iexv110
|
|
|
|
iexv70:
|
|
|
|
cld
|
|
push es
|
|
mov di,[bp].pmUserCX
|
|
mov es,[bp].pmUserBX
|
|
mov si,offset DGROUP:rgbXfrBuf1
|
|
rep movsb
|
|
pop es
|
|
;
|
|
; Restore the caller's CX
|
|
iexv80:
|
|
push ax
|
|
mov ax,[bp].pmUserBX ;BX regster restor
|
|
mov [bp].intUserBX,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserCX
|
|
mov [bp].intUserCX,ax
|
|
pop ax
|
|
iexv90:
|
|
ret
|
|
|
|
iexv100:
|
|
|
|
cld
|
|
push es
|
|
mov di,[bp].pmUserBX
|
|
mov es,[bp].pmUserDS
|
|
mov si,offset DGROUP:rgbXfrBuf1
|
|
rep movsb
|
|
pop es
|
|
;
|
|
; Restore the caller's CX
|
|
iexv110:
|
|
push ax
|
|
mov ax,[bp].pmUserDS ;BX regster restor
|
|
mov [bp].intUserDS,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserBX
|
|
mov [bp].intUserBX,ax
|
|
pop ax
|
|
iexv120:
|
|
ret
|
|
|
|
H98_FontRead_N:
|
|
|
|
cmp dx,2920h
|
|
jb iexvN15
|
|
cmp dx,297fh
|
|
jna iexvNhan
|
|
cmp dx,2a20h
|
|
jb iexvN15
|
|
cmp dx,2a7fh
|
|
jna iexvNhan
|
|
cmp dx,2b20h
|
|
jb iexvN15
|
|
cmp dx,2b7fh
|
|
jna iexvNhan
|
|
cmp dx,7840h
|
|
jb iexvN15
|
|
cmp dx,787fh
|
|
jna iexvNhan
|
|
cmp dx,7d01h
|
|
jb iexvN15
|
|
cmp dx,7d7fh
|
|
jna iexvNhan
|
|
cmp dx,7e01h
|
|
jb iexvN15
|
|
cmp dx,7e7fh
|
|
ja iexvN15
|
|
iexvNhan:
|
|
mov cx,18 ;16byte+2=18 ; jmp iexv70
|
|
|
|
iexvN15:
|
|
mov cx,34 ;32byte+2=34
|
|
jmp iexv70
|
|
|
|
H98_FontRead_H:
|
|
|
|
cmp dx,2920h
|
|
jb iexvN25
|
|
cmp dx,297fh
|
|
jna HiexvNhan
|
|
cmp dx,2a20h
|
|
jb iexvN25
|
|
cmp dx,2a7fh
|
|
jna HiexvNhan
|
|
cmp dx,2b20h
|
|
jb iexvN25
|
|
cmp dx,2b7fh
|
|
jna HiexvNhan
|
|
cmp dx,7840h
|
|
jb iexvN25
|
|
cmp dx,787fh
|
|
jna HiexvNhan
|
|
cmp dx,7d01h
|
|
jb iexvN25
|
|
cmp dx,7d7fh
|
|
jna HiexvNhan
|
|
cmp dx,7e01h
|
|
jb iexvN25
|
|
cmp dx,7e7fh
|
|
ja iexvN25
|
|
HiexvNhan:
|
|
;;;;;;;; mov cx,50 ;48byte+2=50
|
|
mov cx,48 ;48byte
|
|
;;;;;;;; jmp iexv70
|
|
jmp iexv100
|
|
|
|
iexvN25:
|
|
;;;;;;;; mov cx,74 ;72byte+2=74
|
|
mov cx,72 ;72byte
|
|
;;;;;;;; jmp iexv70
|
|
jmp iexv100
|
|
else ;!NEC_98
|
|
cmp ah,10h
|
|
jnz iexv20
|
|
;
|
|
; Palette control function.
|
|
cmp al,9 ;read palette data function
|
|
jnz @F
|
|
mov cx,17
|
|
jmp short iexv70
|
|
;
|
|
@@: cmp al,17h ;read video DAC registers
|
|
jnz @F
|
|
mov cx,[bp].pmUserCX ;each entry in table is 3 bytes long
|
|
add cx,cx
|
|
add cx,[bp].pmUserCX
|
|
jmp short iexv70
|
|
;
|
|
@@: jmp short iexv72
|
|
;
|
|
;
|
|
iexv20: cmp ah,11h
|
|
jnz iexv30
|
|
;
|
|
; Character generator interface function.
|
|
; NOTE: a number of subfunctions of function 11h need to have munging
|
|
; and data buffering performed. However, function 30h is the only
|
|
; one used by Codeview, so this is the only one currently implemented
|
|
cmp al,30h
|
|
jnz @F
|
|
mov ax,[bp].intUserES ;get the paragraph address returned by BIOS
|
|
mov bx,STD_DATA
|
|
call ParaToLDTSelector ;get a selector for that address
|
|
mov [bp].pmUserES,ax ;store the selector so that it will be
|
|
; returned to the caller
|
|
@@: jmp short iexv90
|
|
;
|
|
;
|
|
iexv30: cmp ah,1Bh
|
|
jnz iexv40
|
|
;
|
|
; Video BIOS functionality/state information.
|
|
; On exit, we need to fix up the pointer at the beginning of the
|
|
; data put in our buffer by the BIOS, and then transfer the buffer up
|
|
; to the user.
|
|
mov ax,word ptr rgbXfrBuf0[2] ;get segment of pointer to
|
|
; 'static functionallity table'
|
|
mov bx,STD_DATA
|
|
call ParaToLDTSelector ;convert paragraph to selector
|
|
mov word ptr rgbXfrBuf0[2],ax ;store back into table
|
|
push es
|
|
mov si,offset rgbXfrBuf0 ;pointer to our copy of the table
|
|
mov di,[bp].pmUserDI ;where the user wants it
|
|
mov [bp].intUserDi,di ;restore the DI returned to the user
|
|
mov es,[bp].pmUserES
|
|
mov cx,64 ;the table is 64 bytes long
|
|
cld
|
|
rep movsb ;copy the table to the user's buffer
|
|
pop es
|
|
|
|
jmp short iexv90
|
|
;
|
|
;
|
|
iexv40:
|
|
jmp short iexv90
|
|
|
|
;
|
|
; Copy data from our buffer to the caller's buffer pointed to by ES:DX
|
|
iexv70: cld
|
|
push es
|
|
mov di,[bp].pmUserDX
|
|
mov es,[bp].pmUserES
|
|
mov si,offset DGROUP:rgbXfrBuf1
|
|
rep movsb
|
|
pop es
|
|
;
|
|
; Restore the caller's DX
|
|
iexv72: mov ax,[bp].pmUserDX
|
|
mov [bp].intUserDX,ax
|
|
;
|
|
; All done
|
|
iexv90:
|
|
ret
|
|
endif ;!NEC_98
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl BIOS Misc. Interrupt (Int 15h) Service Routine
|
|
page
|
|
; -------------------------------------------------------
|
|
; BIOS MISC. INTERRUPT (INT 15h) SERVICE ROUTINE
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntrMisc -- Entry point into the interrupt processing code
|
|
; for the BIOS misc functions interrupt (INT 15h).
|
|
;
|
|
; Input: normal registers for Bios calls
|
|
; Output: normal register returns for Bios calls
|
|
; Errors: normal Bios errors
|
|
; Uses: as per Bios calls
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrMisc
|
|
|
|
PMIntrMisc:
|
|
;
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntryMisc
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
sub sp,8 ; make room for stack frame
|
|
push bp
|
|
mov bp,sp
|
|
push es
|
|
push ax
|
|
|
|
xor ax,ax
|
|
mov es,ax
|
|
mov [bp + 8],cs
|
|
mov word ptr [bp + 6],offset pim_10
|
|
mov ax,es:[15h*4]
|
|
mov [bp + 2],ax
|
|
mov ax,es:[15h*4 + 2]
|
|
mov [bp + 4],ax
|
|
pop ax
|
|
pop es
|
|
pop bp
|
|
retf
|
|
|
|
pim_10: pushf
|
|
FCLI
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
call IntExitMisc
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
riret
|
|
|
|
; -------------------------------------------------------
|
|
; MISC INTERRUPT SUPPORT ROUTINES
|
|
; -------------------------------------------------------
|
|
;
|
|
; IntEntryMisc -- This function performs data transfer
|
|
; and register translation on entry to the BIOS Misc.
|
|
; functions interrupt. (INT 15h).
|
|
;
|
|
; Input: AX - BIOS function being performed
|
|
; Output:
|
|
; Errors:
|
|
; Uses: All registers preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntryMisc
|
|
|
|
IntEntryMisc:
|
|
|
|
ifdef NEC_98
|
|
push cx
|
|
cmp ah,90h ;SYSTEM BIOS BLOCK MOVE
|
|
jnz iemDMA1 ;yes = jmp
|
|
jmp iem70
|
|
iemDMA1:
|
|
cmp ah,0D5h ;DMA BIOS DMA
|
|
jnz iemDMA2 ;yes = jmp
|
|
mov cx,8 ;DMA_CBIOS
|
|
jmp iem70
|
|
iemDMA2:
|
|
cmp ah,0D6h ;DMA BIOS DMA
|
|
jnz iemROM1 ;yes = jmp
|
|
jmp iem80 ;Read JMP
|
|
iemROM1:
|
|
cmp ah,0D8h ;ROM
|
|
jnz iemROM2 ;yes = jmp
|
|
mov cx,4
|
|
jmp iem70
|
|
|
|
iemROM2:
|
|
cmp ah,0D9h ;ROM
|
|
jnz iem90 ;yes = jmp
|
|
mov cx,8 ;ROM BIOS
|
|
iem70:
|
|
push ds
|
|
mov si,[bp].pmUserBX ;offset address
|
|
mov ds,[bp].pmUserES ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
iem80:
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
mov [bp].intUserBX,offset DGROUP:rgbXfrBuf1
|
|
iem90:
|
|
pop cx
|
|
ret
|
|
else ;!NEC_98
|
|
; Map requests to set the PS/2 Pointing Device Handler Address
|
|
|
|
cmp ax,0C207h ;PS/2 Set Pointing Device Handler adr?
|
|
jnz iem90
|
|
|
|
mov ax,[bp].pmUserBX ;User's ES:BX -> handler
|
|
mov word ptr lpfnUserPointingHandler,ax
|
|
mov ax,[bp].pmUserES
|
|
mov word ptr [lpfnUserPointingHandler+2],ax
|
|
|
|
mov ax,segDXCodePM ;pass BIOS address of our handler
|
|
mov [bp].intUserES,ax
|
|
mov ax,offset PointDeviceHandler
|
|
mov [bp].intUserBX,ax
|
|
|
|
iem90:
|
|
ret
|
|
endif ;!NEC_98
|
|
|
|
; -------------------------------------------------------
|
|
; IntExitMisc -- This function performs data transfer
|
|
; and register translation on exit from the BIOS Misc.
|
|
; Functions interrupt (INT 15h).
|
|
;
|
|
; Input: AX - BIOS function being performed
|
|
; Output:
|
|
; Errors:
|
|
; Uses: All registers preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitMisc
|
|
|
|
IntExitMisc:
|
|
ifdef NEC_98
|
|
push cx
|
|
cmp ah,90h ;SYSTEM BIOS BLOCK MOVE
|
|
jnz ixmDMA1 ;yes = jmp
|
|
jmp ixm70
|
|
ixmDMA1:
|
|
cmp ah,0D5h ;DMA BIOS
|
|
jnz ixmDMA2 ;yes = jmp
|
|
jmp ixm70
|
|
ixmDMA2:
|
|
cmp ah,0D6h ;DMA BIOS DMA
|
|
jnz ixmROM1 ;yes = jmp
|
|
mov cx,16
|
|
jmp ixm80
|
|
ixmROM1:
|
|
cmp ah,0D8h ; ROM
|
|
jnz ixmROM2 ;yes = jmp
|
|
jmp ixm70
|
|
ixmROM2:
|
|
cmp ah,0D9h ; ROM
|
|
jnz ixm90
|
|
ixm70:
|
|
cld
|
|
push es
|
|
mov di,[bp].pmUserBX
|
|
mov es,[bp].pmUserES
|
|
mov si,offset DGROUP:rgbXfrBuf1
|
|
rep movsb
|
|
pop es
|
|
;
|
|
; Restore the caller's ES,BX
|
|
ixm80:
|
|
push ax
|
|
mov ax,[bp].pmUserES
|
|
mov [bp].intUserES,ax
|
|
mov ax,[bp].pmUserBX
|
|
mov [bp].intUserBX,ax
|
|
pop ax
|
|
ixm90:
|
|
pop cx
|
|
ret
|
|
else ;!NEC_98
|
|
push ax
|
|
push bx
|
|
push cx
|
|
push dx
|
|
;
|
|
; Check for function 0C0h - Return System Configuration Parameters
|
|
cmp ah,0C0h
|
|
jnz ixmi30
|
|
test [bp].intUserFL,1 ;check if the bios call returned an error
|
|
jnz ixmi90 ;(carry flag set in returned flags)
|
|
;
|
|
; The BIOS call succeeded. This means that ES:BX points to a configuration
|
|
; vector. We need to fix up the segment to be a selector.
|
|
mov dx,[bp].intUserES
|
|
cmp dx,0F000h ;does it point to normal BIOS segment
|
|
jnz ixmi22
|
|
mov ax,SEL_BIOSCODE or STD_RING
|
|
jmp short ixmi24
|
|
|
|
ixmi22: call ParaToLinear
|
|
mov cx,0FFFFh
|
|
mov ax,SEL_USERSCR or STD_TBL_RING
|
|
cCall NSetSegmentDscr,<ax,bx,dx,0,cx,STD_DATA>
|
|
ixmi24: mov [bp].pmUserES,ax
|
|
jmp short ixmi90
|
|
|
|
; Chack for function 0C207h - PS/2 Set Pointing Device Handler Address
|
|
|
|
ixmi30:
|
|
cmp ax,0C207h
|
|
jne ixmi90
|
|
|
|
mov ax,[bp].pmUserBX ;restore user's BX
|
|
mov [bp].intUserBX,ax
|
|
|
|
; All done
|
|
ixmi90:
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
pop ax
|
|
ret
|
|
endif ;!NEC_98
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl Mouse Function Interrupt (Int 33h) Service Routine
|
|
page
|
|
; -------------------------------------------------------
|
|
; MOUSE FUNCTION INTERRUPT (INT 33h) SERVICE ROUTINE
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntrMouse - Entry point into interrupt reflector code
|
|
; for mouse driver (int 33h) calls.
|
|
;
|
|
; Input: normal registers for mouse calls
|
|
; Output: normal register returns for mouse calls
|
|
; Errors: normal mouse errors
|
|
; Uses: as per mouse calls
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrMouse
|
|
|
|
PMIntrMouse:
|
|
;
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntryMouse
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
sub sp,8 ; make room for stack frame
|
|
push bp
|
|
mov bp,sp
|
|
push es
|
|
push ax
|
|
|
|
xor ax,ax
|
|
mov es,ax
|
|
mov [bp + 8],cs
|
|
mov word ptr [bp + 6],offset pimo_10
|
|
mov ax,es:[33h*4]
|
|
mov [bp + 2],ax
|
|
mov ax,es:[33h*4 + 2]
|
|
mov [bp + 4],ax
|
|
pop ax
|
|
pop es
|
|
pop bp
|
|
retf
|
|
|
|
pimo_10: pushf
|
|
FCLI
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
call IntExitMouse
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
riret
|
|
|
|
; -------------------------------------------------------
|
|
; MOUSE SUPPORT ROUTINES
|
|
; -------------------------------------------------------
|
|
|
|
; IntEntryMouse -- This function performs data transfer and
|
|
; register translation on entry to mouse driver functions.
|
|
; (INT 33h)
|
|
;
|
|
; Input: AX - mouse function being performed
|
|
; Output:
|
|
; Errors:
|
|
; Uses: NOTHING
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntryMouse
|
|
|
|
IntEntryMouse:
|
|
cld
|
|
push ax
|
|
push cx
|
|
push si
|
|
push di
|
|
;
|
|
cmp al,9 ;Set graphics cursor block?
|
|
jnz ment10
|
|
;
|
|
; The user is setting a graphics cursor. We need to copy the masks
|
|
; down to low memory so that the mouse driver can get at them and then
|
|
; fix up the pointer in DX.
|
|
mov cx,32
|
|
jmp short ment92
|
|
;
|
|
; Mouse interrupt handler establishment
|
|
ment10: cmp al,12 ;Set user defined interrupt subroutine ?
|
|
jnz ment20
|
|
;
|
|
; This command has the effect of causing a call to the address es:ds
|
|
; Whenever an event of one of the types specified by the mask in cx.
|
|
; The address es:dx must be saved in lpfnUserMouseHandler and the
|
|
; real mode address of MouseInterruptHandler substituted.
|
|
mov ax,[bp].pmUserDX ; Load users handler offset
|
|
mov word ptr lpfnUserMouseHandler,ax ; Store for future use
|
|
mov ax,[bp].pmUserES ; Load users handler segment value
|
|
mov word ptr lpfnUserMouseHandler + 2,ax ; Store for future use
|
|
mov ax,segDXCodePM ; Load real mode code segment value
|
|
mov [bp].intUserES,ax ; Store in real mode es register image
|
|
mov ax,offset MouseInterruptHandler ; Load handler offset
|
|
mov [bp].intUserDX,ax ; Store in real mode dx register image
|
|
jmp short ment99 ;Return
|
|
;
|
|
ment20: cmp al,20
|
|
jc ment99
|
|
jnz ment30
|
|
;
|
|
; This is the swap interrupt subroutine function. Not currently implemented
|
|
jmp short ment99
|
|
;
|
|
ment30: cmp al,22 ;Save mouse driver state?
|
|
jnz ment40
|
|
;
|
|
; This is the save mouse driver state function. We need to pass a pointer
|
|
; to the transer buffer down to the mouse driver.
|
|
mov ax,npXfrBuf1
|
|
mov [bp].intUserDX,ax
|
|
jmp short ment99
|
|
|
|
ment40: cmp al,23 ;Restore mouse driver state?
|
|
jnz ment99
|
|
;
|
|
; This is the restore mouse driver state function. We need to copy the
|
|
; mouse state buffer from the pm user location to the transfer buffer,
|
|
; and then pass the pointer to the transfer buffer on to the mouse driver.
|
|
mov cx,cbMouseState
|
|
jcxz ment99
|
|
;
|
|
; Transfer the data pointed to by the user ES:DX to the scratch buffer, and
|
|
; fix up the pointer that is passed on to the mouse driver.
|
|
ment92: mov si,[bp].pmUserDX
|
|
mov di,npXfrBuf1
|
|
mov [bp].intUserDX,di
|
|
push ds
|
|
mov ds,[bp].pmUserES
|
|
cld
|
|
rep movs word ptr [di],word ptr [si]
|
|
pop ds
|
|
;
|
|
ment99: pop di
|
|
pop si
|
|
pop cx
|
|
pop ax
|
|
ret
|
|
|
|
; -------------------------------------------------------
|
|
; IntExitMouse -- This function performs data transfer and
|
|
; register translation on exit from mouse driver functions.
|
|
; (INT 33h)
|
|
;
|
|
; Input: AX - mouse function being performed
|
|
; Output:
|
|
; Errors:
|
|
; Uses:
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitMouse
|
|
|
|
IntExitMouse:
|
|
cld
|
|
cmp al,21 ;get state buffer size?
|
|
jnz mxit20
|
|
;
|
|
; We need to remember the state buffer size, so that later we will know
|
|
; how many bytes to transfer when we do the save/restore state fucntions.
|
|
mov ax,[bp].intUserBX
|
|
mov cbMouseState,ax
|
|
return
|
|
;
|
|
mxit20: cmp al,22 ;Save mouse driver state?
|
|
jnz mxit30
|
|
;
|
|
; We need to restore the original values of ES:DX and transfer the mouse
|
|
; state data from the real mode buffer to the user's protected mode buffer.
|
|
mov cx,cbMouseState
|
|
jcxz mxit28
|
|
push es
|
|
mov si,npXfrBuf1
|
|
mov di,[bp].pmUserDX
|
|
mov [bp].intUserDX,di
|
|
mov es,[bp].pmUserES
|
|
rep movs byte ptr [di],byte ptr [si]
|
|
pop es
|
|
mxit28: return
|
|
;
|
|
mxit30: cmp al,23 ;Restore mouse driver state?
|
|
jnz mxit99
|
|
mov ax,[bp].pmUserDX
|
|
mov [bp].intUserDX,ax
|
|
;
|
|
mxit99: ret
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl PM Interrupt Support Routines
|
|
page
|
|
; -------------------------------------------------------
|
|
; PM INTERRUPT SUPPORT ROUTINES
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
; -------------------------------------------------------
|
|
; EnterIntHandler -- This routine will allocate a stack
|
|
; frame on the interrupt reflector stack and make
|
|
; a copy of the registers on the allocated stack.
|
|
;
|
|
; Note: This routine expects the current stack to contain a near
|
|
; return address and a normal [IP] [CS] [FL] interrupt stack
|
|
; frame. Don't have anything else on the stack before calling
|
|
; this routine!
|
|
;
|
|
; Note: This routine disables interrupts, and leaves them disabled.
|
|
; Most callers already have them disabled, so it doesn't
|
|
; really make a difference, except that this routine
|
|
; requires that they be disabled.
|
|
;
|
|
; Input: none
|
|
; Output: stack frame set up
|
|
; Errors: none
|
|
; Uses: all registers preserved
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public EnterIntHandler
|
|
|
|
EnterIntHandler proc near
|
|
|
|
FCLI ;we really want int's disabled (and
|
|
; XMScontrol doesn't do that)
|
|
push ds
|
|
mov ds,selDgroupPM ;save user's DS and address our DGROUP
|
|
assume ds:DGROUP
|
|
pop regUserDS
|
|
|
|
push bp
|
|
mov bp,sp ;bp -> [BP] [IP] [IP] [CS] [FL]
|
|
push word ptr [bp+8]
|
|
pop regUserFL ;user's flags before doing INT
|
|
pop bp
|
|
|
|
pop pfnReturnAddr ;near return to our immediate caller
|
|
|
|
mov regUserSS,ss ;save caller's stack address
|
|
mov regUserSP,sp
|
|
ASSERT_REFLSTK_OK
|
|
mov ss,selDgroupPM ;switch to interrupt reflector stack
|
|
mov sp,pbReflStack
|
|
sub pbReflStack,CB_STKFRAME ;adjust pointer to next stack frame
|
|
FIX_STACK
|
|
|
|
; Build the stack frame. The stack frame contains the following:
|
|
; dword & word parameter locations
|
|
; original caller's stack address
|
|
; caller's original flags and general registers (in pusha form)
|
|
; caller's original segment registers (DS & ES)
|
|
; flags and general registers to be passed to interrupt routine
|
|
; (initially the same as caller's original values)
|
|
; segment registers (DS & ES) to be passed to interrupt routine
|
|
; (initially set to the Dos Extender data segment address)
|
|
;
|
|
; The parameter words and then the caller's original register values go on top.
|
|
|
|
sub sp,8 ;space for a dd & 2 dw's
|
|
|
|
push regUserSP
|
|
push regUserSS
|
|
push regUserFL
|
|
pusha
|
|
push regUserDS
|
|
push es
|
|
|
|
; Now, put all of the general registers, and values for the segment
|
|
; registers to be passed to the interrupt service routine. We pass
|
|
; the Dos Extender data segment address to the interrupt routine.
|
|
|
|
push regUserFL
|
|
pusha
|
|
push segDXDataPM
|
|
push segDXDataPM
|
|
|
|
; And we are done.
|
|
|
|
mov bp,sp ;set up frame pointer
|
|
mov es,selDgroupPM
|
|
jmp pfnReturnAddr ;return to the caller.
|
|
|
|
EnterIntHandler endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; LeaveIntHandler -- This routine will restore the user registers,
|
|
; release the stack frame, and restore the original user's stack
|
|
; for exit from an interrupt reflector routine.
|
|
;
|
|
; Note: Interrupts must be off when this routine is called.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: none
|
|
; Uses: All registers modified
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public LeaveIntHandler
|
|
|
|
LeaveIntHandler proc near
|
|
|
|
FCLI
|
|
pop pfnReturnAddr
|
|
|
|
; The copy of the register values returned from the interrupt routine
|
|
; (and then possibly modified by the exit handler for the particular
|
|
; interrupt) are what gets returned to the caller. We discard the original
|
|
; register values saved on entry. (They were there so that the exit
|
|
; routine could refer to them if necessary)
|
|
|
|
add sp,4 ;skip over interrupt service routine's
|
|
; segment register values
|
|
popa ;restore general register values
|
|
pop regUserFL ;flags returned by interrupt routine
|
|
pop es ;get segment registers from pmUserES
|
|
pop regUserDS ; and pmUserDS
|
|
add sp,18 ;skip over the original user registers
|
|
; and flags
|
|
pop regUserSS ;original interrupted routine's stack
|
|
pop regUserSP
|
|
mov regUserAX,ax
|
|
|
|
; Switch back to the original user's stack.
|
|
|
|
ASSERT_REFLSTK_OK
|
|
ASSERT_CLI
|
|
CHECK_STACK
|
|
mov ss,regUserSS
|
|
mov sp,regUserSP
|
|
add pbReflStack,CB_STKFRAME
|
|
ASSERT_REFLSTK_OK
|
|
|
|
; We need to replace the image of the flags in the original int return
|
|
; address on the user's stack with the new flags returned from the interrupt
|
|
; service routine.
|
|
|
|
push bp
|
|
mov bp,sp ;stack -> BP IP CS FL
|
|
mov ax,regUserFL ;flags returned by interrupt service routine
|
|
and ax,0BFFFh ;clear the nested task flag
|
|
and [bp+6],0300h ;clear all but the interrupt and trace flags
|
|
; in the caller's original flags
|
|
or [bp+6],ax ;combine in the flags returned by the
|
|
; interrupt service routine. This will cause
|
|
; us to return to the original routine with
|
|
; interrupts on if they were on when the
|
|
; interrupt occured, or if the ISR returned
|
|
; with them on.
|
|
pop bp
|
|
|
|
; And now, return to the caller.
|
|
|
|
push pfnReturnAddr
|
|
mov ax,regUserAX
|
|
mov ds,regUserDS
|
|
assume ds:NOTHING
|
|
ret
|
|
|
|
LeaveIntHandler endp
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl Mouse Interrupt Callback Function Handler
|
|
page
|
|
; -------------------------------------------------------
|
|
; MOUSE INTERRUPT CALLBACK FUNCTION HANDLER
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE segment
|
|
assume cs:DXCODE
|
|
|
|
; -------------------------------------------------------
|
|
; MouseInterruptHandler -- This routine is the entry point for
|
|
; user requested mouse event interrupts. It switches the
|
|
; processor to protected mode and transfers control to the
|
|
; user protected mode mouse handling routine. When that
|
|
; completes, it switches back to real mode and returns control
|
|
; to the mouse driver.
|
|
; Entry to this routine will have been requested by an
|
|
; INT 33H code 12 with the real address of this routine
|
|
; substituted for the users entry point.
|
|
; The address of the user specified mouse handler as specified
|
|
; in the original INT 33H is stored in the variable
|
|
; lpfnUserMouseHandler.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: none
|
|
; Uses: The segment registers are explicitly preserved by
|
|
; this routine. Other registers are as preserved or
|
|
; modified by the users mouse handler.
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public MouseInterruptHandler
|
|
|
|
MouseInterruptHandler proc far
|
|
;
|
|
; On entry, the stack layout is:
|
|
; [2] CS - System mouse handler code segment
|
|
; [0] IP - System mouse handler return offset
|
|
;
|
|
|
|
push es
|
|
push ds
|
|
pushf
|
|
FCLI
|
|
cld
|
|
mov ds,selDgroup
|
|
assume ds:DGROUP
|
|
pop regUserFL
|
|
;
|
|
; Allocate a new stack frame, and then switch to the local stack
|
|
; frame.
|
|
mov regUserSP,sp ;save entry stack pointer so we can restore it
|
|
mov regUSerSS,ss ;save segment too
|
|
mov ss,selDgroup ;switch to our own stack frame
|
|
ASSERT_REFLSTK_OK
|
|
mov sp,pbReflStack
|
|
sub pbReflStack,CB_STKFRAME ;adjust pointer to next stack frame
|
|
FIX_STACK
|
|
;
|
|
; We are now running on our own stack, so we can switch into protected mode.
|
|
push ax ;preserve caller's AX
|
|
SwitchToProtectedMode
|
|
pop ax
|
|
;
|
|
; Build a far return frame on the stack so that the user's
|
|
; routine will return to us when it is finished.
|
|
push regUserSS ; save system mouse handler stack address
|
|
push regUserSP ; so we can restore it later
|
|
push ds
|
|
push cs
|
|
push offset mih50
|
|
;
|
|
; Build an IRET frame on the stack to use to transfer control to the
|
|
; user's protected mode routine
|
|
push regUserFL
|
|
push word ptr lpfnUserMouseHandler+2 ;push segment of user routine
|
|
push word ptr lpfnUserMouseHandler ;push offset of user routine
|
|
;
|
|
; At this point the interrupt reflector stack looks like this:
|
|
;
|
|
; [14] stack segment of original stack
|
|
; [12] stack pointer of original stack
|
|
; [10] real mode dos extender data segment
|
|
; [8] segment of return address back to here
|
|
; [6] offset of return address back here
|
|
; [4] Users flags
|
|
; [2] segment of user routine
|
|
; [0] offset of user routine
|
|
;
|
|
; Execute the users mouse handler
|
|
iret
|
|
;
|
|
; The users handler will return here after it is finsished.
|
|
mih50: FCLI
|
|
cld
|
|
pop ds
|
|
pop regUserSP
|
|
pop regUserSS
|
|
;
|
|
; Switch back to real mode.
|
|
push ax ;preserve AX
|
|
SwitchToRealMode
|
|
pop ax
|
|
CHECK_STACK
|
|
;
|
|
; Switch back to the original stack.
|
|
mov ss,regUserSS
|
|
mov sp,regUserSP
|
|
ASSERT_REFLSTK_OK
|
|
;
|
|
; Deallocate the stack frame that we are using.
|
|
add pbReflStack,CB_STKFRAME
|
|
ASSERT_REFLSTK_OK
|
|
;
|
|
; And return to the original interrupted program.
|
|
pop ds
|
|
pop es
|
|
|
|
ret
|
|
|
|
MouseInterruptHandler endp
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl PS/2 Pointing Device Handler
|
|
page
|
|
; -------------------------------------------------------
|
|
; PS/2 POINTING DEVICE HANDLER
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE segment
|
|
assume cs:DXCODE
|
|
|
|
ifndef NEC_98
|
|
; -------------------------------------------------------
|
|
; PointDeviceHandler -- This routine is the entry point for
|
|
; the PS/2 Pointing Device Handler. It switches the
|
|
; processor to protected mode and transfers control to the
|
|
; user pointing device handler. When that completes,
|
|
; it switches back to real mode and returns control to
|
|
; the PS/2 BIOS.
|
|
;
|
|
; Note: The BIOS calls us with interrutps enabled!
|
|
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: none
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PointDeviceHandler
|
|
|
|
PointDeviceHandler proc far
|
|
|
|
; On entry, the stack layout is:
|
|
;
|
|
; [10] status
|
|
; [8] X coordinate
|
|
; [6] Y coordinate
|
|
; [4] Z coordinate
|
|
; [2] CS - PS/2 BIOS code segment
|
|
; [0] IP - PS/2 BIOS return offset
|
|
|
|
cld
|
|
push es ;save PS/2 BIOS ds/es on it's stack
|
|
push ds
|
|
|
|
mov ds,selDgroup ;addressability to DOSX DGROUP
|
|
push ds
|
|
pop es
|
|
assume ds:DGROUP,es:DGROUP
|
|
|
|
FCLI ;protect global regUserXX vars
|
|
|
|
; Allocate a new stack frame, and then switch to the local stack
|
|
; frame.
|
|
|
|
mov regUserSP,sp ;save entry stack pointer so we can restore it
|
|
mov regUSerSS,ss ;save segment too
|
|
ASSERT_REFLSTK_OK
|
|
mov ss,selDgroup ;switch to our own stack frame
|
|
mov sp,pbReflStack
|
|
sub pbReflStack,CB_STKFRAME ;adjust pointer to next stack frame
|
|
FIX_STACK
|
|
|
|
push regUserSS ;save PS/2 BIOS stack address
|
|
push regUserSP ; so we can restore it later
|
|
|
|
push SEL_DXDATA or STD_RING ;DOSX DS to be poped in PM
|
|
|
|
sub sp,4*2 ;temp save the general regs further down the
|
|
pusha ; stack, they'll get poped in a little while
|
|
|
|
; Copy PS/2 pointing device stack info to our (soon to be) protected mode stack
|
|
|
|
mov si,regUserSP ;PS/2 stack pointer
|
|
mov ds,regUserSS ;PS/2 stack segment
|
|
assume ds:NOTHING
|
|
|
|
FSTI ;no more references to global regUserXX vars
|
|
|
|
add si,4*2 ;skip over es,ds,cs,ip
|
|
mov di,sp ;loc for pointing device
|
|
add di,8*2 ; data on our stack
|
|
mov cx,4
|
|
cld
|
|
rep movsw
|
|
|
|
push es ;restore ds = DGROUP
|
|
pop ds
|
|
assume ds:DGROUP
|
|
|
|
; We are now running on our own stack, so we can switch into protected mode.
|
|
|
|
SwitchToProtectedMode ;disables interrupts again
|
|
FSTI ; but we don't want them disabled
|
|
|
|
popa ;restore general registers
|
|
|
|
; At this point the stack looks like this:
|
|
;
|
|
; [12] stack segment of original stack
|
|
; [10] stack pointer of original stack
|
|
; [8] protect mode dos extender data segment
|
|
; [6] status
|
|
; [4] X coordinate
|
|
; [2] Y coordinate
|
|
; [0] Z coordinate
|
|
|
|
; Execute the user's pointing device handler
|
|
|
|
call [lpfnUserPointingHandler]
|
|
|
|
; The users handler will return here after it is finsished.
|
|
|
|
pdh50:
|
|
cld
|
|
add sp,4*2 ;discard pointing device info
|
|
pop ds
|
|
|
|
FCLI ;protect global regUserXX vars
|
|
pop regUserSP
|
|
pop regUserSS
|
|
|
|
; Switch back to real mode.
|
|
|
|
push ax ;preserve AX
|
|
SwitchToRealMode
|
|
pop ax
|
|
|
|
; Switch back to the original stack.
|
|
|
|
CHECK_STACK
|
|
mov ss,regUserSS
|
|
mov sp,regUserSP
|
|
|
|
; Deallocate the stack frame that we are using.
|
|
|
|
ASSERT_REFLSTK_OK
|
|
add pbReflStack,CB_STKFRAME
|
|
ASSERT_REFLSTK_OK
|
|
|
|
; And return to the PS/2 BIOS
|
|
|
|
FSTI ;we came in with ints enabled
|
|
|
|
pop ds
|
|
pop es
|
|
|
|
ret
|
|
|
|
PointDeviceHandler endp
|
|
|
|
; -------------------------------------------------------
|
|
endif ;!NEC_98
|
|
;
|
|
; -------------------------------------------------------
|
|
subttl Utility Function Definitions
|
|
page
|
|
; -------------------------------------------------------
|
|
; UTILITY FUNCTION DEFINITIONS
|
|
; -------------------------------------------------------
|
|
;
|
|
; SaveRMIntrVectors -- This routine copies the current
|
|
; real mode interrupt vector table to the shadow
|
|
; vector table used by the interrupt reflector.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: none
|
|
; Uses; all registers preserved
|
|
;
|
|
; NOTE: This routine can only be called in REAL MODE.
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public SaveRMIntrVectors
|
|
|
|
SaveRMIntrVectors:
|
|
push cx
|
|
push si
|
|
push di
|
|
push ds
|
|
push es
|
|
;
|
|
cld
|
|
push ds
|
|
pop es
|
|
xor cx,cx
|
|
mov si,cx
|
|
mov ds,cx
|
|
mov di,offset DGROUP:rglpfnRmISR
|
|
mov cx,2*256
|
|
rep movs word ptr [di],word ptr [si]
|
|
;
|
|
pop es
|
|
pop ds
|
|
pop di
|
|
pop si
|
|
pop cx
|
|
ret
|
|
|
|
; -------------------------------------------------------
|
|
; RestoreRMIntrVectors -- This routine copies the
|
|
; interrupt vectors from the real mode interrupt
|
|
; vector shadow table back down to the real interrupt
|
|
; vectors.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: none
|
|
; Uses; all registers preserved
|
|
;
|
|
; NOTE: This routine can only be called in REAL MODE.
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public RestoreRMIntrVectors
|
|
|
|
RestoreRMIntrVectors:
|
|
push cx
|
|
push si
|
|
push di
|
|
push ds
|
|
push es
|
|
;
|
|
FCLI
|
|
cld
|
|
xor cx,cx
|
|
mov di,cx
|
|
mov es,cx
|
|
mov si,offset DGROUP:rglpfnRmISR
|
|
mov cx,2*256
|
|
rep movs word ptr [di],word ptr [si]
|
|
FSTI
|
|
;
|
|
pop es
|
|
pop ds
|
|
pop di
|
|
pop si
|
|
pop cx
|
|
ret
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE ends
|
|
|
|
ifdef NEC_98
|
|
;
|
|
; -------------------------------------------------------
|
|
subttl INT D2h SOUND BIOS HANDRER
|
|
page
|
|
; -------------------------------------------------------
|
|
; PMIntrSound
|
|
;--------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrSound
|
|
|
|
PMIntrSound:
|
|
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntrySD
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*0D2h] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
call IntExitSD
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
iret
|
|
|
|
;--------------------------------------------------------
|
|
; IntEntrySD
|
|
;--------------------------------------------------------
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntrySD
|
|
|
|
IntEntrySD:
|
|
|
|
cmp ah,0 ;BIOS(INITIALIZE)
|
|
jnz ienSD10
|
|
mov bx,0 ;BIOS
|
|
mov si,bx
|
|
mov cx,2FFh ;(256) (512)
|
|
jmp ienSD50
|
|
ienSD10:
|
|
cmp ah,1 ;(PLAY)
|
|
jnz ienSD20
|
|
mov si,[bp].pmUserBX
|
|
mov cx,28
|
|
jmp ienSD50
|
|
ienSD20:
|
|
cmp ah,16h ;(SET PARA BLOCK)
|
|
jnz ienSD90
|
|
mov si,[bp].pmUserBX
|
|
cmp dl,0 ;00=WORD/01=BYTE?
|
|
jnz ienSD21 ;not 0 = JMP
|
|
mov cx,100 ;100
|
|
jmp ienSD50
|
|
ienSD21:
|
|
mov cx,51 ;51
|
|
ienSD50:
|
|
push ds
|
|
;;;; mov si,[bp].pmUserBX ;
|
|
mov ds,[bp].pmUserES ;
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
rep movsb
|
|
pop ds
|
|
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
;------------------------------------------------------------
|
|
mov [bp].intUserBX,offset DGROUP:rgbXfrBuf1
|
|
ienSD90:
|
|
ret
|
|
|
|
;--------------------------------------------------------
|
|
; IntExitSD
|
|
;--------------------------------------------------------
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitSD
|
|
|
|
IntExitSD:
|
|
|
|
cmp ah,0 ;BIOS (INITIALIZE)
|
|
jnz iexSD10
|
|
jmp iexSD50
|
|
iexSD10:
|
|
cmp ah,1 ;(PLAY)
|
|
jnz iexSD20
|
|
jmp iexSD50
|
|
iexSD20:
|
|
cmp ah,16h ;(SET PARA BLOCK)
|
|
jnz iexSD90
|
|
iexSD50:
|
|
push ax
|
|
mov ax,[bp].pmUserES
|
|
mov [bp].intUserES,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserBX
|
|
mov [bp].intUserBX,ax
|
|
pop ax
|
|
iexSD90:
|
|
ret
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl INT 1Ah PRINTER BIOS HANDRER
|
|
page
|
|
|
|
; 30h( ) 2K
|
|
; -------------------------------------------------------
|
|
; PMIntrPrinter
|
|
;--------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrPrinter
|
|
|
|
PMIntrPrinter:
|
|
|
|
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntryPR
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*1Ah] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
call IntExitPR
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
iret
|
|
|
|
;--------------------------------------------------------
|
|
; IntEntryPR
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntryPR
|
|
|
|
IntEntryPR:
|
|
|
|
cmp ah,30h ;
|
|
jnz ienPR20 ;90/08/24
|
|
mov cx,[bp].pmUserCX ;
|
|
cmp cx,2048 ;2K
|
|
jbe ienPR10 ;NO = jmp
|
|
mov cx,2048
|
|
mov [bp].intUserCX,cx
|
|
ienPR10:
|
|
push ds
|
|
mov si,[bp].pmUserBX ;offset address
|
|
mov ds,[bp].pmUserES ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
;------------------------------------------------------------
|
|
mov [bp].intUserBX,offset DGROUP:rgbXfrBuf1
|
|
|
|
ienPR20:
|
|
ret
|
|
|
|
;--------------------------------------------------------
|
|
; IntExitPR
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitPR
|
|
|
|
IntExitPR:
|
|
|
|
cmp ah,30h
|
|
jnz iexPR20
|
|
mov cx,[bp].pmUserCX
|
|
cmp cx,2048
|
|
ja iexPR10 ;YES = jmp
|
|
push ax
|
|
mov ax,[bp].pmUserES
|
|
mov [bp].intUserES,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserBX ;offset address
|
|
mov [bp].intUserBX,ax
|
|
pop ax
|
|
ret
|
|
|
|
iexPR10:
|
|
push ax
|
|
mov ax,[bp].pmUserES
|
|
mov [bp].intUserES,ax
|
|
;------------------------------------------------------------
|
|
mov cx,2048
|
|
sub [bp].pmUserCX,cx
|
|
mov ax,[bp].pmUserCX
|
|
mov [bp].intUserCX,ax
|
|
pop ax
|
|
|
|
push bx
|
|
add [bp].pmUserBX,cx
|
|
mov bx,[bp].pmUserBX
|
|
mov [bp].intUserBX,bx
|
|
pop bx
|
|
iexPR20:
|
|
ret
|
|
|
|
;////////////////////////////////////////////////////////////
|
|
if 0
|
|
;////////////////////////////////////////////////////////////
|
|
IntEntryPR:
|
|
|
|
cmp ah,30h
|
|
jnz ienPR10
|
|
mov cx,[bp].pmUserCX
|
|
cmp cx,2048
|
|
ja ienPR10 ;YES = jmp
|
|
push ds
|
|
mov si,[bp].pmUserBX ;offset address
|
|
mov ds,[bp].pmUserES ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
;------------------------------------------------------------
|
|
mov [bp].intUserBX,offset DGROUP:rgbXfrBuf1
|
|
ret
|
|
|
|
ienPR10:
|
|
push ds
|
|
mov si,[bp].pmUserBX ;offset address
|
|
mov ds,[bp].pmUserES ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
;------------------------------------------------------------
|
|
push bx
|
|
mov bx,offset DGROUP:rgbXfrBuf1 ;
|
|
add bx,cx ;DGROUP:rgbXfrBuf1
|
|
mov [bp].intUserBX,bx ;
|
|
pop bx
|
|
ret
|
|
|
|
; push ds
|
|
; mov [bp].intUserES,ds ;segment address
|
|
; pop ds
|
|
;;------------------------------------------------------------
|
|
; mov bx,offset DGROUP:rgbXfrBuf1 ;
|
|
; add bx,cx ;
|
|
; mov [bp].intUserBX,bx ;
|
|
; ret
|
|
;
|
|
;--------------------------------------------------------
|
|
; IntExitPR
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitPR
|
|
|
|
IntExitPR:
|
|
|
|
cmp ah,30h
|
|
jnz iexPR10
|
|
mov ax,[bp].pmUserES
|
|
mov [bp].intUserES,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserBX ;
|
|
mov [bp].intUserBX,ax
|
|
iexPR10:
|
|
ret
|
|
;////////////////////////////////////////////////////////////
|
|
endif
|
|
;////////////////////////////////////////////////////////////
|
|
|
|
DXPMCODE ends
|
|
|
|
|
|
; -------------------------------------------------------
|
|
subttl INT 1Ch CALENDER/TIMER HANDRER
|
|
page
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntrCalTi
|
|
;--------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrCalTi
|
|
|
|
|
|
PMIntrCalTi:
|
|
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntryCT
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*1Ch] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
call IntExitCT
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
iret
|
|
|
|
|
|
|
|
;--------------------------------------------------------
|
|
; IntEntryCT
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntryCT
|
|
|
|
IntEntryCT:
|
|
|
|
cmp ah,0 ;
|
|
jnz ienCT10
|
|
jmp ienCT80
|
|
ienCT10:
|
|
cmp ah,1 ;
|
|
jnz ienCT20
|
|
mov cx,6 ;
|
|
jmp ienCT70
|
|
ienCT20:
|
|
ienCT50:
|
|
|
|
push es
|
|
push ax
|
|
mov ax,40h
|
|
mov es,ax
|
|
; test byte ptr es:[501h],8h ;if Hmode
|
|
test byte ptr es:[101h],8h ;if Hmode
|
|
jz ienCT90
|
|
|
|
;; test fNHmode,0FFh
|
|
;; jz ienCT90 ;0=Nmode --->jmp
|
|
|
|
;--------------------- Hmode ----------------------
|
|
cmp ah,3
|
|
jnz ienCT30
|
|
mov cx,4
|
|
jmp ienCT70
|
|
ienCT30:
|
|
cmp ah,4
|
|
jnz ienCT40
|
|
mov cx,12
|
|
jmp ienCT70
|
|
ienCT40:
|
|
cmp ah,5
|
|
jnz ienCT90
|
|
mov cx,12
|
|
;--------------------- Hmode ----------------------
|
|
|
|
|
|
ienCT70:
|
|
push ds
|
|
mov si,[bp].pmUserBX ;offset address
|
|
mov ds,[bp].pmUserES ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
ienCT80:
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
;------------------------------------------------------------
|
|
mov [bp].intUserBX,offset DGROUP:rgbXfrBuf1
|
|
ienCT90:
|
|
ret
|
|
|
|
;--------------------------------------------------------
|
|
; IntExitCT
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitCT
|
|
|
|
IntExitCT:
|
|
|
|
cmp ah,0
|
|
jnz iexCT10
|
|
mov cx,6
|
|
jmp iexCT70
|
|
iexCT10:
|
|
cmp ah,1
|
|
jnz iexCT20
|
|
jmp iexCT80
|
|
iexCT20:
|
|
|
|
iexCT50:
|
|
|
|
push es
|
|
push ax
|
|
mov ax,40h
|
|
mov es,ax
|
|
; test byte ptr es:[501h],8h ;if Hmode
|
|
test byte ptr es:[101h],8h ;if Hmode
|
|
jz iexCT90
|
|
|
|
;; test fNHmode,0FFh
|
|
;; jz iexCT90 ;0=Nmode --->jmp
|
|
|
|
;--------------------- Hmode ----------------------
|
|
cmp ah,3
|
|
jnz iexCT30
|
|
jmp iexCT80
|
|
iexCT30:
|
|
cmp ah,4
|
|
jnz iexCT40
|
|
jmp iexCT80
|
|
iexCT40:
|
|
cmp ah,5
|
|
jnz iexCT90
|
|
jmp iexCT80
|
|
;--------------------- Hmode ----------------------
|
|
|
|
iexCT70:
|
|
push es
|
|
mov di,[bp].pmUserBX ;offset address
|
|
mov es,[bp].pmUserES ;segment address
|
|
mov si,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop es
|
|
iexCT80:
|
|
push ax
|
|
|
|
mov ax,[bp].pmUserES
|
|
mov [bp].intUserES,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserBX
|
|
mov [bp].intUserBX,ax
|
|
pop ax
|
|
iexCT90:
|
|
ret
|
|
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
subttl INT DCh extended DOS HANDRER
|
|
page
|
|
|
|
; -------------------------------------------------------
|
|
; PMIntrExDos
|
|
;--------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrExDos
|
|
|
|
PMIntrExDos:
|
|
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
call IntEntryED
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*0DCh] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
; mov ax,[bp].pmUserAX ;get original function code
|
|
mov cx,[bp].pmUserCX ;get original function code
|
|
call IntExitED
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
iret
|
|
|
|
;--------------------------------------------------------
|
|
; IntEntryED
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntEntryED
|
|
|
|
IntEntryED:
|
|
|
|
cmp cl,0Ch
|
|
jnz ienED10
|
|
jmp ienED80
|
|
ienED10:
|
|
;;; push cx
|
|
cmp cl,0Dh
|
|
jz ienED
|
|
jmp ienED20
|
|
ienED:
|
|
push cx
|
|
cmp ax,0
|
|
jnz ienED11
|
|
mov cx,386 ;386byte
|
|
jmp ienED70
|
|
ienED11:
|
|
cmp ax,0FFh
|
|
jnz ienED12
|
|
mov cx,786 ;786byte
|
|
jmp ienED70
|
|
ienED12:
|
|
cmp ax,1
|
|
jb ienED13
|
|
cmp ax,0Ah
|
|
ja ienED13
|
|
mov cx,160 ;16*10=160byte
|
|
jmp ienED70
|
|
ienED13:
|
|
cmp ax,0Bh
|
|
jb ienED14
|
|
cmp ax,14h
|
|
ja ienED14
|
|
mov cx,160 ;16*10=160byte
|
|
jmp ienED70
|
|
ienED14:
|
|
cmp ax,15h
|
|
jb ienED15
|
|
cmp ax,1Fh
|
|
ja ienED15
|
|
mov cx,66 ;6*11=66byte
|
|
jmp ienED70
|
|
ienED15:
|
|
cmp ax,20h
|
|
jb ienED16
|
|
cmp ax,24h
|
|
ja ienED16
|
|
mov cx,80 ;16*5=80byte
|
|
jmp ienED70
|
|
ienED16:
|
|
cmp ax,25h
|
|
jb ienED17
|
|
cmp ax,29h
|
|
ja ienED17
|
|
mov cx,80 ;16*5=80byte
|
|
jmp ienED70
|
|
ienED17:
|
|
cmp ax,2Ah
|
|
jb ienED18
|
|
cmp ax,38h
|
|
ja ienED18
|
|
mov cx,240 ;16*15=240byte
|
|
jmp ienED70
|
|
ienED18:
|
|
cmp ax,100h
|
|
jnz ienED20
|
|
mov cx,514 ;2+512=514byte
|
|
jmp ienED70
|
|
|
|
ienED20:
|
|
cmp cl,10h
|
|
jnz ienED90
|
|
cmp ah,1
|
|
jnz ienED90
|
|
|
|
moji_out:
|
|
mov si,dx
|
|
cmp byte ptr ds:[si],'$'
|
|
;;;;;;;; cmp byte ptr ds:[dx],'$'
|
|
jz ienED90
|
|
push ds
|
|
mov si,[bp].pmUserDX ;offset address
|
|
mov ds,[bp].pmUserDS ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
movsb
|
|
pop ds
|
|
jmp moji_out
|
|
|
|
|
|
ienED70:
|
|
push ds
|
|
mov si,[bp].pmUserDX ;offset address
|
|
mov ds,[bp].pmUserDS ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
pop cx
|
|
ienED80:
|
|
;-----------
|
|
push ax
|
|
mov ax,segDXDataPM
|
|
mov [bp].intUserES,ax ;segment address
|
|
pop ax
|
|
;------------------------------------------------------------
|
|
mov [bp].intUserDX,offset DGROUP:rgbXfrBuf1
|
|
ienED90:
|
|
ret
|
|
|
|
|
|
;--------------------------------------------------------
|
|
; IntExitED
|
|
;--------------------------------------------------------
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public IntExitED
|
|
|
|
IntExitED:
|
|
|
|
cmp cl,0Ch
|
|
jz iexED
|
|
jmp iexED10
|
|
iexED:
|
|
push cx
|
|
cmp ax,0
|
|
jnz iexED1
|
|
mov cx,386 ;386byte
|
|
jmp iexED70
|
|
iexED1:
|
|
cmp ax,0FFh
|
|
jnz iexED2
|
|
mov cx,786 ;786byte
|
|
jmp iexED70
|
|
iexED2:
|
|
cmp ax,1
|
|
jb iexED3
|
|
cmp ax,0Ah
|
|
ja iexED3
|
|
mov cx,160 ;16*10=160byte
|
|
jmp iexED70
|
|
iexED3:
|
|
cmp ax,0Bh
|
|
jb iexED4
|
|
cmp ax,14h
|
|
ja iexED4
|
|
mov cx,160 ;16*10=160byte
|
|
jmp iexED70
|
|
iexED4:
|
|
cmp ax,15h
|
|
jb iexED5
|
|
cmp ax,1Fh
|
|
ja iexED5
|
|
mov cx,66 ;6*11=66byte
|
|
jmp iexED70
|
|
iexED5:
|
|
cmp ax,20h
|
|
jb iexED6
|
|
cmp ax,24h
|
|
ja iexED6
|
|
mov cx,80 ;16*5=80byte
|
|
jmp iexED70
|
|
iexED6:
|
|
cmp ax,25h
|
|
jb iexED7
|
|
cmp ax,29h
|
|
ja iexED7
|
|
mov cx,80 ;16*5=80byte
|
|
jmp iexED70
|
|
iexED7:
|
|
cmp ax,2Ah
|
|
jb iexED8
|
|
cmp ax,38h
|
|
ja iexED8
|
|
mov cx,240 ;16*15=240byte
|
|
jmp iexED70
|
|
iexED8:
|
|
cmp ax,100h
|
|
jnz iexED10
|
|
mov cx,514 ;2+512=514byte
|
|
jmp iexED70
|
|
|
|
iexED10:
|
|
cmp cl,0Dh
|
|
jnz iexED20
|
|
jmp iexED80
|
|
iexED20:
|
|
cmp cl,10h
|
|
jnz iexED90
|
|
cmp ah,1
|
|
jnz iexED90
|
|
jmp iexED80
|
|
iexED70:
|
|
push ds
|
|
mov si,[bp].pmUserDX ;offset address
|
|
mov ds,[bp].pmUserDS ;segment address
|
|
mov di,offset DGROUP:rgbXfrBuf1
|
|
cld
|
|
rep movsb
|
|
pop ds
|
|
pop cx
|
|
iexED80:
|
|
push ax
|
|
;-----------
|
|
mov ax,[bp].pmUserDS
|
|
mov [bp].intUserDS,ax
|
|
;------------------------------------------------------------
|
|
mov ax,[bp].pmUserDX
|
|
mov [bp].intUserDX,ax
|
|
pop ax
|
|
iexED90:
|
|
ret
|
|
|
|
|
|
DXPMCODE ends
|
|
|
|
;/////////////////////////////////////////////////////////////////////////
|
|
; Hmode no GRAPH ha INT 1Dh(Graph BIOS) niyori byouga sareru.
|
|
; DOSX deha,
|
|
;/////////////////////////////////////////////////////////////////////////
|
|
; -------------------------------------------------------
|
|
; PMIntr GRAPH BIOS
|
|
;--------------------------------------------------------
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntrGraph
|
|
|
|
;///////////////////////////////////////////////////////////////////////
|
|
;; extrn fNHmode:BYTE ;NHmode
|
|
;///////////////////////////////////////////////////////////////////////
|
|
|
|
PMIntrGraph:
|
|
|
|
|
|
;; test fNHmode,0FFh
|
|
;; jz GBios_Nmode
|
|
call EnterIntHandler ;build a stack frame and fix up the
|
|
cld ; return address so that the interrupt
|
|
;service routine will return to us.
|
|
;
|
|
; Perform fixups on the entry register values
|
|
|
|
push ax
|
|
mov ax,[bp].pmUserDS
|
|
call GetSegmentAddress
|
|
shr dx,4
|
|
shl bx,12
|
|
or bx,dx ;bx now = seg of parent psp
|
|
mov [bp].intUserDS,bx
|
|
pop ax
|
|
|
|
|
|
;
|
|
; Execute the interrupt service routine
|
|
SwitchToRealMode
|
|
assume ss:DGROUP
|
|
pop es
|
|
pop ds
|
|
assume ds:NOTHING,es:NOTHING
|
|
popa
|
|
call rglpfnRmISR[4*1Dh] ;execute the real mode interrupt routine
|
|
pushf
|
|
cli
|
|
cld
|
|
pusha
|
|
push ds
|
|
push es
|
|
|
|
mov ax,ss
|
|
mov ds,ax
|
|
mov es,ax
|
|
|
|
mov bp,sp ;restore stack frame pointer
|
|
SwitchToProtectedMode
|
|
assume ds:DGROUP,es:DGROUP
|
|
;
|
|
; Perform fixups on the return register values.
|
|
mov ax,[bp].pmUserAX ;get original function code
|
|
;/////////////
|
|
push ax
|
|
mov ax,[bp].pmUserDS
|
|
mov [bp].intUserDS,ax
|
|
pop ax
|
|
;/////////////
|
|
;
|
|
; And return to the original caller.
|
|
call LeaveIntHandler
|
|
|
|
iret
|
|
|
|
|
|
DXPMCODE ends
|
|
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public PMIntr11dummy
|
|
|
|
PMIntr11dummy proc near
|
|
|
|
and ax,0FFFDh
|
|
iret
|
|
|
|
PMIntr11dummy endp
|
|
DXPMCODE ends
|
|
|
|
endif ;NEC_98
|
|
DXPMCODE segment
|
|
assume cs:DXPMCODE
|
|
|
|
IFDEF WOW
|
|
|
|
public Wow32IntrRefl
|
|
Wow32IntrRefl label word
|
|
??intnum = 0
|
|
rept 256
|
|
push word ptr ??intnum
|
|
jmp Wow32Intr16Reflector
|
|
??intnum = ??intnum + 1
|
|
endm
|
|
;--------------------------------------------------------
|
|
;
|
|
; Wow32Intr16Reflector -- This routine reflects a 32 bit
|
|
; interrupt to a 16 bit handler. It switches to the
|
|
; dos extender stack to do so.
|
|
;
|
|
; Inputs: none
|
|
; Outputs: none
|
|
;
|
|
assume ds:nothing,es:nothing,ss:nothing
|
|
public Wow32Intr16Reflector
|
|
Wow32Intr16Reflector proc
|
|
.386p
|
|
push ebp
|
|
mov ebp,esp
|
|
push ds
|
|
push eax
|
|
push ebx
|
|
push edi
|
|
mov ax,ss
|
|
movzx eax,ax
|
|
lar eax,eax
|
|
test eax,(AB_BIG SHL 8)
|
|
jnz w32i16r10
|
|
|
|
movzx ebp,bp
|
|
w32i16r10:
|
|
|
|
;
|
|
; Get a frame on the dosx stack.
|
|
;
|
|
mov ax,selDgroupPM
|
|
mov ds,ax
|
|
assume ds:DGROUP
|
|
|
|
movzx ebx,pbReflStack
|
|
sub pbReflStack,CB_STKFRAME
|
|
|
|
;
|
|
; Build a frame on the stack
|
|
;
|
|
sub bx,30
|
|
mov eax, [ebp+6] ; eip
|
|
mov [bx+20], eax
|
|
mov eax, [ebp+10] ; cs
|
|
mov [bx+24], eax
|
|
|
|
mov [bx + 18],ss ; ss for stack switch back
|
|
mov eax,ebp
|
|
add eax,6 ; ebp, int number
|
|
mov [bx + 14],eax ; esp for stack switch back
|
|
mov ax,[ebp + 14] ; get flags
|
|
mov [bx + 12],ax
|
|
mov ax,cs
|
|
mov [bx + 10],ax
|
|
mov [bx + 8],offset DXPMCODE:w3216r30
|
|
mov eax,[ebp]
|
|
mov [bx],eax ; put ebp on other stack for pop
|
|
;
|
|
; Get handler
|
|
;
|
|
mov di,[ebp + 4] ; int number
|
|
shl di,2 ; al * 4
|
|
add di,offset DGROUP:Wow16BitHandlers
|
|
mov ax,[di]
|
|
mov [bx + 4],ax ; handler ip
|
|
mov ax,[di + 2]
|
|
mov [bx + 6],ax ; handler cs
|
|
|
|
;
|
|
; Set up for stack switch
|
|
;
|
|
push ds
|
|
push ebx
|
|
;
|
|
; Restore registers
|
|
;
|
|
mov ax,[ebp - 2]
|
|
mov ds,ax
|
|
mov eax,[ebp - 6]
|
|
mov ebx,[ebp - 10]
|
|
mov edi,[ebp - 14]
|
|
;
|
|
; Switch stacks, restore ebp, and call handler
|
|
;
|
|
lss esp,[ebp - 20]
|
|
pop ebp
|
|
retf
|
|
;
|
|
; N.B. i31_RMCall looks on the stack to get the original user stack pointer.
|
|
; if you change the stack frame the is passed to the 16 bit int
|
|
; handlers, that WILL break.
|
|
;
|
|
|
|
w3216r30:
|
|
;
|
|
; Switch stacks, deallocate frame from dosx stack and return
|
|
;
|
|
push ebx
|
|
push eax
|
|
push ds
|
|
lds ebx,[esp+10] ;get ss:esp
|
|
mov eax,[esp+16]
|
|
mov [ebx],eax ;eip
|
|
mov eax,[esp+20]
|
|
mov [ebx+4],eax ;cs
|
|
pop ds
|
|
pop eax
|
|
pop ebx
|
|
|
|
lss esp,[esp]
|
|
push ebx
|
|
|
|
|
|
pushfd
|
|
push eax
|
|
mov ax,ss
|
|
movzx eax,ax
|
|
lar eax,eax
|
|
test eax,(AB_BIG SHL 8) ; is the stack big?
|
|
jnz w32i16r40 ; jif yes, use 32bit operations
|
|
pop eax ; restore regs
|
|
popfd
|
|
|
|
rpushfd ; save flags, set virtual int bit
|
|
pop ebx
|
|
push ebp
|
|
movzx ebp, sp
|
|
mov [ebp + 16],ebx ; put flags on iret frame
|
|
pop ebp
|
|
push ds
|
|
mov bx,selDgroupPM
|
|
mov ds,bx
|
|
add pbReflStack,CB_STKFRAME
|
|
pop ds
|
|
pop ebx
|
|
riretd
|
|
|
|
w32i16r40: ; stack is big
|
|
pop eax ; restore regs
|
|
popfd
|
|
|
|
rpushfd32
|
|
pop ebx
|
|
mov [esp + 12],ebx
|
|
push ds
|
|
mov bx,selDgroupPM
|
|
mov ds,bx
|
|
add pbReflStack,CB_STKFRAME
|
|
pop ds
|
|
pop ebx
|
|
riretd32
|
|
|
|
.286p
|
|
Wow32Intr16Reflector endp
|
|
ENDIF
|
|
DXPMCODE ends
|
|
;
|
|
;****************************************************************
|
|
end
|