;
; Command & Conquer Red Alert(tm)
; Copyright 2025 Electronic Arts Inc.
;
; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>.
;
;***************************************************************************
;** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S **
;***************************************************************************
;* *
;* Project Name : Timer stuff *
;* *
;* File Name : TIMERA.ASM *
;* *
;* Programmer : Scott K. Bowen *
;* *
;* Start Date : July 6, 1994 *
;* *
;* Last Update : March 14, 1995 [PWG] *
;* *
;*-------------------------------------------------------------------------*
;* Functions: *
;* Get_RM_Timer_Address -- Return address of real mode code for copy. *
;* Get_RM_Timer_Size -- return size of real mode timer code. *
;* Increment_Tick_Count -- Increments WW system timer. *
;* Timer_Interrupt -- Temp routine to mimic a timer system calling our. *
;* Install_Timer_Interrupt -- Installs the timer interrupt routine. *
;* Remove_Timer_Interrupt -- Removes the timer interrupt vectors. **
;* Set_Timer_Frequency -- Set the frequency of the timer. *
;* Set_Timer_Rate -- Set the rate of the timer. *
;* Get_System_Tick_Count -- Returns the system tick count. *
;* Get_User_Tick_Count -- Get tick count of user clock. *
;* Increment_Timers -- Increments system and user timers. *
;* Get_Num_Interrupts -- Returns the number of interrupts that have occured*
;* Timer_Interrupt_Func -- Handles core timer code *
;* Disable_Timer_Interrupt -- Disables at the hardware level *
;* Enable_Timer_Interrupt -- Enables at the hardware level *
;* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *
IDEAL
P386
MODEL USE32 FLAT
DPMI_INTR equ 31h
TRUE equ 1 ; Boolean 'true' value
FALSE equ 0 ; Boolean 'false' value
LOCALS ??
;//////////////////////////////////////////////////////////////////////////////////////
;///////////////////////////////////// Equates ////////////////////////////////////////
SYSTEM_TIMER_FREQ equ 60 ; Frequency of system timer.
;********************************************************************
; There are two ways to call our interrupt chain in protected mode.
; The obvious way it to call the address that we replaced in the
; PM interrupt chain. This method is a little difficult but works and
; should always work.
;********************************************************************
; The RM and PM interrupts can be installed at the same time or seperately.
; Installing at the same time is the best method, the other method
; can be used to faciliated debugging when you only want one or the other
; called. Both methods work.
; -SKB July 21, 1994.
INSTALL_SEPERATE equ FALSE
INTCHIP0 EQU 20h ; 8259 interrupt chip controller 0
CLEARISR EQU 20h ; Value to write to 8259 to reenable interrupts.
IRQ0INTNUM EQU 08h ; IRQ0 interrupt vector number.
DOS_SYS_CALL EQU 21h ; to do TNT DOS-XNDR system calls.
LOCK_PAGES EQU 5 ; Lock pages subfunction using DX_MEM_MGT
UNLOCK_PAGES EQU 6 ; Unlock pages subfunction using DX_MEM_MGT
TIMER_CONST EQU 1193180 ; TIMER_CONST / FREQ = rate to set 8259 chip
TIMERCMDREG EQU 043H ; timer command register port.
TIMER0PORT EQU 040H ; timer channel 0 port
TIMETYPE EQU 036H ; type of timer.
; 36H = 0011 0110
; -- select channel 0
; -- read/load low byte then high byte for timer
; --- timer mode 3
; - 0 - binary , 1 - BCD data
;//////////////////////////////////////////////////////////////////////////////////////
;///////////////////////////////////// Structs ////////////////////////////////////////
; Structure of memory in real mode handler.
; This is at the very start of the real mode code.
; This information may not change unless the real mode version is also changed.
STRUC TimerType
; For speed, PM uses a DD while RM used DW
; For speed, SysRate and SysError are DD in PM and are DW in real mode.
TrueRate DD ? ; True rate of clock. (only use word)
SysTicks DD ? ; Tick count of timer.
SysRate DD ? ; Desired rate of timer.
SysError DD ? ; Amount of error in clock rate for desired frequency.
SysCurRate DW ? ; Keeps track of when to increment timer.
SysCurError DW ? ; Keeps track of amount of error in timer.
UserTicks DD ? ; Tick count of timer.
UserRate DD ? ; Desired rate of timer.
UserError DD ? ; Amount of error in clock rate for desired frequency.
UserCurRate DW ? ; Keeps track of when to increment timer.
UserCurError DW ? ; Keeps track of amount of error in timer.
DosAdder DW ? ; amount to add to DosFraction each interrupt.
DosFraction DW ? ; Call dos when overflowed.
OldRMI DD ? ; The origianl RM interrupt seg:off.
OldPMIOffset DD ? ; The origianl PM interrupt offset
OldPMISelector DD ? ; The original PM interrupt segment.
CodeOffset DW ? ; Offset of the code in the RM stuff.
CallRMIntOffset DW ? ; Offset of function to call DOS timer interrupt.
CallRMIntAddr DD ? ; PM address of CallRealIntOffset for speed.
PMIssuedInt DD 0 ; PM signals RM to just call Int chain.
; These are just used for information on testing. When all is done, they can
; be removed, but why? The don't add too much proccessing time and can
; be useful.
NumPMInts DD ? ; Number of PM interrupts
NumRMInts DD ? ; Number of RM interrupts.
ENDS
;//////////////////////////////////////////////////////////////////////////////////////
;/////////////////////////////////// Prototypes //////////////////////////////////////
GLOBAL Get_System_Tick_Count:NEAR
GLOBAL Get_User_Tick_Count:NEAR
GLOBAL Get_RM_Timer_Address:NEAR
GLOBAL Get_RM_Timer_Size:NEAR
GLOBAL Set_Timer_Frequency:NEAR
GLOBAL Timer_Interrupt:NEAR
GLOBAL Install_Timer_Interrupt:NEAR
GLOBAL Remove_Timer_Interrupt:NEAR
GLOBAL Get_Num_Interrupts:NEAR
GLOBAL Timer_Interrupt_Func:FAR
GLOBAL Disable_Timer_Interrupt:NEAR
GLOBAL Enable_Timer_Interrupt:NEAR
;//////////////////////////////////////////////////////////////////////////////////////
;//////////////////////////////////////// Data ////////////////////////////////////////
DATASEG
; The current time we will just include the real mode stuff
; into the protected mode code and then copy it down. The C side of
; this will handle this method or reading it off of disk in the real
; method.
LABEL RealBinStart BYTE
include "timereal.ibn"
LABEL RealBinEnd BYTE
LABEL LockedDataStart BYTE
RealModeSel DD 0
RealModePtr DD 0 ; Pointer to real mode memory.
RealModeSize DD 0 ; Pointer to real mode memory.
LABEL LockedDataEnd BYTE
InitFlags DD 0 ; Flags to indicate what has been initialized.
; InitFlags that are set to have a fully functional interrupt.
IF_ALLOC_RM equ 1h ; Allocation of RM was successful.
IF_SET_VECTORS equ 2h ; Vectors have been set.
IF_LOCKED_PM_CODE equ 4h ; Locked PM code for DPMI.
IF_LOCKED_PM_DATA equ 8h ; Locked PM code for DPMI.
IF_RATE_CHANGE equ 10h ; Timer rate was changed.
IF_FUNCTIONAL equ 20h ; Timer is in and functional.
IF_LOCKED_RM_CODE equ 40h ; Timer is in and functional.
;//////////////////////////////////////////////////////////////////////////////////////
;//////////////////////////////////////// Code ////////////////////////////////////////
CODESEG
;//////////////////////////////////////////////////////////////////////////////////////
;/////////////////////////////// Init routines ////////////////////////////////////////
;***************************************************************************
;* GET_RM_TIMER_ADDRESS -- Return address of real mode code for copy. *
;* *
;* *
;* *
;* INPUT: *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Get_RM_Timer_Address C Near
mov eax, OFFSET RealBinStart
ret
ENDP
;***************************************************************************
;* GET_RM_TIMER_SIZE -- return size of real mode timer code. *
;* *
;* *
;* *
;* INPUT: *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Get_RM_Timer_Size C Near
mov eax, OFFSET RealBinEnd - OFFSET RealBinStart
ret
ENDP
;***************************************************************************
;* SET_TIMER_RATE -- Set the rate of the timer. *
;* *
;* *
;* INPUT: ebx = rate to set timer were rate = 1193180 / freq *
;* *
;* OUTPUT: none *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/11/1994 SKB : Created. *
;*=========================================================================*
PROC Set_Timer_Rate Near
push eax
pushf ; to save int enable flag
cli ; disable interupts while setting up swapper
mov al,TIMETYPE ; setup to modify timer 0
out TIMERCMDREG,al ; send command.
mov eax,ebx ; get rate.
out TIMER0PORT,al ; output low byte
mov al,ah
out TIMER0PORT,al ; output high byte
sti
popf ; get int enable flag.
pop eax
ret
ENDP Set_Timer_Rate
;***************************************************************************
;* SET_TIMER_FREQUENCY -- Set the frequency of the timer. *
;* *
;* *
;* INPUT: INT Frequency of user timer. *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Set_Timer_Frequency C NEAR
USES eax,ebx,ecx,edx
ARG freq:DWORD
LOCAL clockrate:DWORD
LOCAL clockfreq:DWORD
test [InitFlags],IF_FUNCTIONAL ; Is our timer system installed?
jz ??timer_not_installed ; if not, this is not legal.
; Find out the greater of the frequencies (user or system.)
; Assign the True rate value based of of that.
; store the max frequency in ecx.
mov ecx,[freq] ; get user frequency.
cmp ecx,SYSTEM_TIMER_FREQ ; compare it with system frequency
jg ??user_is_fastest ; is user frequency faster?
mov ecx,SYSTEM_TIMER_FREQ ; no, set clock freq to system frequency.
??user_is_fastest:
; now get the rate that the clock will be set at.
; ecx is still max frequency.
mov esi,[RealModePtr]
mov eax,TIMER_CONST ; get the clock constant value.
xor edx,edx ; zero for divide.
div ecx ; rate = TC/freq => eax = eax/ecx;
mov [(TimerType PTR esi).TrueRate],eax ; Set our true rate.
mov ebx,eax ; save for later. DO NOT USE UNTIL CALL
; Set up variables to call DOS correctly.
; When DosFraction overflows, DOS is called.
mov [(TimerType PTR esi).DosAdder],ax ; Init count to until call dos.
mov [(TimerType PTR esi).DosFraction],0 ; init the fraction.
; now set up the system timer.
mov ecx,SYSTEM_TIMER_FREQ ; get frequency.
mov eax,TIMER_CONST ; get constant for formula rate=C/freq.
xor edx,edx ; make sure zero for divide
div ecx ; calculate rate
mov [(TimerType PTR esi).SysCurRate],ax ; Init current stuff.
mov [(TimerType PTR esi).SysCurError],ax ; Init current stuff.
mov [(TimerType PTR esi).SysRate],eax ; Save rate of timer
mov [(TimerType PTR esi).SysError],edx ; Save error of timer
; Do not set SysTicks to zero since it always has the same frequency. It
; should be zero out only when the system clock is installed.
; now set up the user timer.
mov ecx,[freq] ; get frequency of user timer.
mov eax,TIMER_CONST ; get constant for formula rate=C/freq.
xor edx,edx ; make sure zero for divide
div ecx ; calculate rate
mov [(TimerType PTR esi).UserCurRate],ax ; Init current stuff.
mov [(TimerType PTR esi).UserCurError],ax; Init current stuff.
mov [(TimerType PTR esi).UserRate],eax ; Save rate of timer
mov [(TimerType PTR esi).UserError],edx ; Save error of timer
mov [(TimerType PTR esi).UserTicks],0 ; User timer sets to zero when freq change.
; Call function to set the rate of the chip, ebx = rate from above.
call Set_Timer_Rate
??timer_not_installed:
ret
ENDP
;***************************************************************************
;* INSTALL_TIMER_Interrupt -- Installs the timer interrupt routine. *
;* *
;* *
;* INPUT: VOID * pointer to RM binary in PM memory. *
;* LONG Size of RM binary. *
;* INT frequency of user timer. *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Install_Timer_Interrupt C Near
USES ebx,ecx,edx
ARG rm_ptr:DWORD
ARG rm_size:DWORD
ARG freq:DWORD
ARG partial:DWORD
; Are they attempting to set timer again?
cmp [RealModePtr],0
jnz ??error
; Make sure all flags are cleared.
cmp [InitFlags],0
jnz ??error
; Before setting the interrupt vectors, the code needs to be locked
; for DPMI compatability. Any code or data accessed must be lockded
; so that no page faults accure during an interrupt.
; First lock the code, then the data. The stack will already be locked.
; The real mode code is also already locked be default.
; To lock a page set up registers :
; AX = 0600h
; BX:CX = starting linear address of memory block
; SI:DI = size of region
mov eax,0600h ; function number.
mov ecx,OFFSET LockedCodeStart ; ecx must have start of memory.
mov edi,OFFSET LockedCodeEnd ; edi will have size of region in bytes.
shld ebx,ecx,16
sub edi, ecx
shld esi,edi,16
int DPMI_INTR ; do call.
jc ??error ; eax = 8 if mem err, eax = 9 if invalid mem region.
or [InitFlags],IF_LOCKED_PM_CODE
mov eax,0600h ; function number.
mov ecx,OFFSET LockedDataStart ; ecx must have start of memory.
mov edi,OFFSET LockedDataEnd ; edi will have size of region in bytes.
shld ebx,ecx,16
sub edi, ecx
shld esi,edi,16
int DPMI_INTR ; do call.
jc ??error ; eax = 8 if mem err, eax = 9 if invalid mem region.
or [InitFlags],IF_LOCKED_PM_DATA
; now allocate real mode memory and copy the rm binary down to it.
mov eax,0100h ; set function number
mov ebx,[rm_size] ; get size of RM binary.
add ebx,15 ; round up
shr ebx,4 ; convert to pages.
int DPMI_INTR ; do call.
jc ??error ; check for error.
mov [ RealModeSel ] , edx
shl eax,4 ; convert segment to offset.
mov [RealModePtr],eax ; save offset to global variable.
; now lock the real mode memory that we allocated, just in
; case it needs to be.
mov eax,0600h ; function number.
mov ecx,[RealModePtr] ; ecx must have start of memory.
mov edi,[rm_size] ; edi will have size of region in bytes.
mov [RealModeSize],edi ; save off the size for the unlock
shld ebx,ecx,16
shld esi,edi,16
int DPMI_INTR ; do call.
jc ??error ; eax = 8 if mem err, eax = 9 if invalid mem region.
or [InitFlags],IF_LOCKED_RM_CODE
; set up source and destination pointers for the copy.
mov eax,[RealModePtr]
mov esi,[rm_ptr] ; Set up our source pointer.
or [InitFlags],IF_ALLOC_RM ; set successful
mov edi,eax ; put it into esi for copy.
mov ecx,[rm_size]
rep movsb ; write RM bin to RM memory.
; restore esi to point to data and initialize some of it.
mov esi,[RealModePtr]
mov eax,esi ; get real mode 32 offset.
shl eax,12 ; make seg in high eax.
mov ax,[(TimerType PTR esi).CallRMIntOffset] ; create RM addr of call chain.
mov [(TimerType PTR esi).CallRMIntAddr],eax ; save it for use in PM int.
cmp [partial],0
jne ??partial_exit
;==========================================================================
; Get the protected mode interrupt vector keyboard.
; input ax = 0204
; bl = number of interrupt to get
; output: cf error
;==========================================================================
mov eax,0204h ; Get proteced mode
mov bl,IRQ0INTNUM ; IRQ1 interrupt vector
int DPMI_INTR ; do call.
jc ??error
mov [(TimerType PTR esi).OldPMIOffset],edx ; save offset.
mov [(TimerType PTR esi).OldPMISelector],ecx ; save selector.
;==========================================================================
; Get the real mode interrupt vector keyboard
; input ax = 2503, cl = number of interrupt to get
; output cf error, CX:DX = address (seg:off) of RM int handler routine.
; cl set above
;==========================================================================
mov eax,0200h
mov bl,IRQ0INTNUM ; IRQ1 interrupt vector
int DPMI_INTR ; do call.
jc ??error
shl edx,16
shld ecx,edx,16
mov [(TimerType PTR esi).OldRMI],ecx
;==========================================================================
; only separate method of installation is posible.
; Now it is time to set the Protected mode interrupt Keyboard
; ax = function number (0205
; bl = number of interrupt to set
; cx:edx = address of PM interrupt handler
;==========================================================================
mov eax, 0205h
mov bl,IRQ0INTNUM
mov cx , cs
lea edx, [Timer_Interrupt] ; get address of protected code int hand.
int DPMI_INTR ; do call.
jc ??error
or [InitFlags],IF_SET_VECTORS
;==========================================================================
; Now it is time to set the real Interrupt Keyboard
; ax = function number (0201
; bl = number of interrupt to set
; cx:dx = address of RM interrupt handler
;==========================================================================
mov eax, 0201h
mov bl,IRQ0INTNUM
mov ecx,[RealModePtr] ; get address of real code int hand.
shr ecx,4 ; put segment in hi word.
mov dx,[(TimerType PTR esi).CodeOffset] ; Get address of code
int DPMI_INTR ; do call.
jc ??error
or [InitFlags],IF_SET_VECTORS
; now set the frequency.
mov eax,[freq]
or [InitFlags],IF_FUNCTIONAL
push eax
call NEAR Set_Timer_Frequency
mov [(TimerType PTR esi).SysTicks],0 ; Only place SysTicks in inited.
mov [(TimerType PTR esi).UserTicks],0 ; Timers start off on same foot.
pop eax
or [InitFlags],IF_RATE_CHANGE
; we have finished with success.
??partial_exit:
mov eax,1 ; signal success.
ret
??error:
xor eax,eax ; signal an error.
ret
ENDP
;***************************************************************************
;* REMOVE_TIMER_INTERRUPT -- Removes the timer interrupt vectors. *
;* *
;* *
;* *
;* INPUT: *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Remove_Timer_Interrupt C NEAR
USES ebx,ecx,edx
; check if timer was previosly install
mov esi,[RealModePtr]
test esi,esi
jz ??error
test [InitFlags],IF_SET_VECTORS
jz ??vectors_not_set
;==========================================================================
; Now it is time to set the real Interrupt Keyboard
; ax = function number (0201
; bl = number of interrupt to set
; cx:dx = address of RM interrupt handler
;====================================================================
mov eax, 0201h
mov bl,IRQ0INTNUM
mov edx,[(TimerType esi).OldRMI] ; get the RM address.
shld ecx , edx , 16
int DPMI_INTR ; do call.
jc ??error
;==========================================================================
; Now it is time to set the Protected mode interrupt
; ax = function number (0205
; bl = number of interrupt to set
; cx:edx = address of PM interrupt handler
;==========================================================================
mov eax, 0205h
mov bl,IRQ0INTNUM
mov ecx,[(TimerType esi).OldPMISelector] ; Get PM segment to put int ds later.
mov edx,[(TimerType esi).OldPMIOffset] ; Get PM offset
int DPMI_INTR ; do call.
jc ??error
??vectors_not_set:
; Call function to set the rate of the chip, ebx = rate.
test [InitFlags],IF_RATE_CHANGE ; was it changed?
jz ??rate_not_changed
mov ebx,0FFFFh ; back to 18.2 time per second.
call Set_Timer_Rate ; call function to set timer.
??rate_not_changed:
; now free up the real mode memory.
test [InitFlags],IF_LOCKED_RM_CODE
jz ??rm_not_locked
mov eax , 0601h
mov ecx, [RealModePtr]
mov edi, [RealModeSize]
shld ebx , ecx , 16
shld esi , edi , 16
int DPMI_INTR ; do call.
jc ??error ; eax = 8 if mem err, eax = 9 if invalid mem region.
??rm_not_locked:
test [InitFlags],IF_ALLOC_RM
jz ??mem_not_allocated
mov eax , 0101h
mov edx,[ RealModeSel ] ; get physical address of real mode buffer.
int DPMI_INTR ; do call.
jc ??error
??mem_not_allocated:
; Now we can unlock all stuff needed for the interrupt.
; Unlock code
test [InitFlags],IF_LOCKED_PM_CODE
jz ??code_not_locked
mov eax , 0601h
mov ecx,OFFSET LockedCodeStart ; ecx must have start of memory.
mov edi,OFFSET LockedCodeEnd ; edx will have size of region in bytes.
sub edi,ecx ; - figure size.
shld ebx , ecx , 16
shld esi , edi , 16
int DPMI_INTR ; do call.
jc ??error ; eax = 8 if mem err, eax = 9 if invalid mem region.
??code_not_locked:
; Unlock data
test [InitFlags],IF_LOCKED_PM_DATA
jz ??data_not_locked
mov ax,0601h ; set es to descriptor of data.
mov ecx,OFFSET LockedDataStart ; ecx must have start of memory.
mov edi,OFFSET LockedDataEnd ; edx will have size of region in bytes.
sub edi,ecx ; - figure size.
shld ebx , ecx , 16
shld esi , edi , 16
int DPMI_INTR ; do call.
jc ??error ; eax = 8 if mem err, eax = 9 if invalid mem region.
??data_not_locked:
; we have finished with success.
mov eax,1 ; signal success.
mov [RealModePtr],0 ; To say we can do it again sometime.
mov [InitFlags],0 ; To say we can do it again sometime.
ret
??error:
xor eax,eax ; signal an error.
ret
ENDP
;//////////////////////////////////////////////////////////////////////////////////////
;/////////////////////////////// Access routines //////////////////////////////////////
;***************************************************************************
;* GET_NUM_INTERRUPTS -- Returns the number of interrupts that have occured*
;* *
;* INPUT: TRUE - returns num RM ints. *
;* FALSE - return num PM ints. *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/12/1994 SKB : Created. *
;*=========================================================================*
PROC Get_Num_Interrupts C Near
USES esi
ARG realmode:DWORD
mov esi,[RealModePtr]
cmp [realmode],0
je ??prot_mode
mov eax,[(TimerType PTR esi).NumRMInts]
ret
??prot_mode:
mov eax,[(TimerType PTR esi).NumPMInts]
ret
ENDP
;***************************************************************************
;* GET_SYSTEM_TICK_COUNT -- Returns the system tick count. *
;* *
;* *
;* INPUT: *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Get_System_Tick_Count C Near
USES esi
mov esi,[RealModePtr]
xor eax,eax
cmp esi,0
je ??fini
mov eax,[(TimerType PTR esi).SysTicks]
??fini:
ret
ENDP
;***************************************************************************
;* GET_USER_TICK_COUNT -- Get tick count of user clock. *
;* *
;* *
;* INPUT: *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/12/1994 SKB : Created. *
;*=========================================================================*
PROC Get_User_Tick_Count C Near
USES esi
mov esi,[RealModePtr]
mov eax,[(TimerType PTR esi).UserTicks]
ret
ENDP
;//////////////////////////////////////////////////////////////////////////////////////
;/////////////////////////////// Interrupt routines ///////////////////////////////////
; These macros are placed here to handle to duplicate code in 2 methods in
; the Timer_Interrupt function.
MACRO SET_DS_ESI_TO_RM
; Sets DS : ES to point to DGROUP _DATA selector
; Set esi to point to RealModePtr
; Corrupts eax
mov ax , _DATA
mov ds , ax
mov es , ax
mov esi,[RealModePtr] ; Point to start of RM data.
ENDM
MACRO INCREMENT_TIMERS
; Expects ESI to point to real mode memory.
inc [(TimerType PTR esi).NumPMInts] ; For testing.
mov eax,[(TimerType PTR esi).TrueRate] ; Get the rate of the PC clock.
sub [(TimerType PTR esi).SysCurRate],ax ; Sub from our rate counter.
ja ??end_sys ; If !below zero, do not inc.
mov ebx,[(TimerType PTR esi).SysRate] ; Get rate of timer.
mov ecx,[(TimerType PTR esi).SysError] ; Get amount of error.
add [(TimerType PTR esi).SysCurRate],bx ; Add rate to the current.
sub [(TimerType PTR esi).SysCurError],cx ; Subtract err from error count.
jb ??error_adj_sys ; If wrapped don't inc.
inc [(TimerType PTR esi).SysTicks] ; increment the timer.
jmp short ??end_sys
??error_adj_sys:
add [(TimerType PTR esi).SysCurError],bx ; reajust the error by timer rate.
??end_sys:
sub [(TimerType PTR esi).UserCurRate],ax ; Sub from our rate counter.
ja ??end_user ; If !below zero, do not inc.
mov ebx,[(TimerType PTR esi).UserRate] ; Get rate of timer.
mov ecx,[(TimerType PTR esi).UserError] ; Get amount of error.
add [(TimerType PTR esi).UserCurRate],bx ; Add rate to the current.
sub [(TimerType PTR esi).UserCurError],cx; Subtract err from error count.
jb ??error_adj_user ; If wrapped don't inc.
inc [(TimerType PTR esi).UserTicks] ; increment the timer.
jmp short ??end_user
??error_adj_user:
add [(TimerType PTR esi).UserCurError],bx; reajust the error by timer rate.
??end_user:
ENDM
MACRO ENABLE_CLOCK_INT
; Signal 8259 that we are done and that it can bug us again.
; Corrupts al.
mov al,CLEARISR ; Signal EOI
sti ; enable interrupts.
out INTCHIP0,al ; 8259 interrupt chip controller 0
ENDM
LABEL LockedCodeStart BYTE
;***************************************************************************
;* TIMER_INTERRUPT -- Temp routine to mimic a timer system calling ours *
;* This is a temp routine to call our tick count routine. It will be *
;* replaced once another timer system is put in (such as HMI). *
;* *
;* INPUT: *
;* *
;* OUTPUT: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 07/06/1994 SKB : Created. *
;*=========================================================================*
PROC Timer_Interrupt Near
;////////////////////////////// Call prot mode interrupt vector ////////////////////////////////////////
; This routine will do what it needs to,
; then it will decide if the old vector should be called.
; if so, it calls it and never returns to this function.
; if not, we do our own return.
; the method for doing this is found in:
; "Phar Lap TNT DOS-Extender Reference Manual, First Addition, p. 142"
; It says:
; 1 - Execute a PUSHFD to save the current flags.
; 2 - Dec the stack ptr by 8 bytes to save room for the addr of orig handler
; 3 - Push register I use.
; 4 - Do any processing.
; 5 - Put the address of the original handler in the reserved slot.
; 6 - Pop saved register values
; 7 - Execute an IRETD to transfer control to original handler.
pushfd ; Step 1
sub esp,8 ; Step 2
push ebp ; Step 3
mov ebp,esp ; Set up a stack frame to know where to poke address.
; Step 3 continued. Push used varables.
pushad
push fs gs es ds
; Step 4. Now do processing before I chain.
; Set up ds:esi to point at start of real memory block (data is first)
call far Timer_Interrupt_Func
SET_DS_ESI_TO_RM ; Set ds:esi to point to real mode stuff.
; Now take care of calling the old DOS timer interrupt vector.
; This must be the last operation of this module since if we call
; DOS, we will never return.
mov ax,[(TimerType PTR ds:esi).DosAdder]
add [(TimerType PTR esi).DosFraction],ax
jnc ??no_dos_call ; if not, skip the call.
; Tell RM that we forced the int and not to update timers.
mov [(TimerType PTR esi).PMIssuedInt],1 ; Make it TRUE
; Step 5.
; Now it is time to set up for the call by returning by poking
; the old interrupt handle address in.
mov eax,[(TimerType PTR esi).OldPMIOffset] ; Get orig offset.
mov ebx,[(TimerType PTR esi).OldPMISelector] ; Get orig selector.
mov [ss:ebp+4],eax ; Poke offset.
mov [ss:ebp+8],ebx ; Poke selector.
; Step 6.
pop ds es gs fs
popad
pop ebp
; Step 7.
iretd ; transfer control to original handler.
??no_dos_call:
ENABLE_CLOCK_INT
; Restore all registers.
pop ds es gs fs
popad
pop ebp
add esp,8
popfd
iretd
;////////////////////////////// Call prot mode interrupt vector ////////////////////////////////////////
;//////////////////////////////////////////////////////////////////////////////////////////////////////
ENDP
;***************************************************************************
;* TIMER_INTERRUPT_FUNC -- Handles core timer code *
;* *
;* This function exists so that we can call it from the core HMI driver *
;* code when our timer interrupt has not been installed. *
;* *
;* INPUT: none *
;* *
;* OUTPUT: none *
;* *
;* PROTO: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 03/14/1995 PWG : Created. *
;*=========================================================================*
PROC Timer_Interrupt_Func C Far
pushfd ; save off the flags
pushad ; save off the main registers
push fs gs es ds ; save off the seg registers
SET_DS_ESI_TO_RM ; Set ds:esi to point to real mode stuff.
INCREMENT_TIMERS ; Increment Westwoods timers
pop ds es gs fs
popad
popfd
retf
ENDP
LABEL LockedCodeEnd BYTE
;***************************************************************************
;* DISABLE_TIMER_INTERRUPT_ONLY -- Disables at the hardware level *
;* *
;* *
;* INPUT: none *
;* *
;* OUTPUT: none *
;* *
;* PROTO: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 06/07/1995 DRD : Created. *
;*=========================================================================*
PROC Disable_Timer_Interrupt C Near
push eax
pushf
sti ; disable all interrupts if not disabled
in al,021h ; read interrupt Mask register bits 0-7
; apply to irq's 0-7
; value 0 of enabled
; value 1 of disabled
or al,001h ; setup to disable irq 0
out 021h,al ; disable irq 0
popf ; possibly enable all interrupts (except 0)
pop eax
retf
ENDP
;***************************************************************************
;* ENABLE_TIMER_INTERRUPT_ONLY -- Enables at the hardware level *
;* *
;* *
;* INPUT: none *
;* *
;* OUTPUT: none *
;* *
;* PROTO: *
;* *
;* WARNINGS: *
;* *
;* HISTORY: *
;* 06/07/1995 DRD : Created. *
;*=========================================================================*
PROC Enable_Timer_Interrupt C Near
push eax
pushf
sti ; disable all interrupts if not disabled
in al,021h ; read interrupt Mask register bits 0-7
; apply to irq's 0-7
; value 0 of enabled
; value 1 of disabled
and al,0FEh ; setup to enable irq 0
out 021h,al ; enable irq 0
popf ; possibly enable all interrupts
pop eax
retf
ENDP
END