timer.c File Reference

#include <hal.h>
#include <debug.h>

Include dependency graph for timer.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	PIT_LATCH   0x00

Functions
FORCEINLINE ULONG	HalpRead8254Value (void)
VOID NTAPI	HalpSetTimerRollOver (USHORT RollOver)
VOID NTAPI	HalpInitializeClock (VOID)
VOID NTAPI	HalCalibratePerformanceCounter (IN volatile PLONG Count, IN ULONGLONG NewCount)
ULONG NTAPI	HalSetTimeIncrement (IN ULONG Increment)
LARGE_INTEGER NTAPI	KeQueryPerformanceCounter (PLARGE_INTEGER PerformanceFrequency)

Variables
HALP_ROLLOVER	HalpRolloverTable [15]
LARGE_INTEGER	HalpLastPerfCounter
LARGE_INTEGER	HalpPerfCounter
ULONG	HalpPerfCounterCutoff
BOOLEAN	HalpClockSetMSRate
ULONG	HalpCurrentTimeIncrement
ULONG	HalpCurrentRollOver
ULONG	HalpNextMSRate = 14
ULONG	HalpLargestClockMS = 15

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file timer.c.

PIT_LATCH

#define PIT_LATCH   0x00

Definition at line 18 of file timer.c.

Function Documentation

HalCalibratePerformanceCounter()

VOID NTAPI HalCalibratePerformanceCounter	(	IN volatile PLONG	Count,
		IN ULONGLONG	NewCount
	)

Definition at line 212 of file timer.c.

{
    ULONG_PTR Flags;
 
    /* Disable interrupts */
    Flags = __readeflags();
    _disable();
 
    /* Do a decrement for this CPU */
    _InterlockedDecrement(Count);
 
    /* Wait for other CPUs */
    while (*Count);
 
    /* Restore interrupts if they were previously enabled */
    __writeeflags(Flags);
}

HalpInitializeClock()

VOID NTAPI HalpInitializeClock

(

VOID

)

Definition at line 92 of file timer.c.

{
    ULONG Increment;
    USHORT RollOver;
 
    DPRINT("HalpInitializeClock()\n");
 
#if defined(SARCH_PC98)
    HalpInitializeClockPc98();
#endif
 
    /* Get increment and rollover for the largest time clock ms possible */
    Increment = HalpRolloverTable[HalpLargestClockMS - 1].Increment;
    RollOver = (USHORT)HalpRolloverTable[HalpLargestClockMS - 1].RollOver;
 
    /* Set the maximum and minimum increment with the kernel */
    KeSetTimeIncrement(Increment, HalpRolloverTable[0].Increment);
 
    /* Set the rollover value for the timer */
    HalpSetTimerRollOver(RollOver);
 
    /* Save rollover and increment */
    HalpCurrentRollOver = RollOver;
    HalpCurrentTimeIncrement = Increment;
}

HalpRead8254Value()

FORCEINLINE ULONG HalpRead8254Value

(

void

)

Definition at line 35 of file timer.c.

{
    ULONG TimerValue;
 
    /* Send counter latch command for channel 0 */
    __outbyte(TIMER_CONTROL_PORT, PIT_LATCH);
    __nop();
 
    /* Read the value, LSB first */
    TimerValue = __inbyte(TIMER_CHANNEL0_DATA_PORT);
    __nop();
    TimerValue |= __inbyte(TIMER_CHANNEL0_DATA_PORT) << 8;
 
    return TimerValue;
}

Referenced by KeQueryPerformanceCounter().

HalpSetTimerRollOver()

VOID NTAPI HalpSetTimerRollOver

(

USHORT

RollOver

)

Definition at line 53 of file timer.c.

{
    ULONG_PTR Flags;
    TIMER_CONTROL_PORT_REGISTER TimerControl;
 
    /* Disable interrupts */
    Flags = __readeflags();
    _disable();
 
    /* Program the PIT for binary mode */
    TimerControl.BcdMode = FALSE;
 
    /*
     * Program the PIT to generate a normal rate wave (Mode 2) on channel 0.
     * Channel 0 is used for the IRQ0 clock interval timer, and channel
     * 1 is used for DRAM refresh.
     *
     * Mode 2 gives much better accuracy than Mode 3.
     */
    TimerControl.OperatingMode = PitOperatingMode2;
    TimerControl.Channel = PitChannel0;
 
    /* Set the access mode that we'll use to program the reload value */
    TimerControl.AccessMode = PitAccessModeLowHigh;
 
    /* Now write the programming bits */
    __outbyte(TIMER_CONTROL_PORT, TimerControl.Bits);
 
    /* Next we write the reload value for channel 0 */
    __outbyte(TIMER_CHANNEL0_DATA_PORT, RollOver & 0xFF);
    __outbyte(TIMER_CHANNEL0_DATA_PORT, RollOver >> 8);
 
    /* Restore interrupts if they were previously enabled */
    __writeeflags(Flags);
}

Referenced by HalpInitializeClock().

HalSetTimeIncrement()

ULONG NTAPI HalSetTimeIncrement

(

IN ULONG

Increment

)

Definition at line 236 of file timer.c.

{
    /* Round increment to ms */
    Increment /= 10000;
 
    /* Normalize between our minimum (1 ms) and maximum (variable) setting */
    if (Increment > HalpLargestClockMS) Increment = HalpLargestClockMS;
    if (Increment <= 0) Increment = 1;
 
    /* Set the rate and tell HAL we want to change it */
    HalpNextMSRate = Increment;
    HalpClockSetMSRate = TRUE;
 
    /* Return the increment */
    return HalpRolloverTable[Increment - 1].Increment;
}

KeQueryPerformanceCounter()

LARGE_INTEGER NTAPI KeQueryPerformanceCounter

(

PLARGE_INTEGER PerformanceFrequency

)

Definition at line 255 of file timer.c.

{
    LARGE_INTEGER CurrentPerfCounter;
    ULONG CounterValue, ClockDelta;
    KIRQL OldIrql;
 
    /* If caller wants performance frequency, return hardcoded value */
    if (PerformanceFrequency) PerformanceFrequency->QuadPart = PIT_FREQUENCY;
 
    /* Check if we were called too early */
    if (HalpCurrentRollOver == 0) return HalpPerfCounter;
 
    /* Check if interrupts are disabled */
    if(!(__readeflags() & EFLAGS_INTERRUPT_MASK)) return HalpPerfCounter;
 
    /* Raise irql to DISPATCH_LEVEL */
    OldIrql = KeGetCurrentIrql();
    if (OldIrql < DISPATCH_LEVEL) KfRaiseIrql(DISPATCH_LEVEL);
 
    do
    {
        /* Get the current performance counter value */
        CurrentPerfCounter = HalpPerfCounter;
 
        /* Read the 8254 counter value */
        CounterValue = HalpRead8254Value();
 
    /* Repeat if the value has changed (a clock interrupt happened) */
    } while (CurrentPerfCounter.QuadPart != HalpPerfCounter.QuadPart);
 
    /* After someone changed the clock rate, during the first clock cycle we
       might see a counter value larger than the rollover. In this case we
       pretend it already has the new rollover value. */
    if (CounterValue > HalpCurrentRollOver) CounterValue = HalpCurrentRollOver;
 
    /* The interrupt is issued on the falling edge of the OUT line, when the
       counter changes from 1 to max. Calculate a clock delta, so that directly
       after the interrupt it is 0, going up to (HalpCurrentRollOver - 1). */
    ClockDelta = HalpCurrentRollOver - CounterValue;
 
    /* Add the clock delta */
    CurrentPerfCounter.QuadPart += ClockDelta;
 
    /* Check if the value is smaller then before, this means, we somehow
       missed an interrupt. This is a sign that the timer interrupt
       is very inaccurate. Probably a virtual machine. */
    if (CurrentPerfCounter.QuadPart < HalpLastPerfCounter.QuadPart)
    {
        /* We missed an interrupt. Assume we will receive it later */
        CurrentPerfCounter.QuadPart += HalpCurrentRollOver;
    }
 
    /* Update the last counter value */
    HalpLastPerfCounter = CurrentPerfCounter;
 
    /* Restore previous irql */
    if (OldIrql < DISPATCH_LEVEL) KfLowerIrql(OldIrql);
 
    /* Return the result */
    return CurrentPerfCounter;
}

Variable Documentation

HalpClockSetMSRate

BOOLEAN HalpClockSetMSRate

Definition at line 25 of file timer.c.

Referenced by HalSetTimeIncrement().

HalpCurrentRollOver

ULONG HalpCurrentRollOver

Definition at line 27 of file timer.c.

Referenced by HalpInitializeClock(), and KeQueryPerformanceCounter().

HalpCurrentTimeIncrement

ULONG HalpCurrentTimeIncrement

Definition at line 26 of file timer.c.

HalpLargestClockMS

ULONG HalpLargestClockMS = 15

Definition at line 29 of file timer.c.

Referenced by HalpInitializeClock(), and HalSetTimeIncrement().

HalpLastPerfCounter

LARGE_INTEGER HalpLastPerfCounter

Definition at line 22 of file timer.c.

Referenced by KeQueryPerformanceCounter().

HalpNextMSRate

ULONG HalpNextMSRate = 14

Definition at line 28 of file timer.c.

Referenced by HalSetTimeIncrement().

HalpPerfCounter

LARGE_INTEGER HalpPerfCounter

Definition at line 23 of file timer.c.

Referenced by KeQueryPerformanceCounter().

HalpPerfCounterCutoff

ULONG HalpPerfCounterCutoff

Definition at line 24 of file timer.c.

HalpRolloverTable

HALP_ROLLOVER HalpRolloverTable[15]

extern

Definition at line 15 of file clock.c.

Referenced by HalpInitializeClock(), HalpInitializeClockPc98(), and HalSetTimeIncrement().