#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "clock.h"
#include "cpu/cpu.h"
#include "hardware/cmos.h"
#include "hardware/ps2.h"
#include "hardware/pit.h"
#include "hardware/video/svga.h"
#include "hardware/mouse.h"

Include dependency graph for clock.c:

Macros
#define	NDEBUG

#define	STEPS_PER_CYCLE 1024

Functions
static VOID FASTCALL	IpsCallback (ULONGLONG ElapsedTime)

VOID	ClockUpdate (VOID)

PHARDWARE_TIMER	CreateHardwareTimer (ULONG Flags, ULONGLONG Delay, PHARDWARE_TIMER_PROC Callback)

VOID	EnableHardwareTimer (PHARDWARE_TIMER Timer)

VOID	DisableHardwareTimer (PHARDWARE_TIMER Timer)

VOID	SetHardwareTimerDelay (PHARDWARE_TIMER Timer, ULONGLONG NewDelay)

VOID	DestroyHardwareTimer (PHARDWARE_TIMER Timer)

BOOLEAN	ClockInitialize (VOID)

Variables
static LIST_ENTRY	Timers

static LARGE_INTEGER	StartPerfCount

static LARGE_INTEGER	Frequency

static LARGE_INTEGER	Counter

static ULONG	CurrentTickCount

static ULONGLONG	LastCycles = 0ULL

static PHARDWARE_TIMER	IpsTimer

ULONGLONG	CurrentCycleCount = 0ULL

ULONGLONG	CurrentIps = 20000000ULL

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 14 of file clock.c.

◆ STEPS_PER_CYCLE

#define STEPS_PER_CYCLE 1024

Definition at line 36 of file clock.c.

Function Documentation

◆ ClockInitialize()

BOOLEAN ClockInitialize ( VOID )

Definition at line 219 of file clock.c.

{
    InitializeListHead(&Timers);
 
    /* Initialize the performance counter (needed for hardware timers) */
    /* Find the starting performance */
    NtQueryPerformanceCounter(&StartPerfCount, &Frequency);
    if (Frequency.QuadPart == 0)
    {
        wprintf(L"FATAL: Performance counter not available\n");
        return FALSE;
    }
 
    /* Find the starting tick count */
    // StartTickCount = GetTickCount();
 
    IpsTimer = CreateHardwareTimer(HARDWARE_TIMER_ENABLED, HZ_TO_NS(10), IpsCallback);
    if (IpsTimer == NULL)
    {
        wprintf(L"FATAL: Cannot create IPS timer.\n");
        return FALSE;
    }
 
    return TRUE;
}

Referenced by EmulatorInitialize().

◆ ClockUpdate()

VOID ClockUpdate ( VOID )

DWORD_PTR oldmask = SetThreadAffinityMask(GetCurrentThread(), 0);

SetThreadAffinityMask(GetCurrentThread(), oldmask);

Definition at line 76 of file clock.c.

{
    extern BOOLEAN CpuRunning;
    UINT i;
    PLIST_ENTRY Entry;
    PHARDWARE_TIMER Timer;
 
    while (VdmRunning && CpuRunning)
    {
        /* Get the current counters */
        CurrentTickCount = GetTickCount();
        NtQueryPerformanceCounter(&Counter, NULL);
 
        /* Continue CPU emulation */
        for (i = 0; VdmRunning && CpuRunning && (i < STEPS_PER_CYCLE); i++)
        {
            CpuStep();
            ++CurrentCycleCount;
        }
 
        Entry = Timers.Flink;
        while (Entry != &Timers)
        {
            ULONGLONG Ticks = (ULONGLONG)-1;
 
            Timer = CONTAINING_RECORD(Entry, HARDWARE_TIMER, Link);
            Entry = Entry->Flink;
 
            ASSERT((Timer->EnableCount > 0) && (Timer->Flags & HARDWARE_TIMER_ENABLED));
 
            if (Timer->Delay)
            {
                if (Timer->Flags & HARDWARE_TIMER_PRECISE)
                {
                    /* Use the performance counter for precise timers */
                    if (Counter.QuadPart <= Timer->LastTick.QuadPart) continue;
                    Ticks = (Counter.QuadPart - Timer->LastTick.QuadPart) / Timer->Delay;
                }
                else
                {
                    /* Use the regular tick count for normal timers */
                    if (CurrentTickCount <= Timer->LastTick.LowPart) continue;
                    Ticks = (CurrentTickCount - Timer->LastTick.LowPart) / (ULONG)Timer->Delay;
                }
 
                if (Ticks == 0) continue;
            }
 
            Timer->Callback(Ticks);
 
            if (Timer->Flags & HARDWARE_TIMER_ONESHOT)
            {
                /* Disable this timer */
                DisableHardwareTimer(Timer);
            }
 
            /* Update the time of the last timer tick */
            Timer->LastTick.QuadPart += Ticks * Timer->Delay;
        }
 
        /* Yield execution to other threads */
        // FIXME: Disabled because it causes timing issues (slowdowns).
        // NtYieldExecution();
    }
}

Referenced by CpuSimulate().

◆ CreateHardwareTimer()

PHARDWARE_TIMER CreateHardwareTimer	(	ULONG	Flags,
		ULONGLONG	Delay,
		PHARDWARE_TIMER_PROC	Callback
	)

Definition at line 144 of file clock.c.

{
    PHARDWARE_TIMER Timer;
 
    Timer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*Timer));
    if (Timer == NULL) return NULL;
 
    Timer->Flags = Flags & ~HARDWARE_TIMER_ENABLED;
    Timer->EnableCount = 0;
    Timer->Callback = Callback;
    Timer->LastTick.QuadPart = 0;
    SetHardwareTimerDelay(Timer, Delay);
 
    if (Flags & HARDWARE_TIMER_ENABLED) EnableHardwareTimer(Timer);
    return Timer;
}

Referenced by ClockInitialize(), CmosInitialize(), MouseInit(), PitInitialize(), PS2Initialize(), and VgaInitialize().

◆ DestroyHardwareTimer()

VOID DestroyHardwareTimer ( PHARDWARE_TIMER Timer )

Definition at line 210 of file clock.c.

{
    if (Timer)
    {
        if (Timer->Flags & HARDWARE_TIMER_ENABLED) RemoveEntryList(&Timer->Link);
        RtlFreeHeap(RtlGetProcessHeap(), 0, Timer);
    }
}

Referenced by CmosCleanup(), PS2Cleanup(), and VgaCleanup().

◆ DisableHardwareTimer()

VOID DisableHardwareTimer ( PHARDWARE_TIMER Timer )

Definition at line 183 of file clock.c.

{
    /* Decrement the count */
    Timer->EnableCount--;
 
    /* Check if the count is 0 or less but the timer is enabled */
    if ((Timer->EnableCount <= 0) && (Timer->Flags & HARDWARE_TIMER_ENABLED))
    {
        /* Disable the timer */
        Timer->Flags &= ~HARDWARE_TIMER_ENABLED;
        RemoveEntryList(&Timer->Link);
    }
}

Referenced by ClockUpdate(), and RtcUpdatePeriodicTimer().

◆ EnableHardwareTimer()

VOID EnableHardwareTimer ( PHARDWARE_TIMER Timer )

Definition at line 161 of file clock.c.

{
    /* Increment the count */
    Timer->EnableCount++;
 
    /* Check if the count is above 0 but the timer isn't enabled */
    if ((Timer->EnableCount > 0) && !(Timer->Flags & HARDWARE_TIMER_ENABLED))
    {
        if (Timer->Flags & HARDWARE_TIMER_PRECISE)
        {
            NtQueryPerformanceCounter(&Timer->LastTick, NULL);
        }
        else
        {
            Timer->LastTick.LowPart = GetTickCount();
        }
 
        Timer->Flags |= HARDWARE_TIMER_ENABLED;
        InsertTailList(&Timers, &Timer->Link);
    }
}

Referenced by CreateHardwareTimer(), PS2QueuePush(), and RtcUpdatePeriodicTimer().

◆ IpsCallback()

static VOID FASTCALL IpsCallback ( ULONGLONG ElapsedTime )

static

Definition at line 53 of file clock.c.

{
#ifdef IPS_DISPLAY
    static INT NumCalls = 0;
#endif
 
    ULONGLONG NewIps = 10ULL * (CurrentCycleCount - LastCycles) / ElapsedTime;
    CurrentIps = (CurrentIps + NewIps) >> 1;
 
#ifdef IPS_DISPLAY
    NumCalls++;
    if (NumCalls == 10)
    {
        DPRINT1("NTVDM: %I64u Instructions Per Second\n", CurrentIps);
        NumCalls = 0;
    }
#endif
 
    LastCycles = CurrentCycleCount;
}

Referenced by ClockInitialize().

◆ SetHardwareTimerDelay()

VOID SetHardwareTimerDelay	(	PHARDWARE_TIMER	Timer,
		ULONGLONG	NewDelay
	)

Definition at line 197 of file clock.c.

{
    if (Timer->Flags & HARDWARE_TIMER_PRECISE)
    {
        /* Convert the delay from nanoseconds to performance counter ticks */
        Timer->Delay = (NewDelay * Frequency.QuadPart + 500000000ULL) / 1000000000ULL;
    }
    else
    {
        Timer->Delay = NewDelay / 1000000ULL;
    }
}