rtctimer.c File Reference

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

Include dependency graph for rtctimer.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
FORCEINLINE ULONG	RtcClockRateToPreciseIncrement (UCHAR Rate)
	Converts the CMOS RTC rate into the time increment in 100ns intervals.
VOID	RtcSetClockRate (UCHAR ClockRate)
VOID NTAPI	HalpInitializeClock (VOID)
VOID FASTCALL	HalpClockInterruptHandler (IN PKTRAP_FRAME TrapFrame)
ULONG NTAPI	HalSetTimeIncrement (IN ULONG Increment)

Variables
static const UCHAR	RtcMinimumClockRate = 6
static const UCHAR	RtcMaximumClockRate = 10
static UCHAR	HalpCurrentClockRate = 10
static ULONG	HalpCurrentTimeIncrement
static ULONG	HalpMinimumTimeIncrement
static ULONG	HalpMaximumTimeIncrement
static ULONG	HalpCurrentFractionalIncrement
static ULONG	HalpRunningFraction
static BOOLEAN	HalpSetClockRate
static UCHAR	HalpNextClockRate

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 16 of file rtctimer.c.

Function Documentation

HalpClockInterruptHandler()

VOID FASTCALL HalpClockInterruptHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 142 of file rtctimer.c.

{
    ULONG LastIncrement;
    KIRQL Irql;
 
    /* Enter trap */
    KiEnterInterruptTrap(TrapFrame);
#ifdef _M_AMD64
    /* This is for debugging */
    TrapFrame->ErrorCode = 0xc10c4;
#endif
 
    /* Start the interrupt */
    if (!HalBeginSystemInterrupt(CLOCK_LEVEL, APIC_CLOCK_VECTOR, &Irql))
    {
        /* Spurious, just end the interrupt */
        KiEoiHelper(TrapFrame);
    }
 
    /* Read register C, so that the next interrupt can happen */
    HalpReadCmos(RTC_REGISTER_C);
 
    /* Save increment */
    LastIncrement = HalpCurrentTimeIncrement;
 
    /* Check if the running fraction has accounted for 100 ns */
    HalpRunningFraction += HalpCurrentFractionalIncrement;
    if (HalpRunningFraction >= 1000)
    {
        LastIncrement++;
        HalpRunningFraction -= 1000;
    }
 
    /* Check if someone changed the time rate */
    if (HalpSetClockRate)
    {
        /* Set new clock rate */
        RtcSetClockRate(HalpNextClockRate);
 
        /* We're done */
        HalpSetClockRate = FALSE;
    }
 
    /* Update the system time -- on x86 the kernel will exit this trap  */
    KeUpdateSystemTime(TrapFrame, LastIncrement, Irql);
}

HalpInitializeClock()

VOID NTAPI HalpInitializeClock

(

VOID

)

Definition at line 100 of file rtctimer.c.

{
    ULONG_PTR EFlags;
    UCHAR RegisterB;
 
    /* Save EFlags and disable interrupts */
    EFlags = __readeflags();
    _disable();
 
    // TODO: disable NMI
 
    /* Acquire CMOS lock */
    HalpAcquireCmosSpinLock();
 
    /* Enable the periodic interrupt in the CMOS */
    RegisterB = HalpReadCmos(RTC_REGISTER_B);
    HalpWriteCmos(RTC_REGISTER_B, RegisterB | RTC_REG_B_PI);
 
    /* Release CMOS lock */
    HalpReleaseCmosSpinLock();
 
    /* Set initial rate */
    RtcSetClockRate(HalpCurrentClockRate);
 
    /* Restore interrupt state */
    __writeeflags(EFlags);
 
    /* Calculate minumum and maximum increment */
    HalpMinimumTimeIncrement = RtcClockRateToPreciseIncrement(RtcMinimumClockRate) / 1000;
    HalpMaximumTimeIncrement = RtcClockRateToPreciseIncrement(RtcMaximumClockRate) / 1000;
 
    /* Notify the kernel about the maximum and minimum increment */
    KeSetTimeIncrement(HalpMaximumTimeIncrement, HalpMinimumTimeIncrement);
 
    /* Enable the timer interrupt */
    HalEnableSystemInterrupt(APIC_CLOCK_VECTOR, CLOCK_LEVEL, Latched);
 
    DPRINT1("Clock initialized\n");
}

HalSetTimeIncrement()

ULONG NTAPI HalSetTimeIncrement

(

IN ULONG

Increment

)

Definition at line 191 of file rtctimer.c.

{
    UCHAR Rate;
    ULONG CurrentIncrement;
 
    /* Lookup largest value below given Increment */
    for (Rate = RtcMinimumClockRate; Rate <= RtcMaximumClockRate; Rate++)
    {
        /* Check if this is the largest rate possible */
        CurrentIncrement = RtcClockRateToPreciseIncrement(Rate + 1) / 1000;
        if (Increment > CurrentIncrement) break;
    }
 
    /* Set the rate and tell HAL we want to change it */
    HalpNextClockRate = Rate;
    HalpSetClockRate = TRUE;
 
    /* Return the real increment */
    return RtcClockRateToPreciseIncrement(Rate) / 1000;
}

RtcClockRateToPreciseIncrement()

FORCEINLINE ULONG RtcClockRateToPreciseIncrement

(

UCHAR

Rate

)

Converts the CMOS RTC rate into the time increment in 100ns intervals.

Rate Frequency Interval (ms) Precise increment (0.1ns)

0 disabled 1 32768 0.03052 305,175 2 16384 0.06103 610,351 3 8192 0.12207 1,220,703 4 4096 0.24414 2,441,406 5 2048 0.48828 4,882,812 6 1024 0.97656 9,765,625 <- minimum 7 512 1.95313 19,531,250 8 256 3.90625 39,062,500 9 128 7.8125 78,125,000 10 64 15.6250 156,250,000 <- maximum / default 11 32 31.25 312,500,000 12 16 62.5 625,000,000 13 8 125 1,250,000,000 14 4 250 2,500,000,000 15 2 500 5,000,000,000

Definition at line 57 of file rtctimer.c.

{
    /* Calculate frequency */
    ULONG Frequency = 32768 >> (Rate - 1);
 
    /* Calculate interval in 0.1ns interval: Interval = (1 / Frequency) * 10,000,000,000 */
    return 10000000000ULL / Frequency;
}

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

RtcSetClockRate()

VOID RtcSetClockRate

(

UCHAR

ClockRate

)

Definition at line 67 of file rtctimer.c.

{
    UCHAR RegisterA;
    ULONG PreciseIncrement;
 
    /* Update the global values */
    HalpCurrentClockRate = ClockRate;
    PreciseIncrement = RtcClockRateToPreciseIncrement(ClockRate);
    HalpCurrentTimeIncrement = PreciseIncrement / 1000;
    HalpCurrentFractionalIncrement = PreciseIncrement % 1000;
 
    /* Acquire CMOS lock */
    HalpAcquireCmosSpinLock();
 
    // TODO: disable NMI
 
    /* Read value of register A */
    RegisterA = HalpReadCmos(RTC_REGISTER_A);
 
    /* Change lower 4 bits to new rate */
    RegisterA &= 0xF0;
    RegisterA |= ClockRate;
 
    /* Write the new value */
    HalpWriteCmos(RTC_REGISTER_A, RegisterA);
 
    /* Release CMOS lock */
    HalpReleaseCmosSpinLock();
}

Referenced by HalpClockInterruptHandler(), and HalpInitializeClock().

Variable Documentation

HalpCurrentClockRate

UCHAR HalpCurrentClockRate = 10

static

Definition at line 23 of file rtctimer.c.

Referenced by HalpInitializeClock(), and RtcSetClockRate().

HalpCurrentFractionalIncrement

ULONG HalpCurrentFractionalIncrement

static

Definition at line 27 of file rtctimer.c.

Referenced by HalpClockInterruptHandler(), and RtcSetClockRate().

HalpCurrentTimeIncrement

ULONG HalpCurrentTimeIncrement

static

Definition at line 24 of file rtctimer.c.

Referenced by HalpClockInterruptHandler(), and RtcSetClockRate().

HalpMaximumTimeIncrement

ULONG HalpMaximumTimeIncrement

static

Definition at line 26 of file rtctimer.c.

Referenced by HalpInitializeClock().

HalpMinimumTimeIncrement

ULONG HalpMinimumTimeIncrement

static

Definition at line 25 of file rtctimer.c.

Referenced by HalpInitializeClock().

HalpNextClockRate

UCHAR HalpNextClockRate

static

Definition at line 30 of file rtctimer.c.

Referenced by HalpClockInterruptHandler(), and HalSetTimeIncrement().

HalpRunningFraction

ULONG HalpRunningFraction

static

Definition at line 28 of file rtctimer.c.

Referenced by HalpClockInterruptHandler().

HalpSetClockRate

BOOLEAN HalpSetClockRate

static

Definition at line 29 of file rtctimer.c.

Referenced by HalpClockInterruptHandler(), and HalSetTimeIncrement().

RtcMaximumClockRate

const UCHAR RtcMaximumClockRate = 10

static

Definition at line 22 of file rtctimer.c.

Referenced by HalpInitializeClock(), and HalSetTimeIncrement().

RtcMinimumClockRate

const UCHAR RtcMinimumClockRate = 6

static

Definition at line 21 of file rtctimer.c.

Referenced by HalpInitializeClock(), and HalSetTimeIncrement().